}
}
-static inline int
+static int
rdata_cmp(const void *rdata1, const void *rdata2) {
return (dns_rdata_compare((const dns_rdata_t *)rdata1,
(const dns_rdata_t *)rdata2));
dns_diff_append(add, &tuple);
}
-static inline bool
+static bool
issigningkey(dns_dnsseckey_t *key) {
return (key->force_sign || key->hint_sign);
}
-static inline bool
+static bool
ispublishedkey(dns_dnsseckey_t *key) {
return ((key->force_publish || key->hint_publish) && !key->hint_remove);
}
-static inline bool
+static bool
iszonekey(dns_dnsseckey_t *key) {
return (dns_name_equal(dst_key_name(key->key), gorigin) &&
dst_key_iszonekey(key->key));
}
-static inline bool
+static bool
isksk(dns_dnsseckey_t *key) {
return (key->ksk);
}
-static inline bool
+static bool
iszsk(dns_dnsseckey_t *key) {
return (ignore_kskflag || !key->ksk);
}
return (false); /* removes a warning */
}
-static inline bool
+static bool
setverifies(dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
dns_rdata_t *rrsig) {
isc_result_t result;
* See if the node contains any non RRSIG/NSEC records and report to
* caller. Clean out extraneous RRSIG records for node.
*/
-static inline bool
+static bool
active_node(dns_dbnode_t *node) {
dns_rdatasetiter_t *rdsiter = NULL;
dns_rdatasetiter_t *rdsiter2 = NULL;
return (0); /* silence compiler warning */
}
-static inline bool
+static bool
isnone(const char *str) {
return ((strcasecmp(str, "none") == 0) ||
(strcasecmp(str, "never") == 0));
return (ISC_R_SUCCESS);
}
-static inline bool
+static bool
command_compare(const char *str, const char *command) {
return (strcasecmp(str, command) == 0);
}
isc_nmhandle_detach(&conn->sendhandle);
}
-static inline void
+static void
log_invalid(isccc_ccmsg_t *ccmsg, isc_result_t result) {
char socktext[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_t peeraddr = isc_nmhandle_peeraddr(ccmsg->handle);
static void
newzone_cfgctx_destroy(void **cfgp);
-static inline isc_result_t
+static isc_result_t
putstr(isc_buffer_t **b, const char *str);
static isc_result_t
static isc_result_t
putuint8(isc_buffer_t **b, uint8_t val);
-static inline isc_result_t
+static isc_result_t
putnull(isc_buffer_t **b);
static int
return (result);
}
-static inline bool
+static bool
argcheck(char *cmd, const char *full) {
size_t l;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
putstr(isc_buffer_t **b, const char *str) {
return (putmem(b, str, strlen(str)));
}
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
putnull(isc_buffer_t **b) {
return (putuint8(b, 0));
}
static int dnstapstats_index[dns_dnstapcounter_max];
static int gluecachestats_index[dns_gluecachestatscounter_max];
-static inline void
+static void
set_desc(int counter, int maxcounter, const char *fdesc, const char **fdescs,
const char *xdesc, const char **xdescs) {
REQUIRE(counter < maxcounter);
/*%
* Convert a config file zone type into a server zone type.
*/
-static inline dns_zonetype_t
+static dns_zonetype_t
zonetype_fromconfig(const cfg_obj_t *map) {
const cfg_obj_t *obj = NULL;
isc_result_t result;
}
}
-static inline void
+static void
check_result(isc_result_t result, const char *msg) {
if (result != ISC_R_SUCCESS) {
fatal("%s: %s", msg, isc_result_totext(result));
static isc_result_t
printmessage(dns_message_t *msg);
-static inline void
+static void
CHECKRESULT(isc_result_t result, const char *msg) {
if (result != ISC_R_SUCCESS) {
printf("%s: %s\n", msg, isc_result_totext(result));
}
/* Return a dot if 's' doesn't already end with one */
-static inline const char *
+static const char *
dot(const char *s) {
return (isrelative(s) ? "." : "");
}
should occur on the same line as the argument list, unless the argument
list is more than one line long:
- static inline void
+ static void
func1(int i) {
/* whatever */
}
/*
* Internal functions (and prototypes).
*/
-static inline dns_adbname_t *
+static dns_adbname_t *
new_adbname(dns_adb_t *, const dns_name_t *);
-static inline void
+static void
free_adbname(dns_adb_t *, dns_adbname_t **);
-static inline dns_adbnamehook_t *
+static dns_adbnamehook_t *
new_adbnamehook(dns_adb_t *, dns_adbentry_t *);
-static inline void
+static void
free_adbnamehook(dns_adb_t *, dns_adbnamehook_t **);
-static inline dns_adblameinfo_t *
+static dns_adblameinfo_t *
new_adblameinfo(dns_adb_t *, const dns_name_t *, dns_rdatatype_t);
-static inline void
+static void
free_adblameinfo(dns_adb_t *, dns_adblameinfo_t **);
-static inline dns_adbentry_t *
+static dns_adbentry_t *
new_adbentry(dns_adb_t *);
-static inline void
+static void
free_adbentry(dns_adb_t *, dns_adbentry_t **);
-static inline dns_adbfind_t *
+static dns_adbfind_t *
new_adbfind(dns_adb_t *);
-static inline bool
+static bool
free_adbfind(dns_adb_t *, dns_adbfind_t **);
-static inline dns_adbaddrinfo_t *
+static dns_adbaddrinfo_t *
new_adbaddrinfo(dns_adb_t *, dns_adbentry_t *, in_port_t);
-static inline dns_adbfetch_t *
+static dns_adbfetch_t *
new_adbfetch(dns_adb_t *);
-static inline void
+static void
free_adbfetch(dns_adb_t *, dns_adbfetch_t **);
-static inline dns_adbname_t *
+static dns_adbname_t *
find_name_and_lock(dns_adb_t *, const dns_name_t *, unsigned int, int *);
-static inline dns_adbentry_t *
+static dns_adbentry_t *
find_entry_and_lock(dns_adb_t *, const isc_sockaddr_t *, int *, isc_stdtime_t);
static void
dump_adb(dns_adb_t *, FILE *, bool debug, isc_stdtime_t);
print_find_list(FILE *, dns_adbname_t *);
static void
print_fetch_list(FILE *, dns_adbname_t *);
-static inline bool
+static bool
dec_adb_irefcnt(dns_adb_t *);
-static inline void
+static void
inc_adb_irefcnt(dns_adb_t *);
-static inline void
+static void
inc_adb_erefcnt(dns_adb_t *);
-static inline void
+static void
inc_entry_refcnt(dns_adb_t *, dns_adbentry_t *, bool);
-static inline bool
+static bool
dec_entry_refcnt(dns_adb_t *, bool, dns_adbentry_t *, bool);
-static inline void
+static void
violate_locking_hierarchy(isc_mutex_t *, isc_mutex_t *);
static bool
clean_namehooks(dns_adb_t *, dns_adbnamehooklist_t *);
static isc_result_t
fetch_name(dns_adbname_t *, bool, unsigned int, isc_counter_t *qc,
dns_rdatatype_t);
-static inline void
+static void
check_exit(dns_adb_t *);
static void
destroy(dns_adb_t *);
shutdown_names(dns_adb_t *);
static bool
shutdown_entries(dns_adb_t *);
-static inline void
+static void
link_name(dns_adb_t *, int, dns_adbname_t *);
-static inline bool
+static bool
unlink_name(dns_adb_t *, dns_adbname_t *);
-static inline void
+static void
link_entry(dns_adb_t *, int, dns_adbentry_t *);
-static inline bool
+static bool
unlink_entry(dns_adb_t *, dns_adbentry_t *);
static bool
kill_name(dns_adbname_t **, isc_eventtype_t);
/*%
* Increment resolver-related statistics counters.
*/
-static inline void
+static void
inc_stats(dns_adb_t *adb, isc_statscounter_t counter) {
if (adb->view->resstats != NULL) {
isc_stats_increment(adb->view->resstats, counter);
/*%
* Set adb-related statistics counters.
*/
-static inline void
+static void
set_adbstat(dns_adb_t *adb, uint64_t val, isc_statscounter_t counter) {
if (adb->view->adbstats != NULL) {
isc_stats_set(adb->view->adbstats, val, counter);
}
}
-static inline void
+static void
dec_adbstats(dns_adb_t *adb, isc_statscounter_t counter) {
if (adb->view->adbstats != NULL) {
isc_stats_decrement(adb->view->adbstats, counter);
}
}
-static inline void
+static void
inc_adbstats(dns_adb_t *adb, isc_statscounter_t counter) {
if (adb->view->adbstats != NULL) {
isc_stats_increment(adb->view->adbstats, counter);
}
}
-static inline dns_ttl_t
+static dns_ttl_t
ttlclamp(dns_ttl_t ttl) {
if (ttl < ADB_CACHE_MINIMUM) {
ttl = ADB_CACHE_MINIMUM;
/*
* Requires the name's bucket be locked.
*/
-static inline void
+static void
link_name(dns_adb_t *adb, int bucket, dns_adbname_t *name) {
INSIST(name->lock_bucket == DNS_ADB_INVALIDBUCKET);
/*
* Requires the name's bucket be locked.
*/
-static inline bool
+static bool
unlink_name(dns_adb_t *adb, dns_adbname_t *name) {
int bucket;
bool result = false;
/*
* Requires the entry's bucket be locked.
*/
-static inline void
+static void
link_entry(dns_adb_t *adb, int bucket, dns_adbentry_t *entry) {
int i;
dns_adbentry_t *e;
/*
* Requires the entry's bucket be locked.
*/
-static inline bool
+static bool
unlink_entry(dns_adb_t *adb, dns_adbentry_t *entry) {
int bucket;
bool result = false;
return (result);
}
-static inline void
+static void
violate_locking_hierarchy(isc_mutex_t *have, isc_mutex_t *want) {
if (isc_mutex_trylock(want) != ISC_R_SUCCESS) {
UNLOCK(have);
DP(ENTER_LEVEL, "EXIT clean_finds_at_name, name %p", name);
}
-static inline void
+static void
check_exit(dns_adb_t *adb) {
isc_event_t *event;
/*
}
}
-static inline bool
+static bool
dec_adb_irefcnt(dns_adb_t *adb) {
isc_event_t *event;
isc_task_t *etask;
return (result);
}
-static inline void
+static void
inc_adb_irefcnt(dns_adb_t *adb) {
LOCK(&adb->reflock);
adb->irefcnt++;
UNLOCK(&adb->reflock);
}
-static inline void
+static void
inc_adb_erefcnt(dns_adb_t *adb) {
LOCK(&adb->reflock);
adb->erefcnt++;
UNLOCK(&adb->reflock);
}
-static inline void
+static void
inc_entry_refcnt(dns_adb_t *adb, dns_adbentry_t *entry, bool lock) {
int bucket;
}
}
-static inline bool
+static bool
dec_entry_refcnt(dns_adb_t *adb, bool overmem, dns_adbentry_t *entry,
bool lock) {
int bucket;
return (result);
}
-static inline dns_adbname_t *
+static dns_adbname_t *
new_adbname(dns_adb_t *adb, const dns_name_t *dnsname) {
dns_adbname_t *name;
return (name);
}
-static inline void
+static void
free_adbname(dns_adb_t *adb, dns_adbname_t **name) {
dns_adbname_t *n;
UNLOCK(&adb->namescntlock);
}
-static inline dns_adbnamehook_t *
+static dns_adbnamehook_t *
new_adbnamehook(dns_adb_t *adb, dns_adbentry_t *entry) {
dns_adbnamehook_t *nh;
return (nh);
}
-static inline void
+static void
free_adbnamehook(dns_adb_t *adb, dns_adbnamehook_t **namehook) {
dns_adbnamehook_t *nh;
isc_mem_put(adb->mctx, nh, sizeof(*nh));
}
-static inline dns_adblameinfo_t *
+static dns_adblameinfo_t *
new_adblameinfo(dns_adb_t *adb, const dns_name_t *qname,
dns_rdatatype_t qtype) {
dns_adblameinfo_t *li;
return (li);
}
-static inline void
+static void
free_adblameinfo(dns_adb_t *adb, dns_adblameinfo_t **lameinfo) {
dns_adblameinfo_t *li;
isc_mem_put(adb->mctx, li, sizeof(*li));
}
-static inline dns_adbentry_t *
+static dns_adbentry_t *
new_adbentry(dns_adb_t *adb) {
dns_adbentry_t *e;
return (e);
}
-static inline void
+static void
free_adbentry(dns_adb_t *adb, dns_adbentry_t **entry) {
dns_adbentry_t *e;
dns_adblameinfo_t *li;
UNLOCK(&adb->entriescntlock);
}
-static inline dns_adbfind_t *
+static dns_adbfind_t *
new_adbfind(dns_adb_t *adb) {
dns_adbfind_t *h;
return (h);
}
-static inline dns_adbfetch_t *
+static dns_adbfetch_t *
new_adbfetch(dns_adb_t *adb) {
dns_adbfetch_t *f;
return (f);
}
-static inline void
+static void
free_adbfetch(dns_adb_t *adb, dns_adbfetch_t **fetch) {
dns_adbfetch_t *f;
isc_mem_put(adb->mctx, f, sizeof(*f));
}
-static inline bool
+static bool
free_adbfind(dns_adb_t *adb, dns_adbfind_t **findp) {
dns_adbfind_t *find;
* must be locked, and the reference count must be bumped up by one
* if this function returns a valid pointer.
*/
-static inline dns_adbaddrinfo_t *
+static dns_adbaddrinfo_t *
new_adbaddrinfo(dns_adb_t *adb, dns_adbentry_t *entry, in_port_t port) {
dns_adbaddrinfo_t *ai;
return (ai);
}
-static inline void
+static void
free_adbaddrinfo(dns_adb_t *adb, dns_adbaddrinfo_t **ainfo) {
dns_adbaddrinfo_t *ai;
* On the first call to this function, *bucketp must be set to
* DNS_ADB_INVALIDBUCKET.
*/
-static inline dns_adbname_t *
+static dns_adbname_t *
find_name_and_lock(dns_adb_t *adb, const dns_name_t *name, unsigned int options,
int *bucketp) {
dns_adbname_t *adbname;
* if this function is called multiple times locking is only done if
* the bucket changes.
*/
-static inline dns_adbentry_t *
+static dns_adbentry_t *
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;
}
}
-static inline void
+static void
print_fetch(FILE *f, dns_adbfetch_t *ft, const char *type) {
fprintf(f, "\t\tFetch(%s): %p -> { fetch %p }\n", type, ft, ft->fetch);
}
#define MAX_RESTARTS 16
-static inline isc_result_t
+static isc_result_t
copy_ptr_targets(dns_byaddr_t *byaddr, dns_rdataset_t *rdataset) {
isc_result_t result;
dns_name_t *name;
static void
water(void *arg, int mark);
-static inline isc_result_t
+static isc_result_t
cache_create_db(dns_cache_t *cache, dns_db_t **db) {
isc_result_t result;
result = dns_db_create(cache->mctx, cache->db_type, dns_rootname,
return (ISC_R_FAILURE);
}
-static inline void
+static void
catz_entry_add_or_mod(dns_catz_zone_t *target, isc_ht_t *ht, unsigned char *key,
size_t keysize, dns_catz_entry_t *nentry,
dns_catz_entry_t *oentry, const char *msg,
client_resfind(rctx, fevent);
}
-static inline isc_result_t
+static isc_result_t
start_fetch(resctx_t *rctx) {
isc_result_t result;
int fopts = 0;
return (true);
}
-static inline unsigned int
+static unsigned int
name_length(const dns_name_t *name) {
isc_region_t r;
dns_name_toregion(name, &r);
ISC_LIST_APPEND(implementations, &rbtimp, link);
}
-static inline dns_dbimplementation_t *
+static dns_dbimplementation_t *
impfind(const char *name) {
dns_dbimplementation_t *imp;
msgbuf);
}
-static inline void
+static void
inc_stats(dns_dispatchmgr_t *mgr, isc_statscounter_t counter) {
if (mgr->stats != NULL) {
isc_stats_increment(mgr->stats, counter);
}
}
-static inline void
+static void
dec_stats(dns_dispatchmgr_t *mgr, isc_statscounter_t counter) {
if (mgr->stats != NULL) {
isc_stats_decrement(mgr->stats, counter);
/*%
* Searches the dlz_implementations list for a driver matching name.
*/
-static inline dns_dlzimplementation_t *
+static dns_dlzimplementation_t *
dlz_impfind(const char *name) {
dns_dlzimplementation_t *imp;
return (dst_context_adddata(ctx, data));
}
-static inline void
+static void
inc_stat(isc_statscounter_t counter) {
if (dns_dnssec_stats != NULL) {
isc_stats_increment(dns_dnssec_stats, counter);
goto out; \
} while (0)
-static inline void
+static void
name_to_gbuffer(const dns_name_t *name, isc_buffer_t *buffer,
gss_buffer_desc *gbuffer) {
dns_name_t tname;
uint8_t key[ISC_MAX_BLOCK_SIZE];
};
-static inline isc_result_t
+static isc_result_t
getkeybits(dst_key_t *key, struct dst_private_element *element) {
uint16_t *bits = (uint16_t *)element->data;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
hmac_createctx(const isc_md_type_t *type, const dst_key_t *key,
dst_context_t *dctx) {
isc_result_t result;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
hmac_destroyctx(dst_context_t *dctx) {
isc_hmac_t *ctx = dctx->ctxdata.hmac_ctx;
REQUIRE(ctx != NULL);
dctx->ctxdata.hmac_ctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
hmac_adddata(const dst_context_t *dctx, const isc_region_t *data) {
isc_result_t result;
isc_hmac_t *ctx = dctx->ctxdata.hmac_ctx;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
hmac_sign(const dst_context_t *dctx, isc_buffer_t *sig) {
isc_hmac_t *ctx = dctx->ctxdata.hmac_ctx;
REQUIRE(ctx != NULL);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
hmac_verify(const dst_context_t *dctx, const isc_region_t *sig) {
isc_hmac_t *ctx = dctx->ctxdata.hmac_ctx;
unsigned char digest[ISC_MAX_MD_SIZE];
: DST_R_VERIFYFAILURE);
}
-static inline bool
+static bool
hmac_compare(const isc_md_type_t *type, const dst_key_t *key1,
const dst_key_t *key2) {
dst_hmac_key_t *hkey1, *hkey2;
isc_md_type_get_block_size(type)));
}
-static inline isc_result_t
+static isc_result_t
hmac_generate(const isc_md_type_t *type, dst_key_t *key) {
isc_buffer_t b;
isc_result_t ret;
return (ret);
}
-static inline bool
+static bool
hmac_isprivate(const dst_key_t *key) {
UNUSED(key);
return (true);
}
-static inline void
+static void
hmac_destroy(dst_key_t *key) {
dst_hmac_key_t *hkey = key->keydata.hmac_key;
isc_safe_memwipe(hkey, sizeof(*hkey));
key->keydata.hmac_key = NULL;
}
-static inline isc_result_t
+static isc_result_t
hmac_todns(const dst_key_t *key, isc_buffer_t *data) {
REQUIRE(key != NULL && key->keydata.hmac_key != NULL);
dst_hmac_key_t *hkey = key->keydata.hmac_key;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
hmac_fromdns(const isc_md_type_t *type, dst_key_t *key, isc_buffer_t *data) {
dst_hmac_key_t *hkey;
unsigned int keylen;
return (ISC_R_SUCCESS);
}
-static inline int
+static int
hmac__get_tag_key(const isc_md_type_t *type) {
if (type == ISC_MD_MD5) {
return (TAG_HMACMD5_KEY);
}
}
-static inline int
+static int
hmac__get_tag_bits(const isc_md_type_t *type) {
if (type == ISC_MD_MD5) {
return (TAG_HMACMD5_BITS);
}
}
-static inline isc_result_t
+static isc_result_t
hmac_tofile(const isc_md_type_t *type, const dst_key_t *key,
const char *directory) {
dst_hmac_key_t *hkey;
return (dst__privstruct_writefile(key, &priv, directory));
}
-static inline int
+static int
hmac__to_dst_alg(const isc_md_type_t *type) {
if (type == ISC_MD_MD5) {
return (DST_ALG_HMACMD5);
}
}
-static inline isc_result_t
+static isc_result_t
hmac_parse(const isc_md_type_t *type, dst_key_t *key, isc_lex_t *lexer,
dst_key_t *pub) {
dst_private_t priv;
static isc_result_t
index_to_disk(dns_journal_t *);
-static inline uint32_t
+static uint32_t
decode_uint32(unsigned char *p) {
return (((uint32_t)p[0] << 24) + ((uint32_t)p[1] << 16) +
((uint32_t)p[2] << 8) + ((uint32_t)p[3] << 0));
}
-static inline void
+static void
encode_uint32(uint32_t val, unsigned char *p) {
p[0] = (uint8_t)(val >> 24);
p[1] = (uint8_t)(val >> 16);
*targetp = source;
}
-static inline void
+static void
destroy(dns_kasp_t *kasp) {
dns_kasp_key_t *key;
dns_kasp_key_t *key_next;
lookup_find(lookup, fevent);
}
-static inline isc_result_t
+static isc_result_t
start_fetch(dns_lookup_t *lookup) {
isc_result_t result;
static dns_name_t const ip6_arpa = DNS_NAME_INITABSOLUTE(ip6_arpa_data,
ip6_arpa_offsets);
-static inline bool
+static bool
dns_master_isprimary(dns_loadctx_t *lctx) {
return ((lctx->options & DNS_MASTER_ZONE) != 0 &&
(lctx->options & DNS_MASTER_SECONDARY) == 0 &&
(lctx->options & DNS_MASTER_KEY) == 0);
}
-static inline isc_result_t
+static isc_result_t
gettoken(isc_lex_t *lex, unsigned int options, isc_token_t *token, bool eol,
dns_rdatacallbacks_t *callbacks) {
isc_result_t result;
* Fill/check exists buffer with 'len' bytes. Track remaining bytes to be
* read when incrementally filling the buffer.
*/
-static inline isc_result_t
+static isc_result_t
read_and_check(bool do_read, isc_buffer_t *buffer, size_t len, FILE *f,
uint32_t *totallen) {
isc_result_t result;
ISC_LINK(dns_msgblock_t) link;
}; /* dynamically sized */
-static inline dns_msgblock_t *
+static dns_msgblock_t *
msgblock_allocate(isc_mem_t *, unsigned int, unsigned int);
#define msgblock_get(block, type) \
((type *)msgblock_internalget(block, sizeof(type)))
-static inline void *
+static void *
msgblock_internalget(dns_msgblock_t *, unsigned int);
-static inline void
+static void
msgblock_reset(dns_msgblock_t *);
-static inline void
+static void
msgblock_free(isc_mem_t *, dns_msgblock_t *, unsigned int);
static void
* Allocate a new dns_msgblock_t, and return a pointer to it. If no memory
* is free, return NULL.
*/
-static inline dns_msgblock_t *
+static dns_msgblock_t *
msgblock_allocate(isc_mem_t *mctx, unsigned int sizeof_type,
unsigned int count) {
dns_msgblock_t *block;
* Return an element from the msgblock. If no more are available, return
* NULL.
*/
-static inline void *
+static void *
msgblock_internalget(dns_msgblock_t *block, unsigned int sizeof_type) {
void *ptr;
return (ptr);
}
-static inline void
+static void
msgblock_reset(dns_msgblock_t *block) {
block->remaining = block->count;
}
/*
* Release memory associated with a message block.
*/
-static inline void
+static void
msgblock_free(isc_mem_t *mctx, dns_msgblock_t *block,
unsigned int sizeof_type) {
unsigned int length;
* "current" buffer. (which is always the last on the list, for our
* uses)
*/
-static inline isc_result_t
+static isc_result_t
newbuffer(dns_message_t *msg, unsigned int size) {
isc_buffer_t *dynbuf;
return (ISC_R_SUCCESS);
}
-static inline isc_buffer_t *
+static isc_buffer_t *
currentbuffer(dns_message_t *msg) {
isc_buffer_t *dynbuf;
return (dynbuf);
}
-static inline void
+static void
releaserdata(dns_message_t *msg, dns_rdata_t *rdata) {
ISC_LIST_PREPEND(msg->freerdata, rdata, link);
}
-static inline dns_rdata_t *
+static dns_rdata_t *
newrdata(dns_message_t *msg) {
dns_msgblock_t *msgblock;
dns_rdata_t *rdata;
return (rdata);
}
-static inline void
+static void
releaserdatalist(dns_message_t *msg, dns_rdatalist_t *rdatalist) {
ISC_LIST_PREPEND(msg->freerdatalist, rdatalist, link);
}
-static inline dns_rdatalist_t *
+static dns_rdatalist_t *
newrdatalist(dns_message_t *msg) {
dns_msgblock_t *msgblock;
dns_rdatalist_t *rdatalist;
return (rdatalist);
}
-static inline dns_offsets_t *
+static dns_offsets_t *
newoffsets(dns_message_t *msg) {
dns_msgblock_t *msgblock;
dns_offsets_t *offsets;
return (offsets);
}
-static inline void
+static void
msginitheader(dns_message_t *m) {
m->id = 0;
m->flags = 0;
m->rdclass = 0;
}
-static inline void
+static void
msginitprivate(dns_message_t *m) {
unsigned int i;
m->buffer = NULL;
}
-static inline void
+static void
msginittsig(dns_message_t *m) {
m->tsigstatus = dns_rcode_noerror;
m->querytsigstatus = dns_rcode_noerror;
* Init elements to default state. Used both when allocating a new element
* and when resetting one.
*/
-static inline void
+static void
msginit(dns_message_t *m) {
msginitheader(m);
msginitprivate(m);
m->indent.count = 0;
}
-static inline void
+static void
msgresetnames(dns_message_t *msg, unsigned int first_section) {
unsigned int i;
dns_name_t *name, *next_name;
return (ISC_R_SUCCESS);
}
-static inline bool
+static bool
wrong_priority(dns_rdataset_t *rds, int pass, dns_rdatatype_t preferred_glue) {
int pass_needed;
dns_ttl_t maxttl, bool optout, bool secure,
dns_rdataset_t *addedrdataset);
-static inline isc_result_t
+static isc_result_t
copy_rdataset(dns_rdataset_t *rdataset, isc_buffer_t *buffer) {
isc_result_t result;
unsigned int count;
return (ISC_R_SUCCESS);
}
-static inline bool
+static bool
match(const dns_name_t *name1, const dns_name_t *name2) {
if (dns_name_iswildcard(name2)) {
return (dns_name_matcheswildcard(name1, name2));
#define HASHSIZE(bits) (UINT64_C(1) << (bits))
-static inline uint32_t
+static uint32_t
hash_32(uint32_t val, unsigned int bits) {
REQUIRE(bits <= RBT_HASH_MAX_BITS);
/* High bits are more random. */
* path of the tree traversal code.
*/
-static inline void
+static void
NODENAME(dns_rbtnode_t *node, dns_name_t *name) {
name->length = NAMELEN(node);
name->labels = OFFSETLEN(node);
}
#ifdef DEBUG
-#define inline
/*
* A little something to help out in GDB.
*/
* Upper node is the parent of the root of the passed node's
* subtree. The passed node must not be NULL.
*/
-static inline dns_rbtnode_t *
+static dns_rbtnode_t *
get_upper_node(dns_rbtnode_t *node) {
return (UPPERNODE(node));
}
static isc_result_t
create_node(isc_mem_t *mctx, const dns_name_t *name, dns_rbtnode_t **nodep);
-static inline void
+static void
hashtable_new(dns_rbt_t *rbt, uint8_t index, uint8_t bits);
-static inline void
+static void
hashtable_free(dns_rbt_t *rbt, uint8_t index);
-static inline void
+static void
hash_node(dns_rbt_t *rbt, dns_rbtnode_t *node, const dns_name_t *name);
-static inline void
+static void
unhash_node(dns_rbt_t *rbt, dns_rbtnode_t *node);
static uint32_t
hashtable_rehash_one(dns_rbt_t *rbt);
static void
maybe_rehash(dns_rbt_t *rbt, size_t size);
-static inline bool
+static bool
rehashing_in_progress(dns_rbt_t *rbt);
#define TRY_NEXTTABLE(hindex, rbt) \
(hindex == rbt->hindex && rehashing_in_progress(rbt))
-static inline void
+static void
rotate_left(dns_rbtnode_t *node, dns_rbtnode_t **rootp);
-static inline void
+static void
rotate_right(dns_rbtnode_t *node, dns_rbtnode_t **rootp);
static void
return (1 << hashbits);
}
-static inline isc_result_t
+static isc_result_t
chain_name(dns_rbtnodechain_t *chain, dns_name_t *name,
bool include_chain_end) {
dns_name_t nodename;
return (result);
}
-static inline isc_result_t
+static isc_result_t
move_chain_to_last(dns_rbtnodechain_t *chain, dns_rbtnode_t *node) {
do {
/*
/*
* Add a node to the hash table
*/
-static inline void
+static void
hash_add_node(dns_rbt_t *rbt, dns_rbtnode_t *node, const dns_name_t *name) {
uint32_t hash;
/*
* Initialize hash table
*/
-static inline void
+static void
hashtable_new(dns_rbt_t *rbt, uint8_t index, uint8_t bits) {
size_t size;
memset(rbt->hashtable[index], 0, size);
}
-static inline void
+static void
hashtable_free(dns_rbt_t *rbt, uint8_t index) {
size_t size = HASHSIZE(rbt->hashbits[index]) * sizeof(dns_rbtnode_t *);
isc_mem_put(rbt->mctx, rbt->hashtable[index], size);
}
}
-static inline bool
+static bool
rehashing_in_progress(dns_rbt_t *rbt) {
return (rbt->hashtable[RBT_HASH_NEXTTABLE(rbt->hindex)] != NULL);
}
-static inline bool
+static bool
hashtable_is_overcommited(dns_rbt_t *rbt) {
return (rbt->nodecount >=
(HASHSIZE(rbt->hashbits[rbt->hindex]) * RBT_HASH_OVERCOMMIT));
* Add a node to the hash table. Rehash the hashtable if the node count
* rises above a critical level.
*/
-static inline void
+static void
hash_node(dns_rbt_t *rbt, dns_rbtnode_t *node, const dns_name_t *name) {
REQUIRE(DNS_RBTNODE_VALID(node));
/*
* Remove a node from the hash table
*/
-static inline void
+static void
unhash_node(dns_rbt_t *rbt, dns_rbtnode_t *dnode) {
uint32_t hash;
uint8_t hindex = rbt->hindex;
UNREACHABLE();
}
-static inline void
+static void
rotate_left(dns_rbtnode_t *node, dns_rbtnode_t **rootp) {
dns_rbtnode_t *child;
PARENT(node) = child;
}
-static inline void
+static void
rotate_right(dns_rbtnode_t *node, dns_rbtnode_t **rootp) {
dns_rbtnode_t *child;
/*! \file */
-/* #define inline */
-
#include <ctype.h>
#include <inttypes.h>
#include <stdbool.h>
#define GOLDEN_RATIO_32 0x61C88647
#define HASHSIZE(bits) (UINT64_C(1) << (bits))
-static inline uint32_t
+static uint32_t
hash_32(uint32_t val, unsigned int bits) {
REQUIRE(bits <= RBTDB_GLUE_TABLE_MAX_BITS);
/* High bits are more random. */
static isc_result_t
rdataset_getclosest(dns_rdataset_t *rdataset, dns_name_t *name,
dns_rdataset_t *neg, dns_rdataset_t *negsig);
-static inline bool
+static bool
need_headerupdate(rdatasetheader_t *header, isc_stdtime_t now);
static void
update_header(dns_rbtdb_t *rbtdb, rdatasetheader_t *header, isc_stdtime_t now);
isc_mem_putanddetach(&rbtdb->common.mctx, rbtdb, sizeof(*rbtdb));
}
-static inline void
+static void
maybe_free_rbtdb(dns_rbtdb_t *rbtdb) {
bool want_free = false;
unsigned int i;
*versionp = (dns_dbversion_t *)version;
}
-static inline rbtdb_version_t *
+static rbtdb_version_t *
allocate_version(isc_mem_t *mctx, rbtdb_serial_t serial,
unsigned int references, bool writer) {
rbtdb_version_t *version;
return (changed);
}
-static inline void
+static void
free_noqname(isc_mem_t *mctx, struct noqname **noqname) {
if (dns_name_dynamic(&(*noqname)->name)) {
dns_name_free(&(*noqname)->name, mctx);
*noqname = NULL;
}
-static inline void
+static void
init_rdataset(dns_rbtdb_t *rbtdb, rdatasetheader_t *h) {
ISC_LINK_INIT(h, link);
h->heap_index = 0;
}
}
-static inline rdatasetheader_t *
+static rdatasetheader_t *
new_rdataset(dns_rbtdb_t *rbtdb, isc_mem_t *mctx) {
rdatasetheader_t *h;
return (h);
}
-static inline void
+static void
free_rdataset(dns_rbtdb_t *rbtdb, isc_mem_t *mctx, rdatasetheader_t *rdataset) {
unsigned int size;
int idx;
isc_mem_put(mctx, rdataset, size);
}
-static inline void
+static void
rollback_node(dns_rbtnode_t *node, rbtdb_serial_t serial) {
rdatasetheader_t *header, *dcurrent;
bool make_dirty = false;
}
}
-static inline void
+static void
mark_header_ancient(dns_rbtdb_t *rbtdb, rdatasetheader_t *header) {
uint_least16_t attributes = atomic_load_acquire(&header->attributes);
uint_least16_t newattributes = 0;
update_rrsetstats(rbtdb, header->type, newattributes, true);
}
-static inline void
+static void
mark_header_stale(dns_rbtdb_t *rbtdb, rdatasetheader_t *header) {
uint_least16_t attributes = atomic_load_acquire(&header->attributes);
uint_least16_t newattributes = 0;
update_rrsetstats(rbtdb, header->type, newattributes, true);
}
-static inline void
+static void
clean_stale_headers(dns_rbtdb_t *rbtdb, isc_mem_t *mctx,
rdatasetheader_t *top) {
rdatasetheader_t *d, *down_next;
top->down = NULL;
}
-static inline void
+static void
clean_cache_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node) {
rdatasetheader_t *current, *top_prev, *top_next;
isc_mem_t *mctx = rbtdb->common.mctx;
node->dirty = 0;
}
-static inline void
+static void
clean_zone_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node,
rbtdb_serial_t least_serial) {
rdatasetheader_t *current, *dcurrent, *down_next, *dparent;
/*
* Caller must be holding the node lock.
*/
-static inline void
+static void
new_reference(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node,
isc_rwlocktype_t locktype) {
if (locktype == isc_rwlocktype_write && ISC_LINK_LINKED(node, deadlink))
/*%
* The tree lock must be held for the result to be valid.
*/
-static inline bool
+static bool
is_leaf(dns_rbtnode_t *node) {
return (node->parent != NULL && node->parent->down == node &&
node->left == NULL && node->right == NULL);
}
-static inline void
+static void
send_to_prune_tree(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node,
isc_rwlocktype_t locktype) {
isc_event_t *ev;
* few cases where the node can be in the deadnode list (only empty nodes can
* have been added to the list).
*/
-static inline void
+static void
reactivate_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node,
isc_rwlocktype_t treelocktype) {
isc_rwlocktype_t locktype = isc_rwlocktype_read;
detach((dns_db_t **)&rbtdb);
}
-static inline void
+static void
make_least_version(dns_rbtdb_t *rbtdb, rbtdb_version_t *version,
rbtdb_changedlist_t *cleanup_list) {
/*
ISC_LIST_INIT(version->changed_list);
}
-static inline void
+static void
cleanup_nondirty(rbtdb_version_t *version, rbtdb_changedlist_t *cleanup_list) {
rbtdb_changed_t *changed, *next_changed;
return (result);
}
-static inline void
+static void
bind_rdataset(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, rdatasetheader_t *header,
isc_stdtime_t now, isc_rwlocktype_t locktype,
dns_rdataset_t *rdataset) {
}
}
-static inline isc_result_t
+static isc_result_t
setup_delegation(rbtdb_search_t *search, dns_dbnode_t **nodep,
dns_name_t *foundname, dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset) {
return (DNS_R_DELEGATION);
}
-static inline bool
+static bool
valid_glue(rbtdb_search_t *search, dns_name_t *name, rbtdb_rdatatype_t type,
dns_rbtnode_t *node) {
unsigned char *raw; /* RDATASLAB */
return (valid);
}
-static inline bool
+static bool
activeempty(rbtdb_search_t *search, dns_rbtnodechain_t *chain,
const dns_name_t *name) {
dns_fixedname_t fnext;
return (answer);
}
-static inline bool
+static bool
activeemptynode(rbtdb_search_t *search, const dns_name_t *qname,
dns_name_t *wname) {
dns_fixedname_t fnext;
return (answer);
}
-static inline isc_result_t
+static isc_result_t
find_wildcard(rbtdb_search_t *search, dns_rbtnode_t **nodep,
const dns_name_t *qname) {
unsigned int i, j;
/*
* Find node of the NSEC/NSEC3 record that is 'name'.
*/
-static inline isc_result_t
+static 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,
* search chain. For NSEC3 records only NSEC3 records that match the
* current NSEC3PARAM record are considered.
*/
-static inline isc_result_t
+static isc_result_t
find_closest_nsec(rbtdb_search_t *search, dns_dbnode_t **nodep,
dns_name_t *foundname, dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset, dns_rbt_t *tree,
return (result);
}
-static inline isc_result_t
+static isc_result_t
find_deepest_zonecut(rbtdb_search_t *search, dns_rbtnode_t *node,
dns_dbnode_t **nodep, dns_name_t *foundname,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) {
}
}
-static inline uint64_t
+static uint64_t
recordsize(rdatasetheader_t *header, unsigned int namelen) {
return (dns_rdataslab_rdatasize((unsigned char *)header,
sizeof(*header)) +
return (ISC_R_SUCCESS);
}
-static inline bool
+static bool
delegating_type(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node,
rbtdb_rdatatype_t type) {
if (IS_CACHE(rbtdb)) {
return (false);
}
-static inline isc_result_t
+static isc_result_t
addnoqname(dns_rbtdb_t *rbtdb, rdatasetheader_t *newheader,
dns_rdataset_t *rdataset) {
struct noqname *noqname;
return (result);
}
-static inline isc_result_t
+static isc_result_t
addclosest(dns_rbtdb_t *rbtdb, rdatasetheader_t *newheader,
dns_rdataset_t *rdataset) {
struct noqname *closest;
* Database Iterator Methods
*/
-static inline void
+static void
reference_iter_node(rbtdb_dbiterator_t *rbtdbiter) {
dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)rbtdbiter->common.db;
dns_rbtnode_t *node = rbtdbiter->node;
reactivate_node(rbtdb, node, rbtdbiter->tree_locked);
}
-static inline void
+static void
dereference_iter_node(rbtdb_dbiterator_t *rbtdbiter) {
dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)rbtdbiter->common.db;
dns_rbtnode_t *node = rbtdbiter->node;
}
}
-static inline void
+static void
resume_iteration(rbtdb_dbiterator_t *rbtdbiter) {
dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)rbtdbiter->common.db;
*
* Caller must hold the node (read or write) lock.
*/
-static inline bool
+static bool
need_headerupdate(rdatasetheader_t *header, isc_stdtime_t now) {
if (RDATASET_ATTR_GET(header, (RDATASET_ATTR_NONEXISTENT |
RDATASET_ATTR_ANCIENT |
unknown_totext(dns_rdata_t *rdata, dns_rdata_textctx_t *tctx,
isc_buffer_t *target);
-static inline isc_result_t generic_fromtext_key(ARGS_FROMTEXT);
+static isc_result_t generic_fromtext_key(ARGS_FROMTEXT);
-static inline isc_result_t generic_totext_key(ARGS_TOTEXT);
+static isc_result_t generic_totext_key(ARGS_TOTEXT);
-static inline isc_result_t generic_fromwire_key(ARGS_FROMWIRE);
+static isc_result_t generic_fromwire_key(ARGS_FROMWIRE);
-static inline isc_result_t generic_fromstruct_key(ARGS_FROMSTRUCT);
+static isc_result_t generic_fromstruct_key(ARGS_FROMSTRUCT);
-static inline isc_result_t generic_tostruct_key(ARGS_TOSTRUCT);
+static isc_result_t generic_tostruct_key(ARGS_TOSTRUCT);
-static inline void generic_freestruct_key(ARGS_FREESTRUCT);
+static void generic_freestruct_key(ARGS_FREESTRUCT);
static isc_result_t generic_fromtext_txt(ARGS_FROMTEXT);
* \note
* (1) does not touch `dst' unless it's returning 1.
*/
-static inline int
+static int
locator_pton(const char *src, unsigned char *dst) {
static const char xdigits_l[] = "0123456789abcdef",
xdigits_u[] = "0123456789ABCDEF";
return (1);
}
-static inline void
+static void
name_duporclone(const dns_name_t *source, isc_mem_t *mctx, dns_name_t *target) {
if (mctx != NULL) {
dns_name_dup(source, mctx, target);
}
}
-static inline void *
+static void *
mem_maybedup(isc_mem_t *mctx, void *source, size_t length) {
void *copy = NULL;
return (copy);
}
-static inline isc_result_t
+static isc_result_t
typemap_fromtext(isc_lex_t *lexer, isc_buffer_t *target, bool allow_empty) {
isc_token_t token;
unsigned char bm[8 * 1024]; /* 64k bits */
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
typemap_totext(isc_region_t *sr, dns_rdata_textctx_t *tctx,
isc_buffer_t *target) {
unsigned int i, j, k;
#define RRTYPE_TSIG_ATTRIBUTES \
(DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_NOTQUESTION)
-static inline isc_result_t
+static isc_result_t
fromtext_any_tsig(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
return (isc_base64_tobuffer(lexer, target, (int)token.value.as_ulong));
}
-static inline isc_result_t
+static isc_result_t
totext_any_tsig(ARGS_TOTEXT) {
isc_region_t sr;
isc_region_t sigr;
}
}
-static inline isc_result_t
+static isc_result_t
fromwire_any_tsig(ARGS_FROMWIRE) {
isc_region_t sr;
dns_name_t name;
return (mem_tobuffer(target, sr.base, n + 2));
}
-static inline isc_result_t
+static isc_result_t
towire_any_tsig(ARGS_TOWIRE) {
isc_region_t sr;
dns_name_t name;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline int
+static int
compare_any_tsig(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_any_tsig(ARGS_FROMSTRUCT) {
dns_rdata_any_tsig_t *tsig = source;
isc_region_t tr;
return (mem_tobuffer(target, tsig->other, tsig->otherlen));
}
-static inline isc_result_t
+static isc_result_t
tostruct_any_tsig(ARGS_TOSTRUCT) {
dns_rdata_any_tsig_t *tsig;
dns_name_t alg;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_any_tsig(ARGS_FREESTRUCT) {
dns_rdata_any_tsig_t *tsig = (dns_rdata_any_tsig_t *)source;
tsig->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_any_tsig(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_tsig);
REQUIRE(rdata->rdclass == dns_rdataclass_any);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_any_tsig(ARGS_DIGEST) {
REQUIRE(rdata->type == dns_rdatatype_tsig);
REQUIRE(rdata->rdclass == dns_rdataclass_any);
return (ISC_R_NOTIMPLEMENTED);
}
-static inline bool
+static bool
checkowner_any_tsig(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_tsig);
REQUIRE(rdclass == dns_rdataclass_any);
return (true);
}
-static inline bool
+static bool
checknames_any_tsig(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_tsig);
REQUIRE(rdata->rdclass == dns_rdataclass_any);
return (true);
}
-static inline int
+static int
casecompare_any_tsig(ARGS_COMPARE) {
return (compare_any_tsig(rdata1, rdata2));
}
#define RRTYPE_A_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_ch_a(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
return (uint16_tobuffer(token.value.as_ulong, target));
}
-static inline isc_result_t
+static isc_result_t
totext_ch_a(ARGS_TOTEXT) {
isc_region_t region;
dns_name_t name;
return (str_totext(buf, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_ch_a(ARGS_FROMWIRE) {
isc_region_t sregion;
isc_region_t tregion;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
towire_ch_a(ARGS_TOWIRE) {
dns_name_t name;
dns_offsets_t offsets;
return (ISC_R_SUCCESS);
}
-static inline int
+static int
compare_ch_a(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
return (order);
}
-static inline isc_result_t
+static isc_result_t
fromstruct_ch_a(ARGS_FROMSTRUCT) {
dns_rdata_ch_a_t *a = source;
isc_region_t region;
return (uint16_tobuffer(ntohs(a->ch_addr), target));
}
-static inline isc_result_t
+static isc_result_t
tostruct_ch_a(ARGS_TOSTRUCT) {
dns_rdata_ch_a_t *a = target;
isc_region_t region;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_ch_a(ARGS_FREESTRUCT) {
dns_rdata_ch_a_t *a = source;
a->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_ch_a(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_a);
REQUIRE(rdata->rdclass == dns_rdataclass_ch);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_ch_a(ARGS_DIGEST) {
isc_region_t r;
dns_name_t name;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_ch_a(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_a);
REQUIRE(rdclass == dns_rdataclass_ch);
return (dns_name_ishostname(name, wildcard));
}
-static inline bool
+static bool
checknames_ch_a(ARGS_CHECKNAMES) {
isc_region_t region;
dns_name_t name;
return (true);
}
-static inline int
+static int
casecompare_ch_a(ARGS_COMPARE) {
return (compare_ch_a(rdata1, rdata2));
}
#define RRTYPE_AFSDB_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_afsdb(ARGS_FROMTEXT) {
isc_token_t token;
isc_buffer_t buffer;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_afsdb(ARGS_TOTEXT) {
dns_name_t name;
dns_name_t prefix;
return (dns_name_totext(&prefix, sub, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_afsdb(ARGS_FROMWIRE) {
dns_name_t name;
isc_region_t sr;
return (dns_name_fromwire(&name, source, dctx, options, target));
}
-static inline isc_result_t
+static isc_result_t
towire_afsdb(ARGS_TOWIRE) {
isc_region_t tr;
isc_region_t sr;
return (dns_name_towire(&name, cctx, target));
}
-static inline int
+static int
compare_afsdb(ARGS_COMPARE) {
int result;
dns_name_t name1;
return (dns_name_rdatacompare(&name1, &name2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_afsdb(ARGS_FROMSTRUCT) {
dns_rdata_afsdb_t *afsdb = source;
isc_region_t region;
return (isc_buffer_copyregion(target, ®ion));
}
-static inline isc_result_t
+static isc_result_t
tostruct_afsdb(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_afsdb_t *afsdb = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_afsdb(ARGS_FREESTRUCT) {
dns_rdata_afsdb_t *afsdb = source;
afsdb->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_afsdb(ARGS_ADDLDATA) {
dns_name_t name;
dns_offsets_t offsets;
return ((add)(arg, &name, dns_rdatatype_a, NULL));
}
-static inline isc_result_t
+static isc_result_t
digest_afsdb(ARGS_DIGEST) {
isc_region_t r1, r2;
dns_name_t name;
return (dns_name_digest(&name, digest, arg));
}
-static inline bool
+static bool
checkowner_afsdb(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_afsdb);
return (true);
}
-static inline bool
+static bool
checknames_afsdb(ARGS_CHECKNAMES) {
isc_region_t region;
dns_name_t name;
return (true);
}
-static inline int
+static int
casecompare_afsdb(ARGS_COMPARE) {
return (compare_afsdb(rdata1, rdata2));
}
#define RRTYPE_AMTRELAY_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_amtrelay(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
}
}
-static inline isc_result_t
+static isc_result_t
totext_amtrelay(ARGS_TOTEXT) {
isc_region_t region;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_amtrelay(ARGS_FROMWIRE) {
dns_name_t name;
isc_region_t region;
}
}
-static inline isc_result_t
+static isc_result_t
towire_amtrelay(ARGS_TOWIRE) {
isc_region_t region;
return (mem_tobuffer(target, region.base, region.length));
}
-static inline int
+static int
compare_amtrelay(ARGS_COMPARE) {
isc_region_t region1;
isc_region_t region2;
return (isc_region_compare(®ion1, ®ion2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_amtrelay(ARGS_FROMSTRUCT) {
dns_rdata_amtrelay_t *amtrelay = source;
isc_region_t region;
}
}
-static inline isc_result_t
+static isc_result_t
tostruct_amtrelay(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_amtrelay_t *amtrelay = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_amtrelay(ARGS_FREESTRUCT) {
dns_rdata_amtrelay_t *amtrelay = source;
amtrelay->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_amtrelay(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_amtrelay);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_amtrelay(ARGS_DIGEST) {
isc_region_t region;
return ((digest)(arg, ®ion));
}
-static inline bool
+static bool
checkowner_amtrelay(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_amtrelay);
return (true);
}
-static inline bool
+static bool
checknames_amtrelay(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_amtrelay);
return (true);
}
-static inline int
+static int
casecompare_amtrelay(ARGS_COMPARE) {
isc_region_t region1;
isc_region_t region2;
#define RRTYPE_AVC_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_avc(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_avc);
return (generic_fromtext_txt(CALL_FROMTEXT));
}
-static inline isc_result_t
+static isc_result_t
totext_avc(ARGS_TOTEXT) {
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_avc);
return (generic_totext_txt(CALL_TOTEXT));
}
-static inline isc_result_t
+static isc_result_t
fromwire_avc(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_avc);
return (generic_fromwire_txt(CALL_FROMWIRE));
}
-static inline isc_result_t
+static isc_result_t
towire_avc(ARGS_TOWIRE) {
REQUIRE(rdata->type == dns_rdatatype_avc);
return (mem_tobuffer(target, rdata->data, rdata->length));
}
-static inline int
+static int
compare_avc(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_avc(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_avc);
return (generic_fromstruct_txt(CALL_FROMSTRUCT));
}
-static inline isc_result_t
+static isc_result_t
tostruct_avc(ARGS_TOSTRUCT) {
dns_rdata_avc_t *avc = target;
return (generic_tostruct_txt(CALL_TOSTRUCT));
}
-static inline void
+static void
freestruct_avc(ARGS_FREESTRUCT) {
dns_rdata_avc_t *avc = source;
generic_freestruct_txt(source);
}
-static inline isc_result_t
+static isc_result_t
additionaldata_avc(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_avc);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_avc(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_avc(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_avc);
return (true);
}
-static inline bool
+static bool
checknames_avc(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_avc);
return (true);
}
-static inline int
+static int
casecompare_avc(ARGS_COMPARE) {
return (compare_avc(rdata1, rdata2));
}
0,
};
-static inline isc_result_t
+static isc_result_t
fromtext_caa(ARGS_FROMTEXT) {
isc_token_t token;
isc_textregion_t tr;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_caa(ARGS_TOTEXT) {
isc_region_t region;
uint8_t flags;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_caa(ARGS_FROMWIRE) {
isc_region_t sr;
unsigned int len, i;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline isc_result_t
+static isc_result_t
towire_caa(ARGS_TOWIRE) {
isc_region_t region;
return (mem_tobuffer(target, region.base, region.length));
}
-static inline int
+static int
compare_caa(ARGS_COMPARE) {
isc_region_t r1, r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_caa(ARGS_FROMSTRUCT) {
dns_rdata_caa_t *caa = source;
isc_region_t region;
return (isc_buffer_copyregion(target, ®ion));
}
-static inline isc_result_t
+static isc_result_t
tostruct_caa(ARGS_TOSTRUCT) {
dns_rdata_caa_t *caa = target;
isc_region_t sr;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_caa(ARGS_FREESTRUCT) {
dns_rdata_caa_t *caa = (dns_rdata_caa_t *)source;
caa->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_caa(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_caa);
REQUIRE(rdata->data != NULL);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_caa(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_caa(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_caa);
return (true);
}
-static inline bool
+static bool
checknames_caa(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_caa);
REQUIRE(rdata->data != NULL);
return (true);
}
-static inline int
+static int
casecompare_caa(ARGS_COMPARE) {
return (compare_caa(rdata1, rdata2));
}
#define RRTYPE_CDNSKEY_ATTRIBUTES 0
-static inline isc_result_t
+static isc_result_t
fromtext_cdnskey(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_cdnskey);
return (generic_fromtext_key(CALL_FROMTEXT));
}
-static inline isc_result_t
+static isc_result_t
totext_cdnskey(ARGS_TOTEXT) {
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_cdnskey);
return (generic_totext_key(CALL_TOTEXT));
}
-static inline isc_result_t
+static isc_result_t
fromwire_cdnskey(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_cdnskey);
return (generic_fromwire_key(CALL_FROMWIRE));
}
-static inline isc_result_t
+static isc_result_t
towire_cdnskey(ARGS_TOWIRE) {
isc_region_t sr;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline int
+static int
compare_cdnskey(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_cdnskey(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_cdnskey);
return (generic_fromstruct_key(CALL_FROMSTRUCT));
}
-static inline isc_result_t
+static isc_result_t
tostruct_cdnskey(ARGS_TOSTRUCT) {
dns_rdata_cdnskey_t *dnskey = target;
return (generic_tostruct_key(CALL_TOSTRUCT));
}
-static inline void
+static void
freestruct_cdnskey(ARGS_FREESTRUCT) {
dns_rdata_cdnskey_t *dnskey = (dns_rdata_cdnskey_t *)source;
generic_freestruct_key(source);
}
-static inline isc_result_t
+static isc_result_t
additionaldata_cdnskey(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_cdnskey);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_cdnskey(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_cdnskey(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_cdnskey);
return (true);
}
-static inline bool
+static bool
checknames_cdnskey(ARGS_CHECKNAMES) {
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_cdnskey);
return (true);
}
-static inline int
+static int
casecompare_cdnskey(ARGS_COMPARE) {
/*
* Treat ALG 253 (private DNS) subtype name case sensitively.
#include <dns/ds.h>
-static inline isc_result_t
+static isc_result_t
fromtext_cds(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_cds);
return (generic_fromtext_ds(CALL_FROMTEXT));
}
-static inline isc_result_t
+static isc_result_t
totext_cds(ARGS_TOTEXT) {
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_cds);
return (generic_totext_ds(CALL_TOTEXT));
}
-static inline isc_result_t
+static isc_result_t
fromwire_cds(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_cds);
return (generic_fromwire_ds(CALL_FROMWIRE));
}
-static inline isc_result_t
+static isc_result_t
towire_cds(ARGS_TOWIRE) {
isc_region_t sr;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline int
+static int
compare_cds(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_cds(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_cds);
return (generic_fromstruct_ds(CALL_FROMSTRUCT));
}
-static inline isc_result_t
+static isc_result_t
tostruct_cds(ARGS_TOSTRUCT) {
dns_rdata_cds_t *cds = target;
return (generic_tostruct_ds(CALL_TOSTRUCT));
}
-static inline void
+static void
freestruct_cds(ARGS_FREESTRUCT) {
dns_rdata_cds_t *cds = source;
cds->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_cds(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_cds);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_cds(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_cds(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_cds);
return (true);
}
-static inline bool
+static bool
checknames_cds(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_cds);
return (true);
}
-static inline int
+static int
casecompare_cds(ARGS_COMPARE) {
return (compare_cds(rdata1, rdata2));
}
#define RRTYPE_CERT_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_cert(ARGS_FROMTEXT) {
isc_token_t token;
dns_secalg_t secalg;
return (isc_base64_tobuffer(lexer, target, -2));
}
-static inline isc_result_t
+static isc_result_t
totext_cert(ARGS_TOTEXT) {
isc_region_t sr;
char buf[sizeof("64000 ")];
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_cert(ARGS_FROMWIRE) {
isc_region_t sr;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline isc_result_t
+static isc_result_t
towire_cert(ARGS_TOWIRE) {
isc_region_t sr;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline int
+static int
compare_cert(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_cert(ARGS_FROMSTRUCT) {
dns_rdata_cert_t *cert = source;
return (mem_tobuffer(target, cert->certificate, cert->length));
}
-static inline isc_result_t
+static isc_result_t
tostruct_cert(ARGS_TOSTRUCT) {
dns_rdata_cert_t *cert = target;
isc_region_t region;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_cert(ARGS_FREESTRUCT) {
dns_rdata_cert_t *cert = source;
cert->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_cert(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_cert);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_cert(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_cert(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_cert);
return (true);
}
-static inline bool
+static bool
checknames_cert(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_cert);
return (true);
}
-static inline int
+static int
casecompare_cert(ARGS_COMPARE) {
return (compare_cert(rdata1, rdata2));
}
#define RRTYPE_CNAME_ATTRIBUTES \
(DNS_RDATATYPEATTR_EXCLUSIVE | DNS_RDATATYPEATTR_SINGLETON)
-static inline isc_result_t
+static isc_result_t
fromtext_cname(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_cname(ARGS_TOTEXT) {
isc_region_t region;
dns_name_t name;
return (dns_name_totext(&prefix, sub, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_cname(ARGS_FROMWIRE) {
dns_name_t name;
return (dns_name_fromwire(&name, source, dctx, options, target));
}
-static inline isc_result_t
+static isc_result_t
towire_cname(ARGS_TOWIRE) {
dns_name_t name;
dns_offsets_t offsets;
return (dns_name_towire(&name, cctx, target));
}
-static inline int
+static int
compare_cname(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
return (dns_name_rdatacompare(&name1, &name2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_cname(ARGS_FROMSTRUCT) {
dns_rdata_cname_t *cname = source;
isc_region_t region;
return (isc_buffer_copyregion(target, ®ion));
}
-static inline isc_result_t
+static isc_result_t
tostruct_cname(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_cname_t *cname = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_cname(ARGS_FREESTRUCT) {
dns_rdata_cname_t *cname = source;
cname->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_cname(ARGS_ADDLDATA) {
UNUSED(rdata);
UNUSED(owner);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_cname(ARGS_DIGEST) {
isc_region_t r;
dns_name_t name;
return (dns_name_digest(&name, digest, arg));
}
-static inline bool
+static bool
checkowner_cname(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_cname);
return (true);
}
-static inline bool
+static bool
checknames_cname(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_cname);
return (true);
}
-static inline int
+static int
casecompare_cname(ARGS_COMPARE) {
return (compare_cname(rdata1, rdata2));
}
#define RRTYPE_CSYNC_ATTRIBUTES 0
-static inline isc_result_t
+static isc_result_t
fromtext_csync(ARGS_FROMTEXT) {
isc_token_t token;
return (typemap_fromtext(lexer, target, true));
}
-static inline isc_result_t
+static isc_result_t
totext_csync(ARGS_TOTEXT) {
unsigned long num;
char buf[sizeof("0123456789")]; /* Also TYPE65535 */
return (typemap_totext(&sr, NULL, target));
}
-static /* inline */ isc_result_t
+static isc_result_t
fromwire_csync(ARGS_FROMWIRE) {
isc_region_t sr;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
towire_csync(ARGS_TOWIRE) {
REQUIRE(rdata->type == dns_rdatatype_csync);
REQUIRE(rdata->length >= 6);
return (mem_tobuffer(target, rdata->data, rdata->length));
}
-static inline int
+static int
compare_csync(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_csync(ARGS_FROMSTRUCT) {
dns_rdata_csync_t *csync = source;
isc_region_t region;
return (mem_tobuffer(target, csync->typebits, csync->len));
}
-static inline isc_result_t
+static isc_result_t
tostruct_csync(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_csync_t *csync = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_csync(ARGS_FREESTRUCT) {
dns_rdata_csync_t *csync = source;
csync->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_csync(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_csync);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_csync(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_csync(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_csync);
return (true);
}
-static inline bool
+static bool
checknames_csync(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_csync);
return (true);
}
-static inline int
+static int
casecompare_csync(ARGS_COMPARE) {
isc_region_t region1;
isc_region_t region2;
#include <dns/ds.h>
-static inline isc_result_t
+static isc_result_t
fromtext_dlv(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_dlv);
return (generic_fromtext_ds(CALL_FROMTEXT));
}
-static inline isc_result_t
+static isc_result_t
totext_dlv(ARGS_TOTEXT) {
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_dlv);
return (generic_totext_ds(CALL_TOTEXT));
}
-static inline isc_result_t
+static isc_result_t
fromwire_dlv(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_dlv);
return (generic_fromwire_ds(CALL_FROMWIRE));
}
-static inline isc_result_t
+static isc_result_t
towire_dlv(ARGS_TOWIRE) {
isc_region_t sr;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline int
+static int
compare_dlv(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_dlv(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_dlv);
return (generic_fromstruct_ds(CALL_FROMSTRUCT));
}
-static inline isc_result_t
+static isc_result_t
tostruct_dlv(ARGS_TOSTRUCT) {
dns_rdata_dlv_t *dlv = target;
return (generic_tostruct_ds(CALL_TOSTRUCT));
}
-static inline void
+static void
freestruct_dlv(ARGS_FREESTRUCT) {
dns_rdata_dlv_t *dlv = source;
dlv->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_dlv(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_dlv);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_dlv(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_dlv(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_dlv);
return (true);
}
-static inline bool
+static bool
checknames_dlv(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_dlv);
return (true);
}
-static inline int
+static int
casecompare_dlv(ARGS_COMPARE) {
return (compare_dlv(rdata1, rdata2));
}
#define RRTYPE_DNAME_ATTRIBUTES (DNS_RDATATYPEATTR_SINGLETON)
-static inline isc_result_t
+static isc_result_t
fromtext_dname(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_dname(ARGS_TOTEXT) {
isc_region_t region;
dns_name_t name;
return (dns_name_totext(&prefix, sub, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_dname(ARGS_FROMWIRE) {
dns_name_t name;
return (dns_name_fromwire(&name, source, dctx, options, target));
}
-static inline isc_result_t
+static isc_result_t
towire_dname(ARGS_TOWIRE) {
dns_name_t name;
dns_offsets_t offsets;
return (dns_name_towire(&name, cctx, target));
}
-static inline int
+static int
compare_dname(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
return (dns_name_rdatacompare(&name1, &name2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_dname(ARGS_FROMSTRUCT) {
dns_rdata_dname_t *dname = source;
isc_region_t region;
return (isc_buffer_copyregion(target, ®ion));
}
-static inline isc_result_t
+static isc_result_t
tostruct_dname(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_dname_t *dname = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_dname(ARGS_FREESTRUCT) {
dns_rdata_dname_t *dname = source;
dname->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_dname(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_dname);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_dname(ARGS_DIGEST) {
isc_region_t r;
dns_name_t name;
return (dns_name_digest(&name, digest, arg));
}
-static inline bool
+static bool
checkowner_dname(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_dname);
return (true);
}
-static inline bool
+static bool
checknames_dname(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_dname);
return (true);
}
-static inline int
+static int
casecompare_dname(ARGS_COMPARE) {
return (compare_dname(rdata1, rdata2));
}
#define RRTYPE_DNSKEY_ATTRIBUTES (DNS_RDATATYPEATTR_DNSSEC)
-static inline isc_result_t
+static isc_result_t
fromtext_dnskey(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_dnskey);
return (generic_fromtext_key(CALL_FROMTEXT));
}
-static inline isc_result_t
+static isc_result_t
totext_dnskey(ARGS_TOTEXT) {
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_dnskey);
return (generic_totext_key(CALL_TOTEXT));
}
-static inline isc_result_t
+static isc_result_t
fromwire_dnskey(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_dnskey);
return (generic_fromwire_key(CALL_FROMWIRE));
}
-static inline isc_result_t
+static isc_result_t
towire_dnskey(ARGS_TOWIRE) {
isc_region_t sr;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline int
+static int
compare_dnskey(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_dnskey(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_dnskey);
return (generic_fromstruct_key(CALL_FROMSTRUCT));
}
-static inline isc_result_t
+static isc_result_t
tostruct_dnskey(ARGS_TOSTRUCT) {
dns_rdata_dnskey_t *dnskey = target;
return (generic_tostruct_key(CALL_TOSTRUCT));
}
-static inline void
+static void
freestruct_dnskey(ARGS_FREESTRUCT) {
dns_rdata_dnskey_t *dnskey = (dns_rdata_dnskey_t *)source;
generic_freestruct_key(source);
}
-static inline isc_result_t
+static isc_result_t
additionaldata_dnskey(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_dnskey);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_dnskey(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_dnskey(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_dnskey);
return (true);
}
-static inline bool
+static bool
checknames_dnskey(ARGS_CHECKNAMES) {
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_dnskey);
return (true);
}
-static inline int
+static int
casecompare_dnskey(ARGS_COMPARE) {
/*
* Treat ALG 253 (private DNS) subtype name case sensitively.
#define RRTYPE_DOA_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_doa(ARGS_FROMTEXT) {
isc_token_t token;
}
}
-static inline isc_result_t
+static isc_result_t
totext_doa(ARGS_TOTEXT) {
char buf[sizeof("4294967295 ")];
isc_region_t region;
}
}
-static inline isc_result_t
+static isc_result_t
fromwire_doa(ARGS_FROMWIRE) {
isc_region_t region;
return (mem_tobuffer(target, region.base, region.length));
}
-static inline isc_result_t
+static isc_result_t
towire_doa(ARGS_TOWIRE) {
isc_region_t region;
return (mem_tobuffer(target, region.base, region.length));
}
-static inline int
+static int
compare_doa(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_doa(ARGS_FROMSTRUCT) {
dns_rdata_doa_t *doa = source;
return (mem_tobuffer(target, doa->data, doa->data_len));
}
-static inline isc_result_t
+static isc_result_t
tostruct_doa(ARGS_TOSTRUCT) {
dns_rdata_doa_t *doa = target;
isc_region_t region;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_doa(ARGS_FREESTRUCT) {
dns_rdata_doa_t *doa = source;
doa->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_doa(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_doa);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_doa(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_doa(ARGS_CHECKOWNER) {
UNUSED(name);
UNUSED(type);
return (true);
}
-static inline bool
+static bool
checknames_doa(ARGS_CHECKNAMES) {
UNUSED(rdata);
UNUSED(owner);
return (true);
}
-static inline int
+static int
casecompare_doa(ARGS_COMPARE) {
return (compare_doa(rdata1, rdata2));
}
#include <dns/ds.h>
-static inline isc_result_t
+static isc_result_t
generic_fromtext_ds(ARGS_FROMTEXT) {
isc_token_t token;
unsigned char c;
return (isc_hex_tobuffer(lexer, target, length));
}
-static inline isc_result_t
+static isc_result_t
fromtext_ds(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_ds);
return (generic_fromtext_ds(CALL_FROMTEXT));
}
-static inline isc_result_t
+static isc_result_t
generic_totext_ds(ARGS_TOTEXT) {
isc_region_t sr;
char buf[sizeof("64000 ")];
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_ds(ARGS_TOTEXT) {
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_ds);
return (generic_totext_ds(CALL_TOTEXT));
}
-static inline isc_result_t
+static isc_result_t
generic_fromwire_ds(ARGS_FROMWIRE) {
isc_region_t sr;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline isc_result_t
+static isc_result_t
fromwire_ds(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_ds);
return (generic_fromwire_ds(CALL_FROMWIRE));
}
-static inline isc_result_t
+static isc_result_t
towire_ds(ARGS_TOWIRE) {
isc_region_t sr;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline int
+static int
compare_ds(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
generic_fromstruct_ds(ARGS_FROMSTRUCT) {
dns_rdata_ds_t *ds = source;
return (mem_tobuffer(target, ds->digest, ds->length));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_ds(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_ds);
return (generic_fromstruct_ds(CALL_FROMSTRUCT));
}
-static inline isc_result_t
+static isc_result_t
generic_tostruct_ds(ARGS_TOSTRUCT) {
dns_rdata_ds_t *ds = target;
isc_region_t region;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
tostruct_ds(ARGS_TOSTRUCT) {
dns_rdata_ds_t *ds = target;
return (generic_tostruct_ds(CALL_TOSTRUCT));
}
-static inline void
+static void
freestruct_ds(ARGS_FREESTRUCT) {
dns_rdata_ds_t *ds = source;
ds->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_ds(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_ds);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_ds(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_ds(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_ds);
return (true);
}
-static inline bool
+static bool
checknames_ds(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_ds);
return (true);
}
-static inline int
+static int
casecompare_ds(ARGS_COMPARE) {
return (compare_ds(rdata1, rdata2));
}
#define RRTYPE_EUI48_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_eui48(ARGS_FROMTEXT) {
isc_token_t token;
unsigned char eui48[6];
return (mem_tobuffer(target, eui48, sizeof(eui48)));
}
-static inline isc_result_t
+static isc_result_t
totext_eui48(ARGS_TOTEXT) {
char buf[sizeof("xx-xx-xx-xx-xx-xx")];
return (str_totext(buf, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_eui48(ARGS_FROMWIRE) {
isc_region_t sregion;
return (mem_tobuffer(target, sregion.base, sregion.length));
}
-static inline isc_result_t
+static isc_result_t
towire_eui48(ARGS_TOWIRE) {
REQUIRE(rdata->type == dns_rdatatype_eui48);
REQUIRE(rdata->length == 6);
return (mem_tobuffer(target, rdata->data, rdata->length));
}
-static inline int
+static int
compare_eui48(ARGS_COMPARE) {
isc_region_t region1;
isc_region_t region2;
return (isc_region_compare(®ion1, ®ion2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_eui48(ARGS_FROMSTRUCT) {
dns_rdata_eui48_t *eui48 = source;
return (mem_tobuffer(target, eui48->eui48, sizeof(eui48->eui48)));
}
-static inline isc_result_t
+static isc_result_t
tostruct_eui48(ARGS_TOSTRUCT) {
dns_rdata_eui48_t *eui48 = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_eui48(ARGS_FREESTRUCT) {
dns_rdata_eui48_t *eui48 = source;
return;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_eui48(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_eui48);
REQUIRE(rdata->length == 6);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_eui48(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_eui48(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_eui48);
return (true);
}
-static inline bool
+static bool
checknames_eui48(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_eui48);
REQUIRE(rdata->length == 6);
return (true);
}
-static inline int
+static int
casecompare_eui48(ARGS_COMPARE) {
return (compare_eui48(rdata1, rdata2));
}
#define RRTYPE_EUI64_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_eui64(ARGS_FROMTEXT) {
isc_token_t token;
unsigned char eui64[8];
return (mem_tobuffer(target, eui64, sizeof(eui64)));
}
-static inline isc_result_t
+static isc_result_t
totext_eui64(ARGS_TOTEXT) {
char buf[sizeof("xx-xx-xx-xx-xx-xx-xx-xx")];
return (str_totext(buf, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_eui64(ARGS_FROMWIRE) {
isc_region_t sregion;
return (mem_tobuffer(target, sregion.base, sregion.length));
}
-static inline isc_result_t
+static isc_result_t
towire_eui64(ARGS_TOWIRE) {
REQUIRE(rdata->type == dns_rdatatype_eui64);
REQUIRE(rdata->length == 8);
return (mem_tobuffer(target, rdata->data, rdata->length));
}
-static inline int
+static int
compare_eui64(ARGS_COMPARE) {
isc_region_t region1;
isc_region_t region2;
return (isc_region_compare(®ion1, ®ion2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_eui64(ARGS_FROMSTRUCT) {
dns_rdata_eui64_t *eui64 = source;
return (mem_tobuffer(target, eui64->eui64, sizeof(eui64->eui64)));
}
-static inline isc_result_t
+static isc_result_t
tostruct_eui64(ARGS_TOSTRUCT) {
dns_rdata_eui64_t *eui64 = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_eui64(ARGS_FREESTRUCT) {
dns_rdata_eui64_t *eui64 = source;
return;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_eui64(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_eui64);
REQUIRE(rdata->length == 8);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_eui64(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_eui64(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_eui64);
return (true);
}
-static inline bool
+static bool
checknames_eui64(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_eui64);
REQUIRE(rdata->length == 8);
return (true);
}
-static inline int
+static int
casecompare_eui64(ARGS_COMPARE) {
return (compare_eui64(rdata1, rdata2));
}
#define RRTYPE_GPOS_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_gpos(ARGS_FROMTEXT) {
isc_token_t token;
int i;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_gpos(ARGS_TOTEXT) {
isc_region_t region;
int i;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_gpos(ARGS_FROMWIRE) {
int i;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
towire_gpos(ARGS_TOWIRE) {
REQUIRE(rdata->type == dns_rdatatype_gpos);
REQUIRE(rdata->length != 0);
return (mem_tobuffer(target, rdata->data, rdata->length));
}
-static inline int
+static int
compare_gpos(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_gpos(ARGS_FROMSTRUCT) {
dns_rdata_gpos_t *gpos = source;
return (mem_tobuffer(target, gpos->altitude, gpos->alt_len));
}
-static inline isc_result_t
+static isc_result_t
tostruct_gpos(ARGS_TOSTRUCT) {
dns_rdata_gpos_t *gpos = target;
isc_region_t region;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_gpos(ARGS_FREESTRUCT) {
dns_rdata_gpos_t *gpos = source;
gpos->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_gpos(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_gpos);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_gpos(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_gpos(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_gpos);
return (true);
}
-static inline bool
+static bool
checknames_gpos(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_gpos);
return (true);
}
-static inline int
+static int
casecompare_gpos(ARGS_COMPARE) {
return (compare_gpos(rdata1, rdata2));
}
#define RRTYPE_HINFO_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_hinfo(ARGS_FROMTEXT) {
isc_token_t token;
int i;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_hinfo(ARGS_TOTEXT) {
isc_region_t region;
return (txt_totext(®ion, true, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_hinfo(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_hinfo);
return (txt_fromwire(source, target));
}
-static inline isc_result_t
+static isc_result_t
towire_hinfo(ARGS_TOWIRE) {
UNUSED(cctx);
return (mem_tobuffer(target, rdata->data, rdata->length));
}
-static inline int
+static int
compare_hinfo(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_hinfo(ARGS_FROMSTRUCT) {
dns_rdata_hinfo_t *hinfo = source;
return (mem_tobuffer(target, hinfo->os, hinfo->os_len));
}
-static inline isc_result_t
+static isc_result_t
tostruct_hinfo(ARGS_TOSTRUCT) {
dns_rdata_hinfo_t *hinfo = target;
isc_region_t region;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_hinfo(ARGS_FREESTRUCT) {
dns_rdata_hinfo_t *hinfo = source;
hinfo->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_hinfo(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_hinfo);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_hinfo(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_hinfo(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_hinfo);
return (true);
}
-static inline bool
+static bool
checknames_hinfo(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_hinfo);
return (true);
}
-static inline int
+static int
casecompare_hinfo(ARGS_COMPARE) {
return (compare_hinfo(rdata1, rdata2));
}
#define RRTYPE_HIP_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_hip(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_hip(ARGS_TOTEXT) {
isc_region_t region;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_hip(ARGS_FROMWIRE) {
isc_region_t region, rr;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
towire_hip(ARGS_TOWIRE) {
isc_region_t region;
return (mem_tobuffer(target, region.base, region.length));
}
-static inline int
+static int
compare_hip(ARGS_COMPARE) {
isc_region_t region1;
isc_region_t region2;
return (isc_region_compare(®ion1, ®ion2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_hip(ARGS_FROMSTRUCT) {
dns_rdata_hip_t *hip = source;
dns_rdata_hip_t myhip;
return (mem_tobuffer(target, hip->servers, hip->servers_len));
}
-static inline isc_result_t
+static isc_result_t
tostruct_hip(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_hip_t *hip = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_hip(ARGS_FREESTRUCT) {
dns_rdata_hip_t *hip = source;
hip->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_hip(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_hip);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_hip(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_hip(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_hip);
return (true);
}
-static inline bool
+static bool
checknames_hip(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_hip);
INSIST(name->length + hip->offset <= hip->servers_len);
}
-static inline int
+static int
casecompare_hip(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
#define RRTYPE_IPSECKEY_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_ipseckey(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
return (isc_base64_tobuffer(lexer, target, -2));
}
-static inline isc_result_t
+static isc_result_t
totext_ipseckey(ARGS_TOTEXT) {
isc_region_t region;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_ipseckey(ARGS_FROMWIRE) {
dns_name_t name;
isc_region_t region;
}
}
-static inline isc_result_t
+static isc_result_t
towire_ipseckey(ARGS_TOWIRE) {
isc_region_t region;
return (mem_tobuffer(target, region.base, region.length));
}
-static inline int
+static int
compare_ipseckey(ARGS_COMPARE) {
isc_region_t region1;
isc_region_t region2;
return (isc_region_compare(®ion1, ®ion2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_ipseckey(ARGS_FROMSTRUCT) {
dns_rdata_ipseckey_t *ipseckey = source;
isc_region_t region;
return (mem_tobuffer(target, ipseckey->key, ipseckey->keylength));
}
-static inline isc_result_t
+static isc_result_t
tostruct_ipseckey(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_ipseckey_t *ipseckey = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_ipseckey(ARGS_FREESTRUCT) {
dns_rdata_ipseckey_t *ipseckey = source;
ipseckey->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_ipseckey(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_ipseckey);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_ipseckey(ARGS_DIGEST) {
isc_region_t region;
return ((digest)(arg, ®ion));
}
-static inline bool
+static bool
checkowner_ipseckey(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_ipseckey);
return (true);
}
-static inline bool
+static bool
checknames_ipseckey(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_ipseckey);
return (true);
}
-static inline int
+static int
casecompare_ipseckey(ARGS_COMPARE) {
isc_region_t region1;
isc_region_t region2;
#define RRTYPE_ISDN_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_isdn(ARGS_FROMTEXT) {
isc_token_t token;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_isdn(ARGS_TOTEXT) {
isc_region_t region;
return (txt_totext(®ion, true, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_isdn(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_isdn);
return (txt_fromwire(source, target));
}
-static inline isc_result_t
+static isc_result_t
towire_isdn(ARGS_TOWIRE) {
UNUSED(cctx);
return (mem_tobuffer(target, rdata->data, rdata->length));
}
-static inline int
+static int
compare_isdn(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_isdn(ARGS_FROMSTRUCT) {
dns_rdata_isdn_t *isdn = source;
return (mem_tobuffer(target, isdn->subaddress, isdn->subaddress_len));
}
-static inline isc_result_t
+static isc_result_t
tostruct_isdn(ARGS_TOSTRUCT) {
dns_rdata_isdn_t *isdn = target;
isc_region_t r;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_isdn(ARGS_FREESTRUCT) {
dns_rdata_isdn_t *isdn = source;
isdn->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_isdn(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_isdn);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_isdn(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_isdn(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_isdn);
return (true);
}
-static inline bool
+static bool
checknames_isdn(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_isdn);
return (true);
}
-static inline int
+static int
casecompare_isdn(ARGS_COMPARE) {
return (compare_isdn(rdata1, rdata2));
}
* DNSKEY - RFC 4034
* RKEY - draft-reid-dnsext-rkey-00
*/
-static inline bool
+static bool
generic_key_nokey(dns_rdatatype_t type, unsigned int flags) {
switch (type) {
case dns_rdatatype_cdnskey:
}
}
-static inline isc_result_t
+static isc_result_t
generic_fromtext_key(ARGS_FROMTEXT) {
isc_token_t token;
dns_secalg_t alg;
return (isc_base64_tobuffer(lexer, target, -2));
}
-static inline isc_result_t
+static isc_result_t
generic_totext_key(ARGS_TOTEXT) {
isc_region_t sr;
char buf[sizeof("[key id = 64000]")];
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
generic_fromwire_key(ARGS_FROMWIRE) {
unsigned char algorithm;
uint16_t flags;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline isc_result_t
+static isc_result_t
fromtext_key(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_key);
return (generic_fromtext_key(CALL_FROMTEXT));
}
-static inline isc_result_t
+static isc_result_t
totext_key(ARGS_TOTEXT) {
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_key);
return (generic_totext_key(CALL_TOTEXT));
}
-static inline isc_result_t
+static isc_result_t
fromwire_key(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_key);
return (generic_fromwire_key(CALL_FROMWIRE));
}
-static inline isc_result_t
+static isc_result_t
towire_key(ARGS_TOWIRE) {
isc_region_t sr;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline int
+static int
compare_key(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
generic_fromstruct_key(ARGS_FROMSTRUCT) {
dns_rdata_key_t *key = source;
return (mem_tobuffer(target, key->data, key->datalen));
}
-static inline isc_result_t
+static isc_result_t
generic_tostruct_key(ARGS_TOSTRUCT) {
dns_rdata_key_t *key = target;
isc_region_t sr;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
generic_freestruct_key(ARGS_FREESTRUCT) {
dns_rdata_key_t *key = (dns_rdata_key_t *)source;
key->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
fromstruct_key(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_key);
return (generic_fromstruct_key(CALL_FROMSTRUCT));
}
-static inline isc_result_t
+static isc_result_t
tostruct_key(ARGS_TOSTRUCT) {
dns_rdata_key_t *key = target;
return (generic_tostruct_key(CALL_TOSTRUCT));
}
-static inline void
+static void
freestruct_key(ARGS_FREESTRUCT) {
dns_rdata_key_t *key = (dns_rdata_key_t *)source;
generic_freestruct_key(source);
}
-static inline isc_result_t
+static isc_result_t
additionaldata_key(ARGS_ADDLDATA) {
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_key);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_key(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_key(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_key);
return (true);
}
-static inline bool
+static bool
checknames_key(ARGS_CHECKNAMES) {
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_key);
return (true);
}
-static inline int
+static int
casecompare_key(ARGS_COMPARE) {
return (compare_key(rdata1, rdata2));
}
#define RRTYPE_KEYDATA_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_keydata(ARGS_FROMTEXT) {
isc_token_t token;
dns_secalg_t alg;
return (isc_base64_tobuffer(lexer, target, -2));
}
-static inline isc_result_t
+static isc_result_t
totext_keydata(ARGS_TOTEXT) {
isc_region_t sr;
char buf[sizeof("64000")];
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_keydata(ARGS_FROMWIRE) {
isc_region_t sr;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline isc_result_t
+static isc_result_t
towire_keydata(ARGS_TOWIRE) {
isc_region_t sr;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline int
+static int
compare_keydata(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_keydata(ARGS_FROMSTRUCT) {
dns_rdata_keydata_t *keydata = source;
return (mem_tobuffer(target, keydata->data, keydata->datalen));
}
-static inline isc_result_t
+static isc_result_t
tostruct_keydata(ARGS_TOSTRUCT) {
dns_rdata_keydata_t *keydata = target;
isc_region_t sr;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_keydata(ARGS_FREESTRUCT) {
dns_rdata_keydata_t *keydata = (dns_rdata_keydata_t *)source;
keydata->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_keydata(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_keydata);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_keydata(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_keydata(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_keydata);
return (true);
}
-static inline bool
+static bool
checknames_keydata(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_keydata);
return (true);
}
-static inline int
+static int
casecompare_keydata(ARGS_COMPARE) {
return (compare_keydata(rdata1, rdata2));
}
#define RRTYPE_L32_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_l32(ARGS_FROMTEXT) {
isc_token_t token;
struct in_addr addr;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_l32(ARGS_TOTEXT) {
isc_region_t region;
char buf[sizeof("65000")];
return (inet_totext(AF_INET, tctx->flags, ®ion, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_l32(ARGS_FROMWIRE) {
isc_region_t sregion;
return (mem_tobuffer(target, sregion.base, sregion.length));
}
-static inline isc_result_t
+static isc_result_t
towire_l32(ARGS_TOWIRE) {
REQUIRE(rdata->type == dns_rdatatype_l32);
REQUIRE(rdata->length == 6);
return (mem_tobuffer(target, rdata->data, rdata->length));
}
-static inline int
+static int
compare_l32(ARGS_COMPARE) {
isc_region_t region1;
isc_region_t region2;
return (isc_region_compare(®ion1, ®ion2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_l32(ARGS_FROMSTRUCT) {
dns_rdata_l32_t *l32 = source;
uint32_t n;
return (uint32_tobuffer(n, target));
}
-static inline isc_result_t
+static isc_result_t
tostruct_l32(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_l32_t *l32 = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_l32(ARGS_FREESTRUCT) {
dns_rdata_l32_t *l32 = source;
return;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_l32(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_l32);
REQUIRE(rdata->length == 6);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_l32(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_l32(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_l32);
return (true);
}
-static inline bool
+static bool
checknames_l32(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_l32);
REQUIRE(rdata->length == 6);
return (true);
}
-static inline int
+static int
casecompare_l32(ARGS_COMPARE) {
return (compare_l32(rdata1, rdata2));
}
#define RRTYPE_L64_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_l64(ARGS_FROMTEXT) {
isc_token_t token;
unsigned char locator[NS_LOCATORSZ];
return (mem_tobuffer(target, locator, NS_LOCATORSZ));
}
-static inline isc_result_t
+static isc_result_t
totext_l64(ARGS_TOTEXT) {
isc_region_t region;
char buf[sizeof("xxxx:xxxx:xxxx:xxxx")];
return (str_totext(buf, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_l64(ARGS_FROMWIRE) {
isc_region_t sregion;
return (mem_tobuffer(target, sregion.base, sregion.length));
}
-static inline isc_result_t
+static isc_result_t
towire_l64(ARGS_TOWIRE) {
REQUIRE(rdata->type == dns_rdatatype_l64);
REQUIRE(rdata->length == 10);
return (mem_tobuffer(target, rdata->data, rdata->length));
}
-static inline int
+static int
compare_l64(ARGS_COMPARE) {
isc_region_t region1;
isc_region_t region2;
return (isc_region_compare(®ion1, ®ion2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_l64(ARGS_FROMSTRUCT) {
dns_rdata_l64_t *l64 = source;
return (mem_tobuffer(target, l64->l64, sizeof(l64->l64)));
}
-static inline isc_result_t
+static isc_result_t
tostruct_l64(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_l64_t *l64 = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_l64(ARGS_FREESTRUCT) {
dns_rdata_l64_t *l64 = source;
return;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_l64(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_l64);
REQUIRE(rdata->length == 10);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_l64(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_l64(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_l64);
return (true);
}
-static inline bool
+static bool
checknames_l64(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_l64);
REQUIRE(rdata->length == 10);
return (true);
}
-static inline int
+static int
casecompare_l64(ARGS_COMPARE) {
return (compare_l64(rdata1, rdata2));
}
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
loc_getlatitude(isc_lex_t *lexer, unsigned long *latitude) {
unsigned long d1 = 0, m1 = 0, s1 = 0;
int direction = 0;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
loc_getlongitude(isc_lex_t *lexer, unsigned long *longitude) {
unsigned long d2 = 0, m2 = 0, s2 = 0;
int direction = 0;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
loc_getaltitude(isc_lex_t *lexer, unsigned long *altitude) {
isc_token_t token;
unsigned long cm;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
loc_getoptionalprecision(isc_lex_t *lexer, unsigned char *valuep) {
isc_token_t token;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
loc_getsize(isc_lex_t *lexer, unsigned char *sizep) {
return (loc_getoptionalprecision(lexer, sizep));
}
-static inline isc_result_t
+static isc_result_t
loc_gethorizontalprecision(isc_lex_t *lexer, unsigned char *hpp) {
return (loc_getoptionalprecision(lexer, hpp));
}
-static inline isc_result_t
+static isc_result_t
loc_getverticalprecision(isc_lex_t *lexer, unsigned char *vpp) {
return (loc_getoptionalprecision(lexer, vpp));
}
* ZIP/postal code area sizes, since it is often easy to find
* approximate geographical location by ZIP/postal code.
*/
-static inline isc_result_t
+static isc_result_t
fromtext_loc(ARGS_FROMTEXT) {
isc_result_t result = ISC_R_SUCCESS;
unsigned long latitude = 0;
return (result);
}
-static inline isc_result_t
+static isc_result_t
totext_loc(ARGS_TOTEXT) {
int d1, m1, s1, fs1;
int d2, m2, s2, fs2;
return (str_totext(buf, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_loc(ARGS_FROMWIRE) {
isc_region_t sr;
unsigned char c;
return (mem_tobuffer(target, sr.base, 16));
}
-static inline isc_result_t
+static isc_result_t
towire_loc(ARGS_TOWIRE) {
UNUSED(cctx);
return (mem_tobuffer(target, rdata->data, rdata->length));
}
-static inline int
+static int
compare_loc(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_loc(ARGS_FROMSTRUCT) {
dns_rdata_loc_t *loc = source;
uint8_t c;
return (uint32_tobuffer(loc->v.v0.altitude, target));
}
-static inline isc_result_t
+static isc_result_t
tostruct_loc(ARGS_TOSTRUCT) {
dns_rdata_loc_t *loc = target;
isc_region_t r;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_loc(ARGS_FREESTRUCT) {
dns_rdata_loc_t *loc = source;
UNUSED(loc);
}
-static inline isc_result_t
+static isc_result_t
additionaldata_loc(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_loc);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_loc(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_loc(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_loc);
return (true);
}
-static inline bool
+static bool
checknames_loc(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_loc);
return (true);
}
-static inline int
+static int
casecompare_loc(ARGS_COMPARE) {
return (compare_loc(rdata1, rdata2));
}
#define RRTYPE_LP_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_lp(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
return (dns_name_fromtext(&name, &buffer, origin, options, target));
}
-static inline isc_result_t
+static isc_result_t
totext_lp(ARGS_TOTEXT) {
isc_region_t region;
dns_name_t name;
return (dns_name_totext(&prefix, sub, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_lp(ARGS_FROMWIRE) {
dns_name_t name;
isc_region_t sregion;
return (dns_name_fromwire(&name, source, dctx, options, target));
}
-static inline isc_result_t
+static isc_result_t
towire_lp(ARGS_TOWIRE) {
REQUIRE(rdata->type == dns_rdatatype_lp);
REQUIRE(rdata->length != 0);
return (mem_tobuffer(target, rdata->data, rdata->length));
}
-static inline int
+static int
compare_lp(ARGS_COMPARE) {
isc_region_t region1;
isc_region_t region2;
return (isc_region_compare(®ion1, ®ion2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_lp(ARGS_FROMSTRUCT) {
dns_rdata_lp_t *lp = source;
isc_region_t region;
return (isc_buffer_copyregion(target, ®ion));
}
-static inline isc_result_t
+static isc_result_t
tostruct_lp(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_lp_t *lp = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_lp(ARGS_FREESTRUCT) {
dns_rdata_lp_t *lp = source;
lp->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_lp(ARGS_ADDLDATA) {
dns_name_t name;
dns_offsets_t offsets;
return ((add)(arg, &name, dns_rdatatype_l64, NULL));
}
-static inline isc_result_t
+static isc_result_t
digest_lp(ARGS_DIGEST) {
isc_region_t region;
return ((digest)(arg, ®ion));
}
-static inline bool
+static bool
checkowner_lp(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_lp);
return (true);
}
-static inline bool
+static bool
checknames_lp(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_lp);
return (true);
}
-static inline int
+static int
casecompare_lp(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
#define RRTYPE_MB_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_mb(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_mb(ARGS_TOTEXT) {
isc_region_t region;
dns_name_t name;
return (dns_name_totext(&prefix, sub, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_mb(ARGS_FROMWIRE) {
dns_name_t name;
return (dns_name_fromwire(&name, source, dctx, options, target));
}
-static inline isc_result_t
+static isc_result_t
towire_mb(ARGS_TOWIRE) {
dns_name_t name;
dns_offsets_t offsets;
return (dns_name_towire(&name, cctx, target));
}
-static inline int
+static int
compare_mb(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
return (dns_name_rdatacompare(&name1, &name2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_mb(ARGS_FROMSTRUCT) {
dns_rdata_mb_t *mb = source;
isc_region_t region;
return (isc_buffer_copyregion(target, ®ion));
}
-static inline isc_result_t
+static isc_result_t
tostruct_mb(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_mb_t *mb = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_mb(ARGS_FREESTRUCT) {
dns_rdata_mb_t *mb = source;
mb->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_mb(ARGS_ADDLDATA) {
dns_name_t name;
dns_offsets_t offsets;
return ((add)(arg, &name, dns_rdatatype_a, NULL));
}
-static inline isc_result_t
+static isc_result_t
digest_mb(ARGS_DIGEST) {
isc_region_t r;
dns_name_t name;
return (dns_name_digest(&name, digest, arg));
}
-static inline bool
+static bool
checkowner_mb(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_mb);
return (dns_name_ismailbox(name));
}
-static inline bool
+static bool
checknames_mb(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_mb);
return (true);
}
-static inline int
+static int
casecompare_mb(ARGS_COMPARE) {
return (compare_mb(rdata1, rdata2));
}
#define RRTYPE_MD_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_md(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_md(ARGS_TOTEXT) {
isc_region_t region;
dns_name_t name;
return (dns_name_totext(&prefix, sub, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_md(ARGS_FROMWIRE) {
dns_name_t name;
return (dns_name_fromwire(&name, source, dctx, options, target));
}
-static inline isc_result_t
+static isc_result_t
towire_md(ARGS_TOWIRE) {
dns_name_t name;
dns_offsets_t offsets;
return (dns_name_towire(&name, cctx, target));
}
-static inline int
+static int
compare_md(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
return (dns_name_rdatacompare(&name1, &name2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_md(ARGS_FROMSTRUCT) {
dns_rdata_md_t *md = source;
isc_region_t region;
return (isc_buffer_copyregion(target, ®ion));
}
-static inline isc_result_t
+static isc_result_t
tostruct_md(ARGS_TOSTRUCT) {
dns_rdata_md_t *md = target;
isc_region_t r;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_md(ARGS_FREESTRUCT) {
dns_rdata_md_t *md = source;
md->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_md(ARGS_ADDLDATA) {
dns_name_t name;
dns_offsets_t offsets;
return ((add)(arg, &name, dns_rdatatype_a, NULL));
}
-static inline isc_result_t
+static isc_result_t
digest_md(ARGS_DIGEST) {
isc_region_t r;
dns_name_t name;
return (dns_name_digest(&name, digest, arg));
}
-static inline bool
+static bool
checkowner_md(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_md);
return (true);
}
-static inline bool
+static bool
checknames_md(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_md);
return (true);
}
-static inline int
+static int
casecompare_md(ARGS_COMPARE) {
return (compare_md(rdata1, rdata2));
}
#define RRTYPE_MF_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_mf(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_mf(ARGS_TOTEXT) {
isc_region_t region;
dns_name_t name;
return (dns_name_totext(&prefix, sub, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_mf(ARGS_FROMWIRE) {
dns_name_t name;
return (dns_name_fromwire(&name, source, dctx, options, target));
}
-static inline isc_result_t
+static isc_result_t
towire_mf(ARGS_TOWIRE) {
dns_name_t name;
dns_offsets_t offsets;
return (dns_name_towire(&name, cctx, target));
}
-static inline int
+static int
compare_mf(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
return (dns_name_rdatacompare(&name1, &name2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_mf(ARGS_FROMSTRUCT) {
dns_rdata_mf_t *mf = source;
isc_region_t region;
return (isc_buffer_copyregion(target, ®ion));
}
-static inline isc_result_t
+static isc_result_t
tostruct_mf(ARGS_TOSTRUCT) {
dns_rdata_mf_t *mf = target;
isc_region_t r;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_mf(ARGS_FREESTRUCT) {
dns_rdata_mf_t *mf = source;
mf->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_mf(ARGS_ADDLDATA) {
dns_name_t name;
dns_offsets_t offsets;
return ((add)(arg, &name, dns_rdatatype_a, NULL));
}
-static inline isc_result_t
+static isc_result_t
digest_mf(ARGS_DIGEST) {
isc_region_t r;
dns_name_t name;
return (dns_name_digest(&name, digest, arg));
}
-static inline bool
+static bool
checkowner_mf(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_mf);
return (true);
}
-static inline bool
+static bool
checknames_mf(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_mf);
return (true);
}
-static inline int
+static int
casecompare_mf(ARGS_COMPARE) {
return (compare_mf(rdata1, rdata2));
}
#define RRTYPE_MG_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_mg(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_mg(ARGS_TOTEXT) {
isc_region_t region;
dns_name_t name;
return (dns_name_totext(&prefix, sub, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_mg(ARGS_FROMWIRE) {
dns_name_t name;
return (dns_name_fromwire(&name, source, dctx, options, target));
}
-static inline isc_result_t
+static isc_result_t
towire_mg(ARGS_TOWIRE) {
dns_name_t name;
dns_offsets_t offsets;
return (dns_name_towire(&name, cctx, target));
}
-static inline int
+static int
compare_mg(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
return (dns_name_rdatacompare(&name1, &name2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_mg(ARGS_FROMSTRUCT) {
dns_rdata_mg_t *mg = source;
isc_region_t region;
return (isc_buffer_copyregion(target, ®ion));
}
-static inline isc_result_t
+static isc_result_t
tostruct_mg(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_mg_t *mg = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_mg(ARGS_FREESTRUCT) {
dns_rdata_mg_t *mg = source;
mg->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_mg(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_mg);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_mg(ARGS_DIGEST) {
isc_region_t r;
dns_name_t name;
return (dns_name_digest(&name, digest, arg));
}
-static inline bool
+static bool
checkowner_mg(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_mg);
return (dns_name_ismailbox(name));
}
-static inline bool
+static bool
checknames_mg(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_mg);
return (true);
}
-static inline int
+static int
casecompare_mg(ARGS_COMPARE) {
return (compare_mg(rdata1, rdata2));
}
#define RRTYPE_MINFO_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_minfo(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_minfo(ARGS_TOTEXT) {
isc_region_t region;
dns_name_t rmail;
return (dns_name_totext(&prefix, sub, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_minfo(ARGS_FROMWIRE) {
dns_name_t rmail;
dns_name_t email;
return (dns_name_fromwire(&email, source, dctx, options, target));
}
-static inline isc_result_t
+static isc_result_t
towire_minfo(ARGS_TOWIRE) {
isc_region_t region;
dns_name_t rmail;
return (dns_name_towire(&rmail, cctx, target));
}
-static inline int
+static int
compare_minfo(ARGS_COMPARE) {
isc_region_t region1;
isc_region_t region2;
return (order);
}
-static inline isc_result_t
+static isc_result_t
fromstruct_minfo(ARGS_FROMSTRUCT) {
dns_rdata_minfo_t *minfo = source;
isc_region_t region;
return (isc_buffer_copyregion(target, ®ion));
}
-static inline isc_result_t
+static isc_result_t
tostruct_minfo(ARGS_TOSTRUCT) {
dns_rdata_minfo_t *minfo = target;
isc_region_t region;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_minfo(ARGS_FREESTRUCT) {
dns_rdata_minfo_t *minfo = source;
minfo->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_minfo(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_minfo);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_minfo(ARGS_DIGEST) {
isc_region_t r;
dns_name_t name;
return (dns_name_digest(&name, digest, arg));
}
-static inline bool
+static bool
checkowner_minfo(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_minfo);
return (true);
}
-static inline bool
+static bool
checknames_minfo(ARGS_CHECKNAMES) {
isc_region_t region;
dns_name_t name;
return (true);
}
-static inline int
+static int
casecompare_minfo(ARGS_COMPARE) {
return (compare_minfo(rdata1, rdata2));
}
#define RRTYPE_MR_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_mr(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_mr(ARGS_TOTEXT) {
isc_region_t region;
dns_name_t name;
return (dns_name_totext(&prefix, sub, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_mr(ARGS_FROMWIRE) {
dns_name_t name;
return (dns_name_fromwire(&name, source, dctx, options, target));
}
-static inline isc_result_t
+static isc_result_t
towire_mr(ARGS_TOWIRE) {
dns_name_t name;
dns_offsets_t offsets;
return (dns_name_towire(&name, cctx, target));
}
-static inline int
+static int
compare_mr(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
return (dns_name_rdatacompare(&name1, &name2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_mr(ARGS_FROMSTRUCT) {
dns_rdata_mr_t *mr = source;
isc_region_t region;
return (isc_buffer_copyregion(target, ®ion));
}
-static inline isc_result_t
+static isc_result_t
tostruct_mr(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_mr_t *mr = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_mr(ARGS_FREESTRUCT) {
dns_rdata_mr_t *mr = source;
mr->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_mr(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_mr);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_mr(ARGS_DIGEST) {
isc_region_t r;
dns_name_t name;
return (dns_name_digest(&name, digest, arg));
}
-static inline bool
+static bool
checkowner_mr(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_mr);
return (true);
}
-static inline bool
+static bool
checknames_mr(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_mr);
return (true);
}
-static inline int
+static int
casecompare_mr(ARGS_COMPARE) {
return (compare_mr(rdata1, rdata2));
}
return (true);
}
-static inline isc_result_t
+static isc_result_t
fromtext_mx(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_mx(ARGS_TOTEXT) {
isc_region_t region;
dns_name_t name;
return (dns_name_totext(&prefix, sub, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_mx(ARGS_FROMWIRE) {
dns_name_t name;
isc_region_t sregion;
return (dns_name_fromwire(&name, source, dctx, options, target));
}
-static inline isc_result_t
+static isc_result_t
towire_mx(ARGS_TOWIRE) {
dns_name_t name;
dns_offsets_t offsets;
return (dns_name_towire(&name, cctx, target));
}
-static inline int
+static int
compare_mx(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
return (dns_name_rdatacompare(&name1, &name2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_mx(ARGS_FROMSTRUCT) {
dns_rdata_mx_t *mx = source;
isc_region_t region;
return (isc_buffer_copyregion(target, ®ion));
}
-static inline isc_result_t
+static isc_result_t
tostruct_mx(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_mx_t *mx = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_mx(ARGS_FREESTRUCT) {
dns_rdata_mx_t *mx = source;
static dns_name_t port25 = DNS_NAME_INITNONABSOLUTE(port25_ndata,
port25_offset);
-static inline isc_result_t
+static isc_result_t
additionaldata_mx(ARGS_ADDLDATA) {
isc_result_t result;
dns_fixedname_t fixed;
NULL));
}
-static inline isc_result_t
+static isc_result_t
digest_mx(ARGS_DIGEST) {
isc_region_t r1, r2;
dns_name_t name;
return (dns_name_digest(&name, digest, arg));
}
-static inline bool
+static bool
checkowner_mx(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_mx);
return (dns_name_ishostname(name, wildcard));
}
-static inline bool
+static bool
checknames_mx(ARGS_CHECKNAMES) {
isc_region_t region;
dns_name_t name;
return (true);
}
-static inline int
+static int
casecompare_mx(ARGS_COMPARE) {
return (compare_mx(rdata1, rdata2));
}
* Check the wire format of the Regexp field.
* Don't allow embedded NUL's.
*/
-static inline isc_result_t
+static isc_result_t
txt_valid_regex(const unsigned char *txt) {
unsigned int nsub = 0;
char regex[256];
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromtext_naptr(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_naptr(ARGS_TOTEXT) {
isc_region_t region;
dns_name_t name;
return (dns_name_totext(&prefix, sub, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_naptr(ARGS_FROMWIRE) {
dns_name_t name;
isc_region_t sr;
return (dns_name_fromwire(&name, source, dctx, options, target));
}
-static inline isc_result_t
+static isc_result_t
towire_naptr(ARGS_TOWIRE) {
dns_name_t name;
dns_offsets_t offsets;
return (dns_name_towire(&name, cctx, target));
}
-static inline int
+static int
compare_naptr(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
return (dns_name_rdatacompare(&name1, &name2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_naptr(ARGS_FROMSTRUCT) {
dns_rdata_naptr_t *naptr = source;
isc_region_t region;
return (isc_buffer_copyregion(target, ®ion));
}
-static inline isc_result_t
+static isc_result_t
tostruct_naptr(ARGS_TOSTRUCT) {
dns_rdata_naptr_t *naptr = target;
isc_region_t r;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_naptr(ARGS_FREESTRUCT) {
dns_rdata_naptr_t *naptr = source;
naptr->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_naptr(ARGS_ADDLDATA) {
dns_name_t name;
dns_offsets_t offsets;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_naptr(ARGS_DIGEST) {
isc_region_t r1, r2;
unsigned int length, n;
return (dns_name_digest(&name, digest, arg));
}
-static inline bool
+static bool
checkowner_naptr(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_naptr);
return (true);
}
-static inline bool
+static bool
checknames_naptr(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_naptr);
return (true);
}
-static inline int
+static int
casecompare_naptr(ARGS_COMPARE) {
return (compare_naptr(rdata1, rdata2));
}
#define RRTYPE_NID_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_nid(ARGS_FROMTEXT) {
isc_token_t token;
unsigned char locator[NS_LOCATORSZ];
return (mem_tobuffer(target, locator, NS_LOCATORSZ));
}
-static inline isc_result_t
+static isc_result_t
totext_nid(ARGS_TOTEXT) {
isc_region_t region;
char buf[sizeof("xxxx:xxxx:xxxx:xxxx")];
return (str_totext(buf, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_nid(ARGS_FROMWIRE) {
isc_region_t sregion;
return (mem_tobuffer(target, sregion.base, sregion.length));
}
-static inline isc_result_t
+static isc_result_t
towire_nid(ARGS_TOWIRE) {
REQUIRE(rdata->type == dns_rdatatype_nid);
REQUIRE(rdata->length == 10);
return (mem_tobuffer(target, rdata->data, rdata->length));
}
-static inline int
+static int
compare_nid(ARGS_COMPARE) {
isc_region_t region1;
isc_region_t region2;
return (isc_region_compare(®ion1, ®ion2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_nid(ARGS_FROMSTRUCT) {
dns_rdata_nid_t *nid = source;
return (mem_tobuffer(target, nid->nid, sizeof(nid->nid)));
}
-static inline isc_result_t
+static isc_result_t
tostruct_nid(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_nid_t *nid = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_nid(ARGS_FREESTRUCT) {
dns_rdata_nid_t *nid = source;
return;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_nid(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_nid);
REQUIRE(rdata->length == 10);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_nid(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_nid(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_nid);
return (true);
}
-static inline bool
+static bool
checknames_nid(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_nid);
REQUIRE(rdata->length == 10);
return (true);
}
-static inline int
+static int
casecompare_nid(ARGS_COMPARE) {
return (compare_nid(rdata1, rdata2));
}
#define RRTYPE_NINFO_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_ninfo(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_ninfo);
return (generic_fromtext_txt(CALL_FROMTEXT));
}
-static inline isc_result_t
+static isc_result_t
totext_ninfo(ARGS_TOTEXT) {
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_ninfo);
return (generic_totext_txt(CALL_TOTEXT));
}
-static inline isc_result_t
+static isc_result_t
fromwire_ninfo(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_ninfo);
return (generic_fromwire_txt(CALL_FROMWIRE));
}
-static inline isc_result_t
+static isc_result_t
towire_ninfo(ARGS_TOWIRE) {
REQUIRE(rdata->type == dns_rdatatype_ninfo);
return (mem_tobuffer(target, rdata->data, rdata->length));
}
-static inline int
+static int
compare_ninfo(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_ninfo(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_ninfo);
return (generic_fromstruct_txt(CALL_FROMSTRUCT));
}
-static inline isc_result_t
+static isc_result_t
tostruct_ninfo(ARGS_TOSTRUCT) {
dns_rdata_ninfo_t *ninfo = target;
return (generic_tostruct_txt(CALL_TOSTRUCT));
}
-static inline void
+static void
freestruct_ninfo(ARGS_FREESTRUCT) {
dns_rdata_ninfo_t *ninfo = source;
generic_freestruct_txt(source);
}
-static inline isc_result_t
+static isc_result_t
additionaldata_ninfo(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_ninfo);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_ninfo(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_ninfo(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_ninfo);
return (true);
}
-static inline bool
+static bool
checknames_ninfo(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_ninfo);
return (true);
}
-static inline int
+static int
casecompare_ninfo(ARGS_COMPARE) {
return (compare_ninfo(rdata1, rdata2));
}
#define RRTYPE_NS_ATTRIBUTES (DNS_RDATATYPEATTR_ZONECUTAUTH)
-static inline isc_result_t
+static isc_result_t
fromtext_ns(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_ns(ARGS_TOTEXT) {
isc_region_t region;
dns_name_t name;
return (dns_name_totext(&prefix, sub, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_ns(ARGS_FROMWIRE) {
dns_name_t name;
return (dns_name_fromwire(&name, source, dctx, options, target));
}
-static inline isc_result_t
+static isc_result_t
towire_ns(ARGS_TOWIRE) {
dns_name_t name;
dns_offsets_t offsets;
return (dns_name_towire(&name, cctx, target));
}
-static inline int
+static int
compare_ns(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
return (dns_name_rdatacompare(&name1, &name2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_ns(ARGS_FROMSTRUCT) {
dns_rdata_ns_t *ns = source;
isc_region_t region;
return (isc_buffer_copyregion(target, ®ion));
}
-static inline isc_result_t
+static isc_result_t
tostruct_ns(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_ns_t *ns = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_ns(ARGS_FREESTRUCT) {
dns_rdata_ns_t *ns = source;
ns->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_ns(ARGS_ADDLDATA) {
dns_name_t name;
dns_offsets_t offsets;
return ((add)(arg, &name, dns_rdatatype_a, NULL));
}
-static inline isc_result_t
+static isc_result_t
digest_ns(ARGS_DIGEST) {
isc_region_t r;
dns_name_t name;
return (dns_name_digest(&name, digest, arg));
}
-static inline bool
+static bool
checkowner_ns(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_ns);
return (true);
}
-static inline bool
+static bool
checknames_ns(ARGS_CHECKNAMES) {
isc_region_t region;
dns_name_t name;
return (true);
}
-static inline int
+static int
casecompare_ns(ARGS_COMPARE) {
return (compare_ns(rdata1, rdata2));
}
#define RRTYPE_NSEC3_ATTRIBUTES DNS_RDATATYPEATTR_DNSSEC
-static inline isc_result_t
+static isc_result_t
fromtext_nsec3(ARGS_FROMTEXT) {
isc_token_t token;
unsigned int flags;
return (typemap_fromtext(lexer, target, true));
}
-static inline isc_result_t
+static isc_result_t
totext_nsec3(ARGS_TOTEXT) {
isc_region_t sr;
unsigned int i, j;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_nsec3(ARGS_FROMWIRE) {
isc_region_t sr, rr;
unsigned int saltlen, hashlen;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
towire_nsec3(ARGS_TOWIRE) {
isc_region_t sr;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline int
+static int
compare_nsec3(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_nsec3(ARGS_FROMSTRUCT) {
dns_rdata_nsec3_t *nsec3 = source;
isc_region_t region;
return (mem_tobuffer(target, nsec3->typebits, nsec3->len));
}
-static inline isc_result_t
+static isc_result_t
tostruct_nsec3(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_nsec3_t *nsec3 = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_nsec3(ARGS_FREESTRUCT) {
dns_rdata_nsec3_t *nsec3 = source;
nsec3->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_nsec3(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_nsec3);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_nsec3(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_nsec3(ARGS_CHECKOWNER) {
unsigned char owner[NSEC3_MAX_HASH_LENGTH];
isc_buffer_t buffer;
return (false);
}
-static inline bool
+static bool
checknames_nsec3(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_nsec3);
return (true);
}
-static inline int
+static int
casecompare_nsec3(ARGS_COMPARE) {
return (compare_nsec3(rdata1, rdata2));
}
#define RRTYPE_NSEC3PARAM_ATTRIBUTES (DNS_RDATATYPEATTR_DNSSEC)
-static inline isc_result_t
+static isc_result_t
fromtext_nsec3param(ARGS_FROMTEXT) {
isc_token_t token;
unsigned int flags = 0;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_nsec3param(ARGS_TOTEXT) {
isc_region_t sr;
unsigned int i, j;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_nsec3param(ARGS_FROMWIRE) {
isc_region_t sr, rr;
unsigned int saltlen;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
towire_nsec3param(ARGS_TOWIRE) {
isc_region_t sr;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline int
+static int
compare_nsec3param(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_nsec3param(ARGS_FROMSTRUCT) {
dns_rdata_nsec3param_t *nsec3param = source;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
tostruct_nsec3param(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_nsec3param_t *nsec3param = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_nsec3param(ARGS_FREESTRUCT) {
dns_rdata_nsec3param_t *nsec3param = source;
nsec3param->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_nsec3param(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_nsec3param);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_nsec3param(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_nsec3param(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_nsec3param);
return (true);
}
-static inline bool
+static bool
checknames_nsec3param(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_nsec3param);
return (true);
}
-static inline int
+static int
casecompare_nsec3param(ARGS_COMPARE) {
return (compare_nsec3param(rdata1, rdata2));
}
(DNS_RDATATYPEATTR_DNSSEC | DNS_RDATATYPEATTR_ZONECUTAUTH | \
DNS_RDATATYPEATTR_ATCNAME)
-static inline isc_result_t
+static isc_result_t
fromtext_nsec(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
return (typemap_fromtext(lexer, target, false));
}
-static inline isc_result_t
+static isc_result_t
totext_nsec(ARGS_TOTEXT) {
isc_region_t sr;
dns_name_t name;
return (typemap_totext(&sr, NULL, target));
}
-static /* inline */ isc_result_t
+static isc_result_t
fromwire_nsec(ARGS_FROMWIRE) {
isc_region_t sr;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
towire_nsec(ARGS_TOWIRE) {
isc_region_t sr;
dns_name_t name;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline int
+static int
compare_nsec(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_nsec(ARGS_FROMSTRUCT) {
dns_rdata_nsec_t *nsec = source;
isc_region_t region;
return (mem_tobuffer(target, nsec->typebits, nsec->len));
}
-static inline isc_result_t
+static isc_result_t
tostruct_nsec(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_nsec_t *nsec = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_nsec(ARGS_FREESTRUCT) {
dns_rdata_nsec_t *nsec = source;
nsec->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_nsec(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_nsec);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_nsec(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_nsec(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_nsec);
return (true);
}
-static inline bool
+static bool
checknames_nsec(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_nsec);
return (true);
}
-static inline int
+static int
casecompare_nsec(ARGS_COMPARE) {
isc_region_t region1;
isc_region_t region2;
#define RRTYPE_NULL_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_null(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_null);
return (DNS_R_SYNTAX);
}
-static inline isc_result_t
+static isc_result_t
totext_null(ARGS_TOTEXT) {
REQUIRE(rdata->type == dns_rdatatype_null);
return (unknown_totext(rdata, tctx, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_null(ARGS_FROMWIRE) {
isc_region_t sr;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline isc_result_t
+static isc_result_t
towire_null(ARGS_TOWIRE) {
REQUIRE(rdata->type == dns_rdatatype_null);
return (mem_tobuffer(target, rdata->data, rdata->length));
}
-static inline int
+static int
compare_null(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_null(ARGS_FROMSTRUCT) {
dns_rdata_null_t *null = source;
return (mem_tobuffer(target, null->data, null->length));
}
-static inline isc_result_t
+static isc_result_t
tostruct_null(ARGS_TOSTRUCT) {
dns_rdata_null_t *null = target;
isc_region_t r;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_null(ARGS_FREESTRUCT) {
dns_rdata_null_t *null = source;
null->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_null(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_null);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_null(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_null(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_null);
return (true);
}
-static inline bool
+static bool
checknames_null(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_null);
return (true);
}
-static inline int
+static int
casecompare_null(ARGS_COMPARE) {
return (compare_null(rdata1, rdata2));
}
*/
#define RRTYPE_NXT_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_nxt(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
return (mem_tobuffer(target, bm, n));
}
-static inline isc_result_t
+static isc_result_t
totext_nxt(ARGS_TOTEXT) {
isc_region_t sr;
unsigned int i, j;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_nxt(ARGS_FROMWIRE) {
isc_region_t sr;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
towire_nxt(ARGS_TOWIRE) {
isc_region_t sr;
dns_name_t name;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline int
+static int
compare_nxt(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_nxt(ARGS_FROMSTRUCT) {
dns_rdata_nxt_t *nxt = source;
isc_region_t region;
return (mem_tobuffer(target, nxt->typebits, nxt->len));
}
-static inline isc_result_t
+static isc_result_t
tostruct_nxt(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_nxt_t *nxt = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_nxt(ARGS_FREESTRUCT) {
dns_rdata_nxt_t *nxt = source;
nxt->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_nxt(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_nxt);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_nxt(ARGS_DIGEST) {
isc_region_t r;
dns_name_t name;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_nxt(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_nxt);
return (true);
}
-static inline bool
+static bool
checknames_nxt(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_nxt);
return (true);
}
-static inline int
+static int
casecompare_nxt(ARGS_COMPARE) {
return (compare_nxt(rdata1, rdata2));
}
#define RRTYPE_OPENPGPKEY_ATTRIBUTES 0
-static inline isc_result_t
+static isc_result_t
fromtext_openpgpkey(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_openpgpkey);
return (isc_base64_tobuffer(lexer, target, -2));
}
-static inline isc_result_t
+static isc_result_t
totext_openpgpkey(ARGS_TOTEXT) {
isc_region_t sr;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_openpgpkey(ARGS_FROMWIRE) {
isc_region_t sr;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline isc_result_t
+static isc_result_t
towire_openpgpkey(ARGS_TOWIRE) {
isc_region_t sr;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline int
+static int
compare_openpgpkey(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_openpgpkey(ARGS_FROMSTRUCT) {
dns_rdata_openpgpkey_t *sig = source;
return (mem_tobuffer(target, sig->keyring, sig->length));
}
-static inline isc_result_t
+static isc_result_t
tostruct_openpgpkey(ARGS_TOSTRUCT) {
isc_region_t sr;
dns_rdata_openpgpkey_t *sig = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_openpgpkey(ARGS_FREESTRUCT) {
dns_rdata_openpgpkey_t *sig = (dns_rdata_openpgpkey_t *)source;
sig->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_openpgpkey(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_openpgpkey);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_openpgpkey(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_openpgpkey(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_openpgpkey);
return (true);
}
-static inline bool
+static bool
checknames_openpgpkey(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_openpgpkey);
return (true);
}
-static inline int
+static int
casecompare_openpgpkey(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
#include <isc/utf8.h>
-static inline isc_result_t
+static isc_result_t
fromtext_opt(ARGS_FROMTEXT) {
/*
* OPT records do not have a text format.
return (ISC_R_NOTIMPLEMENTED);
}
-static inline isc_result_t
+static isc_result_t
totext_opt(ARGS_TOTEXT) {
isc_region_t r;
isc_region_t or ;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_opt(ARGS_FROMWIRE) {
isc_region_t sregion;
isc_region_t tregion;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
towire_opt(ARGS_TOWIRE) {
REQUIRE(rdata->type == dns_rdatatype_opt);
return (mem_tobuffer(target, rdata->data, rdata->length));
}
-static inline int
+static int
compare_opt(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_opt(ARGS_FROMSTRUCT) {
dns_rdata_opt_t *opt = source;
isc_region_t region;
return (mem_tobuffer(target, opt->options, opt->length));
}
-static inline isc_result_t
+static isc_result_t
tostruct_opt(ARGS_TOSTRUCT) {
dns_rdata_opt_t *opt = target;
isc_region_t r;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_opt(ARGS_FREESTRUCT) {
dns_rdata_opt_t *opt = source;
opt->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_opt(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_opt);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_opt(ARGS_DIGEST) {
/*
* OPT records are not digested.
return (ISC_R_NOTIMPLEMENTED);
}
-static inline bool
+static bool
checkowner_opt(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_opt);
return (dns_name_equal(name, dns_rootname));
}
-static inline bool
+static bool
checknames_opt(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_opt);
return (true);
}
-static inline int
+static int
casecompare_opt(ARGS_COMPARE) {
return (compare_opt(rdata1, rdata2));
}
#define RRTYPE_ #_ATTRIBUTES(0)
-static inline isc_result_t fromtext_ #(ARGS_FROMTEXT) {
+static isc_result_t fromtext_ #(ARGS_FROMTEXT) {
isc_token_t token;
REQUIRE(type == dns_rdatatype_proforma.c #);
return (ISC_R_NOTIMPLEMENTED);
}
-static inline isc_result_t totext_ #(ARGS_TOTEXT) {
+static isc_result_t totext_ #(ARGS_TOTEXT) {
REQUIRE(rdata->type == dns_rdatatype_proforma.c #);
REQUIRE(rdata->rdclass == #);
REQUIRE(rdata->length != 0); /* XXX */
return (ISC_R_NOTIMPLEMENTED);
}
-static inline isc_result_t fromwire_ #(ARGS_FROMWIRE) {
+static isc_result_t fromwire_ #(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_proforma.c #);
REQUIRE(rdclass == #);
return (ISC_R_NOTIMPLEMENTED);
}
-static inline isc_result_t towire_ #(ARGS_TOWIRE) {
+static isc_result_t towire_ #(ARGS_TOWIRE) {
REQUIRE(rdata->type == dns_rdatatype_proforma.c #);
REQUIRE(rdata->rdclass == #);
REQUIRE(rdata->length != 0); /* XXX */
return (ISC_R_NOTIMPLEMENTED);
}
-static inline int compare_ #(ARGS_COMPARE) {
+static int compare_ #(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t fromstruct_ #(ARGS_FROMSTRUCT) {
+static isc_result_t fromstruct_ #(ARGS_FROMSTRUCT) {
dns_rdata_ #_t *# = source;
REQUIRE(type == dns_rdatatype_proforma.c #);
return (ISC_R_NOTIMPLEMENTED);
}
-static inline isc_result_t tostruct_ #(ARGS_TOSTRUCT) {
+static isc_result_t tostruct_ #(ARGS_TOSTRUCT) {
REQUIRE(rdata->type == dns_rdatatype_proforma.c #);
REQUIRE(rdata->rdclass == #);
REQUIRE(rdata->length != 0); /* XXX */
return (ISC_R_NOTIMPLEMENTED);
}
-static inline void freestruct_ #(ARGS_FREESTRUCT) {
+static void freestruct_ #(ARGS_FREESTRUCT) {
dns_rdata_ #_t *# = source;
REQUIRE(# != NULL);
REQUIRE(#->common.rdclass == #);
}
-static inline isc_result_t additionaldata_ #(ARGS_ADDLDATA) {
+static isc_result_t additionaldata_ #(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_proforma.c #);
REQUIRE(rdata->rdclass == #);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t digest_ #(ARGS_DIGEST) {
+static isc_result_t digest_ #(ARGS_DIGEST) {
isc_region_t r;
REQUIRE(rdata->type == dns_rdatatype_proforma.c #);
return ((digest)(arg, &r));
}
-static inline bool checkowner_ #(ARGS_CHECKOWNER) {
+static bool checkowner_ #(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_proforma.c #);
REQUIRE(rdclass == #);
return (true);
}
-static inline bool checknames_ #(ARGS_CHECKNAMES) {
+static bool checknames_ #(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_proforma.c #);
REQUIRE(rdata->rdclass == #);
return (true);
}
-static inline int casecompare_ #(ARGS_COMPARE) {
+static int casecompare_ #(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
#define RRTYPE_PTR_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_ptr(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_ptr(ARGS_TOTEXT) {
isc_region_t region;
dns_name_t name;
return (dns_name_totext(&prefix, sub, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_ptr(ARGS_FROMWIRE) {
dns_name_t name;
return (dns_name_fromwire(&name, source, dctx, options, target));
}
-static inline isc_result_t
+static isc_result_t
towire_ptr(ARGS_TOWIRE) {
dns_name_t name;
dns_offsets_t offsets;
return (dns_name_towire(&name, cctx, target));
}
-static inline int
+static int
compare_ptr(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
return (dns_name_rdatacompare(&name1, &name2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_ptr(ARGS_FROMSTRUCT) {
dns_rdata_ptr_t *ptr = source;
isc_region_t region;
return (isc_buffer_copyregion(target, ®ion));
}
-static inline isc_result_t
+static isc_result_t
tostruct_ptr(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_ptr_t *ptr = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_ptr(ARGS_FREESTRUCT) {
dns_rdata_ptr_t *ptr = source;
ptr->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_ptr(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_ptr);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_ptr(ARGS_DIGEST) {
isc_region_t r;
dns_name_t name;
return (dns_name_digest(&name, digest, arg));
}
-static inline bool
+static bool
checkowner_ptr(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_ptr);
static const dns_name_t in_addr_arpa =
DNS_NAME_INITABSOLUTE(in_addr_arpa_data, in_addr_arpa_offsets);
-static inline bool
+static bool
checknames_ptr(ARGS_CHECKNAMES) {
isc_region_t region;
dns_name_t name;
return (true);
}
-static inline int
+static int
casecompare_ptr(ARGS_COMPARE) {
return (compare_ptr(rdata1, rdata2));
}
#define RRTYPE_RKEY_ATTRIBUTES 0
-static inline isc_result_t
+static isc_result_t
fromtext_rkey(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_rkey);
return (generic_fromtext_key(CALL_FROMTEXT));
}
-static inline isc_result_t
+static isc_result_t
totext_rkey(ARGS_TOTEXT) {
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_rkey);
return (generic_totext_key(CALL_TOTEXT));
}
-static inline isc_result_t
+static isc_result_t
fromwire_rkey(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_rkey);
return (generic_fromwire_key(CALL_FROMWIRE));
}
-static inline isc_result_t
+static isc_result_t
towire_rkey(ARGS_TOWIRE) {
isc_region_t sr;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline int
+static int
compare_rkey(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_rkey(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_rkey);
return (generic_fromstruct_key(CALL_FROMSTRUCT));
}
-static inline isc_result_t
+static isc_result_t
tostruct_rkey(ARGS_TOSTRUCT) {
dns_rdata_rkey_t *rkey = target;
return (generic_tostruct_key(CALL_TOSTRUCT));
}
-static inline void
+static void
freestruct_rkey(ARGS_FREESTRUCT) {
dns_rdata_rkey_t *rkey = (dns_rdata_rkey_t *)source;
generic_freestruct_key(source);
}
-static inline isc_result_t
+static isc_result_t
additionaldata_rkey(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_rkey);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_rkey(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_rkey(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_rkey);
return (true);
}
-static inline bool
+static bool
checknames_rkey(ARGS_CHECKNAMES) {
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_rkey);
return (true);
}
-static inline int
+static int
casecompare_rkey(ARGS_COMPARE) {
/*
* Treat ALG 253 (private DNS) subtype name case sensitively.
#define RRTYPE_RP_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_rp(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_rp(ARGS_TOTEXT) {
isc_region_t region;
dns_name_t rmail;
return (dns_name_totext(&prefix, sub, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_rp(ARGS_FROMWIRE) {
dns_name_t rmail;
dns_name_t email;
return (dns_name_fromwire(&email, source, dctx, options, target));
}
-static inline isc_result_t
+static isc_result_t
towire_rp(ARGS_TOWIRE) {
isc_region_t region;
dns_name_t rmail;
return (dns_name_towire(&rmail, cctx, target));
}
-static inline int
+static int
compare_rp(ARGS_COMPARE) {
isc_region_t region1;
isc_region_t region2;
return (dns_name_rdatacompare(&name1, &name2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_rp(ARGS_FROMSTRUCT) {
dns_rdata_rp_t *rp = source;
isc_region_t region;
return (isc_buffer_copyregion(target, ®ion));
}
-static inline isc_result_t
+static isc_result_t
tostruct_rp(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_rp_t *rp = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_rp(ARGS_FREESTRUCT) {
dns_rdata_rp_t *rp = source;
rp->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_rp(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_rp);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_rp(ARGS_DIGEST) {
isc_region_t r;
dns_name_t name;
return (dns_name_digest(&name, digest, arg));
}
-static inline bool
+static bool
checkowner_rp(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_rp);
return (true);
}
-static inline bool
+static bool
checknames_rp(ARGS_CHECKNAMES) {
isc_region_t region;
dns_name_t name;
return (true);
}
-static inline int
+static int
casecompare_rp(ARGS_COMPARE) {
return (compare_rp(rdata1, rdata2));
}
(DNS_RDATATYPEATTR_DNSSEC | DNS_RDATATYPEATTR_ZONECUTAUTH | \
DNS_RDATATYPEATTR_ATCNAME)
-static inline isc_result_t
+static isc_result_t
fromtext_rrsig(ARGS_FROMTEXT) {
isc_token_t token;
unsigned char c;
return (isc_base64_tobuffer(lexer, target, -2));
}
-static inline isc_result_t
+static isc_result_t
totext_rrsig(ARGS_TOTEXT) {
isc_region_t sr;
char buf[sizeof("4294967295")]; /* Also TYPE65000. */
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_rrsig(ARGS_FROMWIRE) {
isc_region_t sr;
dns_name_t name;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline isc_result_t
+static isc_result_t
towire_rrsig(ARGS_TOWIRE) {
isc_region_t sr;
dns_name_t name;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline int
+static int
compare_rrsig(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_rrsig(ARGS_FROMSTRUCT) {
dns_rdata_rrsig_t *sig = source;
return (mem_tobuffer(target, sig->signature, sig->siglen));
}
-static inline isc_result_t
+static isc_result_t
tostruct_rrsig(ARGS_TOSTRUCT) {
isc_region_t sr;
dns_rdata_rrsig_t *sig = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_rrsig(ARGS_FREESTRUCT) {
dns_rdata_rrsig_t *sig = (dns_rdata_rrsig_t *)source;
sig->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_rrsig(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_rrsig);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_rrsig(ARGS_DIGEST) {
REQUIRE(rdata->type == dns_rdatatype_rrsig);
return (ISC_R_NOTIMPLEMENTED);
}
-static inline dns_rdatatype_t
+static dns_rdatatype_t
covers_rrsig(dns_rdata_t *rdata) {
dns_rdatatype_t type;
isc_region_t r;
return (type);
}
-static inline bool
+static bool
checkowner_rrsig(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_rrsig);
return (true);
}
-static inline bool
+static bool
checknames_rrsig(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_rrsig);
return (true);
}
-static inline int
+static int
casecompare_rrsig(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
#define RRTYPE_RT_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_rt(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_rt(ARGS_TOTEXT) {
isc_region_t region;
dns_name_t name;
return (dns_name_totext(&prefix, sub, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_rt(ARGS_FROMWIRE) {
dns_name_t name;
isc_region_t sregion;
return (dns_name_fromwire(&name, source, dctx, options, target));
}
-static inline isc_result_t
+static isc_result_t
towire_rt(ARGS_TOWIRE) {
dns_name_t name;
dns_offsets_t offsets;
return (dns_name_towire(&name, cctx, target));
}
-static inline int
+static int
compare_rt(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
return (dns_name_rdatacompare(&name1, &name2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_rt(ARGS_FROMSTRUCT) {
dns_rdata_rt_t *rt = source;
isc_region_t region;
return (isc_buffer_copyregion(target, ®ion));
}
-static inline isc_result_t
+static isc_result_t
tostruct_rt(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_rt_t *rt = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_rt(ARGS_FREESTRUCT) {
dns_rdata_rt_t *rt = source;
rt->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_rt(ARGS_ADDLDATA) {
dns_name_t name;
dns_offsets_t offsets;
return ((add)(arg, &name, dns_rdatatype_a, NULL));
}
-static inline isc_result_t
+static isc_result_t
digest_rt(ARGS_DIGEST) {
isc_region_t r1, r2;
isc_result_t result;
return (dns_name_digest(&name, digest, arg));
}
-static inline bool
+static bool
checkowner_rt(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_rt);
return (true);
}
-static inline bool
+static bool
checknames_rt(ARGS_CHECKNAMES) {
isc_region_t region;
dns_name_t name;
return (true);
}
-static inline int
+static int
casecompare_rt(ARGS_COMPARE) {
return (compare_rt(rdata1, rdata2));
}
#define RRTYPE_SIG_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_sig(ARGS_FROMTEXT) {
isc_token_t token;
unsigned char c;
return (isc_base64_tobuffer(lexer, target, -2));
}
-static inline isc_result_t
+static isc_result_t
totext_sig(ARGS_TOTEXT) {
isc_region_t sr;
char buf[sizeof("4294967295")];
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_sig(ARGS_FROMWIRE) {
isc_region_t sr;
dns_name_t name;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline isc_result_t
+static isc_result_t
towire_sig(ARGS_TOWIRE) {
isc_region_t sr;
dns_name_t name;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline int
+static int
compare_sig(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_sig(ARGS_FROMSTRUCT) {
dns_rdata_sig_t *sig = source;
return (mem_tobuffer(target, sig->signature, sig->siglen));
}
-static inline isc_result_t
+static isc_result_t
tostruct_sig(ARGS_TOSTRUCT) {
isc_region_t sr;
dns_rdata_sig_t *sig = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_sig(ARGS_FREESTRUCT) {
dns_rdata_sig_t *sig = (dns_rdata_sig_t *)source;
sig->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_sig(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_sig);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_sig(ARGS_DIGEST) {
REQUIRE(rdata->type == dns_rdatatype_sig);
return (ISC_R_NOTIMPLEMENTED);
}
-static inline dns_rdatatype_t
+static dns_rdatatype_t
covers_sig(dns_rdata_t *rdata) {
dns_rdatatype_t type;
isc_region_t r;
return (type);
}
-static inline bool
+static bool
checkowner_sig(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_sig);
return (true);
}
-static inline bool
+static bool
checknames_sig(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_sig);
return (true);
}
-static inline int
+static int
casecompare_sig(ARGS_COMPARE) {
return (compare_sig(rdata1, rdata2));
}
#define RRTYPE_SINK_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_sink(ARGS_FROMTEXT) {
isc_token_t token;
return (isc_base64_tobuffer(lexer, target, -1));
}
-static inline isc_result_t
+static isc_result_t
totext_sink(ARGS_TOTEXT) {
isc_region_t sr;
char buf[sizeof("255 255 255")];
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_sink(ARGS_FROMWIRE) {
isc_region_t sr;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
towire_sink(ARGS_TOWIRE) {
REQUIRE(rdata->type == dns_rdatatype_sink);
REQUIRE(rdata->length >= 3);
return (mem_tobuffer(target, rdata->data, rdata->length));
}
-static inline int
+static int
compare_sink(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_sink(ARGS_FROMSTRUCT) {
dns_rdata_sink_t *sink = source;
return (mem_tobuffer(target, sink->data, sink->datalen));
}
-static inline isc_result_t
+static isc_result_t
tostruct_sink(ARGS_TOSTRUCT) {
dns_rdata_sink_t *sink = target;
isc_region_t sr;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_sink(ARGS_FREESTRUCT) {
dns_rdata_sink_t *sink = (dns_rdata_sink_t *)source;
sink->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_sink(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_sink);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_sink(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_sink(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_sink);
return (true);
}
-static inline bool
+static bool
checknames_sink(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_sink);
return (true);
}
-static inline int
+static int
casecompare_sink(ARGS_COMPARE) {
return (compare_sink(rdata1, rdata2));
}
#define RRTYPE_SMIMEA_ATTRIBUTES 0
-static inline isc_result_t
+static isc_result_t
fromtext_smimea(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_smimea);
return (generic_fromtext_tlsa(CALL_FROMTEXT));
}
-static inline isc_result_t
+static isc_result_t
totext_smimea(ARGS_TOTEXT) {
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_smimea);
return (generic_totext_tlsa(CALL_TOTEXT));
}
-static inline isc_result_t
+static isc_result_t
fromwire_smimea(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_smimea);
return (generic_fromwire_tlsa(CALL_FROMWIRE));
}
-static inline isc_result_t
+static isc_result_t
towire_smimea(ARGS_TOWIRE) {
isc_region_t sr;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline int
+static int
compare_smimea(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_smimea(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_smimea);
return (generic_fromstruct_tlsa(CALL_FROMSTRUCT));
}
-static inline isc_result_t
+static isc_result_t
tostruct_smimea(ARGS_TOSTRUCT) {
dns_rdata_smimea_t *smimea = target;
return (generic_tostruct_tlsa(CALL_TOSTRUCT));
}
-static inline void
+static void
freestruct_smimea(ARGS_FREESTRUCT) {
dns_rdata_smimea_t *smimea = source;
generic_freestruct_tlsa(source);
}
-static inline isc_result_t
+static isc_result_t
additionaldata_smimea(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_smimea);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_smimea(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_smimea(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_smimea);
return (true);
}
-static inline bool
+static bool
checknames_smimea(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_smimea);
return (true);
}
-static inline int
+static int
casecompare_smimea(ARGS_COMPARE) {
return (compare_smimea(rdata1, rdata2));
}
#define RRTYPE_SOA_ATTRIBUTES (DNS_RDATATYPEATTR_SINGLETON)
-static inline isc_result_t
+static isc_result_t
fromtext_soa(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
static const char *soa_fieldnames[5] = { "serial", "refresh", "retry", "expire",
"minimum" };
-static inline isc_result_t
+static isc_result_t
totext_soa(ARGS_TOTEXT) {
isc_region_t dregion;
dns_name_t mname;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_soa(ARGS_FROMWIRE) {
dns_name_t mname;
dns_name_t rname;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
towire_soa(ARGS_TOWIRE) {
isc_region_t sregion;
isc_region_t tregion;
return (ISC_R_SUCCESS);
}
-static inline int
+static int
compare_soa(ARGS_COMPARE) {
isc_region_t region1;
isc_region_t region2;
return (isc_region_compare(®ion1, ®ion2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_soa(ARGS_FROMSTRUCT) {
dns_rdata_soa_t *soa = source;
isc_region_t region;
return (uint32_tobuffer(soa->minimum, target));
}
-static inline isc_result_t
+static isc_result_t
tostruct_soa(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_soa_t *soa = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_soa(ARGS_FREESTRUCT) {
dns_rdata_soa_t *soa = source;
soa->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_soa(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_soa);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_soa(ARGS_DIGEST) {
isc_region_t r;
dns_name_t name;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_soa(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_soa);
return (true);
}
-static inline bool
+static bool
checknames_soa(ARGS_CHECKNAMES) {
isc_region_t region;
dns_name_t name;
return (true);
}
-static inline int
+static int
casecompare_soa(ARGS_COMPARE) {
return (compare_soa(rdata1, rdata2));
}
#define RRTYPE_SPF_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_spf(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_spf);
return (generic_fromtext_txt(CALL_FROMTEXT));
}
-static inline isc_result_t
+static isc_result_t
totext_spf(ARGS_TOTEXT) {
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_spf);
return (generic_totext_txt(CALL_TOTEXT));
}
-static inline isc_result_t
+static isc_result_t
fromwire_spf(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_spf);
return (generic_fromwire_txt(CALL_FROMWIRE));
}
-static inline isc_result_t
+static isc_result_t
towire_spf(ARGS_TOWIRE) {
REQUIRE(rdata->type == dns_rdatatype_spf);
return (mem_tobuffer(target, rdata->data, rdata->length));
}
-static inline int
+static int
compare_spf(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_spf(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_spf);
return (generic_fromstruct_txt(CALL_FROMSTRUCT));
}
-static inline isc_result_t
+static isc_result_t
tostruct_spf(ARGS_TOSTRUCT) {
dns_rdata_spf_t *spf = target;
return (generic_tostruct_txt(CALL_TOSTRUCT));
}
-static inline void
+static void
freestruct_spf(ARGS_FREESTRUCT) {
dns_rdata_spf_t *spf = source;
generic_freestruct_txt(source);
}
-static inline isc_result_t
+static isc_result_t
additionaldata_spf(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_spf);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_spf(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_spf(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_spf);
return (true);
}
-static inline bool
+static bool
checknames_spf(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_spf);
return (true);
}
-static inline int
+static int
casecompare_spf(ARGS_COMPARE) {
return (compare_spf(rdata1, rdata2));
}
#define RRTYPE_SSHFP_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_sshfp(ARGS_FROMTEXT) {
isc_token_t token;
int len = -1;
return (isc_hex_tobuffer(lexer, target, len));
}
-static inline isc_result_t
+static isc_result_t
totext_sshfp(ARGS_TOTEXT) {
isc_region_t sr;
char buf[sizeof("64000 ")];
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_sshfp(ARGS_FROMWIRE) {
isc_region_t sr;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline isc_result_t
+static isc_result_t
towire_sshfp(ARGS_TOWIRE) {
isc_region_t sr;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline int
+static int
compare_sshfp(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_sshfp(ARGS_FROMSTRUCT) {
dns_rdata_sshfp_t *sshfp = source;
return (mem_tobuffer(target, sshfp->digest, sshfp->length));
}
-static inline isc_result_t
+static isc_result_t
tostruct_sshfp(ARGS_TOSTRUCT) {
dns_rdata_sshfp_t *sshfp = target;
isc_region_t region;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_sshfp(ARGS_FREESTRUCT) {
dns_rdata_sshfp_t *sshfp = source;
sshfp->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_sshfp(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_sshfp);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_sshfp(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_sshfp(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_sshfp);
return (true);
}
-static inline bool
+static bool
checknames_sshfp(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_sshfp);
return (true);
}
-static inline int
+static int
casecompare_sshfp(ARGS_COMPARE) {
return (compare_sshfp(rdata1, rdata2));
}
#define RRTYPE_TA_ATTRIBUTES 0
-static inline isc_result_t
+static isc_result_t
fromtext_ta(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_ta);
return (generic_fromtext_ds(CALL_FROMTEXT));
}
-static inline isc_result_t
+static isc_result_t
totext_ta(ARGS_TOTEXT) {
REQUIRE(rdata->type == dns_rdatatype_ta);
return (generic_totext_ds(CALL_TOTEXT));
}
-static inline isc_result_t
+static isc_result_t
fromwire_ta(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_ta);
return (generic_fromwire_ds(CALL_FROMWIRE));
}
-static inline isc_result_t
+static isc_result_t
towire_ta(ARGS_TOWIRE) {
isc_region_t sr;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline int
+static int
compare_ta(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_ta(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_ta);
return (generic_fromstruct_ds(CALL_FROMSTRUCT));
}
-static inline isc_result_t
+static isc_result_t
tostruct_ta(ARGS_TOSTRUCT) {
dns_rdata_ds_t *ds = target;
return (generic_tostruct_ds(CALL_TOSTRUCT));
}
-static inline void
+static void
freestruct_ta(ARGS_FREESTRUCT) {
dns_rdata_ta_t *ds = source;
ds->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_ta(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_ta);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_ta(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_ta(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_ta);
return (true);
}
-static inline bool
+static bool
checknames_ta(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_ta);
return (true);
}
-static inline int
+static int
casecompare_ta(ARGS_COMPARE) {
return (compare_ta(rdata1, rdata2));
}
#define RRTYPE_TALINK_ATTRIBUTES 0
-static inline isc_result_t
+static isc_result_t
fromtext_talink(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_talink(ARGS_TOTEXT) {
isc_region_t dregion;
dns_name_t prev;
return (dns_name_totext(&prefix, sub, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_talink(ARGS_FROMWIRE) {
dns_name_t prev;
dns_name_t next;
return (dns_name_fromwire(&next, source, dctx, options, target));
}
-static inline isc_result_t
+static isc_result_t
towire_talink(ARGS_TOWIRE) {
isc_region_t sregion;
dns_name_t prev;
return (dns_name_towire(&next, cctx, target));
}
-static inline int
+static int
compare_talink(ARGS_COMPARE) {
isc_region_t region1;
isc_region_t region2;
return (isc_region_compare(®ion1, ®ion2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_talink(ARGS_FROMSTRUCT) {
dns_rdata_talink_t *talink = source;
isc_region_t region;
return (isc_buffer_copyregion(target, ®ion));
}
-static inline isc_result_t
+static isc_result_t
tostruct_talink(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_talink_t *talink = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_talink(ARGS_FREESTRUCT) {
dns_rdata_talink_t *talink = source;
talink->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_talink(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_talink);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_talink(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_talink(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_talink);
return (true);
}
-static inline bool
+static bool
checknames_talink(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_talink);
return (true);
}
-static inline int
+static int
casecompare_talink(ARGS_COMPARE) {
return (compare_talink(rdata1, rdata2));
}
#define RRTYPE_TKEY_ATTRIBUTES (DNS_RDATATYPEATTR_META)
-static inline isc_result_t
+static isc_result_t
fromtext_tkey(ARGS_FROMTEXT) {
isc_token_t token;
dns_rcode_t rcode;
return (isc_base64_tobuffer(lexer, target, (int)token.value.as_ulong));
}
-static inline isc_result_t
+static isc_result_t
totext_tkey(ARGS_TOTEXT) {
isc_region_t sr, dr;
char buf[sizeof("4294967295 ")];
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_tkey(ARGS_FROMWIRE) {
isc_region_t sr;
unsigned long n;
return (mem_tobuffer(target, sr.base, n + 2));
}
-static inline isc_result_t
+static isc_result_t
towire_tkey(ARGS_TOWIRE) {
isc_region_t sr;
dns_name_t name;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline int
+static int
compare_tkey(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_tkey(ARGS_FROMSTRUCT) {
dns_rdata_tkey_t *tkey = source;
return (mem_tobuffer(target, tkey->other, tkey->otherlen));
}
-static inline isc_result_t
+static isc_result_t
tostruct_tkey(ARGS_TOSTRUCT) {
dns_rdata_tkey_t *tkey = target;
dns_name_t alg;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_tkey(ARGS_FREESTRUCT) {
dns_rdata_tkey_t *tkey = (dns_rdata_tkey_t *)source;
tkey->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_tkey(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_tkey);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_tkey(ARGS_DIGEST) {
UNUSED(rdata);
UNUSED(digest);
return (ISC_R_NOTIMPLEMENTED);
}
-static inline bool
+static bool
checkowner_tkey(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_tkey);
return (true);
}
-static inline bool
+static bool
checknames_tkey(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_tkey);
return (true);
}
-static inline int
+static int
casecompare_tkey(ARGS_COMPARE) {
return (compare_tkey(rdata1, rdata2));
}
#define RRTYPE_TLSA_ATTRIBUTES 0
-static inline isc_result_t
+static isc_result_t
generic_fromtext_tlsa(ARGS_FROMTEXT) {
isc_token_t token;
return (isc_hex_tobuffer(lexer, target, -2));
}
-static inline isc_result_t
+static isc_result_t
generic_totext_tlsa(ARGS_TOTEXT) {
isc_region_t sr;
char buf[sizeof("64000 ")];
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
generic_fromwire_tlsa(ARGS_FROMWIRE) {
isc_region_t sr;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline isc_result_t
+static isc_result_t
fromtext_tlsa(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_tlsa);
return (generic_fromtext_tlsa(CALL_FROMTEXT));
}
-static inline isc_result_t
+static isc_result_t
totext_tlsa(ARGS_TOTEXT) {
REQUIRE(rdata->type == dns_rdatatype_tlsa);
return (generic_totext_tlsa(CALL_TOTEXT));
}
-static inline isc_result_t
+static isc_result_t
fromwire_tlsa(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_tlsa);
return (generic_fromwire_tlsa(CALL_FROMWIRE));
}
-static inline isc_result_t
+static isc_result_t
towire_tlsa(ARGS_TOWIRE) {
isc_region_t sr;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline int
+static int
compare_tlsa(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
generic_fromstruct_tlsa(ARGS_FROMSTRUCT) {
dns_rdata_tlsa_t *tlsa = source;
return (mem_tobuffer(target, tlsa->data, tlsa->length));
}
-static inline isc_result_t
+static isc_result_t
generic_tostruct_tlsa(ARGS_TOSTRUCT) {
dns_rdata_tlsa_t *tlsa = target;
isc_region_t region;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
generic_freestruct_tlsa(ARGS_FREESTRUCT) {
dns_rdata_tlsa_t *tlsa = source;
tlsa->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
fromstruct_tlsa(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_tlsa);
return (generic_fromstruct_tlsa(CALL_FROMSTRUCT));
}
-static inline isc_result_t
+static isc_result_t
tostruct_tlsa(ARGS_TOSTRUCT) {
dns_rdata_tlsa_t *tlsa = target;
return (generic_tostruct_tlsa(CALL_TOSTRUCT));
}
-static inline void
+static void
freestruct_tlsa(ARGS_FREESTRUCT) {
dns_rdata_tlsa_t *tlsa = source;
generic_freestruct_tlsa(source);
}
-static inline isc_result_t
+static isc_result_t
additionaldata_tlsa(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_tlsa);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_tlsa(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_tlsa(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_tlsa);
return (true);
}
-static inline bool
+static bool
checknames_tlsa(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_tlsa);
return (true);
}
-static inline int
+static int
casecompare_tlsa(ARGS_COMPARE) {
return (compare_tlsa(rdata1, rdata2));
}
#define RRTYPE_TXT_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
generic_fromtext_txt(ARGS_FROMTEXT) {
isc_token_t token;
int strings;
return (strings == 0 ? ISC_R_UNEXPECTEDEND : ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
generic_totext_txt(ARGS_TOTEXT) {
isc_region_t region;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
generic_fromwire_txt(ARGS_FROMWIRE) {
isc_result_t result;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromtext_txt(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_txt);
return (generic_fromtext_txt(CALL_FROMTEXT));
}
-static inline isc_result_t
+static isc_result_t
totext_txt(ARGS_TOTEXT) {
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_txt);
return (generic_totext_txt(CALL_TOTEXT));
}
-static inline isc_result_t
+static isc_result_t
fromwire_txt(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_txt);
return (generic_fromwire_txt(CALL_FROMWIRE));
}
-static inline isc_result_t
+static isc_result_t
towire_txt(ARGS_TOWIRE) {
REQUIRE(rdata->type == dns_rdatatype_txt);
return (mem_tobuffer(target, rdata->data, rdata->length));
}
-static inline int
+static int
compare_txt(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
generic_fromstruct_txt(ARGS_FROMSTRUCT) {
dns_rdata_txt_t *txt = source;
isc_region_t region;
return (mem_tobuffer(target, txt->txt, txt->txt_len));
}
-static inline isc_result_t
+static isc_result_t
generic_tostruct_txt(ARGS_TOSTRUCT) {
dns_rdata_txt_t *txt = target;
isc_region_t r;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
generic_freestruct_txt(ARGS_FREESTRUCT) {
dns_rdata_txt_t *txt = source;
txt->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
fromstruct_txt(ARGS_FROMSTRUCT) {
REQUIRE(type == dns_rdatatype_txt);
return (generic_fromstruct_txt(CALL_FROMSTRUCT));
}
-static inline isc_result_t
+static isc_result_t
tostruct_txt(ARGS_TOSTRUCT) {
dns_rdata_txt_t *txt = target;
return (generic_tostruct_txt(CALL_TOSTRUCT));
}
-static inline void
+static void
freestruct_txt(ARGS_FREESTRUCT) {
dns_rdata_txt_t *txt = source;
generic_freestruct_txt(source);
}
-static inline isc_result_t
+static isc_result_t
additionaldata_txt(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_txt);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_txt(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_txt(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_txt);
return (true);
}
-static inline bool
+static bool
checknames_txt(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_txt);
return (true);
}
-static inline int
+static int
casecompare_txt(ARGS_COMPARE) {
return (compare_txt(rdata1, rdata2));
}
#define RRTYPE_URI_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_uri(ARGS_FROMTEXT) {
isc_token_t token;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_uri(ARGS_TOTEXT) {
isc_region_t region;
unsigned short priority, weight;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_uri(ARGS_FROMWIRE) {
isc_region_t region;
return (mem_tobuffer(target, region.base, region.length));
}
-static inline isc_result_t
+static isc_result_t
towire_uri(ARGS_TOWIRE) {
isc_region_t region;
return (mem_tobuffer(target, region.base, region.length));
}
-static inline int
+static int
compare_uri(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_uri(ARGS_FROMSTRUCT) {
dns_rdata_uri_t *uri = source;
return (mem_tobuffer(target, uri->target, uri->tgt_len));
}
-static inline isc_result_t
+static isc_result_t
tostruct_uri(ARGS_TOSTRUCT) {
dns_rdata_uri_t *uri = target;
isc_region_t sr;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_uri(ARGS_FREESTRUCT) {
dns_rdata_uri_t *uri = (dns_rdata_uri_t *)source;
uri->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_uri(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_uri);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_uri(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_uri(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_uri);
return (true);
}
-static inline bool
+static bool
checknames_uri(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_uri);
return (true);
}
-static inline int
+static int
casecompare_uri(ARGS_COMPARE) {
return (compare_uri(rdata1, rdata2));
}
#define RRTYPE_X25_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_x25(ARGS_FROMTEXT) {
isc_token_t token;
unsigned int i;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_x25(ARGS_TOTEXT) {
isc_region_t region;
return (txt_totext(®ion, true, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_x25(ARGS_FROMWIRE) {
isc_region_t sr;
unsigned int i;
return (txt_fromwire(source, target));
}
-static inline isc_result_t
+static isc_result_t
towire_x25(ARGS_TOWIRE) {
UNUSED(cctx);
return (mem_tobuffer(target, rdata->data, rdata->length));
}
-static inline int
+static int
compare_x25(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_x25(ARGS_FROMSTRUCT) {
dns_rdata_x25_t *x25 = source;
uint8_t i;
return (mem_tobuffer(target, x25->x25, x25->x25_len));
}
-static inline isc_result_t
+static isc_result_t
tostruct_x25(ARGS_TOSTRUCT) {
dns_rdata_x25_t *x25 = target;
isc_region_t r;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_x25(ARGS_FREESTRUCT) {
dns_rdata_x25_t *x25 = source;
x25->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_x25(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_x25);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_x25(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_x25(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_x25);
return (true);
}
-static inline bool
+static bool
checknames_x25(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_x25);
return (true);
}
-static inline int
+static int
casecompare_x25(ARGS_COMPARE) {
return (compare_x25(rdata1, rdata2));
}
#define RRTYPE_ZONEMD_ATTRIBUTES 0
-static inline isc_result_t
+static isc_result_t
fromtext_zonemd(ARGS_FROMTEXT) {
isc_token_t token;
int digest_type, length;
return (result);
}
-static inline isc_result_t
+static isc_result_t
totext_zonemd(ARGS_TOTEXT) {
isc_region_t sr;
char buf[sizeof("0123456789")];
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_zonemd(ARGS_FROMWIRE) {
isc_region_t sr;
size_t digestlen = 0;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline isc_result_t
+static isc_result_t
towire_zonemd(ARGS_TOWIRE) {
isc_region_t sr;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline int
+static int
compare_zonemd(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_zonemd(ARGS_FROMSTRUCT) {
dns_rdata_zonemd_t *zonemd = source;
return (mem_tobuffer(target, zonemd->digest, zonemd->length));
}
-static inline isc_result_t
+static isc_result_t
tostruct_zonemd(ARGS_TOSTRUCT) {
dns_rdata_zonemd_t *zonemd = target;
isc_region_t region;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_zonemd(ARGS_FREESTRUCT) {
dns_rdata_zonemd_t *zonemd = source;
zonemd->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_zonemd(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_zonemd);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_zonemd(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_zonemd(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_zonemd);
return (true);
}
-static inline bool
+static bool
checknames_zonemd(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_zonemd);
return (true);
}
-static inline int
+static int
casecompare_zonemd(ARGS_COMPARE) {
return (compare_zonemd(rdata1, rdata2));
}
#define RRTYPE_A_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_hs_a(ARGS_FROMTEXT) {
isc_token_t token;
struct in_addr addr;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_hs_a(ARGS_TOTEXT) {
isc_region_t region;
return (inet_totext(AF_INET, tctx->flags, ®ion, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_hs_a(ARGS_FROMWIRE) {
isc_region_t sregion;
isc_region_t tregion;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
towire_hs_a(ARGS_TOWIRE) {
isc_region_t region;
return (ISC_R_SUCCESS);
}
-static inline int
+static int
compare_hs_a(ARGS_COMPARE) {
int order;
return (order);
}
-static inline isc_result_t
+static isc_result_t
fromstruct_hs_a(ARGS_FROMSTRUCT) {
dns_rdata_hs_a_t *a = source;
uint32_t n;
return (uint32_tobuffer(n, target));
}
-static inline isc_result_t
+static isc_result_t
tostruct_hs_a(ARGS_TOSTRUCT) {
dns_rdata_hs_a_t *a = target;
uint32_t n;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_hs_a(ARGS_FREESTRUCT) {
UNUSED(source);
REQUIRE(source != NULL);
}
-static inline isc_result_t
+static isc_result_t
additionaldata_hs_a(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_a);
REQUIRE(rdata->rdclass == dns_rdataclass_hs);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_hs_a(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_hs_a(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_a);
REQUIRE(rdclass == dns_rdataclass_hs);
return (true);
}
-static inline bool
+static bool
checknames_hs_a(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_a);
REQUIRE(rdata->rdclass == dns_rdataclass_hs);
return (true);
}
-static inline int
+static int
casecompare_hs_a(ARGS_COMPARE) {
return (compare_hs_a(rdata1, rdata2));
}
#define RRTYPE_A6_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_in_a6(ARGS_FROMTEXT) {
isc_token_t token;
unsigned char addr[16];
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_in_a6(ARGS_TOTEXT) {
isc_region_t sr, ar;
unsigned char addr[16];
return (dns_name_totext(&prefix, sub, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_in_a6(ARGS_FROMWIRE) {
isc_region_t sr;
unsigned char prefixlen;
return (dns_name_fromwire(&name, source, dctx, options, target));
}
-static inline isc_result_t
+static isc_result_t
towire_in_a6(ARGS_TOWIRE) {
isc_region_t sr;
dns_name_t name;
return (dns_name_towire(&name, cctx, target));
}
-static inline int
+static int
compare_in_a6(ARGS_COMPARE) {
int order;
unsigned char prefixlen1, prefixlen2;
return (dns_name_rdatacompare(&name1, &name2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_in_a6(ARGS_FROMSTRUCT) {
dns_rdata_in_a6_t *a6 = source;
isc_region_t region;
return (isc_buffer_copyregion(target, ®ion));
}
-static inline isc_result_t
+static isc_result_t
tostruct_in_a6(ARGS_TOSTRUCT) {
dns_rdata_in_a6_t *a6 = target;
unsigned char octets;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_in_a6(ARGS_FREESTRUCT) {
dns_rdata_in_a6_t *a6 = source;
a6->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_in_a6(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_a6);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_in_a6(ARGS_DIGEST) {
isc_region_t r1, r2;
unsigned char prefixlen, octets;
return (dns_name_digest(&name, digest, arg));
}
-static inline bool
+static bool
checkowner_in_a6(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_a6);
REQUIRE(rdclass == dns_rdataclass_in);
return (dns_name_ishostname(name, wildcard));
}
-static inline bool
+static bool
checknames_in_a6(ARGS_CHECKNAMES) {
isc_region_t region;
dns_name_t name;
return (true);
}
-static inline int
+static int
casecompare_in_a6(ARGS_COMPARE) {
return (compare_in_a6(rdata1, rdata2));
}
#define RRTYPE_A_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_in_a(ARGS_FROMTEXT) {
isc_token_t token;
struct in_addr addr;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_in_a(ARGS_TOTEXT) {
isc_region_t region;
return (inet_totext(AF_INET, tctx->flags, ®ion, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_in_a(ARGS_FROMWIRE) {
isc_region_t sregion;
isc_region_t tregion;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
towire_in_a(ARGS_TOWIRE) {
isc_region_t region;
return (ISC_R_SUCCESS);
}
-static inline int
+static int
compare_in_a(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_in_a(ARGS_FROMSTRUCT) {
dns_rdata_in_a_t *a = source;
uint32_t n;
return (uint32_tobuffer(n, target));
}
-static inline isc_result_t
+static isc_result_t
tostruct_in_a(ARGS_TOSTRUCT) {
dns_rdata_in_a_t *a = target;
uint32_t n;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_in_a(ARGS_FREESTRUCT) {
dns_rdata_in_a_t *a = source;
UNUSED(a);
}
-static inline isc_result_t
+static isc_result_t
additionaldata_in_a(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_a);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_in_a(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_in_a(ARGS_CHECKOWNER) {
dns_name_t prefix, suffix;
unsigned int labels, i;
return (dns_name_ishostname(name, wildcard));
}
-static inline bool
+static bool
checknames_in_a(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_a);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (true);
}
-static inline int
+static int
casecompare_in_a(ARGS_COMPARE) {
return (compare_in_a(rdata1, rdata2));
}
#define RRTYPE_AAAA_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_in_aaaa(ARGS_FROMTEXT) {
isc_token_t token;
unsigned char addr[16];
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_in_aaaa(ARGS_TOTEXT) {
isc_region_t region;
return (inet_totext(AF_INET6, tctx->flags, ®ion, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_in_aaaa(ARGS_FROMWIRE) {
isc_region_t sregion;
isc_region_t tregion;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
towire_in_aaaa(ARGS_TOWIRE) {
isc_region_t region;
return (ISC_R_SUCCESS);
}
-static inline int
+static int
compare_in_aaaa(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_in_aaaa(ARGS_FROMSTRUCT) {
dns_rdata_in_aaaa_t *aaaa = source;
return (mem_tobuffer(target, aaaa->in6_addr.s6_addr, 16));
}
-static inline isc_result_t
+static isc_result_t
tostruct_in_aaaa(ARGS_TOSTRUCT) {
dns_rdata_in_aaaa_t *aaaa = target;
isc_region_t r;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_in_aaaa(ARGS_FREESTRUCT) {
dns_rdata_in_aaaa_t *aaaa = source;
UNUSED(aaaa);
}
-static inline isc_result_t
+static isc_result_t
additionaldata_in_aaaa(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_aaaa);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_in_aaaa(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_in_aaaa(ARGS_CHECKOWNER) {
dns_name_t prefix, suffix;
return (dns_name_ishostname(name, wildcard));
}
-static inline bool
+static bool
checknames_in_aaaa(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_aaaa);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (true);
}
-static inline int
+static int
casecompare_in_aaaa(ARGS_COMPARE) {
return (compare_in_aaaa(rdata1, rdata2));
}
#define RRTYPE_APL_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_in_apl(ARGS_FROMTEXT) {
isc_token_t token;
unsigned char addr[16];
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_in_apl(ARGS_TOTEXT) {
isc_region_t sr;
isc_region_t ir;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_in_apl(ARGS_FROMWIRE) {
isc_region_t sr, sr2;
isc_region_t tr;
return (mem_tobuffer(target, sr2.base, sr2.length));
}
-static inline isc_result_t
+static isc_result_t
towire_in_apl(ARGS_TOWIRE) {
UNUSED(cctx);
return (mem_tobuffer(target, rdata->data, rdata->length));
}
-static inline int
+static int
compare_in_apl(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_in_apl(ARGS_FROMSTRUCT) {
dns_rdata_in_apl_t *apl = source;
isc_buffer_t b;
return (fromwire_in_apl(rdclass, type, &b, NULL, false, target));
}
-static inline isc_result_t
+static isc_result_t
tostruct_in_apl(ARGS_TOSTRUCT) {
dns_rdata_in_apl_t *apl = target;
isc_region_t r;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_in_apl(ARGS_FREESTRUCT) {
dns_rdata_in_apl_t *apl = source;
return (apl->apl_len);
}
-static inline isc_result_t
+static isc_result_t
additionaldata_in_apl(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_apl);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_in_apl(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_in_apl(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_apl);
REQUIRE(rdclass == dns_rdataclass_in);
return (true);
}
-static inline bool
+static bool
checknames_in_apl(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_apl);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (true);
}
-static inline int
+static int
casecompare_in_apl(ARGS_COMPARE) {
return (compare_in_apl(rdata1, rdata2));
}
#define RRTYPE_ATMA_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_in_atma(ARGS_FROMTEXT) {
isc_token_t token;
isc_textregion_t *sr;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_in_atma(ARGS_TOTEXT) {
isc_region_t region;
char buf[sizeof("xx")];
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_in_atma(ARGS_FROMWIRE) {
isc_region_t region;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
towire_in_atma(ARGS_TOWIRE) {
REQUIRE(rdata->type == dns_rdatatype_atma);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (mem_tobuffer(target, rdata->data, rdata->length));
}
-static inline int
+static int
compare_in_atma(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_in_atma(ARGS_FROMSTRUCT) {
dns_rdata_in_atma_t *atma = source;
return (mem_tobuffer(target, atma->atma, atma->atma_len));
}
-static inline isc_result_t
+static isc_result_t
tostruct_in_atma(ARGS_TOSTRUCT) {
dns_rdata_in_atma_t *atma = target;
isc_region_t r;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_in_atma(ARGS_FREESTRUCT) {
dns_rdata_in_atma_t *atma = source;
atma->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_in_atma(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_atma);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_in_atma(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_in_atma(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_atma);
REQUIRE(rdclass == dns_rdataclass_in);
return (true);
}
-static inline bool
+static bool
checknames_in_atma(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_atma);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (true);
}
-static inline int
+static int
casecompare_in_atma(ARGS_COMPARE) {
return (compare_in_atma(rdata1, rdata2));
}
#define RRTYPE_DHCID_ATTRIBUTES 0
-static inline isc_result_t
+static isc_result_t
fromtext_in_dhcid(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_dhcid);
REQUIRE(rdclass == dns_rdataclass_in);
return (isc_base64_tobuffer(lexer, target, -2));
}
-static inline isc_result_t
+static isc_result_t
totext_in_dhcid(ARGS_TOTEXT) {
isc_region_t sr, sr2;
/* " ; 64000 255 64000" */
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_in_dhcid(ARGS_FROMWIRE) {
isc_region_t sr;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline isc_result_t
+static isc_result_t
towire_in_dhcid(ARGS_TOWIRE) {
isc_region_t sr;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline int
+static int
compare_in_dhcid(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_in_dhcid(ARGS_FROMSTRUCT) {
dns_rdata_in_dhcid_t *dhcid = source;
return (mem_tobuffer(target, dhcid->dhcid, dhcid->length));
}
-static inline isc_result_t
+static isc_result_t
tostruct_in_dhcid(ARGS_TOSTRUCT) {
dns_rdata_in_dhcid_t *dhcid = target;
isc_region_t region;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_in_dhcid(ARGS_FREESTRUCT) {
dns_rdata_in_dhcid_t *dhcid = source;
dhcid->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_in_dhcid(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_dhcid);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_in_dhcid(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_in_dhcid(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_dhcid);
REQUIRE(rdclass == dns_rdataclass_in);
return (true);
}
-static inline bool
+static bool
checknames_in_dhcid(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_dhcid);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (true);
}
-static inline int
+static int
casecompare_in_dhcid(ARGS_COMPARE) {
return (compare_in_dhcid(rdata1, rdata2));
}
#define RRTYPE_EID_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_in_eid(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_eid);
REQUIRE(rdclass == dns_rdataclass_in);
return (isc_hex_tobuffer(lexer, target, -2));
}
-static inline isc_result_t
+static isc_result_t
totext_in_eid(ARGS_TOTEXT) {
isc_region_t region;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_in_eid(ARGS_FROMWIRE) {
isc_region_t region;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
towire_in_eid(ARGS_TOWIRE) {
REQUIRE(rdata->type == dns_rdatatype_eid);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (mem_tobuffer(target, rdata->data, rdata->length));
}
-static inline int
+static int
compare_in_eid(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_in_eid(ARGS_FROMSTRUCT) {
dns_rdata_in_eid_t *eid = source;
return (mem_tobuffer(target, eid->eid, eid->eid_len));
}
-static inline isc_result_t
+static isc_result_t
tostruct_in_eid(ARGS_TOSTRUCT) {
dns_rdata_in_eid_t *eid = target;
isc_region_t r;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_in_eid(ARGS_FREESTRUCT) {
dns_rdata_in_eid_t *eid = source;
eid->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_in_eid(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_eid);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_in_eid(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_in_eid(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_eid);
REQUIRE(rdclass == dns_rdataclass_in);
return (true);
}
-static inline bool
+static bool
checknames_in_eid(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_eid);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (true);
}
-static inline int
+static int
casecompare_in_eid(ARGS_COMPARE) {
return (compare_in_eid(rdata1, rdata2));
}
* since wire and presentation formats are identical.
*/
-static inline isc_result_t
+static isc_result_t
fromtext_in_https(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_https);
REQUIRE(rdclass == dns_rdataclass_in);
return (generic_fromtext_in_svcb(CALL_FROMTEXT));
}
-static inline isc_result_t
+static isc_result_t
totext_in_https(ARGS_TOTEXT) {
REQUIRE(rdata->type == dns_rdatatype_https);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (generic_totext_in_svcb(CALL_TOTEXT));
}
-static inline isc_result_t
+static isc_result_t
fromwire_in_https(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_https);
REQUIRE(rdclass == dns_rdataclass_in);
return (generic_fromwire_in_svcb(CALL_FROMWIRE));
}
-static inline isc_result_t
+static isc_result_t
towire_in_https(ARGS_TOWIRE) {
REQUIRE(rdata->type == dns_rdatatype_https);
REQUIRE(rdata->length != 0);
return (generic_towire_in_svcb(CALL_TOWIRE));
}
-static inline int
+static int
compare_in_https(ARGS_COMPARE) {
isc_region_t region1;
isc_region_t region2;
return (isc_region_compare(®ion1, ®ion2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_in_https(ARGS_FROMSTRUCT) {
dns_rdata_in_https_t *https = source;
return (generic_fromstruct_in_svcb(CALL_FROMSTRUCT));
}
-static inline isc_result_t
+static isc_result_t
tostruct_in_https(ARGS_TOSTRUCT) {
dns_rdata_in_https_t *https = target;
return (generic_tostruct_in_svcb(CALL_TOSTRUCT));
}
-static inline void
+static void
freestruct_in_https(ARGS_FREESTRUCT) {
dns_rdata_in_https_t *https = source;
generic_freestruct_in_svcb(CALL_FREESTRUCT);
}
-static inline isc_result_t
+static isc_result_t
additionaldata_in_https(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_https);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (generic_additionaldata_in_svcb(CALL_ADDLDATA));
}
-static inline isc_result_t
+static isc_result_t
digest_in_https(ARGS_DIGEST) {
isc_region_t region1;
return ((digest)(arg, ®ion1));
}
-static inline bool
+static bool
checkowner_in_https(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_https);
REQUIRE(rdclass == dns_rdataclass_in);
return (true);
}
-static inline bool
+static bool
checknames_in_https(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_https);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (generic_checknames_in_svcb(CALL_CHECKNAMES));
}
-static inline int
+static int
casecompare_in_https(ARGS_COMPARE) {
return (compare_in_https(rdata1, rdata2));
}
#define RRTYPE_KX_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_in_kx(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_in_kx(ARGS_TOTEXT) {
isc_region_t region;
dns_name_t name;
return (dns_name_totext(&prefix, sub, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_in_kx(ARGS_FROMWIRE) {
dns_name_t name;
isc_region_t sregion;
return (dns_name_fromwire(&name, source, dctx, options, target));
}
-static inline isc_result_t
+static isc_result_t
towire_in_kx(ARGS_TOWIRE) {
dns_name_t name;
dns_offsets_t offsets;
return (dns_name_towire(&name, cctx, target));
}
-static inline int
+static int
compare_in_kx(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
return (dns_name_rdatacompare(&name1, &name2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_in_kx(ARGS_FROMSTRUCT) {
dns_rdata_in_kx_t *kx = source;
isc_region_t region;
return (isc_buffer_copyregion(target, ®ion));
}
-static inline isc_result_t
+static isc_result_t
tostruct_in_kx(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_in_kx_t *kx = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_in_kx(ARGS_FREESTRUCT) {
dns_rdata_in_kx_t *kx = source;
kx->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_in_kx(ARGS_ADDLDATA) {
dns_name_t name;
dns_offsets_t offsets;
return ((add)(arg, &name, dns_rdatatype_a, NULL));
}
-static inline isc_result_t
+static isc_result_t
digest_in_kx(ARGS_DIGEST) {
isc_region_t r1, r2;
dns_name_t name;
return (dns_name_digest(&name, digest, arg));
}
-static inline bool
+static bool
checkowner_in_kx(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_kx);
REQUIRE(rdclass == dns_rdataclass_in);
return (true);
}
-static inline bool
+static bool
checknames_in_kx(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_kx);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (true);
}
-static inline int
+static int
casecompare_in_kx(ARGS_COMPARE) {
return (compare_in_kx(rdata1, rdata2));
}
#define RRTYPE_NIMLOC_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_in_nimloc(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_nimloc);
REQUIRE(rdclass == dns_rdataclass_in);
return (isc_hex_tobuffer(lexer, target, -2));
}
-static inline isc_result_t
+static isc_result_t
totext_in_nimloc(ARGS_TOTEXT) {
isc_region_t region;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_in_nimloc(ARGS_FROMWIRE) {
isc_region_t region;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
towire_in_nimloc(ARGS_TOWIRE) {
REQUIRE(rdata->type == dns_rdatatype_nimloc);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (mem_tobuffer(target, rdata->data, rdata->length));
}
-static inline int
+static int
compare_in_nimloc(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_in_nimloc(ARGS_FROMSTRUCT) {
dns_rdata_in_nimloc_t *nimloc = source;
return (mem_tobuffer(target, nimloc->nimloc, nimloc->nimloc_len));
}
-static inline isc_result_t
+static isc_result_t
tostruct_in_nimloc(ARGS_TOSTRUCT) {
dns_rdata_in_nimloc_t *nimloc = target;
isc_region_t r;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_in_nimloc(ARGS_FREESTRUCT) {
dns_rdata_in_nimloc_t *nimloc = source;
nimloc->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_in_nimloc(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_nimloc);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_in_nimloc(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_in_nimloc(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_nimloc);
REQUIRE(rdclass == dns_rdataclass_in);
return (true);
}
-static inline bool
+static bool
checknames_in_nimloc(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_nimloc);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (true);
}
-static inline int
+static int
casecompare_in_nimloc(ARGS_COMPARE) {
return (compare_in_nimloc(rdata1, rdata2));
}
#define RRTYPE_NSAP_PTR_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_in_nsap_ptr(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_in_nsap_ptr(ARGS_TOTEXT) {
isc_region_t region;
dns_name_t name;
return (dns_name_totext(&prefix, sub, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_in_nsap_ptr(ARGS_FROMWIRE) {
dns_name_t name;
return (dns_name_fromwire(&name, source, dctx, options, target));
}
-static inline isc_result_t
+static isc_result_t
towire_in_nsap_ptr(ARGS_TOWIRE) {
dns_name_t name;
dns_offsets_t offsets;
return (dns_name_towire(&name, cctx, target));
}
-static inline int
+static int
compare_in_nsap_ptr(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
return (dns_name_rdatacompare(&name1, &name2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_in_nsap_ptr(ARGS_FROMSTRUCT) {
dns_rdata_in_nsap_ptr_t *nsap_ptr = source;
isc_region_t region;
return (isc_buffer_copyregion(target, ®ion));
}
-static inline isc_result_t
+static isc_result_t
tostruct_in_nsap_ptr(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_in_nsap_ptr_t *nsap_ptr = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_in_nsap_ptr(ARGS_FREESTRUCT) {
dns_rdata_in_nsap_ptr_t *nsap_ptr = source;
nsap_ptr->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_in_nsap_ptr(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_nsap_ptr);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_in_nsap_ptr(ARGS_DIGEST) {
isc_region_t r;
dns_name_t name;
return (dns_name_digest(&name, digest, arg));
}
-static inline bool
+static bool
checkowner_in_nsap_ptr(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_nsap_ptr);
REQUIRE(rdclass == dns_rdataclass_in);
return (true);
}
-static inline bool
+static bool
checknames_in_nsap_ptr(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_nsap_ptr);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (true);
}
-static inline int
+static int
casecompare_in_nsap_ptr(ARGS_COMPARE) {
return (compare_in_nsap_ptr(rdata1, rdata2));
}
#define RRTYPE_NSAP_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_in_nsap(ARGS_FROMTEXT) {
isc_token_t token;
isc_textregion_t *sr;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_in_nsap(ARGS_TOTEXT) {
isc_region_t region;
char buf[sizeof("xx")];
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_in_nsap(ARGS_FROMWIRE) {
isc_region_t region;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
towire_in_nsap(ARGS_TOWIRE) {
REQUIRE(rdata->type == dns_rdatatype_nsap);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (mem_tobuffer(target, rdata->data, rdata->length));
}
-static inline int
+static int
compare_in_nsap(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_in_nsap(ARGS_FROMSTRUCT) {
dns_rdata_in_nsap_t *nsap = source;
return (mem_tobuffer(target, nsap->nsap, nsap->nsap_len));
}
-static inline isc_result_t
+static isc_result_t
tostruct_in_nsap(ARGS_TOSTRUCT) {
dns_rdata_in_nsap_t *nsap = target;
isc_region_t r;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_in_nsap(ARGS_FREESTRUCT) {
dns_rdata_in_nsap_t *nsap = source;
nsap->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_in_nsap(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_nsap);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_in_nsap(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_in_nsap(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_nsap);
REQUIRE(rdclass == dns_rdataclass_in);
return (true);
}
-static inline bool
+static bool
checknames_in_nsap(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_nsap);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (true);
}
-static inline int
+static int
casecompare_in_nsap(ARGS_COMPARE) {
return (compare_in_nsap(rdata1, rdata2));
}
#define RRTYPE_PX_ATTRIBUTES (0)
-static inline isc_result_t
+static isc_result_t
fromtext_in_px(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_in_px(ARGS_TOTEXT) {
isc_region_t region;
dns_name_t name;
return (dns_name_totext(&prefix, sub, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_in_px(ARGS_FROMWIRE) {
dns_name_t name;
isc_region_t sregion;
return (dns_name_fromwire(&name, source, dctx, options, target));
}
-static inline isc_result_t
+static isc_result_t
towire_in_px(ARGS_TOWIRE) {
dns_name_t name;
dns_offsets_t offsets;
return (dns_name_towire(&name, cctx, target));
}
-static inline int
+static int
compare_in_px(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
return (dns_name_rdatacompare(&name1, &name2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_in_px(ARGS_FROMSTRUCT) {
dns_rdata_in_px_t *px = source;
isc_region_t region;
return (isc_buffer_copyregion(target, ®ion));
}
-static inline isc_result_t
+static isc_result_t
tostruct_in_px(ARGS_TOSTRUCT) {
dns_rdata_in_px_t *px = target;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_in_px(ARGS_FREESTRUCT) {
dns_rdata_in_px_t *px = source;
px->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_in_px(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_px);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_in_px(ARGS_DIGEST) {
isc_region_t r1, r2;
dns_name_t name;
return (dns_name_digest(&name, digest, arg));
}
-static inline bool
+static bool
checkowner_in_px(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_px);
REQUIRE(rdclass == dns_rdataclass_in);
return (true);
}
-static inline bool
+static bool
checknames_in_px(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_px);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (true);
}
-static inline int
+static int
casecompare_in_px(ARGS_COMPARE) {
return (compare_in_px(rdata1, rdata2));
}
#define RRTYPE_SRV_ATTRIBUTES (DNS_RDATATYPEATTR_FOLLOWADDITIONAL)
-static inline isc_result_t
+static isc_result_t
fromtext_in_srv(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_in_srv(ARGS_TOTEXT) {
isc_region_t region;
dns_name_t name;
return (dns_name_totext(&prefix, sub, target));
}
-static inline isc_result_t
+static isc_result_t
fromwire_in_srv(ARGS_FROMWIRE) {
dns_name_t name;
isc_region_t sr;
return (dns_name_fromwire(&name, source, dctx, options, target));
}
-static inline isc_result_t
+static isc_result_t
towire_in_srv(ARGS_TOWIRE) {
dns_name_t name;
dns_offsets_t offsets;
return (dns_name_towire(&name, cctx, target));
}
-static inline int
+static int
compare_in_srv(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
return (dns_name_rdatacompare(&name1, &name2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_in_srv(ARGS_FROMSTRUCT) {
dns_rdata_in_srv_t *srv = source;
isc_region_t region;
return (isc_buffer_copyregion(target, ®ion));
}
-static inline isc_result_t
+static isc_result_t
tostruct_in_srv(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_in_srv_t *srv = target;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_in_srv(ARGS_FREESTRUCT) {
dns_rdata_in_srv_t *srv = source;
srv->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_in_srv(ARGS_ADDLDATA) {
char buf[sizeof("_65000._tcp")];
dns_fixedname_t fixed;
NULL));
}
-static inline isc_result_t
+static isc_result_t
digest_in_srv(ARGS_DIGEST) {
isc_region_t r1, r2;
dns_name_t name;
return (dns_name_digest(&name, digest, arg));
}
-static inline bool
+static bool
checkowner_in_srv(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_srv);
REQUIRE(rdclass == dns_rdataclass_in);
return (true);
}
-static inline bool
+static bool
checknames_in_srv(ARGS_CHECKNAMES) {
isc_region_t region;
dns_name_t name;
return (true);
}
-static inline int
+static int
casecompare_in_srv(ARGS_COMPARE) {
return (compare_in_srv(rdata1, rdata2));
}
}
}
-static inline isc_result_t
+static isc_result_t
generic_fromtext_in_svcb(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
}
}
-static inline isc_result_t
+static isc_result_t
fromtext_in_svcb(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_svcb);
REQUIRE(rdclass == dns_rdataclass_in);
return (generic_fromtext_in_svcb(CALL_FROMTEXT));
}
-static inline isc_result_t
+static isc_result_t
generic_totext_in_svcb(ARGS_TOTEXT) {
isc_region_t region;
dns_name_t name;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
totext_in_svcb(ARGS_TOTEXT) {
REQUIRE(rdata->type == dns_rdatatype_svcb);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (generic_totext_in_svcb(CALL_TOTEXT));
}
-static inline isc_result_t
+static isc_result_t
generic_fromwire_in_svcb(ARGS_FROMWIRE) {
dns_name_t name;
isc_region_t region, man = { .base = NULL, .length = 0 };
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_in_svcb(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_svcb);
REQUIRE(rdclass == dns_rdataclass_in);
return (generic_fromwire_in_svcb(CALL_FROMWIRE));
}
-static inline isc_result_t
+static isc_result_t
generic_towire_in_svcb(ARGS_TOWIRE) {
dns_name_t name;
dns_offsets_t offsets;
return (mem_tobuffer(target, region.base, region.length));
}
-static inline isc_result_t
+static isc_result_t
towire_in_svcb(ARGS_TOWIRE) {
REQUIRE(rdata->type == dns_rdatatype_svcb);
REQUIRE(rdata->length != 0);
return (generic_towire_in_svcb(CALL_TOWIRE));
}
-static inline int
+static int
compare_in_svcb(ARGS_COMPARE) {
isc_region_t region1;
isc_region_t region2;
return (isc_region_compare(®ion1, ®ion2));
}
-static inline isc_result_t
+static isc_result_t
generic_fromstruct_in_svcb(ARGS_FROMSTRUCT) {
dns_rdata_in_svcb_t *svcb = source;
isc_region_t region;
return (mem_tobuffer(target, svcb->svc, svcb->svclen));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_in_svcb(ARGS_FROMSTRUCT) {
dns_rdata_in_svcb_t *svcb = source;
return (generic_fromstruct_in_svcb(CALL_FROMSTRUCT));
}
-static inline isc_result_t
+static isc_result_t
generic_tostruct_in_svcb(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_in_svcb_t *svcb = target;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
tostruct_in_svcb(ARGS_TOSTRUCT) {
dns_rdata_in_svcb_t *svcb = target;
return (generic_tostruct_in_svcb(CALL_TOSTRUCT));
}
-static inline void
+static void
generic_freestruct_in_svcb(ARGS_FREESTRUCT) {
dns_rdata_in_svcb_t *svcb = source;
svcb->mctx = NULL;
}
-static inline void
+static void
freestruct_in_svcb(ARGS_FREESTRUCT) {
dns_rdata_in_svcb_t *svcb = source;
generic_freestruct_in_svcb(CALL_FREESTRUCT);
}
-static inline isc_result_t
+static isc_result_t
generic_additionaldata_in_svcb(ARGS_ADDLDATA) {
bool alias, done = false;
dns_fixedname_t fixed;
return ((add)(arg, &name, dns_rdatatype_a, NULL));
}
-static inline isc_result_t
+static isc_result_t
additionaldata_in_svcb(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_svcb);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (generic_additionaldata_in_svcb(CALL_ADDLDATA));
}
-static inline isc_result_t
+static isc_result_t
digest_in_svcb(ARGS_DIGEST) {
isc_region_t region1;
return ((digest)(arg, ®ion1));
}
-static inline bool
+static bool
checkowner_in_svcb(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_svcb);
REQUIRE(rdclass == dns_rdataclass_in);
return (true);
}
-static inline bool
+static bool
generic_checknames_in_svcb(ARGS_CHECKNAMES) {
isc_region_t region;
dns_name_t name;
return (true);
}
-static inline bool
+static bool
checknames_in_svcb(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_svcb);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (generic_checknames_in_svcb(CALL_CHECKNAMES));
}
-static inline int
+static int
casecompare_in_svcb(ARGS_COMPARE) {
return (compare_in_svcb(rdata1, rdata2));
}
return (se != NULL);
}
-static inline isc_result_t
+static isc_result_t
fromtext_in_wks(ARGS_FROMTEXT) {
static isc_once_t once = ISC_ONCE_INIT;
isc_token_t token;
return (result);
}
-static inline isc_result_t
+static isc_result_t
totext_in_wks(ARGS_TOTEXT) {
isc_region_t sr;
unsigned short proto;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
fromwire_in_wks(ARGS_FROMWIRE) {
isc_region_t sr;
isc_region_t tr;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
towire_in_wks(ARGS_TOWIRE) {
isc_region_t sr;
return (mem_tobuffer(target, sr.base, sr.length));
}
-static inline int
+static int
compare_in_wks(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
return (isc_region_compare(&r1, &r2));
}
-static inline isc_result_t
+static isc_result_t
fromstruct_in_wks(ARGS_FROMSTRUCT) {
dns_rdata_in_wks_t *wks = source;
uint32_t a;
return (mem_tobuffer(target, wks->map, wks->map_len));
}
-static inline isc_result_t
+static isc_result_t
tostruct_in_wks(ARGS_TOSTRUCT) {
dns_rdata_in_wks_t *wks = target;
uint32_t n;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
freestruct_in_wks(ARGS_FREESTRUCT) {
dns_rdata_in_wks_t *wks = source;
wks->mctx = NULL;
}
-static inline isc_result_t
+static isc_result_t
additionaldata_in_wks(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_wks);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
digest_in_wks(ARGS_DIGEST) {
isc_region_t r;
return ((digest)(arg, &r));
}
-static inline bool
+static bool
checkowner_in_wks(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_wks);
REQUIRE(rdclass == dns_rdataclass_in);
return (dns_name_ishostname(name, wildcard));
}
-static inline bool
+static bool
checknames_in_wks(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_wks);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (true);
}
-static inline int
+static int
casecompare_in_wks(ARGS_COMPARE) {
return (compare_in_wks(rdata1, rdata2));
}
return (a->key - b->key);
}
-static inline void
+static void
swap_rdata(dns_rdata_t *in, unsigned int a, unsigned int b) {
dns_rdata_t rdata = in[a];
in[a] = in[b];
* 'type' and class 'rdclass', and advance '*current' to
* point to the next item in the slab.
*/
-static inline void
+static void
rdata_from_slab(unsigned char **current, dns_rdataclass_t rdclass,
dns_rdatatype_t type, dns_rdata_t *rdata) {
unsigned char *tcurrent = *current;
* contains an rdata identical to 'rdata'. This does case insensitive
* comparisons per DNSSEC.
*/
-static inline bool
+static bool
rdata_in_slab(unsigned char *slab, unsigned int reservelen,
dns_rdataclass_t rdclass, dns_rdatatype_t type,
dns_rdata_t *rdata) {
return (requestmgr->hash % DNS_REQUEST_NLOCKS);
}
-static inline void
+static void
req_send(dns_request_t *request) {
isc_region_t r;
#define RES_DOMAIN_NEXTTABLE(hindex) ((hindex == 0) ? 1 : 0)
-static inline uint32_t
+static uint32_t
hash_32(uint32_t val, unsigned int bits) {
REQUIRE(bits <= RES_DOMAIN_MAX_BITS);
/* High bits are more random. */
static void
add_bad(fetchctx_t *fctx, dns_message_t *rmessage, dns_adbaddrinfo_t *addrinfo,
isc_result_t reason, badnstype_t badtype);
-static inline isc_result_t
+static isc_result_t
findnoqname(fetchctx_t *fctx, dns_message_t *message, dns_name_t *name,
dns_rdatatype_t type, dns_name_t **noqname);
/*%
* Increment resolver-related statistics counters.
*/
-static inline void
+static void
inc_stats(dns_resolver_t *res, isc_statscounter_t counter) {
if (res->view->resstats != NULL) {
isc_stats_increment(res->view->resstats, counter);
}
}
-static inline void
+static void
dec_stats(dns_resolver_t *res, isc_statscounter_t counter) {
if (res->view->resstats != NULL) {
isc_stats_decrement(res->view->resstats, counter);
return (true);
}
-static inline void
+static void
resquery_destroy(resquery_t *query) {
fetchctx_t *fctx = query->fctx;
dns_resolver_t *res = fctx->res;
* trigger if, for example, some ADB or validator dependency
* loop occurs and causes a fetch to hang.
*/
-static inline isc_result_t
+static isc_result_t
fctx_starttimer(fetchctx_t *fctx) {
isc_interval_t interval;
isc_time_t now;
true));
}
-static inline void
+static void
fctx_stoptimer(fetchctx_t *fctx) {
isc_result_t result;
UNLOCK(&dbucket->lock);
}
-static inline void
+static void
fctx_sendevents(fetchctx_t *fctx, isc_result_t result, int line) {
dns_fetchevent_t *event, *next_event;
isc_task_t *task;
resquery_detach(&query);
}
-static inline isc_result_t
+static isc_result_t
fctx_addopt(dns_message_t *message, unsigned int version, uint16_t udpsize,
dns_ednsopt_t *ednsopts, size_t count) {
dns_rdataset_t *rdataset = NULL;
return (dns_message_setopt(message, rdataset));
}
-static inline void
+static void
fctx_setretryinterval(fetchctx_t *fctx, unsigned int rtt) {
unsigned int seconds, us;
uint64_t limit;
ISC_LIST_INITANDAPPEND(fctx->edns, tried, link);
}
-static inline size_t
+static size_t
addr2buf(void *buf, const size_t bufsize, const isc_sockaddr_t *sockaddr) {
isc_netaddr_t netaddr;
isc_netaddr_fromsockaddr(&netaddr, sockaddr);
return (0);
}
-static inline size_t
+static size_t
add_serveraddr(uint8_t *buf, const size_t bufsize, const resquery_t *query) {
return (addr2buf(buf, bufsize, &query->addrinfo->sockaddr));
}
fctx_detach(&fctx);
}
-static inline bool
+static bool
bad_server(fetchctx_t *fctx, isc_sockaddr_t *address) {
isc_sockaddr_t *sa;
return (false);
}
-static inline bool
+static bool
mark_bad(fetchctx_t *fctx) {
dns_adbfind_t *curr;
dns_adbaddrinfo_t *addrinfo;
* occurrance anyway, we regard this theoretical SERVFAIL as the lesser
* evil.
*/
-static inline bool
+static bool
waiting_for(dns_adbfind_t *find, dns_rdatatype_t type) {
switch (type) {
case dns_rdatatype_a:
return (result);
}
-static inline void
+static void
possibly_mark(fetchctx_t *fctx, dns_adbaddrinfo_t *addr) {
isc_netaddr_t na;
char buf[ISC_NETADDR_FORMATSIZE];
}
}
-static inline dns_adbaddrinfo_t *
+static dns_adbaddrinfo_t *
fctx_nextaddress(fetchctx_t *fctx) {
dns_adbfind_t *find, *start;
dns_adbaddrinfo_t *addrinfo;
* Fetch Creation, Joining, and Cancellation.
*/
-static inline void
+static void
fctx_add_event(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,
}
}
-static inline isc_result_t
+static isc_result_t
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,
return (ISC_R_SUCCESS);
}
-static inline void
+static void
log_ns_ttl(fetchctx_t *fctx, const char *where) {
char namebuf[DNS_NAME_FORMATSIZE];
char domainbuf[DNS_NAME_FORMATSIZE];
/*
* Handle Responses
*/
-static inline bool
+static bool
is_lame(fetchctx_t *fctx, dns_message_t *message) {
dns_name_t *name;
dns_rdataset_t *rdataset;
return (false);
}
-static inline void
+static void
log_lame(fetchctx_t *fctx, dns_adbaddrinfo_t *addrinfo) {
char namebuf[DNS_NAME_FORMATSIZE];
char domainbuf[DNS_NAME_FORMATSIZE];
domainbuf, addrbuf);
}
-static inline void
+static void
log_formerr(fetchctx_t *fctx, const char *format, ...) {
char nsbuf[ISC_SOCKADDR_FORMATSIZE];
char msgbuf[2048];
fctx->info, msgbuf);
}
-static inline isc_result_t
+static isc_result_t
findnoqname(fetchctx_t *fctx, dns_message_t *message, dns_name_t *name,
dns_rdatatype_t type, dns_name_t **noqnamep) {
dns_rdataset_t *nrdataset, *next, *sigrdataset;
return (result);
}
-static inline isc_result_t
+static isc_result_t
cache_name(fetchctx_t *fctx, dns_name_t *name, dns_message_t *message,
dns_adbaddrinfo_t *addrinfo, isc_stdtime_t now) {
dns_rdataset_t *rdataset = NULL, *sigrdataset = NULL;
return (result);
}
-static inline isc_result_t
+static isc_result_t
cache_message(fetchctx_t *fctx, dns_message_t *message,
dns_adbaddrinfo_t *addrinfo, isc_stdtime_t now) {
isc_result_t result;
return (result);
}
-static inline isc_result_t
+static isc_result_t
ncache_message(fetchctx_t *fctx, dns_message_t *message,
dns_adbaddrinfo_t *addrinfo, dns_rdatatype_t covers,
isc_stdtime_t now) {
return (result);
}
-static inline void
+static void
mark_related(dns_name_t *name, dns_rdataset_t *rdataset, bool external,
bool gluing) {
name->attributes |= DNS_NAMEATTR_CACHE;
fctx_detach(&fctx);
}
-static inline void
+static void
checknamessection(dns_message_t *message, dns_section_t section) {
isc_result_t result;
dns_name_t *name;
isc_mem_put(mctx, buf, buflen);
}
-static inline bool
+static bool
iscname(dns_message_t *message, dns_name_t *name) {
isc_result_t result;
}
}
-static inline bool
+static bool
fctx_match(fetchctx_t *fctx, const dns_name_t *name, dns_rdatatype_t type,
unsigned int options) {
/*
return (dns_name_equal(fctx->name, name));
}
-static inline void
+static void
log_fetch(const dns_name_t *name, dns_rdatatype_t type) {
char namebuf[DNS_NAME_FORMATSIZE];
char typebuf[DNS_RDATATYPE_FORMATSIZE];
* \brief Count Leading Zeros: Find the location of the left-most set
* bit.
*/
-static inline unsigned int
+static unsigned int
clz(dns_rpz_cidr_word_t w) {
unsigned int bit;
* Given a hit while searching the radix trees,
* clear all bits for higher numbered zones.
*/
-static inline dns_rpz_zbits_t
+static dns_rpz_zbits_t
trim_zbits(dns_rpz_zbits_t zbits, dns_rpz_zbits_t found) {
dns_rpz_zbits_t x;
/*
* Convert a timestamp to a number of seconds in the past.
*/
-static inline int
+static int
delta_rrl_time(isc_stdtime_t ts, isc_stdtime_t now) {
int delta;
return (0);
}
-static inline int
+static int
get_age(const dns_rrl_t *rrl, const dns_rrl_entry_t *e, isc_stdtime_t now) {
if (!e->ts_valid) {
return (DNS_RRL_FOREVER);
return (delta_rrl_time(e->ts + rrl->ts_bases[e->ts_gen], now));
}
-static inline void
+static void
set_age(dns_rrl_t *rrl, dns_rrl_entry_t *e, isc_stdtime_t now) {
dns_rrl_entry_t *e_old;
unsigned int ts_gen;
return (ISC_R_SUCCESS);
}
-static inline dns_rrl_bin_t *
+static dns_rrl_bin_t *
get_bin(dns_rrl_hash_t *hash, unsigned int hval) {
INSIST(hash != NULL);
return (&hash->bins[hval % hash->length]);
}
}
-static inline bool
+static bool
key_cmp(const dns_rrl_key_t *a, const dns_rrl_key_t *b) {
if (memcmp(a, b, sizeof(dns_rrl_key_t)) == 0) {
return (true);
return (false);
}
-static inline uint32_t
+static uint32_t
hash_key(const dns_rrl_key_t *key) {
uint32_t hval;
int i;
}
}
-static inline dns_rrl_rate_t *
+static dns_rrl_rate_t *
get_rate(dns_rrl_t *rrl, dns_rrl_rtype_t rtype) {
switch (rtype) {
case DNS_RRL_RTYPE_QUERY:
hash_key(&e->key), age_str, e->responses, action);
}
-static inline dns_rrl_result_t
+static dns_rrl_result_t
debit_rrl_entry(dns_rrl_t *rrl, dns_rrl_entry_t *e, double qps, double scale,
const isc_sockaddr_t *client_addr, isc_stdtime_t now,
char *log_buf, unsigned int log_buf_len) {
return (DNS_RRL_RESULT_DROP);
}
-static inline dns_rrl_qname_buf_t *
+static dns_rrl_qname_buf_t *
get_qname(dns_rrl_t *rrl, const dns_rrl_entry_t *e) {
dns_rrl_qname_buf_t *qbuf;
return (qbuf);
}
-static inline void
+static void
free_qname(dns_rrl_t *rrl, dns_rrl_entry_t *e) {
dns_rrl_qname_buf_t *qbuf;
isc_mem_putanddetach(&imp->mctx, imp, sizeof(dns_sdbimplementation_t));
}
-static inline unsigned int
+static unsigned int
initial_size(unsigned int len) {
unsigned int size;
}
}
-static inline unsigned int
+static unsigned int
initial_size(const char *data) {
unsigned int len = (strlen(data) / 64) + 1;
return (len * 64 + 64);
#include <dns/rdatastruct.h>
#include <dns/soa.h>
-static inline uint32_t
+static uint32_t
decode_uint32(unsigned char *p) {
return (((uint32_t)p[0] << 24) + ((uint32_t)p[1] << 16) +
((uint32_t)p[2] << 8) + ((uint32_t)p[3] << 0));
}
-static inline void
+static void
encode_uint32(uint32_t val, unsigned char *p) {
p[0] = (uint8_t)(val >> 24);
p[1] = (uint8_t)(val >> 16);
*tablep = table;
}
-static inline void
+static void
destroy(dns_ssutable_t *table) {
isc_mem_t *mctx;
ISC_LIST_INITANDAPPEND(table->rules, rule, link);
}
-static inline bool
+static bool
isusertype(dns_rdatatype_t type) {
return (type != dns_rdatatype_ns && type != dns_rdatatype_soa &&
type != dns_rdatatype_rrsig);
isc_stats_increment(stats->counters, counter);
}
-inline static isc_statscounter_t
+static isc_statscounter_t
rdatatype2counter(dns_rdatatype_t type) {
if (type > (dns_rdatatype_t)RDTYPECOUNTER_MAXTYPE) {
return (0);
isc_stats_increment(stats->counters, counter);
}
-static inline void
+static void
update_rdatasetstats(dns_stats_t *stats, dns_rdatastatstype_t rrsettype,
bool increment) {
isc_statscounter_t counter;
* If we are validating a name that is marked as "must be secure", log a
* warning and return DNS_R_MUSTBESECURE instead.
*/
-static inline isc_result_t
+static isc_result_t
markanswer(dns_validator_t *val, const char *where, const char *mbstext) {
if (val->mustbesecure && mbstext != NULL) {
validator_log(val, ISC_LOG_WARNING,
/*%
* Mark the RRsets in val->event with trust level secure.
*/
-static inline void
+static void
marksecure(dns_validatorevent_t *event) {
dns_rdataset_settrust(event->rdataset, dns_trust_secure);
if (event->sigrdataset != NULL) {
/*
* Called when deciding whether to destroy validator 'val'.
*/
-static inline bool
+static bool
exit_check(dns_validator_t *val) {
/*
* Caller must be holding the lock.
* \li DNS_R_NXDOMAIN
* \li DNS_R_BROKENCHAIN
*/
-static inline isc_result_t
+static isc_result_t
view_find(dns_validator_t *val, dns_name_t *name, dns_rdatatype_t type) {
dns_fixedname_t fixedname;
dns_name_t *foundname;
* Checks to make sure we are not going to loop. As we use a SHARED fetch
* the validation process will stall if looping was to occur.
*/
-static inline bool
+static bool
check_deadlock(dns_validator_t *val, dns_name_t *name, dns_rdatatype_t type,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) {
dns_validator_t *parent;
/*%
* Start a fetch for the requested name and type.
*/
-static inline isc_result_t
+static isc_result_t
create_fetch(dns_validator_t *val, dns_name_t *name, dns_rdatatype_t type,
isc_taskaction_t callback, const char *caller) {
unsigned int fopts = 0;
/*%
* Start a subvalidation process.
*/
-static inline isc_result_t
+static isc_result_t
create_validator(dns_validator_t *val, dns_name_t *name, dns_rdatatype_t type,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset,
isc_taskaction_t action, const char *caller) {
return (result);
}
-static inline void
+static void
destroy(dns_view_t *view) {
dns_dns64_t *dns64;
dns_dlzdb_t *dlzdb;
zone_idetach(dns_zone_t **zonep);
static isc_result_t
zone_replacedb(dns_zone_t *zone, dns_db_t *db, bool dump);
-static inline void
+static void
zone_attachdb(dns_zone_t *zone, dns_db_t *db);
-static inline void
+static void
zone_detachdb(dns_zone_t *zone);
static void
zone_catz_enable(dns_zone_t *zone, dns_catz_zones_t *catzs);
/*%
* Increment resolver-related statistics counters. Zone must be locked.
*/
-static inline void
+static void
inc_stats(dns_zone_t *zone, isc_statscounter_t counter) {
if (zone->stats != NULL) {
isc_stats_increment(zone->stats, counter);
* Returns true iff this the signed side of an inline-signing zone.
* Caller should hold zone lock.
*/
-static inline bool
+static bool
inline_secure(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
if (zone->raw != NULL) {
* Returns true iff this the unsigned side of an inline-signing zone
* Caller should hold zone lock.
*/
-static inline bool
+static bool
inline_raw(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
if (zone->secure != NULL) {
UNLOCK_ZONE(zone);
}
-static inline bool
+static bool
was_dumping(dns_zone_t *zone) {
REQUIRE(LOCKED_ZONE(zone));
* 1/10 * OrigTTL,
* 1/10 * RRSigExpirationInterval))
*/
-static inline isc_stdtime_t
+static isc_stdtime_t
refresh_time(dns_keyfetch_t *kfetch, bool retry) {
isc_result_t result;
uint32_t t;
/***
*** Private
***/
-static inline isc_result_t
+static isc_result_t
create_query(dns_zone_t *zone, dns_rdatatype_t rdtype, dns_name_t *name,
dns_message_t **messagep) {
dns_message_t *message = NULL;
return (result);
}
-static inline isc_result_t
+static isc_result_t
save_nsrrset(dns_message_t *message, dns_name_t *name,
struct stub_cb_args *cb_args, dns_db_t *db,
dns_dbversion_t *version) {
}
/* The caller must hold the dblock as a writer. */
-static inline void
+static void
zone_attachdb(dns_zone_t *zone, dns_db_t *db) {
REQUIRE(zone->db == NULL && db != NULL);
}
/* The caller must hold the dblock as a writer. */
-static inline void
+static void
zone_detachdb(dns_zone_t *zone) {
REQUIRE(zone->db != NULL);
#define GOLDEN_RATIO_32 0x61C88647
#define HASHSIZE(bits) (UINT64_C(1) << (bits))
-static inline uint32_t
+static uint32_t
hash_index(uint32_t val, uint32_t bits) {
return (val * GOLDEN_RATIO_32 >> (32 - bits));
}
return (result);
}
-static inline dns_ttl_t
+static dns_ttl_t
zone_nsecttl(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
* Helper function used to calculate length of variable-length
* data section in object pointed to by 'chain'.
*/
-static inline size_t
+static size_t
chain_length(struct nsec3_chain_fixed *chain) {
return (chain->salt_length + 2 * chain->next_length);
}
return (false);
}
-static inline bool
+static bool
checknext(isc_mem_t *mctx, const vctx_t *vctx,
const struct nsec3_chain_fixed *first, struct nsec3_chain_fixed *prev,
const struct nsec3_chain_fixed *cur) {
return (result);
}
-static inline bool
+static bool
checklast(isc_mem_t *mctx, const vctx_t *vctx, struct nsec3_chain_fixed *first,
struct nsec3_chain_fixed *prev) {
bool result = _checknext(vctx, prev, first);
bool pad; /*%< Expect padding */
} base32_decode_ctx_t;
-static inline void
+static void
base32_decode_init(base32_decode_ctx_t *ctx, int length, const char base[],
bool pad, isc_buffer_t *target) {
ctx->digits = 0;
ctx->pad = pad;
}
-static inline isc_result_t
+static isc_result_t
base32_decode_char(base32_decode_ctx_t *ctx, int c) {
const char *s;
unsigned int last;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
base32_decode_finish(base32_decode_ctx_t *ctx) {
if (ctx->length > 0) {
return (ISC_R_UNEXPECTEDEND);
int val[4];
} base64_decode_ctx_t;
-static inline void
+static void
base64_decode_init(base64_decode_ctx_t *ctx, int length, isc_buffer_t *target) {
ctx->digits = 0;
ctx->seen_end = false;
ctx->target = target;
}
-static inline isc_result_t
+static isc_result_t
base64_decode_char(base64_decode_ctx_t *ctx, int c) {
const char *s;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
base64_decode_finish(base64_decode_ctx_t *ctx) {
if (ctx->length > 0) {
return (ISC_R_UNEXPECTEDEND);
int val[2];
} hex_decode_ctx_t;
-static inline void
+static void
hex_decode_init(hex_decode_ctx_t *ctx, int length, isc_buffer_t *target) {
ctx->digits = 0;
ctx->length = length;
ctx->target = target;
}
-static inline isc_result_t
+static isc_result_t
hex_decode_char(hex_decode_ctx_t *ctx, int c) {
const char *s;
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
hex_decode_finish(hex_decode_ctx_t *ctx) {
if (ctx->length > 0) {
return (ISC_R_UNEXPECTEDEND);
static void
httpdmgr_detach(isc_httpdmgr_t **);
-static inline void
+static void
free_buffer(isc_mem_t *mctx, isc_buffer_t *buffer) {
isc_region_t r;
LIST(struct inputsource) sources;
};
-static inline isc_result_t
+static isc_result_t
grow_data(isc_lex_t *lex, size_t *remainingp, char **currp, char **prevp) {
char *tmp;
memmove(lex->specials, specials, 256);
}
-static inline isc_result_t
+static isc_result_t
new_source(isc_lex_t *lex, bool is_file, bool need_close, void *input,
const char *name) {
inputsource *source;
print_active(isc_mem_t *ctx, FILE *out);
#endif /* ISC_MEM_TRACKLINES */
-static inline size_t
+static size_t
increment_malloced(isc_mem_t *ctx, size_t size) {
size_t malloced = atomic_fetch_add_relaxed(&ctx->malloced, size) + size;
size_t maxmalloced = atomic_load_relaxed(&ctx->maxmalloced);
return (malloced);
}
-static inline size_t
+static size_t
decrement_malloced(isc_mem_t *ctx, size_t size) {
size_t malloced = atomic_fetch_sub_relaxed(&ctx->malloced, size) - size;
/*!
* Perform a malloc, doing memory filling and overrun detection as necessary.
*/
-static inline void *
+static void *
mem_get(isc_mem_t *ctx, size_t size, int flags) {
char *ret = NULL;
* Perform a free, doing memory filling and overrun detection as necessary.
*/
/* coverity[+free : arg-1] */
-static inline void
+static void
mem_put(isc_mem_t *ctx, void *mem, size_t size, int flags) {
ADJUST_ZERO_ALLOCATION_SIZE(size);
sdallocx(mem, size, flags);
}
-static inline void *
+static void *
mem_realloc(isc_mem_t *ctx, void *old_ptr, size_t old_size, size_t new_size,
int flags) {
void *new_ptr = NULL;
/*!
* Update internal counters after a memory get.
*/
-static inline void
+static void
mem_getstats(isc_mem_t *ctx, size_t size) {
struct stats *stats = stats_bucket(ctx, size);
/*!
* Update internal counters after a memory put.
*/
-static inline void
+static void
mem_putstats(isc_mem_t *ctx, void *ptr, size_t size) {
struct stats *stats = stats_bucket(ctx, size);
} \
}
-static inline bool
+static bool
hi_water(isc_mem_t *ctx) {
size_t inuse;
size_t maxinuse;
return (true);
}
-static inline bool
+static bool
lo_water(isc_mem_t *ctx) {
size_t inuse;
size_t lowater = atomic_load_relaxed(&ctx->lo_water);
#if ISC_CMSG_IP_TOS || defined(IPV6_TCLASS)
-static inline socklen_t
+static socklen_t
cmsg_len(socklen_t len) {
#ifdef CMSG_LEN
return (CMSG_LEN(len));
#endif /* ifdef CMSG_LEN */
}
-static inline socklen_t
+static socklen_t
cmsg_space(socklen_t len) {
#ifdef CMSG_SPACE
return (CMSG_SPACE(len));
#include <unistd.h>
-static inline long
+static long
sysconf_ncpus(void) {
#if defined(_SC_NPROCESSORS_ONLN)
return (sysconf((_SC_NPROCESSORS_ONLN)));
uint32_t buf[ISC_PORTSET_BUFSIZE];
};
-static inline bool
+static bool
portset_isset(isc_portset_t *portset, in_port_t port) {
return ((portset->buf[port >> 5] & ((uint32_t)1 << (port & 31))) != 0);
}
-static inline void
+static void
portset_add(isc_portset_t *portset, in_port_t port) {
if (!portset_isset(portset, port)) {
portset->nports++;
}
}
-static inline void
+static void
portset_remove(isc_portset_t *portset, in_port_t port) {
if (portset_isset(portset, port)) {
portset->nports--;
*/
static thread_local uint32_t seed[4] = { 0 };
-static inline uint32_t
+static uint32_t
rotl(const uint32_t x, int k) {
return ((x << k) | (x >> (32 - k)));
}
-static inline uint32_t
+static uint32_t
next(void) {
uint32_t result_starstar, t;
isc_mem_putanddetach(&symtab->mctx, symtab, sizeof(*symtab));
}
-static inline unsigned int
+static unsigned int
hash(const char *key, bool case_sensitive) {
const char *s;
unsigned int h = 0;
*targetp = source;
}
-static inline bool
+static bool
task_shutdown(isc_task_t *task) {
bool was_idle = false;
isc_event_t *event, *prev;
*
* Caller must NOT hold queue lock.
*/
-static inline void
+static void
task_ready(isc_task_t *task) {
isc_taskmgr_t *manager = task->manager;
REQUIRE(VALID_MANAGER(manager));
task_ready(task);
}
-static inline bool
+static bool
task_detach(isc_task_t *task) {
/*
* Caller must be holding the task lock.
*taskp = NULL;
}
-static inline bool
+static bool
task_send(isc_task_t *task, isc_event_t **eventp, int c) {
bool was_idle = false;
isc_event_t *event;
return (false);
}
-static inline isc_result_t
+static isc_result_t
time_now(isc_time_t *t, clockid_t clock) {
struct timespec ts;
return (ISC_R_SUCCESS);
}
-static inline void
+static void
free_elt(isccc_symtab_t *symtab, unsigned int bucket, elt_t *elt) {
ISC_LIST_UNLINK(symtab->table[bucket], elt, link);
if (symtab->undefine_action != NULL) {
free(symtab);
}
-static inline unsigned int
+static unsigned int
hash(const char *key, bool case_sensitive) {
const char *s;
unsigned int h = 0;
return (ISC_R_SUCCESS);
}
-static inline ns_dbversion_t *
+static ns_dbversion_t *
client_getdbversion(ns_client_t *client) {
ns_dbversion_t *dbversion = NULL;
#define STALE_WINDOW(r) (((r)->attributes & DNS_RDATASETATTR_STALE_WINDOW) != 0)
#ifdef WANT_QUERYTRACE
-static inline void
+static void
client_trace(ns_client_t *client, int level, const char *message) {
if (client != NULL && client->query.qname != NULL) {
if (isc_log_wouldlog(ns_lctx, level)) {
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset,
dns_name_t *fname, bool exact, dns_name_t *found);
-static inline void
+static void
log_queryerror(ns_client_t *client, isc_result_t result, int line, int level);
static void
* Return the hooktable in use with 'qctx', or if there isn't one
* set, return the default hooktable.
*/
-static inline ns_hooktable_t *
+static ns_hooktable_t *
get_hooktab(query_ctx_t *qctx) {
if (qctx == NULL || qctx->view == NULL || qctx->view->hooktable == NULL)
{
*
* (Note that a hook function may set the 'result' to ISC_R_SUCCESS but
* still terminate processing within the calling function. That's why this
- * is a macro instead of an inline function; it needs to be able to use
+ * is a macro instead of a static function; it needs to be able to use
* 'goto cleanup' regardless of the return value.)
*/
#define CALL_HOOK(_id, _qctx) \
* codes are ignored. This is intended for use with initialization and
* destruction calls which *must* run in every configured module.
*
- * (This could be implemented as an inline void function, but is left as a
+ * (This could be implemented as a static void function, but is left as a
* macro for symmetry with CALL_HOOK above.)
*/
#define CALL_HOOK_NORETURN(_id, _qctx) \
/*
* Increment query statistics counters.
*/
-static inline void
+static void
inc_stats(ns_client_t *client, isc_statscounter_t counter) {
dns_zone_t *zone = client->query.authzone;
dns_rdatatype_t qtype;
}
}
-static inline void
+static void
query_freefreeversions(ns_client_t *client, bool everything) {
ns_dbversion_t *dbversion, *dbversion_next;
unsigned int i;
UNLOCK(&client->query.fetchlock);
}
-static inline void
+static void
query_reset(ns_client_t *client, bool everything) {
isc_buffer_t *dbuf, *dbuf_next;
ns_dbversion_t *dbversion, *dbversion_next;
: DNS_R_REFUSED);
}
-static inline isc_result_t
+static isc_result_t
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,
return (ISC_R_SUCCESS);
}
-static inline isc_result_t
+static isc_result_t
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) {
* Find a cache database to answer the query. This may fail with DNS_R_REFUSED
* if the client is not allowed to use the cache.
*/
-static inline isc_result_t
+static isc_result_t
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;
return (result);
}
-static inline isc_result_t
+static isc_result_t
query_getdb(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, bool *is_zonep) {
return (result);
}
-static inline bool
+static bool
query_isduplicate(ns_client_t *client, dns_name_t *name, dns_rdatatype_t type,
dns_name_t **mnamep) {
dns_section_t section;
/*
* Add 'rdataset' to 'name'.
*/
-static inline void
+static void
query_addtoname(dns_name_t *name, dns_rdataset_t *rdataset) {
ISC_LIST_APPEND(name->list, rdataset, link);
}
ns_stats_increment(client->sctx->nsstats, ns_statscounter_prefetch);
}
-static inline void
+static void
rpz_clean(dns_zone_t **zonep, dns_db_t **dbp, dns_dbnode_t **nodep,
dns_rdataset_t **rdatasetp) {
if (nodep != NULL && *nodep != NULL) {
}
}
-static inline void
+static void
rpz_match_clear(dns_rpz_st_t *st) {
rpz_clean(&st->m.zone, &st->m.db, &st->m.node, &st->m.rdataset);
st->m.version = NULL;
}
-static inline isc_result_t
+static isc_result_t
rpz_ready(ns_client_t *client, dns_rdataset_t **rdatasetp) {
REQUIRE(rdatasetp != NULL);
* answered, in order to avoid answering the query twice, when the original
* fetch finishes.
*/
-static inline void
+static void
query_lookup_stale(ns_client_t *client) {
query_ctx_t qctx;
* When sending a referral, if the answer to the question is
* in the glue, sort it to the start of the additional section.
*/
-static inline void
+static void
query_glueanswer(query_ctx_t *qctx) {
const dns_namelist_t *secs = qctx->client->message->sections;
const dns_section_t section = DNS_SECTION_ADDITIONAL;
return (result);
}
-static inline void
+static void
log_tat(ns_client_t *client) {
char namebuf[DNS_NAME_FORMATSIZE];
char clientbuf[ISC_NETADDR_FORMATSIZE];
}
}
-static inline void
+static void
log_query(ns_client_t *client, unsigned int flags, unsigned int extflags) {
char namebuf[DNS_NAME_FORMATSIZE];
char typebuf[DNS_RDATATYPE_FORMATSIZE];
onbuf, ecsbuf);
}
-static inline void
+static void
log_queryerror(ns_client_t *client, isc_result_t result, int line, int level) {
char namebuf[DNS_NAME_FORMATSIZE];
char typebuf[DNS_RDATATYPE_FORMATSIZE];
/*%
* Increment updated-related statistics counters.
*/
-static inline void
+static void
inc_stats(ns_client_t *client, dns_zone_t *zone, isc_statscounter_t counter) {
ns_stats_increment(client->sctx->nsstats, counter);
/**************************************************************************/
-static inline void
+static void
inc_stats(ns_client_t *client, dns_zone_t *zone, isc_statscounter_t counter) {
ns_stats_increment(client->sctx->nsstats, counter);
if (zone != NULL) {
projects / thirdparty / bind9.git / commitdiff
