upstream/bind9
1
0
Fork 0
mirror of https://github.com/isc-projects/bind9.git synced 2026-06-09 14:20:00 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Remove use of the inline keyword used as suggestion to compiler

Browse source 
Historically, the inline keyword was a strong suggestion to the compiler
that it should inline the function marked inline.  As compilers became
better at optimising, this functionality has receded, and using inline
as a suggestion to inline a function is obsolete.  The compiler will
happily ignore it and inline something else entirely if it finds that's
a better optimisation.

Therefore, remove all the occurences of the inline keyword with static
functions inside single compilation unit and leave the decision whether
to inline a function or not entirely on the compiler

NOTE: We keep the usage the inline keyword when the purpose is to change
the linkage behaviour.
This commit is contained in:
Ondřej Surý 2021-10-11 13:43:12 +02:00 committed by Ondřej Surý
parent 04d0b70ba2
commit 20f0936cf2
151 changed files with 1485 additions and 1488 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
bin/dnssec/dnssec-cds.c
View file

@ -845,7 +845,7 @@ make_new_ds_set(ds_maker_func_t *ds_from_rdata, uint32_t ttl,
}
}
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));

14
bin/dnssec/dnssec-signzone.c
View file

@ -325,28 +325,28 @@ signwithkey(dns_name_t *name, dns_rdataset_t *rdataset, dst_key_t *key,
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);
}
@ -465,7 +465,7 @@ expecttofindkey(dns_name_t *name) {
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;
@ -1244,7 +1244,7 @@ signname(dns_dbnode_t *node, dns_name_t *name) {
* 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;

2
bin/dnssec/dnssectool.c
View file

@ -239,7 +239,7 @@ time_units(isc_stdtime_t offset, char *suffix, const char *str) {
return (0); /* silence compiler warning */
}
static inline bool
static bool
isnone(const char *str) {
return ((strcasecmp(str, "none") == 0) ||
(strcasecmp(str, "never") == 0));

2
bin/named/control.c
View file

@ -59,7 +59,7 @@ getcommand(isc_lex_t *lex, char **cmdp) {
return (ISC_R_SUCCESS);
}
static inline bool
static bool
command_compare(const char *str, const char *command) {
return (strcasecmp(str, command) == 0);
}

2
bin/named/controlconf.c
View file

@ -257,7 +257,7 @@ cleanup_sendhandle:
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);

10
bin/named/server.c
View file

@ -455,7 +455,7 @@ end_reserved_dispatches(named_server_t *server, bool all);
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
@ -464,7 +464,7 @@ putmem(isc_buffer_t **b, const char *str, size_t len);
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
@ -15037,7 +15037,7 @@ cleanup:
return (result);
}
static inline bool
static bool
argcheck(char *cmd, const char *full) {
size_t l;
@ -15375,7 +15375,7 @@ putmem(isc_buffer_t **b, const char *str, size_t len) {
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)));
}
@ -15393,7 +15393,7 @@ putuint8(isc_buffer_t **b, uint8_t val) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
putnull(isc_buffer_t **b) {
return (putuint8(b, 0));
}

2
bin/named/statschannel.c
View file

@ -211,7 +211,7 @@ static int tcpoutsizestats_index[dns_sizecounter_out_max];
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);

2
bin/named/zoneconf.c
View file

@ -682,7 +682,7 @@ cleanup:
/*%
* 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;

2
bin/nsupdate/nsupdate.c
View file

@ -304,7 +304,7 @@ ddebug(const char *format, ...) {
}
}
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));

2
bin/tests/wire_test.c
View file

@ -37,7 +37,7 @@ process_message(isc_buffer_t *source);
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));

2
contrib/dlz/modules/mysqldyn/dlz_mysqldyn_mod.c
View file

@ -494,7 +494,7 @@ isrelative(const char *s) {
}
/* 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) ? "." : "");
}

2
doc/dev/style.md
View file

@ -269,7 +269,7 @@ specifying the implementation of the function. The opening curly brace
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 */
}

118
lib/dns/adb.c
View file

@ -273,35 +273,35 @@ struct dns_adbentry {
/*
* 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);
@ -314,17 +314,17 @@ static void
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 *);
@ -343,7 +343,7 @@ dbfind_name(dns_adbname_t *, isc_stdtime_t, dns_rdatatype_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 *);
@ -351,13 +351,13 @@ static bool
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);
@ -502,7 +502,7 @@ DP(int level, const char *format, ...) {
/*%
* 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);
@ -512,28 +512,28 @@ inc_stats(dns_adb_t *adb, isc_statscounter_t 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;
@ -1132,7 +1132,7 @@ check_expire_namehooks(dns_adbname_t *name, isc_stdtime_t now) {
/*
* 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);
@ -1144,7 +1144,7 @@ link_name(dns_adb_t *adb, int bucket, dns_adbname_t *name) {
/*
* 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;
@ -1169,7 +1169,7 @@ unlink_name(dns_adb_t *adb, dns_adbname_t *name) {
/*
* 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;
@ -1200,7 +1200,7 @@ link_entry(dns_adb_t *adb, int bucket, dns_adbentry_t *entry) {
/*
* 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;
@ -1222,7 +1222,7 @@ unlink_entry(dns_adb_t *adb, dns_adbentry_t *entry) {
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);
@ -1563,7 +1563,7 @@ clean_finds_at_name(dns_adbname_t *name, isc_eventtype_t evtype,
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;
/*
@ -1584,7 +1584,7 @@ check_exit(dns_adb_t *adb) {
}
}
static inline bool
static bool
dec_adb_irefcnt(dns_adb_t *adb) {
isc_event_t *event;
isc_task_t *etask;
@ -1613,21 +1613,21 @@ dec_adb_irefcnt(dns_adb_t *adb) {
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;
@ -1644,7 +1644,7 @@ inc_entry_refcnt(dns_adb_t *adb, dns_adbentry_t *entry, bool lock) {
}
}
static inline bool
static bool
dec_entry_refcnt(dns_adb_t *adb, bool overmem, dns_adbentry_t *entry,
bool lock) {
int bucket;
@ -1687,7 +1687,7 @@ dec_entry_refcnt(dns_adb_t *adb, bool overmem, dns_adbentry_t *entry,
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;
@ -1730,7 +1730,7 @@ new_adbname(dns_adb_t *adb, const dns_name_t *dnsname) {
return (name);
}
static inline void
static void
free_adbname(dns_adb_t *adb, dns_adbname_t **name) {
dns_adbname_t *n;
@ -1756,7 +1756,7 @@ free_adbname(dns_adb_t *adb, dns_adbname_t **name) {
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;
@ -1770,7 +1770,7 @@ new_adbnamehook(dns_adb_t *adb, dns_adbentry_t *entry) {
return (nh);
}
static inline void
static void
free_adbnamehook(dns_adb_t *adb, dns_adbnamehook_t **namehook) {
dns_adbnamehook_t *nh;
@ -1787,7 +1787,7 @@ free_adbnamehook(dns_adb_t *adb, dns_adbnamehook_t **namehook) {
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;
@ -1804,7 +1804,7 @@ new_adblameinfo(dns_adb_t *adb, const dns_name_t *qname,
return (li);
}
static inline void
static void
free_adblameinfo(dns_adb_t *adb, dns_adblameinfo_t **lameinfo) {
dns_adblameinfo_t *li;
@ -1821,7 +1821,7 @@ free_adblameinfo(dns_adb_t *adb, dns_adblameinfo_t **lameinfo) {
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;
@ -1866,7 +1866,7 @@ new_adbentry(dns_adb_t *adb) {
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;
@ -1899,7 +1899,7 @@ free_adbentry(dns_adb_t *adb, dns_adbentry_t **entry) {
UNLOCK(&adb->entriescntlock);
}
static inline dns_adbfind_t *
static dns_adbfind_t *
new_adbfind(dns_adb_t *adb) {
dns_adbfind_t *h;
@ -1935,7 +1935,7 @@ new_adbfind(dns_adb_t *adb) {
return (h);
}
static inline dns_adbfetch_t *
static dns_adbfetch_t *
new_adbfetch(dns_adb_t *adb) {
dns_adbfetch_t *f;
@ -1951,7 +1951,7 @@ new_adbfetch(dns_adb_t *adb) {
return (f);
}
static inline void
static void
free_adbfetch(dns_adb_t *adb, dns_adbfetch_t **fetch) {
dns_adbfetch_t *f;
@ -1968,7 +1968,7 @@ free_adbfetch(dns_adb_t *adb, dns_adbfetch_t **fetch) {
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;
@ -1996,7 +1996,7 @@ free_adbfind(dns_adb_t *adb, dns_adbfind_t **findp) {
* 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;
@ -2014,7 +2014,7 @@ new_adbaddrinfo(dns_adb_t *adb, dns_adbentry_t *entry, in_port_t port) {
return (ai);
}
static inline void
static void
free_adbaddrinfo(dns_adb_t *adb, dns_adbaddrinfo_t **ainfo) {
dns_adbaddrinfo_t *ai;
@ -2037,7 +2037,7 @@ free_adbaddrinfo(dns_adb_t *adb, dns_adbaddrinfo_t **ainfo) {
* 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;
@ -2080,7 +2080,7 @@ find_name_and_lock(dns_adb_t *adb, const dns_name_t *name, unsigned int options,
* 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;
@ -3624,7 +3624,7 @@ print_namehook_list(FILE *f, const char *legend, dns_adb_t *adb,
}
}
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);
}

2
lib/dns/byaddr.c
View file

@ -108,7 +108,7 @@ struct dns_byaddr {
#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;

2
lib/dns/cache.c
View file

@ -166,7 +166,7 @@ overmem_cleaning_action(isc_task_t *task, isc_event_t *event);
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,

2
lib/dns/catz.c
View file

@ -1325,7 +1325,7 @@ catz_process_zones_suboption(dns_catz_zone_t *zone, dns_rdataset_t *value,
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,

2
lib/dns/client.c
View file

@ -519,7 +519,7 @@ fetch_done(isc_task_t *task, isc_event_t *event) {
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;

2
lib/dns/compress.c
View file

@ -362,7 +362,7 @@ found:
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);

2
lib/dns/db.c
View file

@ -82,7 +82,7 @@ initialize(void) {
ISC_LIST_APPEND(implementations, &rbtimp, link);
}
static inline dns_dbimplementation_t *
static dns_dbimplementation_t *
impfind(const char *name) {
dns_dbimplementation_t *imp;

4
lib/dns/dispatch.c
View file

@ -240,14 +240,14 @@ mgr_log(dns_dispatchmgr_t *mgr, int level, const char *fmt, ...) {
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);

2
lib/dns/dlz.c
View file

@ -88,7 +88,7 @@ dlz_initialize(void) {
/*%
* 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;

2
lib/dns/dnssec.c
View file

@ -73,7 +73,7 @@ digest_callback(void *arg, isc_region_t *data) {
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);

2
lib/dns/gssapictx.c
View file

@ -100,7 +100,7 @@ static gss_OID_desc __gss_spnego_mechanism_oid_desc = {
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;

34
lib/dns/hmac_link.c
View file

@ -142,7 +142,7 @@ struct dst_hmac_key {
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;
@ -155,7 +155,7 @@ getkeybits(dst_key_t *key, struct dst_private_element *element) {
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;
@ -172,7 +172,7 @@ hmac_createctx(const isc_md_type_t *type, const dst_key_t *key,
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);
@ -181,7 +181,7 @@ hmac_destroyctx(dst_context_t *dctx) {
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;
@ -196,7 +196,7 @@ hmac_adddata(const dst_context_t *dctx, const isc_region_t *data) {
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);
@ -220,7 +220,7 @@ hmac_sign(const dst_context_t *dctx, isc_buffer_t *sig) {
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];
@ -245,7 +245,7 @@ hmac_verify(const dst_context_t *dctx, const isc_region_t *sig) {
: 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;
@ -263,7 +263,7 @@ hmac_compare(const isc_md_type_t *type, const dst_key_t *key1,
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;
@ -291,13 +291,13 @@ hmac_generate(const isc_md_type_t *type, dst_key_t *key) {
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));
@ -305,7 +305,7 @@ hmac_destroy(dst_key_t *key) {
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;
@ -320,7 +320,7 @@ hmac_todns(const dst_key_t *key, isc_buffer_t *data) {
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;
@ -355,7 +355,7 @@ hmac_fromdns(const isc_md_type_t *type, dst_key_t *key, isc_buffer_t *data) {
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);
@ -374,7 +374,7 @@ hmac__get_tag_key(const isc_md_type_t *type) {
}
}
static inline int
static int
hmac__get_tag_bits(const isc_md_type_t *type) {
if (type == ISC_MD_MD5) {
return (TAG_HMACMD5_BITS);
@ -393,7 +393,7 @@ hmac__get_tag_bits(const isc_md_type_t *type) {
}
}
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;
@ -426,7 +426,7 @@ hmac_tofile(const isc_md_type_t *type, const dst_key_t *key,
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);
@ -445,7 +445,7 @@ hmac__to_dst_alg(const isc_md_type_t *type) {
}
}
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;

4
lib/dns/journal.c
View file

@ -110,13 +110,13 @@
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);

2
lib/dns/kasp.c
View file

@ -80,7 +80,7 @@ dns_kasp_attach(dns_kasp_t *source, dns_kasp_t **targetp) {
*targetp = source;
}
static inline void
static void
destroy(dns_kasp_t *kasp) {
dns_kasp_key_t *key;
dns_kasp_key_t *key_next;

2
lib/dns/lookup.c
View file

@ -73,7 +73,7 @@ fetch_done(isc_task_t *task, isc_event_t *event) {
lookup_find(lookup, fevent);
}
static inline isc_result_t
static isc_result_t
start_fetch(dns_lookup_t *lookup) {
isc_result_t result;

6
lib/dns/master.c
View file

@ -335,14 +335,14 @@ static unsigned char ip6_arpa_offsets[] = { 0, 4, 9 };
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;
@ -2204,7 +2204,7 @@ cleanup:
* 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;

42
lib/dns/message.c
View file

@ -170,19 +170,19 @@ struct dns_msgblock {
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
@ -195,7 +195,7 @@ logfmtpacket(dns_message_t *message, const char *description,
* 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;
@ -217,7 +217,7 @@ msgblock_allocate(isc_mem_t *mctx, unsigned int sizeof_type,
* 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;
@ -233,7 +233,7 @@ msgblock_internalget(dns_msgblock_t *block, unsigned int sizeof_type) {
return (ptr);
}
static inline void
static void
msgblock_reset(dns_msgblock_t *block) {
block->remaining = block->count;
}
@ -241,7 +241,7 @@ msgblock_reset(dns_msgblock_t *block) {
/*
* 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;
@ -256,7 +256,7 @@ msgblock_free(isc_mem_t *mctx, dns_msgblock_t *block,
* "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;
@ -267,7 +267,7 @@ newbuffer(dns_message_t *msg, unsigned int size) {
return (ISC_R_SUCCESS);
}
static inline isc_buffer_t *
static isc_buffer_t *
currentbuffer(dns_message_t *msg) {
isc_buffer_t *dynbuf;
@ -277,12 +277,12 @@ currentbuffer(dns_message_t *msg) {
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;
@ -307,12 +307,12 @@ newrdata(dns_message_t *msg) {
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;
@ -337,7 +337,7 @@ out:
return (rdatalist);
}
static inline dns_offsets_t *
static dns_offsets_t *
newoffsets(dns_message_t *msg) {
dns_msgblock_t *msgblock;
dns_offsets_t *offsets;
@ -355,7 +355,7 @@ newoffsets(dns_message_t *msg) {
return (offsets);
}
static inline void
static void
msginitheader(dns_message_t *m) {
m->id = 0;
m->flags = 0;
@ -364,7 +364,7 @@ msginitheader(dns_message_t *m) {
m->rdclass = 0;
}
static inline void
static void
msginitprivate(dns_message_t *m) {
unsigned int i;
@ -386,7 +386,7 @@ msginitprivate(dns_message_t *m) {
m->buffer = NULL;
}
static inline void
static void
msginittsig(dns_message_t *m) {
m->tsigstatus = dns_rcode_noerror;
m->querytsigstatus = dns_rcode_noerror;
@ -402,7 +402,7 @@ msginittsig(dns_message_t *m) {
* 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);
@ -431,7 +431,7 @@ msginit(dns_message_t *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;
@ -1848,7 +1848,7 @@ dns_message_renderreserve(dns_message_t *msg, unsigned int space) {
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;

2
lib/dns/ncache.c
View file

@ -48,7 +48,7 @@ addoptout(dns_message_t *message, dns_db_t *cache, dns_dbnode_t *node,
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;

2
lib/dns/order.c
View file

@ -90,7 +90,7 @@ dns_order_add(dns_order_t *order, const dns_name_t *name,
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));

43
lib/dns/rbt.c
View file

@ -71,7 +71,7 @@
#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. */
@ -172,7 +172,7 @@ struct dns_rbt {
* 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);
@ -183,7 +183,6 @@ NODENAME(dns_rbtnode_t *node, dns_name_t *name) {
}
#ifdef DEBUG
#define inline
/*
* A little something to help out in GDB.
*/
@ -206,7 +205,7 @@ Name(dns_rbtnode_t *node) {
* 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));
}
@ -232,15 +231,15 @@ dns__rbtnode_getdistance(dns_rbtnode_t *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
@ -251,15 +250,15 @@ static void
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
@ -388,7 +387,7 @@ dns_rbt_hashsize(dns_rbt_t *rbt) {
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;
@ -415,7 +414,7 @@ chain_name(dns_rbtnodechain_t *chain, dns_name_t *name,
return (result);
}
static inline isc_result_t
static isc_result_t
move_chain_to_last(dns_rbtnodechain_t *chain, dns_rbtnode_t *node) {
do {
/*
@ -1609,7 +1608,7 @@ create_node(isc_mem_t *mctx, const dns_name_t *name, dns_rbtnode_t **nodep) {
/*
* 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;
@ -1626,7 +1625,7 @@ hash_add_node(dns_rbt_t *rbt, dns_rbtnode_t *node, const dns_name_t *name) {
/*
* Initialize hash table
*/
static inline void
static void
hashtable_new(dns_rbt_t *rbt, uint8_t index, uint8_t bits) {
size_t size;
@ -1642,7 +1641,7 @@ hashtable_new(dns_rbt_t *rbt, uint8_t index, uint8_t bits) {
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);
@ -1734,12 +1733,12 @@ maybe_rehash(dns_rbt_t *rbt, size_t newcount) {
}
}
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));
@ -1749,7 +1748,7 @@ hashtable_is_overcommited(dns_rbt_t *rbt) {
* 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));
@ -1767,7 +1766,7 @@ hash_node(dns_rbt_t *rbt, dns_rbtnode_t *node, const dns_name_t *name) {
/*
* 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;
@ -1808,7 +1807,7 @@ nexttable:
UNREACHABLE();
}
static inline void
static void
rotate_left(dns_rbtnode_t *node, dns_rbtnode_t **rootp) {
dns_rbtnode_t *child;
@ -1841,7 +1840,7 @@ rotate_left(dns_rbtnode_t *node, dns_rbtnode_t **rootp) {
PARENT(node) = child;
}
static inline void
static void
rotate_right(dns_rbtnode_t *node, dns_rbtnode_t **rootp) {
dns_rbtnode_t *child;

76
lib/dns/rbtdb.c
View file

@ -13,8 +13,6 @@
/*! \file */
/* #define inline */
#include <ctype.h>
#include <inttypes.h>
#include <stdbool.h>
@ -319,7 +317,7 @@ typedef ISC_LIST(dns_rbtnode_t) rbtnodelist_t;
#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. */
@ -548,7 +546,7 @@ rdataset_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name,
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);
@ -1155,7 +1153,7 @@ free_rbtdb(dns_rbtdb_t *rbtdb, bool log, isc_event_t *event) {
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;
@ -1242,7 +1240,7 @@ currentversion(dns_db_t *db, dns_dbversion_t **versionp) {
*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;
@ -1359,7 +1357,7 @@ add_changed(dns_rbtdb_t *rbtdb, rbtdb_version_t *version, dns_rbtnode_t *node) {
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);
@ -1376,7 +1374,7 @@ free_noqname(isc_mem_t *mctx, struct noqname **noqname) {
*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;
@ -1407,7 +1405,7 @@ update_newheader(rdatasetheader_t *newh, rdatasetheader_t *old) {
}
}
static inline rdatasetheader_t *
static rdatasetheader_t *
new_rdataset(dns_rbtdb_t *rbtdb, isc_mem_t *mctx) {
rdatasetheader_t *h;
@ -1424,7 +1422,7 @@ new_rdataset(dns_rbtdb_t *rbtdb, isc_mem_t *mctx) {
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;
@ -1460,7 +1458,7 @@ free_rdataset(dns_rbtdb_t *rbtdb, isc_mem_t *mctx, rdatasetheader_t *rdataset) {
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;
@ -1493,7 +1491,7 @@ rollback_node(dns_rbtnode_t *node, rbtdb_serial_t serial) {
}
}
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;
@ -1522,7 +1520,7 @@ mark_header_ancient(dns_rbtdb_t *rbtdb, rdatasetheader_t *header) {
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;
@ -1551,7 +1549,7 @@ mark_header_stale(dns_rbtdb_t *rbtdb, rdatasetheader_t *header) {
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;
@ -1563,7 +1561,7 @@ clean_stale_headers(dns_rbtdb_t *rbtdb, isc_mem_t *mctx,
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;
@ -1596,7 +1594,7 @@ clean_cache_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node) {
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;
@ -1807,7 +1805,7 @@ delete_node(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node) {
/*
* 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))
@ -1825,13 +1823,13 @@ new_reference(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node,
/*%
* 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;
@ -1906,7 +1904,7 @@ cleanup_dead_nodes(dns_rbtdb_t *rbtdb, int bucketnum) {
* 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;
@ -2178,7 +2176,7 @@ prune_tree(isc_task_t *task, isc_event_t *event) {
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) {
/*
@ -2190,7 +2188,7 @@ make_least_version(dns_rbtdb_t *rbtdb, rbtdb_version_t *version,
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;
@ -2972,7 +2970,7 @@ zone_zonecut_callback(dns_rbtnode_t *node, dns_name_t *name, void *arg) {
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) {
@ -3093,7 +3091,7 @@ bind_rdataset(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, rdatasetheader_t *header,
}
}
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) {
@ -3153,7 +3151,7 @@ setup_delegation(rbtdb_search_t *search, dns_dbnode_t **nodep,
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 */
@ -3209,7 +3207,7 @@ valid_glue(rbtdb_search_t *search, dns_name_t *name, rbtdb_rdatatype_t type,
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;
@ -3262,7 +3260,7 @@ activeempty(rbtdb_search_t *search, dns_rbtnodechain_t *chain,
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;
@ -3382,7 +3380,7 @@ activeemptynode(rbtdb_search_t *search, const dns_name_t *qname,
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;
@ -3582,7 +3580,7 @@ matchparams(rdatasetheader_t *header, rbtdb_search_t *search) {
/*
* 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,
@ -3698,7 +3696,7 @@ previous_closest_nsec(dns_rdatatype_t type, rbtdb_search_t *search,
* 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,
@ -4623,7 +4621,7 @@ cache_zonecut_callback(dns_rbtnode_t *node, dns_name_t *name, void *arg) {
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) {
@ -6063,7 +6061,7 @@ resign_delete(dns_rbtdb_t *rbtdb, rbtdb_version_t *version,
}
}
static inline uint64_t
static uint64_t
recordsize(rdatasetheader_t *header, unsigned int namelen) {
return (dns_rdataslab_rdatasize((unsigned char *)header,
sizeof(*header)) +
@ -6616,7 +6614,7 @@ find_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)) {
@ -6634,7 +6632,7 @@ delegating_type(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node,
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;
@ -6679,7 +6677,7 @@ cleanup:
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;
@ -8837,7 +8835,7 @@ rdatasetiter_current(dns_rdatasetiter_t *iterator, dns_rdataset_t *rdataset) {
* 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;
@ -8850,7 +8848,7 @@ reference_iter_node(rbtdb_dbiterator_t *rbtdbiter) {
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;
@ -8919,7 +8917,7 @@ flush_deletions(rbtdb_dbiterator_t *rbtdbiter) {
}
}
static inline void
static void
resume_iteration(rbtdb_dbiterator_t *rbtdbiter) {
dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)rbtdbiter->common.db;
@ -9969,7 +9967,7 @@ no_glue:
*
* 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 |

22
lib/dns/rdata.c
View file

@ -259,17 +259,17 @@ static isc_result_t
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);
@ -351,7 +351,7 @@ static dns_name_t const gc_msdcs = DNS_NAME_INITNONABSOLUTE(gc_msdcs_data,
* \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";
@ -409,7 +409,7 @@ locator_pton(const char *src, unsigned char *dst) {
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);
@ -418,7 +418,7 @@ name_duporclone(const dns_name_t *source, isc_mem_t *mctx, dns_name_t *target) {
}
}
static inline void *
static void *
mem_maybedup(isc_mem_t *mctx, void *source, size_t length) {
void *copy = NULL;
@ -434,7 +434,7 @@ mem_maybedup(isc_mem_t *mctx, void *source, size_t length) {
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 */
@ -502,7 +502,7 @@ typemap_fromtext(isc_lex_t *lexer, isc_buffer_t *target, bool allow_empty) {
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;

26
lib/dns/rdata/any_255/tsig_250.c
View file

@ -17,7 +17,7 @@
#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;
@ -130,7 +130,7 @@ fromtext_any_tsig(ARGS_FROMTEXT) {
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;
@ -251,7 +251,7 @@ totext_any_tsig(ARGS_TOTEXT) {
}
}
static inline isc_result_t
static isc_result_t
fromwire_any_tsig(ARGS_FROMWIRE) {
isc_region_t sr;
dns_name_t name;
@ -320,7 +320,7 @@ fromwire_any_tsig(ARGS_FROMWIRE) {
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;
@ -339,7 +339,7 @@ towire_any_tsig(ARGS_TOWIRE) {
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;
@ -369,7 +369,7 @@ compare_any_tsig(ARGS_COMPARE) {
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;
@ -441,7 +441,7 @@ fromstruct_any_tsig(ARGS_FROMSTRUCT) {
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;
@ -526,7 +526,7 @@ tostruct_any_tsig(ARGS_TOSTRUCT) {
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;
@ -548,7 +548,7 @@ freestruct_any_tsig(ARGS_FREESTRUCT) {
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);
@ -561,7 +561,7 @@ additionaldata_any_tsig(ARGS_ADDLDATA) {
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);
@ -573,7 +573,7 @@ digest_any_tsig(ARGS_DIGEST) {
return (ISC_R_NOTIMPLEMENTED);
}
static inline bool
static bool
checkowner_any_tsig(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_tsig);
REQUIRE(rdclass == dns_rdataclass_any);
@ -586,7 +586,7 @@ checkowner_any_tsig(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_any_tsig(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_tsig);
REQUIRE(rdata->rdclass == dns_rdataclass_any);
@ -598,7 +598,7 @@ checknames_any_tsig(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_any_tsig(ARGS_COMPARE) {
return (compare_any_tsig(rdata1, rdata2));
}

26
lib/dns/rdata/ch_3/a_1.c
View file

@ -21,7 +21,7 @@
#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;
@ -64,7 +64,7 @@ fromtext_ch_a(ARGS_FROMTEXT) {
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;
@ -93,7 +93,7 @@ totext_ch_a(ARGS_TOTEXT) {
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;
@ -127,7 +127,7 @@ fromwire_ch_a(ARGS_FROMWIRE) {
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;
@ -158,7 +158,7 @@ towire_ch_a(ARGS_TOWIRE) {
return (ISC_R_SUCCESS);
}
static inline int
static int
compare_ch_a(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
@ -196,7 +196,7 @@ compare_ch_a(ARGS_COMPARE) {
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;
@ -215,7 +215,7 @@ fromstruct_ch_a(ARGS_FROMSTRUCT) {
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;
@ -242,7 +242,7 @@ tostruct_ch_a(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_ch_a(ARGS_FREESTRUCT) {
dns_rdata_ch_a_t *a = source;
@ -257,7 +257,7 @@ freestruct_ch_a(ARGS_FREESTRUCT) {
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);
@ -270,7 +270,7 @@ additionaldata_ch_a(ARGS_ADDLDATA) {
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;
@ -286,7 +286,7 @@ digest_ch_a(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_ch_a(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_a);
REQUIRE(rdclass == dns_rdataclass_ch);
@ -296,7 +296,7 @@ checkowner_ch_a(ARGS_CHECKOWNER) {
return (dns_name_ishostname(name, wildcard));
}
static inline bool
static bool
checknames_ch_a(ARGS_CHECKNAMES) {
isc_region_t region;
dns_name_t name;
@ -319,7 +319,7 @@ checknames_ch_a(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_ch_a(ARGS_COMPARE) {
return (compare_ch_a(rdata1, rdata2));
}

26
lib/dns/rdata/generic/afsdb_18.c
View file

@ -18,7 +18,7 @@
#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;
@ -65,7 +65,7 @@ fromtext_afsdb(ARGS_FROMTEXT) {
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;
@ -90,7 +90,7 @@ totext_afsdb(ARGS_TOTEXT) {
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;
@ -119,7 +119,7 @@ fromwire_afsdb(ARGS_FROMWIRE) {
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;
@ -145,7 +145,7 @@ towire_afsdb(ARGS_TOWIRE) {
return (dns_name_towire(&name, cctx, target));
}
static inline int
static int
compare_afsdb(ARGS_COMPARE) {
int result;
dns_name_t name1;
@ -179,7 +179,7 @@ compare_afsdb(ARGS_COMPARE) {
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;
@ -197,7 +197,7 @@ fromstruct_afsdb(ARGS_FROMSTRUCT) {
return (isc_buffer_copyregion(target, &region));
}
static inline isc_result_t
static isc_result_t
tostruct_afsdb(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_afsdb_t *afsdb = target;
@ -226,7 +226,7 @@ tostruct_afsdb(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_afsdb(ARGS_FREESTRUCT) {
dns_rdata_afsdb_t *afsdb = source;
@ -241,7 +241,7 @@ freestruct_afsdb(ARGS_FREESTRUCT) {
afsdb->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_afsdb(ARGS_ADDLDATA) {
dns_name_t name;
dns_offsets_t offsets;
@ -259,7 +259,7 @@ additionaldata_afsdb(ARGS_ADDLDATA) {
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;
@ -277,7 +277,7 @@ digest_afsdb(ARGS_DIGEST) {
return (dns_name_digest(&name, digest, arg));
}
static inline bool
static bool
checkowner_afsdb(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_afsdb);
@ -289,7 +289,7 @@ checkowner_afsdb(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_afsdb(ARGS_CHECKNAMES) {
isc_region_t region;
dns_name_t name;
@ -311,7 +311,7 @@ checknames_afsdb(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_afsdb(ARGS_COMPARE) {
return (compare_afsdb(rdata1, rdata2));
}

26
lib/dns/rdata/generic/amtrelay_260.c
View file

@ -20,7 +20,7 @@
#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;
@ -120,7 +120,7 @@ fromtext_amtrelay(ARGS_FROMTEXT) {
}
}
static inline isc_result_t
static isc_result_t
totext_amtrelay(ARGS_TOTEXT) {
isc_region_t region;
dns_name_t name;
@ -182,7 +182,7 @@ totext_amtrelay(ARGS_TOTEXT) {
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;
@ -234,7 +234,7 @@ fromwire_amtrelay(ARGS_FROMWIRE) {
}
}
static inline isc_result_t
static isc_result_t
towire_amtrelay(ARGS_TOWIRE) {
isc_region_t region;
@ -247,7 +247,7 @@ towire_amtrelay(ARGS_TOWIRE) {
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;
@ -264,7 +264,7 @@ compare_amtrelay(ARGS_COMPARE) {
return (isc_region_compare(&region1, &region2));
}
static inline isc_result_t
static isc_result_t
fromstruct_amtrelay(ARGS_FROMSTRUCT) {
dns_rdata_amtrelay_t *amtrelay = source;
isc_region_t region;
@ -304,7 +304,7 @@ fromstruct_amtrelay(ARGS_FROMSTRUCT) {
}
}
static inline isc_result_t
static isc_result_t
tostruct_amtrelay(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_amtrelay_t *amtrelay = target;
@ -365,7 +365,7 @@ tostruct_amtrelay(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_amtrelay(ARGS_FREESTRUCT) {
dns_rdata_amtrelay_t *amtrelay = source;
@ -387,7 +387,7 @@ freestruct_amtrelay(ARGS_FREESTRUCT) {
amtrelay->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_amtrelay(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_amtrelay);
@ -399,7 +399,7 @@ additionaldata_amtrelay(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_amtrelay(ARGS_DIGEST) {
isc_region_t region;
@ -409,7 +409,7 @@ digest_amtrelay(ARGS_DIGEST) {
return ((digest)(arg, &region));
}
static inline bool
static bool
checkowner_amtrelay(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_amtrelay);
@ -421,7 +421,7 @@ checkowner_amtrelay(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_amtrelay(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_amtrelay);
@ -432,7 +432,7 @@ checknames_amtrelay(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_amtrelay(ARGS_COMPARE) {
isc_region_t region1;
isc_region_t region2;

26
lib/dns/rdata/generic/avc_258.c
View file

@ -16,14 +16,14 @@
#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);
@ -31,14 +31,14 @@ totext_avc(ARGS_TOTEXT) {
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);
@ -47,7 +47,7 @@ towire_avc(ARGS_TOWIRE) {
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;
@ -61,14 +61,14 @@ compare_avc(ARGS_COMPARE) {
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;
@ -82,7 +82,7 @@ tostruct_avc(ARGS_TOSTRUCT) {
return (generic_tostruct_txt(CALL_TOSTRUCT));
}
static inline void
static void
freestruct_avc(ARGS_FREESTRUCT) {
dns_rdata_avc_t *avc = source;
@ -92,7 +92,7 @@ freestruct_avc(ARGS_FREESTRUCT) {
generic_freestruct_txt(source);
}
static inline isc_result_t
static isc_result_t
additionaldata_avc(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_avc);
@ -104,7 +104,7 @@ additionaldata_avc(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_avc(ARGS_DIGEST) {
isc_region_t r;
@ -115,7 +115,7 @@ digest_avc(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_avc(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_avc);
@ -127,7 +127,7 @@ checkowner_avc(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_avc(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_avc);
@ -138,7 +138,7 @@ checknames_avc(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_avc(ARGS_COMPARE) {
return (compare_avc(rdata1, rdata2));
}

26
lib/dns/rdata/generic/caa_257.c
View file

@ -275,7 +275,7 @@ static unsigned char const alphanumeric[256] = {
0,
};
static inline isc_result_t
static isc_result_t
fromtext_caa(ARGS_FROMTEXT) {
isc_token_t token;
isc_textregion_t tr;
@ -326,7 +326,7 @@ fromtext_caa(ARGS_FROMTEXT) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
totext_caa(ARGS_TOTEXT) {
isc_region_t region;
uint8_t flags;
@ -360,7 +360,7 @@ totext_caa(ARGS_TOTEXT) {
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;
@ -411,7 +411,7 @@ fromwire_caa(ARGS_FROMWIRE) {
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;
@ -425,7 +425,7 @@ towire_caa(ARGS_TOWIRE) {
return (mem_tobuffer(target, region.base, region.length));
}
static inline int
static int
compare_caa(ARGS_COMPARE) {
isc_region_t r1, r2;
@ -442,7 +442,7 @@ compare_caa(ARGS_COMPARE) {
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;
@ -488,7 +488,7 @@ fromstruct_caa(ARGS_FROMSTRUCT) {
return (isc_buffer_copyregion(target, &region));
}
static inline isc_result_t
static isc_result_t
tostruct_caa(ARGS_TOSTRUCT) {
dns_rdata_caa_t *caa = target;
isc_region_t sr;
@ -533,7 +533,7 @@ tostruct_caa(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_caa(ARGS_FREESTRUCT) {
dns_rdata_caa_t *caa = (dns_rdata_caa_t *)source;
@ -553,7 +553,7 @@ freestruct_caa(ARGS_FREESTRUCT) {
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);
@ -567,7 +567,7 @@ additionaldata_caa(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_caa(ARGS_DIGEST) {
isc_region_t r;
@ -580,7 +580,7 @@ digest_caa(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_caa(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_caa);
@ -592,7 +592,7 @@ checkowner_caa(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_caa(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_caa);
REQUIRE(rdata->data != NULL);
@ -605,7 +605,7 @@ checknames_caa(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_caa(ARGS_COMPARE) {
return (compare_caa(rdata1, rdata2));
}

26
lib/dns/rdata/generic/cdnskey_60.c
View file

@ -20,14 +20,14 @@
#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);
@ -35,14 +35,14 @@ totext_cdnskey(ARGS_TOTEXT) {
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;
@ -55,7 +55,7 @@ towire_cdnskey(ARGS_TOWIRE) {
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;
@ -73,14 +73,14 @@ compare_cdnskey(ARGS_COMPARE) {
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;
@ -95,7 +95,7 @@ tostruct_cdnskey(ARGS_TOSTRUCT) {
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;
@ -105,7 +105,7 @@ freestruct_cdnskey(ARGS_FREESTRUCT) {
generic_freestruct_key(source);
}
static inline isc_result_t
static isc_result_t
additionaldata_cdnskey(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_cdnskey);
@ -117,7 +117,7 @@ additionaldata_cdnskey(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_cdnskey(ARGS_DIGEST) {
isc_region_t r;
@ -129,7 +129,7 @@ digest_cdnskey(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_cdnskey(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_cdnskey);
@ -141,7 +141,7 @@ checkowner_cdnskey(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_cdnskey(ARGS_CHECKNAMES) {
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_cdnskey);
@ -153,7 +153,7 @@ checknames_cdnskey(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_cdnskey(ARGS_COMPARE) {
/*
* Treat ALG 253 (private DNS) subtype name case sensitively.

26
lib/dns/rdata/generic/cds_59.c
View file

@ -20,14 +20,14 @@
#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);
@ -35,14 +35,14 @@ totext_cds(ARGS_TOTEXT) {
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;
@ -55,7 +55,7 @@ towire_cds(ARGS_TOWIRE) {
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;
@ -71,14 +71,14 @@ compare_cds(ARGS_COMPARE) {
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;
@ -96,7 +96,7 @@ tostruct_cds(ARGS_TOSTRUCT) {
return (generic_tostruct_ds(CALL_TOSTRUCT));
}
static inline void
static void
freestruct_cds(ARGS_FREESTRUCT) {
dns_rdata_cds_t *cds = source;
@ -113,7 +113,7 @@ freestruct_cds(ARGS_FREESTRUCT) {
cds->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_cds(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_cds);
@ -125,7 +125,7 @@ additionaldata_cds(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_cds(ARGS_DIGEST) {
isc_region_t r;
@ -136,7 +136,7 @@ digest_cds(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_cds(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_cds);
@ -148,7 +148,7 @@ checkowner_cds(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_cds(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_cds);
@ -159,7 +159,7 @@ checknames_cds(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_cds(ARGS_COMPARE) {
return (compare_cds(rdata1, rdata2));
}

26
lib/dns/rdata/generic/cert_37.c
View file

@ -18,7 +18,7 @@
#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;
@ -61,7 +61,7 @@ fromtext_cert(ARGS_FROMTEXT) {
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 ")];
@ -115,7 +115,7 @@ totext_cert(ARGS_TOTEXT) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
fromwire_cert(ARGS_FROMWIRE) {
isc_region_t sr;
@ -135,7 +135,7 @@ fromwire_cert(ARGS_FROMWIRE) {
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;
@ -148,7 +148,7 @@ towire_cert(ARGS_TOWIRE) {
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;
@ -164,7 +164,7 @@ compare_cert(ARGS_COMPARE) {
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;
@ -183,7 +183,7 @@ fromstruct_cert(ARGS_FROMSTRUCT) {
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;
@ -211,7 +211,7 @@ tostruct_cert(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_cert(ARGS_FREESTRUCT) {
dns_rdata_cert_t *cert = source;
@ -228,7 +228,7 @@ freestruct_cert(ARGS_FREESTRUCT) {
cert->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_cert(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_cert);
@ -240,7 +240,7 @@ additionaldata_cert(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_cert(ARGS_DIGEST) {
isc_region_t r;
@ -251,7 +251,7 @@ digest_cert(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_cert(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_cert);
@ -263,7 +263,7 @@ checkowner_cert(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_cert(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_cert);
@ -274,7 +274,7 @@ checknames_cert(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_cert(ARGS_COMPARE) {
return (compare_cert(rdata1, rdata2));
}

26
lib/dns/rdata/generic/cname_5.c
View file

@ -17,7 +17,7 @@
#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;
@ -41,7 +41,7 @@ fromtext_cname(ARGS_FROMTEXT) {
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;
@ -62,7 +62,7 @@ totext_cname(ARGS_TOTEXT) {
return (dns_name_totext(&prefix, sub, target));
}
static inline isc_result_t
static isc_result_t
fromwire_cname(ARGS_FROMWIRE) {
dns_name_t name;
@ -77,7 +77,7 @@ fromwire_cname(ARGS_FROMWIRE) {
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;
@ -95,7 +95,7 @@ towire_cname(ARGS_TOWIRE) {
return (dns_name_towire(&name, cctx, target));
}
static inline int
static int
compare_cname(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
@ -120,7 +120,7 @@ compare_cname(ARGS_COMPARE) {
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;
@ -137,7 +137,7 @@ fromstruct_cname(ARGS_FROMSTRUCT) {
return (isc_buffer_copyregion(target, &region));
}
static inline isc_result_t
static isc_result_t
tostruct_cname(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_cname_t *cname = target;
@ -160,7 +160,7 @@ tostruct_cname(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_cname(ARGS_FREESTRUCT) {
dns_rdata_cname_t *cname = source;
@ -174,7 +174,7 @@ freestruct_cname(ARGS_FREESTRUCT) {
cname->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_cname(ARGS_ADDLDATA) {
UNUSED(rdata);
UNUSED(owner);
@ -186,7 +186,7 @@ additionaldata_cname(ARGS_ADDLDATA) {
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;
@ -200,7 +200,7 @@ digest_cname(ARGS_DIGEST) {
return (dns_name_digest(&name, digest, arg));
}
static inline bool
static bool
checkowner_cname(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_cname);
@ -212,7 +212,7 @@ checkowner_cname(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_cname(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_cname);
@ -223,7 +223,7 @@ checknames_cname(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_cname(ARGS_COMPARE) {
return (compare_cname(rdata1, rdata2));
}

26
lib/dns/rdata/generic/csync_62.c
View file

@ -18,7 +18,7 @@
#define RRTYPE_CSYNC_ATTRIBUTES 0
static inline isc_result_t
static isc_result_t
fromtext_csync(ARGS_FROMTEXT) {
isc_token_t token;
@ -47,7 +47,7 @@ fromtext_csync(ARGS_FROMTEXT) {
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 */
@ -81,7 +81,7 @@ totext_csync(ARGS_TOTEXT) {
return (typemap_totext(&sr, NULL, target));
}
static /* inline */ isc_result_t
static isc_result_t
fromwire_csync(ARGS_FROMWIRE) {
isc_region_t sr;
@ -111,7 +111,7 @@ fromwire_csync(ARGS_FROMWIRE) {
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);
@ -121,7 +121,7 @@ towire_csync(ARGS_TOWIRE) {
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;
@ -137,7 +137,7 @@ compare_csync(ARGS_COMPARE) {
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;
@ -160,7 +160,7 @@ fromstruct_csync(ARGS_FROMSTRUCT) {
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;
@ -187,7 +187,7 @@ tostruct_csync(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_csync(ARGS_FREESTRUCT) {
dns_rdata_csync_t *csync = source;
@ -204,7 +204,7 @@ freestruct_csync(ARGS_FREESTRUCT) {
csync->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_csync(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_csync);
@ -216,7 +216,7 @@ additionaldata_csync(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_csync(ARGS_DIGEST) {
isc_region_t r;
@ -226,7 +226,7 @@ digest_csync(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_csync(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_csync);
@ -238,7 +238,7 @@ checkowner_csync(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_csync(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_csync);
@ -249,7 +249,7 @@ checknames_csync(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_csync(ARGS_COMPARE) {
isc_region_t region1;
isc_region_t region2;

26
lib/dns/rdata/generic/dlv_32769.c
View file

@ -20,14 +20,14 @@
#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);
@ -35,14 +35,14 @@ totext_dlv(ARGS_TOTEXT) {
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;
@ -55,7 +55,7 @@ towire_dlv(ARGS_TOWIRE) {
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;
@ -71,14 +71,14 @@ compare_dlv(ARGS_COMPARE) {
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;
@ -92,7 +92,7 @@ tostruct_dlv(ARGS_TOSTRUCT) {
return (generic_tostruct_ds(CALL_TOSTRUCT));
}
static inline void
static void
freestruct_dlv(ARGS_FREESTRUCT) {
dns_rdata_dlv_t *dlv = source;
@ -109,7 +109,7 @@ freestruct_dlv(ARGS_FREESTRUCT) {
dlv->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_dlv(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_dlv);
@ -121,7 +121,7 @@ additionaldata_dlv(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_dlv(ARGS_DIGEST) {
isc_region_t r;
@ -132,7 +132,7 @@ digest_dlv(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_dlv(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_dlv);
@ -144,7 +144,7 @@ checkowner_dlv(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_dlv(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_dlv);
@ -155,7 +155,7 @@ checknames_dlv(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_dlv(ARGS_COMPARE) {
return (compare_dlv(rdata1, rdata2));
}

26
lib/dns/rdata/generic/dname_39.c
View file

@ -18,7 +18,7 @@
#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;
@ -42,7 +42,7 @@ fromtext_dname(ARGS_FROMTEXT) {
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;
@ -63,7 +63,7 @@ totext_dname(ARGS_TOTEXT) {
return (dns_name_totext(&prefix, sub, target));
}
static inline isc_result_t
static isc_result_t
fromwire_dname(ARGS_FROMWIRE) {
dns_name_t name;
@ -78,7 +78,7 @@ fromwire_dname(ARGS_FROMWIRE) {
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;
@ -95,7 +95,7 @@ towire_dname(ARGS_TOWIRE) {
return (dns_name_towire(&name, cctx, target));
}
static inline int
static int
compare_dname(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
@ -120,7 +120,7 @@ compare_dname(ARGS_COMPARE) {
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;
@ -137,7 +137,7 @@ fromstruct_dname(ARGS_FROMSTRUCT) {
return (isc_buffer_copyregion(target, &region));
}
static inline isc_result_t
static isc_result_t
tostruct_dname(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_dname_t *dname = target;
@ -160,7 +160,7 @@ tostruct_dname(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_dname(ARGS_FREESTRUCT) {
dns_rdata_dname_t *dname = source;
@ -175,7 +175,7 @@ freestruct_dname(ARGS_FREESTRUCT) {
dname->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_dname(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_dname);
@ -187,7 +187,7 @@ additionaldata_dname(ARGS_ADDLDATA) {
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;
@ -201,7 +201,7 @@ digest_dname(ARGS_DIGEST) {
return (dns_name_digest(&name, digest, arg));
}
static inline bool
static bool
checkowner_dname(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_dname);
@ -213,7 +213,7 @@ checkowner_dname(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_dname(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_dname);
@ -224,7 +224,7 @@ checknames_dname(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_dname(ARGS_COMPARE) {
return (compare_dname(rdata1, rdata2));
}

26
lib/dns/rdata/generic/dnskey_48.c
View file

@ -20,14 +20,14 @@
#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);
@ -35,14 +35,14 @@ totext_dnskey(ARGS_TOTEXT) {
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;
@ -56,7 +56,7 @@ towire_dnskey(ARGS_TOWIRE) {
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;
@ -74,14 +74,14 @@ compare_dnskey(ARGS_COMPARE) {
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;
@ -96,7 +96,7 @@ tostruct_dnskey(ARGS_TOSTRUCT) {
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;
@ -106,7 +106,7 @@ freestruct_dnskey(ARGS_FREESTRUCT) {
generic_freestruct_key(source);
}
static inline isc_result_t
static isc_result_t
additionaldata_dnskey(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_dnskey);
@ -118,7 +118,7 @@ additionaldata_dnskey(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_dnskey(ARGS_DIGEST) {
isc_region_t r;
@ -130,7 +130,7 @@ digest_dnskey(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_dnskey(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_dnskey);
@ -142,7 +142,7 @@ checkowner_dnskey(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_dnskey(ARGS_CHECKNAMES) {
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_dnskey);
@ -154,7 +154,7 @@ checknames_dnskey(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_dnskey(ARGS_COMPARE) {
/*
* Treat ALG 253 (private DNS) subtype name case sensitively.

26
lib/dns/rdata/generic/doa_259.c
View file

@ -16,7 +16,7 @@
#define RRTYPE_DOA_ATTRIBUTES (0)
static inline isc_result_t
static isc_result_t
fromtext_doa(ARGS_FROMTEXT) {
isc_token_t token;
@ -71,7 +71,7 @@ fromtext_doa(ARGS_FROMTEXT) {
}
}
static inline isc_result_t
static isc_result_t
totext_doa(ARGS_TOTEXT) {
char buf[sizeof("4294967295 ")];
isc_region_t region;
@ -125,7 +125,7 @@ totext_doa(ARGS_TOTEXT) {
}
}
static inline isc_result_t
static isc_result_t
fromwire_doa(ARGS_FROMWIRE) {
isc_region_t region;
@ -156,7 +156,7 @@ fromwire_doa(ARGS_FROMWIRE) {
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;
@ -170,7 +170,7 @@ towire_doa(ARGS_TOWIRE) {
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;
@ -188,7 +188,7 @@ compare_doa(ARGS_COMPARE) {
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;
@ -205,7 +205,7 @@ fromstruct_doa(ARGS_FROMSTRUCT) {
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;
@ -263,7 +263,7 @@ tostruct_doa(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_doa(ARGS_FREESTRUCT) {
dns_rdata_doa_t *doa = source;
@ -284,7 +284,7 @@ freestruct_doa(ARGS_FREESTRUCT) {
doa->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_doa(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_doa);
@ -296,7 +296,7 @@ additionaldata_doa(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_doa(ARGS_DIGEST) {
isc_region_t r;
@ -307,7 +307,7 @@ digest_doa(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_doa(ARGS_CHECKOWNER) {
UNUSED(name);
UNUSED(type);
@ -319,7 +319,7 @@ checkowner_doa(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_doa(ARGS_CHECKNAMES) {
UNUSED(rdata);
UNUSED(owner);
@ -330,7 +330,7 @@ checknames_doa(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_doa(ARGS_COMPARE) {
return (compare_doa(rdata1, rdata2));
}

36
lib/dns/rdata/generic/ds_43.c
View file

@ -24,7 +24,7 @@
#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;
@ -82,14 +82,14 @@ generic_fromtext_ds(ARGS_FROMTEXT) {
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 ")];
@ -148,7 +148,7 @@ generic_totext_ds(ARGS_TOTEXT) {
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);
@ -156,7 +156,7 @@ totext_ds(ARGS_TOTEXT) {
return (generic_totext_ds(CALL_TOTEXT));
}
static inline isc_result_t
static isc_result_t
generic_fromwire_ds(ARGS_FROMWIRE) {
isc_region_t sr;
@ -198,14 +198,14 @@ generic_fromwire_ds(ARGS_FROMWIRE) {
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;
@ -218,7 +218,7 @@ towire_ds(ARGS_TOWIRE) {
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;
@ -234,7 +234,7 @@ compare_ds(ARGS_COMPARE) {
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;
@ -264,14 +264,14 @@ generic_fromstruct_ds(ARGS_FROMSTRUCT) {
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;
@ -297,7 +297,7 @@ generic_tostruct_ds(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
tostruct_ds(ARGS_TOSTRUCT) {
dns_rdata_ds_t *ds = target;
@ -311,7 +311,7 @@ tostruct_ds(ARGS_TOSTRUCT) {
return (generic_tostruct_ds(CALL_TOSTRUCT));
}
static inline void
static void
freestruct_ds(ARGS_FREESTRUCT) {
dns_rdata_ds_t *ds = source;
@ -328,7 +328,7 @@ freestruct_ds(ARGS_FREESTRUCT) {
ds->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_ds(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_ds);
@ -340,7 +340,7 @@ additionaldata_ds(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_ds(ARGS_DIGEST) {
isc_region_t r;
@ -351,7 +351,7 @@ digest_ds(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_ds(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_ds);
@ -363,7 +363,7 @@ checkowner_ds(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_ds(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_ds);
@ -374,7 +374,7 @@ checknames_ds(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_ds(ARGS_COMPARE) {
return (compare_ds(rdata1, rdata2));
}

26
lib/dns/rdata/generic/eui48_108.c
View file

@ -18,7 +18,7 @@
#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];
@ -52,7 +52,7 @@ fromtext_eui48(ARGS_FROMTEXT) {
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")];
@ -67,7 +67,7 @@ totext_eui48(ARGS_TOTEXT) {
return (str_totext(buf, target));
}
static inline isc_result_t
static isc_result_t
fromwire_eui48(ARGS_FROMWIRE) {
isc_region_t sregion;
@ -86,7 +86,7 @@ fromwire_eui48(ARGS_FROMWIRE) {
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);
@ -96,7 +96,7 @@ towire_eui48(ARGS_TOWIRE) {
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;
@ -112,7 +112,7 @@ compare_eui48(ARGS_COMPARE) {
return (isc_region_compare(&region1, &region2));
}
static inline isc_result_t
static isc_result_t
fromstruct_eui48(ARGS_FROMSTRUCT) {
dns_rdata_eui48_t *eui48 = source;
@ -127,7 +127,7 @@ fromstruct_eui48(ARGS_FROMSTRUCT) {
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;
@ -145,7 +145,7 @@ tostruct_eui48(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_eui48(ARGS_FREESTRUCT) {
dns_rdata_eui48_t *eui48 = source;
@ -155,7 +155,7 @@ freestruct_eui48(ARGS_FREESTRUCT) {
return;
}
static inline isc_result_t
static isc_result_t
additionaldata_eui48(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_eui48);
REQUIRE(rdata->length == 6);
@ -168,7 +168,7 @@ additionaldata_eui48(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_eui48(ARGS_DIGEST) {
isc_region_t r;
@ -180,7 +180,7 @@ digest_eui48(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_eui48(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_eui48);
@ -192,7 +192,7 @@ checkowner_eui48(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_eui48(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_eui48);
REQUIRE(rdata->length == 6);
@ -204,7 +204,7 @@ checknames_eui48(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_eui48(ARGS_COMPARE) {
return (compare_eui48(rdata1, rdata2));
}

26
lib/dns/rdata/generic/eui64_109.c
View file

@ -18,7 +18,7 @@
#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];
@ -54,7 +54,7 @@ fromtext_eui64(ARGS_FROMTEXT) {
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")];
@ -70,7 +70,7 @@ totext_eui64(ARGS_TOTEXT) {
return (str_totext(buf, target));
}
static inline isc_result_t
static isc_result_t
fromwire_eui64(ARGS_FROMWIRE) {
isc_region_t sregion;
@ -89,7 +89,7 @@ fromwire_eui64(ARGS_FROMWIRE) {
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);
@ -99,7 +99,7 @@ towire_eui64(ARGS_TOWIRE) {
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;
@ -115,7 +115,7 @@ compare_eui64(ARGS_COMPARE) {
return (isc_region_compare(&region1, &region2));
}
static inline isc_result_t
static isc_result_t
fromstruct_eui64(ARGS_FROMSTRUCT) {
dns_rdata_eui64_t *eui64 = source;
@ -130,7 +130,7 @@ fromstruct_eui64(ARGS_FROMSTRUCT) {
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;
@ -148,7 +148,7 @@ tostruct_eui64(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_eui64(ARGS_FREESTRUCT) {
dns_rdata_eui64_t *eui64 = source;
@ -158,7 +158,7 @@ freestruct_eui64(ARGS_FREESTRUCT) {
return;
}
static inline isc_result_t
static isc_result_t
additionaldata_eui64(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_eui64);
REQUIRE(rdata->length == 8);
@ -171,7 +171,7 @@ additionaldata_eui64(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_eui64(ARGS_DIGEST) {
isc_region_t r;
@ -183,7 +183,7 @@ digest_eui64(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_eui64(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_eui64);
@ -195,7 +195,7 @@ checkowner_eui64(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_eui64(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_eui64);
REQUIRE(rdata->length == 8);
@ -207,7 +207,7 @@ checknames_eui64(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_eui64(ARGS_COMPARE) {
return (compare_eui64(rdata1, rdata2));
}

26
lib/dns/rdata/generic/gpos_27.c
View file

@ -18,7 +18,7 @@
#define RRTYPE_GPOS_ATTRIBUTES (0)
static inline isc_result_t
static isc_result_t
fromtext_gpos(ARGS_FROMTEXT) {
isc_token_t token;
int i;
@ -39,7 +39,7 @@ fromtext_gpos(ARGS_FROMTEXT) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
totext_gpos(ARGS_TOTEXT) {
isc_region_t region;
int i;
@ -61,7 +61,7 @@ totext_gpos(ARGS_TOTEXT) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
fromwire_gpos(ARGS_FROMWIRE) {
int i;
@ -78,7 +78,7 @@ fromwire_gpos(ARGS_FROMWIRE) {
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);
@ -88,7 +88,7 @@ towire_gpos(ARGS_TOWIRE) {
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;
@ -104,7 +104,7 @@ compare_gpos(ARGS_COMPARE) {
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;
@ -124,7 +124,7 @@ fromstruct_gpos(ARGS_FROMSTRUCT) {
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;
@ -160,7 +160,7 @@ tostruct_gpos(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_gpos(ARGS_FREESTRUCT) {
dns_rdata_gpos_t *gpos = source;
@ -183,7 +183,7 @@ freestruct_gpos(ARGS_FREESTRUCT) {
gpos->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_gpos(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_gpos);
@ -195,7 +195,7 @@ additionaldata_gpos(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_gpos(ARGS_DIGEST) {
isc_region_t r;
@ -206,7 +206,7 @@ digest_gpos(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_gpos(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_gpos);
@ -218,7 +218,7 @@ checkowner_gpos(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_gpos(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_gpos);
@ -229,7 +229,7 @@ checknames_gpos(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_gpos(ARGS_COMPARE) {
return (compare_gpos(rdata1, rdata2));
}

26
lib/dns/rdata/generic/hinfo_13.c
View file

@ -15,7 +15,7 @@
#define RRTYPE_HINFO_ATTRIBUTES (0)
static inline isc_result_t
static isc_result_t
fromtext_hinfo(ARGS_FROMTEXT) {
isc_token_t token;
int i;
@ -36,7 +36,7 @@ fromtext_hinfo(ARGS_FROMTEXT) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
totext_hinfo(ARGS_TOTEXT) {
isc_region_t region;
@ -51,7 +51,7 @@ totext_hinfo(ARGS_TOTEXT) {
return (txt_totext(&region, true, target));
}
static inline isc_result_t
static isc_result_t
fromwire_hinfo(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_hinfo);
@ -64,7 +64,7 @@ fromwire_hinfo(ARGS_FROMWIRE) {
return (txt_fromwire(source, target));
}
static inline isc_result_t
static isc_result_t
towire_hinfo(ARGS_TOWIRE) {
UNUSED(cctx);
@ -74,7 +74,7 @@ towire_hinfo(ARGS_TOWIRE) {
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;
@ -90,7 +90,7 @@ compare_hinfo(ARGS_COMPARE) {
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;
@ -108,7 +108,7 @@ fromstruct_hinfo(ARGS_FROMSTRUCT) {
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;
@ -134,7 +134,7 @@ tostruct_hinfo(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_hinfo(ARGS_FREESTRUCT) {
dns_rdata_hinfo_t *hinfo = source;
@ -153,7 +153,7 @@ freestruct_hinfo(ARGS_FREESTRUCT) {
hinfo->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_hinfo(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_hinfo);
@ -165,7 +165,7 @@ additionaldata_hinfo(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_hinfo(ARGS_DIGEST) {
isc_region_t r;
@ -176,7 +176,7 @@ digest_hinfo(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_hinfo(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_hinfo);
@ -188,7 +188,7 @@ checkowner_hinfo(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_hinfo(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_hinfo);
@ -199,7 +199,7 @@ checknames_hinfo(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_hinfo(ARGS_COMPARE) {
return (compare_hinfo(rdata1, rdata2));
}

26
lib/dns/rdata/generic/hip_55.c
View file

@ -17,7 +17,7 @@
#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;
@ -116,7 +116,7 @@ fromtext_hip(ARGS_FROMTEXT) {
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;
@ -189,7 +189,7 @@ totext_hip(ARGS_TOTEXT) {
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;
@ -234,7 +234,7 @@ fromwire_hip(ARGS_FROMWIRE) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
towire_hip(ARGS_TOWIRE) {
isc_region_t region;
@ -247,7 +247,7 @@ towire_hip(ARGS_TOWIRE) {
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;
@ -263,7 +263,7 @@ compare_hip(ARGS_COMPARE) {
return (isc_region_compare(&region1, &region2));
}
static inline isc_result_t
static isc_result_t
fromstruct_hip(ARGS_FROMSTRUCT) {
dns_rdata_hip_t *hip = source;
dns_rdata_hip_t myhip;
@ -297,7 +297,7 @@ fromstruct_hip(ARGS_FROMSTRUCT) {
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;
@ -341,7 +341,7 @@ tostruct_hip(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_hip(ARGS_FREESTRUCT) {
dns_rdata_hip_t *hip = source;
@ -359,7 +359,7 @@ freestruct_hip(ARGS_FREESTRUCT) {
hip->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_hip(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_hip);
@ -371,7 +371,7 @@ additionaldata_hip(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_hip(ARGS_DIGEST) {
isc_region_t r;
@ -381,7 +381,7 @@ digest_hip(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_hip(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_hip);
@ -393,7 +393,7 @@ checkowner_hip(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_hip(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_hip);
@ -444,7 +444,7 @@ dns_rdata_hip_current(dns_rdata_hip_t *hip, dns_name_t *name) {
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;

26
lib/dns/rdata/generic/ipseckey_45.c
View file

@ -20,7 +20,7 @@
#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;
@ -121,7 +121,7 @@ fromtext_ipseckey(ARGS_FROMTEXT) {
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;
@ -211,7 +211,7 @@ totext_ipseckey(ARGS_TOTEXT) {
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;
@ -268,7 +268,7 @@ fromwire_ipseckey(ARGS_FROMWIRE) {
}
}
static inline isc_result_t
static isc_result_t
towire_ipseckey(ARGS_TOWIRE) {
isc_region_t region;
@ -281,7 +281,7 @@ towire_ipseckey(ARGS_TOWIRE) {
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;
@ -298,7 +298,7 @@ compare_ipseckey(ARGS_COMPARE) {
return (isc_region_compare(&region1, &region2));
}
static inline isc_result_t
static isc_result_t
fromstruct_ipseckey(ARGS_FROMSTRUCT) {
dns_rdata_ipseckey_t *ipseckey = source;
isc_region_t region;
@ -342,7 +342,7 @@ fromstruct_ipseckey(ARGS_FROMSTRUCT) {
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;
@ -405,7 +405,7 @@ tostruct_ipseckey(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_ipseckey(ARGS_FREESTRUCT) {
dns_rdata_ipseckey_t *ipseckey = source;
@ -427,7 +427,7 @@ freestruct_ipseckey(ARGS_FREESTRUCT) {
ipseckey->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_ipseckey(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_ipseckey);
@ -439,7 +439,7 @@ additionaldata_ipseckey(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_ipseckey(ARGS_DIGEST) {
isc_region_t region;
@ -449,7 +449,7 @@ digest_ipseckey(ARGS_DIGEST) {
return ((digest)(arg, &region));
}
static inline bool
static bool
checkowner_ipseckey(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_ipseckey);
@ -461,7 +461,7 @@ checkowner_ipseckey(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_ipseckey(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_ipseckey);
@ -472,7 +472,7 @@ checknames_ipseckey(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_ipseckey(ARGS_COMPARE) {
isc_region_t region1;
isc_region_t region2;

26
lib/dns/rdata/generic/isdn_20.c
View file

@ -18,7 +18,7 @@
#define RRTYPE_ISDN_ATTRIBUTES (0)
static inline isc_result_t
static isc_result_t
fromtext_isdn(ARGS_FROMTEXT) {
isc_token_t token;
@ -47,7 +47,7 @@ fromtext_isdn(ARGS_FROMTEXT) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
totext_isdn(ARGS_TOTEXT) {
isc_region_t region;
@ -65,7 +65,7 @@ totext_isdn(ARGS_TOTEXT) {
return (txt_totext(&region, true, target));
}
static inline isc_result_t
static isc_result_t
fromwire_isdn(ARGS_FROMWIRE) {
REQUIRE(type == dns_rdatatype_isdn);
@ -81,7 +81,7 @@ fromwire_isdn(ARGS_FROMWIRE) {
return (txt_fromwire(source, target));
}
static inline isc_result_t
static isc_result_t
towire_isdn(ARGS_TOWIRE) {
UNUSED(cctx);
@ -91,7 +91,7 @@ towire_isdn(ARGS_TOWIRE) {
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;
@ -107,7 +107,7 @@ compare_isdn(ARGS_COMPARE) {
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;
@ -128,7 +128,7 @@ fromstruct_isdn(ARGS_FROMSTRUCT) {
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;
@ -162,7 +162,7 @@ tostruct_isdn(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_isdn(ARGS_FREESTRUCT) {
dns_rdata_isdn_t *isdn = source;
@ -181,7 +181,7 @@ freestruct_isdn(ARGS_FREESTRUCT) {
isdn->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_isdn(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_isdn);
@ -193,7 +193,7 @@ additionaldata_isdn(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_isdn(ARGS_DIGEST) {
isc_region_t r;
@ -204,7 +204,7 @@ digest_isdn(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_isdn(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_isdn);
@ -216,7 +216,7 @@ checkowner_isdn(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_isdn(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_isdn);
@ -227,7 +227,7 @@ checknames_isdn(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_isdn(ARGS_COMPARE) {
return (compare_isdn(rdata1, rdata2));
}

40
lib/dns/rdata/generic/key_25.c
View file

@ -31,7 +31,7 @@
* 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:
@ -44,7 +44,7 @@ generic_key_nokey(dns_rdatatype_t type, unsigned int flags) {
}
}
static inline isc_result_t
static isc_result_t
generic_fromtext_key(ARGS_FROMTEXT) {
isc_token_t token;
dns_secalg_t alg;
@ -85,7 +85,7 @@ generic_fromtext_key(ARGS_FROMTEXT) {
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]")];
@ -190,7 +190,7 @@ generic_totext_key(ARGS_TOTEXT) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
generic_fromwire_key(ARGS_FROMWIRE) {
unsigned char algorithm;
uint16_t flags;
@ -234,14 +234,14 @@ generic_fromwire_key(ARGS_FROMWIRE) {
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);
@ -249,14 +249,14 @@ totext_key(ARGS_TOTEXT) {
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;
@ -270,7 +270,7 @@ towire_key(ARGS_TOWIRE) {
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;
@ -288,7 +288,7 @@ compare_key(ARGS_COMPARE) {
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;
@ -316,7 +316,7 @@ generic_fromstruct_key(ARGS_FROMSTRUCT) {
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;
@ -350,7 +350,7 @@ generic_tostruct_key(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
generic_freestruct_key(ARGS_FREESTRUCT) {
dns_rdata_key_t *key = (dns_rdata_key_t *)source;
@ -366,14 +366,14 @@ generic_freestruct_key(ARGS_FREESTRUCT) {
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;
@ -388,7 +388,7 @@ tostruct_key(ARGS_TOSTRUCT) {
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;
@ -398,7 +398,7 @@ freestruct_key(ARGS_FREESTRUCT) {
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);
@ -411,7 +411,7 @@ additionaldata_key(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_key(ARGS_DIGEST) {
isc_region_t r;
@ -423,7 +423,7 @@ digest_key(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_key(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_key);
@ -435,7 +435,7 @@ checkowner_key(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_key(ARGS_CHECKNAMES) {
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_key);
@ -447,7 +447,7 @@ checknames_key(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_key(ARGS_COMPARE) {
return (compare_key(rdata1, rdata2));
}

26
lib/dns/rdata/generic/keydata_65533.c
View file

@ -21,7 +21,7 @@
#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;
@ -86,7 +86,7 @@ fromtext_keydata(ARGS_FROMTEXT) {
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")];
@ -249,7 +249,7 @@ totext_keydata(ARGS_TOTEXT) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
fromwire_keydata(ARGS_FROMWIRE) {
isc_region_t sr;
@ -265,7 +265,7 @@ fromwire_keydata(ARGS_FROMWIRE) {
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;
@ -277,7 +277,7 @@ towire_keydata(ARGS_TOWIRE) {
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;
@ -291,7 +291,7 @@ compare_keydata(ARGS_COMPARE) {
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;
@ -325,7 +325,7 @@ fromstruct_keydata(ARGS_FROMSTRUCT) {
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;
@ -394,7 +394,7 @@ tostruct_keydata(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_keydata(ARGS_FREESTRUCT) {
dns_rdata_keydata_t *keydata = (dns_rdata_keydata_t *)source;
@ -411,7 +411,7 @@ freestruct_keydata(ARGS_FREESTRUCT) {
keydata->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_keydata(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_keydata);
@ -423,7 +423,7 @@ additionaldata_keydata(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_keydata(ARGS_DIGEST) {
isc_region_t r;
@ -434,7 +434,7 @@ digest_keydata(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_keydata(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_keydata);
@ -446,7 +446,7 @@ checkowner_keydata(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_keydata(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_keydata);
@ -457,7 +457,7 @@ checknames_keydata(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_keydata(ARGS_COMPARE) {
return (compare_keydata(rdata1, rdata2));
}

26
lib/dns/rdata/generic/l32_105.c
View file

@ -20,7 +20,7 @@
#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;
@ -56,7 +56,7 @@ fromtext_l32(ARGS_FROMTEXT) {
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")];
@ -78,7 +78,7 @@ totext_l32(ARGS_TOTEXT) {
return (inet_totext(AF_INET, tctx->flags, &region, target));
}
static inline isc_result_t
static isc_result_t
fromwire_l32(ARGS_FROMWIRE) {
isc_region_t sregion;
@ -97,7 +97,7 @@ fromwire_l32(ARGS_FROMWIRE) {
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);
@ -107,7 +107,7 @@ towire_l32(ARGS_TOWIRE) {
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;
@ -123,7 +123,7 @@ compare_l32(ARGS_COMPARE) {
return (isc_region_compare(&region1, &region2));
}
static inline isc_result_t
static isc_result_t
fromstruct_l32(ARGS_FROMSTRUCT) {
dns_rdata_l32_t *l32 = source;
uint32_t n;
@ -141,7 +141,7 @@ fromstruct_l32(ARGS_FROMSTRUCT) {
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;
@ -164,7 +164,7 @@ tostruct_l32(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_l32(ARGS_FREESTRUCT) {
dns_rdata_l32_t *l32 = source;
@ -174,7 +174,7 @@ freestruct_l32(ARGS_FREESTRUCT) {
return;
}
static inline isc_result_t
static isc_result_t
additionaldata_l32(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_l32);
REQUIRE(rdata->length == 6);
@ -187,7 +187,7 @@ additionaldata_l32(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_l32(ARGS_DIGEST) {
isc_region_t r;
@ -199,7 +199,7 @@ digest_l32(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_l32(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_l32);
@ -211,7 +211,7 @@ checkowner_l32(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_l32(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_l32);
REQUIRE(rdata->length == 6);
@ -223,7 +223,7 @@ checknames_l32(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_l32(ARGS_COMPARE) {
return (compare_l32(rdata1, rdata2));
}

26
lib/dns/rdata/generic/l64_106.c
View file

@ -20,7 +20,7 @@
#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];
@ -49,7 +49,7 @@ fromtext_l64(ARGS_FROMTEXT) {
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")];
@ -76,7 +76,7 @@ totext_l64(ARGS_TOTEXT) {
return (str_totext(buf, target));
}
static inline isc_result_t
static isc_result_t
fromwire_l64(ARGS_FROMWIRE) {
isc_region_t sregion;
@ -95,7 +95,7 @@ fromwire_l64(ARGS_FROMWIRE) {
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);
@ -105,7 +105,7 @@ towire_l64(ARGS_TOWIRE) {
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;
@ -121,7 +121,7 @@ compare_l64(ARGS_COMPARE) {
return (isc_region_compare(&region1, &region2));
}
static inline isc_result_t
static isc_result_t
fromstruct_l64(ARGS_FROMSTRUCT) {
dns_rdata_l64_t *l64 = source;
@ -137,7 +137,7 @@ fromstruct_l64(ARGS_FROMSTRUCT) {
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;
@ -158,7 +158,7 @@ tostruct_l64(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_l64(ARGS_FREESTRUCT) {
dns_rdata_l64_t *l64 = source;
@ -168,7 +168,7 @@ freestruct_l64(ARGS_FREESTRUCT) {
return;
}
static inline isc_result_t
static isc_result_t
additionaldata_l64(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_l64);
REQUIRE(rdata->length == 10);
@ -181,7 +181,7 @@ additionaldata_l64(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_l64(ARGS_DIGEST) {
isc_region_t r;
@ -193,7 +193,7 @@ digest_l64(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_l64(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_l64);
@ -205,7 +205,7 @@ checkowner_l64(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_l64(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_l64);
REQUIRE(rdata->length == 10);
@ -217,7 +217,7 @@ checknames_l64(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_l64(ARGS_COMPARE) {
return (compare_l64(rdata1, rdata2));
}

40
lib/dns/rdata/generic/loc_29.c
View file

@ -257,7 +257,7 @@ done:
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;
@ -278,7 +278,7 @@ loc_getlatitude(isc_lex_t *lexer, unsigned long *latitude) {
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;
@ -299,7 +299,7 @@ loc_getlongitude(isc_lex_t *lexer, unsigned long *longitude) {
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;
@ -325,7 +325,7 @@ loc_getaltitude(isc_lex_t *lexer, unsigned long *altitude) {
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;
@ -341,17 +341,17 @@ loc_getoptionalprecision(isc_lex_t *lexer, unsigned char *valuep) {
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));
}
@ -380,7 +380,7 @@ loc_getverticalprecision(isc_lex_t *lexer, unsigned char *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;
@ -433,7 +433,7 @@ encode:
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;
@ -552,7 +552,7 @@ totext_loc(ARGS_TOTEXT) {
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;
@ -652,7 +652,7 @@ fromwire_loc(ARGS_FROMWIRE) {
return (mem_tobuffer(target, sr.base, 16));
}
static inline isc_result_t
static isc_result_t
towire_loc(ARGS_TOWIRE) {
UNUSED(cctx);
@ -662,7 +662,7 @@ towire_loc(ARGS_TOWIRE) {
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;
@ -678,7 +678,7 @@ compare_loc(ARGS_COMPARE) {
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;
@ -730,7 +730,7 @@ fromstruct_loc(ARGS_FROMSTRUCT) {
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;
@ -769,7 +769,7 @@ tostruct_loc(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_loc(ARGS_FREESTRUCT) {
dns_rdata_loc_t *loc = source;
@ -780,7 +780,7 @@ freestruct_loc(ARGS_FREESTRUCT) {
UNUSED(loc);
}
static inline isc_result_t
static isc_result_t
additionaldata_loc(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_loc);
@ -792,7 +792,7 @@ additionaldata_loc(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_loc(ARGS_DIGEST) {
isc_region_t r;
@ -803,7 +803,7 @@ digest_loc(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_loc(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_loc);
@ -815,7 +815,7 @@ checkowner_loc(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_loc(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_loc);
@ -826,7 +826,7 @@ checknames_loc(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_loc(ARGS_COMPARE) {
return (compare_loc(rdata1, rdata2));
}

26
lib/dns/rdata/generic/lp_107.c
View file

@ -20,7 +20,7 @@
#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;
@ -50,7 +50,7 @@ fromtext_lp(ARGS_FROMTEXT) {
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;
@ -78,7 +78,7 @@ totext_lp(ARGS_TOTEXT) {
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;
@ -101,7 +101,7 @@ fromwire_lp(ARGS_FROMWIRE) {
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);
@ -111,7 +111,7 @@ towire_lp(ARGS_TOWIRE) {
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;
@ -128,7 +128,7 @@ compare_lp(ARGS_COMPARE) {
return (isc_region_compare(&region1, &region2));
}
static inline isc_result_t
static isc_result_t
fromstruct_lp(ARGS_FROMSTRUCT) {
dns_rdata_lp_t *lp = source;
isc_region_t region;
@ -146,7 +146,7 @@ fromstruct_lp(ARGS_FROMSTRUCT) {
return (isc_buffer_copyregion(target, &region));
}
static inline isc_result_t
static isc_result_t
tostruct_lp(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_lp_t *lp = target;
@ -171,7 +171,7 @@ tostruct_lp(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_lp(ARGS_FREESTRUCT) {
dns_rdata_lp_t *lp = source;
@ -186,7 +186,7 @@ freestruct_lp(ARGS_FREESTRUCT) {
lp->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_lp(ARGS_ADDLDATA) {
dns_name_t name;
dns_offsets_t offsets;
@ -209,7 +209,7 @@ additionaldata_lp(ARGS_ADDLDATA) {
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;
@ -219,7 +219,7 @@ digest_lp(ARGS_DIGEST) {
return ((digest)(arg, &region));
}
static inline bool
static bool
checkowner_lp(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_lp);
@ -231,7 +231,7 @@ checkowner_lp(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_lp(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_lp);
@ -241,7 +241,7 @@ checknames_lp(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_lp(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;

26
lib/dns/rdata/generic/mb_7.c
View file

@ -16,7 +16,7 @@
#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;
@ -40,7 +40,7 @@ fromtext_mb(ARGS_FROMTEXT) {
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;
@ -61,7 +61,7 @@ totext_mb(ARGS_TOTEXT) {
return (dns_name_totext(&prefix, sub, target));
}
static inline isc_result_t
static isc_result_t
fromwire_mb(ARGS_FROMWIRE) {
dns_name_t name;
@ -76,7 +76,7 @@ fromwire_mb(ARGS_FROMWIRE) {
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;
@ -94,7 +94,7 @@ towire_mb(ARGS_TOWIRE) {
return (dns_name_towire(&name, cctx, target));
}
static inline int
static int
compare_mb(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
@ -119,7 +119,7 @@ compare_mb(ARGS_COMPARE) {
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;
@ -136,7 +136,7 @@ fromstruct_mb(ARGS_FROMSTRUCT) {
return (isc_buffer_copyregion(target, &region));
}
static inline isc_result_t
static isc_result_t
tostruct_mb(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_mb_t *mb = target;
@ -159,7 +159,7 @@ tostruct_mb(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_mb(ARGS_FREESTRUCT) {
dns_rdata_mb_t *mb = source;
@ -173,7 +173,7 @@ freestruct_mb(ARGS_FREESTRUCT) {
mb->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_mb(ARGS_ADDLDATA) {
dns_name_t name;
dns_offsets_t offsets;
@ -190,7 +190,7 @@ additionaldata_mb(ARGS_ADDLDATA) {
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;
@ -204,7 +204,7 @@ digest_mb(ARGS_DIGEST) {
return (dns_name_digest(&name, digest, arg));
}
static inline bool
static bool
checkowner_mb(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_mb);
@ -215,7 +215,7 @@ checkowner_mb(ARGS_CHECKOWNER) {
return (dns_name_ismailbox(name));
}
static inline bool
static bool
checknames_mb(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_mb);
@ -226,7 +226,7 @@ checknames_mb(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_mb(ARGS_COMPARE) {
return (compare_mb(rdata1, rdata2));
}

26
lib/dns/rdata/generic/md_3.c
View file

@ -16,7 +16,7 @@
#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;
@ -40,7 +40,7 @@ fromtext_md(ARGS_FROMTEXT) {
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;
@ -61,7 +61,7 @@ totext_md(ARGS_TOTEXT) {
return (dns_name_totext(&prefix, sub, target));
}
static inline isc_result_t
static isc_result_t
fromwire_md(ARGS_FROMWIRE) {
dns_name_t name;
@ -76,7 +76,7 @@ fromwire_md(ARGS_FROMWIRE) {
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;
@ -94,7 +94,7 @@ towire_md(ARGS_TOWIRE) {
return (dns_name_towire(&name, cctx, target));
}
static inline int
static int
compare_md(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
@ -119,7 +119,7 @@ compare_md(ARGS_COMPARE) {
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;
@ -136,7 +136,7 @@ fromstruct_md(ARGS_FROMSTRUCT) {
return (isc_buffer_copyregion(target, &region));
}
static inline isc_result_t
static isc_result_t
tostruct_md(ARGS_TOSTRUCT) {
dns_rdata_md_t *md = target;
isc_region_t r;
@ -159,7 +159,7 @@ tostruct_md(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_md(ARGS_FREESTRUCT) {
dns_rdata_md_t *md = source;
@ -174,7 +174,7 @@ freestruct_md(ARGS_FREESTRUCT) {
md->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_md(ARGS_ADDLDATA) {
dns_name_t name;
dns_offsets_t offsets;
@ -191,7 +191,7 @@ additionaldata_md(ARGS_ADDLDATA) {
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;
@ -205,7 +205,7 @@ digest_md(ARGS_DIGEST) {
return (dns_name_digest(&name, digest, arg));
}
static inline bool
static bool
checkowner_md(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_md);
@ -217,7 +217,7 @@ checkowner_md(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_md(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_md);
@ -228,7 +228,7 @@ checknames_md(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_md(ARGS_COMPARE) {
return (compare_md(rdata1, rdata2));
}

26
lib/dns/rdata/generic/mf_4.c
View file

@ -16,7 +16,7 @@
#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;
@ -40,7 +40,7 @@ fromtext_mf(ARGS_FROMTEXT) {
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;
@ -61,7 +61,7 @@ totext_mf(ARGS_TOTEXT) {
return (dns_name_totext(&prefix, sub, target));
}
static inline isc_result_t
static isc_result_t
fromwire_mf(ARGS_FROMWIRE) {
dns_name_t name;
@ -76,7 +76,7 @@ fromwire_mf(ARGS_FROMWIRE) {
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;
@ -94,7 +94,7 @@ towire_mf(ARGS_TOWIRE) {
return (dns_name_towire(&name, cctx, target));
}
static inline int
static int
compare_mf(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
@ -119,7 +119,7 @@ compare_mf(ARGS_COMPARE) {
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;
@ -136,7 +136,7 @@ fromstruct_mf(ARGS_FROMSTRUCT) {
return (isc_buffer_copyregion(target, &region));
}
static inline isc_result_t
static isc_result_t
tostruct_mf(ARGS_TOSTRUCT) {
dns_rdata_mf_t *mf = target;
isc_region_t r;
@ -159,7 +159,7 @@ tostruct_mf(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_mf(ARGS_FREESTRUCT) {
dns_rdata_mf_t *mf = source;
@ -173,7 +173,7 @@ freestruct_mf(ARGS_FREESTRUCT) {
mf->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_mf(ARGS_ADDLDATA) {
dns_name_t name;
dns_offsets_t offsets;
@ -190,7 +190,7 @@ additionaldata_mf(ARGS_ADDLDATA) {
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;
@ -204,7 +204,7 @@ digest_mf(ARGS_DIGEST) {
return (dns_name_digest(&name, digest, arg));
}
static inline bool
static bool
checkowner_mf(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_mf);
@ -216,7 +216,7 @@ checkowner_mf(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_mf(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_mf);
@ -227,7 +227,7 @@ checknames_mf(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_mf(ARGS_COMPARE) {
return (compare_mf(rdata1, rdata2));
}

26
lib/dns/rdata/generic/mg_8.c
View file

@ -16,7 +16,7 @@
#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;
@ -40,7 +40,7 @@ fromtext_mg(ARGS_FROMTEXT) {
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;
@ -61,7 +61,7 @@ totext_mg(ARGS_TOTEXT) {
return (dns_name_totext(&prefix, sub, target));
}
static inline isc_result_t
static isc_result_t
fromwire_mg(ARGS_FROMWIRE) {
dns_name_t name;
@ -76,7 +76,7 @@ fromwire_mg(ARGS_FROMWIRE) {
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;
@ -94,7 +94,7 @@ towire_mg(ARGS_TOWIRE) {
return (dns_name_towire(&name, cctx, target));
}
static inline int
static int
compare_mg(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
@ -119,7 +119,7 @@ compare_mg(ARGS_COMPARE) {
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;
@ -136,7 +136,7 @@ fromstruct_mg(ARGS_FROMSTRUCT) {
return (isc_buffer_copyregion(target, &region));
}
static inline isc_result_t
static isc_result_t
tostruct_mg(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_mg_t *mg = target;
@ -159,7 +159,7 @@ tostruct_mg(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_mg(ARGS_FREESTRUCT) {
dns_rdata_mg_t *mg = source;
@ -173,7 +173,7 @@ freestruct_mg(ARGS_FREESTRUCT) {
mg->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_mg(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_mg);
@ -185,7 +185,7 @@ additionaldata_mg(ARGS_ADDLDATA) {
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;
@ -199,7 +199,7 @@ digest_mg(ARGS_DIGEST) {
return (dns_name_digest(&name, digest, arg));
}
static inline bool
static bool
checkowner_mg(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_mg);
@ -210,7 +210,7 @@ checkowner_mg(ARGS_CHECKOWNER) {
return (dns_name_ismailbox(name));
}
static inline bool
static bool
checknames_mg(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_mg);
@ -221,7 +221,7 @@ checknames_mg(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_mg(ARGS_COMPARE) {
return (compare_mg(rdata1, rdata2));
}

26
lib/dns/rdata/generic/minfo_14.c
View file

@ -16,7 +16,7 @@
#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;
@ -55,7 +55,7 @@ fromtext_minfo(ARGS_FROMTEXT) {
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;
@ -88,7 +88,7 @@ totext_minfo(ARGS_TOTEXT) {
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;
@ -107,7 +107,7 @@ fromwire_minfo(ARGS_FROMWIRE) {
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;
@ -136,7 +136,7 @@ towire_minfo(ARGS_TOWIRE) {
return (dns_name_towire(&rmail, cctx, target));
}
static inline int
static int
compare_minfo(ARGS_COMPARE) {
isc_region_t region1;
isc_region_t region2;
@ -177,7 +177,7 @@ compare_minfo(ARGS_COMPARE) {
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;
@ -196,7 +196,7 @@ fromstruct_minfo(ARGS_FROMSTRUCT) {
return (isc_buffer_copyregion(target, &region));
}
static inline isc_result_t
static isc_result_t
tostruct_minfo(ARGS_TOSTRUCT) {
dns_rdata_minfo_t *minfo = target;
isc_region_t region;
@ -224,7 +224,7 @@ tostruct_minfo(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_minfo(ARGS_FREESTRUCT) {
dns_rdata_minfo_t *minfo = source;
@ -240,7 +240,7 @@ freestruct_minfo(ARGS_FREESTRUCT) {
minfo->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_minfo(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_minfo);
@ -252,7 +252,7 @@ additionaldata_minfo(ARGS_ADDLDATA) {
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;
@ -274,7 +274,7 @@ digest_minfo(ARGS_DIGEST) {
return (dns_name_digest(&name, digest, arg));
}
static inline bool
static bool
checkowner_minfo(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_minfo);
@ -286,7 +286,7 @@ checkowner_minfo(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_minfo(ARGS_CHECKNAMES) {
isc_region_t region;
dns_name_t name;
@ -315,7 +315,7 @@ checknames_minfo(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_minfo(ARGS_COMPARE) {
return (compare_minfo(rdata1, rdata2));
}

26
lib/dns/rdata/generic/mr_9.c
View file

@ -16,7 +16,7 @@
#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;
@ -40,7 +40,7 @@ fromtext_mr(ARGS_FROMTEXT) {
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;
@ -61,7 +61,7 @@ totext_mr(ARGS_TOTEXT) {
return (dns_name_totext(&prefix, sub, target));
}
static inline isc_result_t
static isc_result_t
fromwire_mr(ARGS_FROMWIRE) {
dns_name_t name;
@ -76,7 +76,7 @@ fromwire_mr(ARGS_FROMWIRE) {
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;
@ -94,7 +94,7 @@ towire_mr(ARGS_TOWIRE) {
return (dns_name_towire(&name, cctx, target));
}
static inline int
static int
compare_mr(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
@ -119,7 +119,7 @@ compare_mr(ARGS_COMPARE) {
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;
@ -136,7 +136,7 @@ fromstruct_mr(ARGS_FROMSTRUCT) {
return (isc_buffer_copyregion(target, &region));
}
static inline isc_result_t
static isc_result_t
tostruct_mr(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_mr_t *mr = target;
@ -159,7 +159,7 @@ tostruct_mr(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_mr(ARGS_FREESTRUCT) {
dns_rdata_mr_t *mr = source;
@ -173,7 +173,7 @@ freestruct_mr(ARGS_FREESTRUCT) {
mr->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_mr(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_mr);
@ -185,7 +185,7 @@ additionaldata_mr(ARGS_ADDLDATA) {
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;
@ -199,7 +199,7 @@ digest_mr(ARGS_DIGEST) {
return (dns_name_digest(&name, digest, arg));
}
static inline bool
static bool
checkowner_mr(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_mr);
@ -211,7 +211,7 @@ checkowner_mr(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_mr(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_mr);
@ -222,7 +222,7 @@ checknames_mr(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_mr(ARGS_COMPARE) {
return (compare_mr(rdata1, rdata2));
}

26
lib/dns/rdata/generic/mx_15.c
View file

@ -44,7 +44,7 @@ check_mx(isc_token_t *token) {
return (true);
}
static inline isc_result_t
static isc_result_t
fromtext_mx(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
@ -96,7 +96,7 @@ fromtext_mx(ARGS_FROMTEXT) {
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;
@ -124,7 +124,7 @@ totext_mx(ARGS_TOTEXT) {
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;
@ -147,7 +147,7 @@ fromwire_mx(ARGS_FROMWIRE) {
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;
@ -168,7 +168,7 @@ towire_mx(ARGS_TOWIRE) {
return (dns_name_towire(&name, cctx, target));
}
static inline int
static int
compare_mx(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
@ -202,7 +202,7 @@ compare_mx(ARGS_COMPARE) {
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;
@ -220,7 +220,7 @@ fromstruct_mx(ARGS_FROMSTRUCT) {
return (isc_buffer_copyregion(target, &region));
}
static inline isc_result_t
static isc_result_t
tostruct_mx(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_mx_t *mx = target;
@ -245,7 +245,7 @@ tostruct_mx(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_mx(ARGS_FREESTRUCT) {
dns_rdata_mx_t *mx = source;
@ -265,7 +265,7 @@ static unsigned char port25_ndata[] = "\003_25\004_tcp";
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;
@ -302,7 +302,7 @@ additionaldata_mx(ARGS_ADDLDATA) {
NULL));
}
static inline isc_result_t
static isc_result_t
digest_mx(ARGS_DIGEST) {
isc_region_t r1, r2;
dns_name_t name;
@ -319,7 +319,7 @@ digest_mx(ARGS_DIGEST) {
return (dns_name_digest(&name, digest, arg));
}
static inline bool
static bool
checkowner_mx(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_mx);
@ -329,7 +329,7 @@ checkowner_mx(ARGS_CHECKOWNER) {
return (dns_name_ishostname(name, wildcard));
}
static inline bool
static bool
checknames_mx(ARGS_CHECKNAMES) {
isc_region_t region;
dns_name_t name;
@ -351,7 +351,7 @@ checknames_mx(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_mx(ARGS_COMPARE) {
return (compare_mx(rdata1, rdata2));
}

28
lib/dns/rdata/generic/naptr_35.c
View file

@ -24,7 +24,7 @@
* 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];
@ -169,7 +169,7 @@ txt_valid_regex(const unsigned char *txt) {
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;
@ -239,7 +239,7 @@ fromtext_naptr(ARGS_FROMTEXT) {
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;
@ -300,7 +300,7 @@ totext_naptr(ARGS_TOTEXT) {
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;
@ -348,7 +348,7 @@ fromwire_naptr(ARGS_FROMWIRE) {
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;
@ -391,7 +391,7 @@ towire_naptr(ARGS_TOWIRE) {
return (dns_name_towire(&name, cctx, target));
}
static inline int
static int
compare_naptr(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
@ -463,7 +463,7 @@ compare_naptr(ARGS_COMPARE) {
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;
@ -491,7 +491,7 @@ fromstruct_naptr(ARGS_FROMSTRUCT) {
return (isc_buffer_copyregion(target, &region));
}
static inline isc_result_t
static isc_result_t
tostruct_naptr(ARGS_TOSTRUCT) {
dns_rdata_naptr_t *naptr = target;
isc_region_t r;
@ -543,7 +543,7 @@ tostruct_naptr(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_naptr(ARGS_FREESTRUCT) {
dns_rdata_naptr_t *naptr = source;
@ -567,7 +567,7 @@ freestruct_naptr(ARGS_FREESTRUCT) {
naptr->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_naptr(ARGS_ADDLDATA) {
dns_name_t name;
dns_offsets_t offsets;
@ -627,7 +627,7 @@ additionaldata_naptr(ARGS_ADDLDATA) {
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;
@ -686,7 +686,7 @@ digest_naptr(ARGS_DIGEST) {
return (dns_name_digest(&name, digest, arg));
}
static inline bool
static bool
checkowner_naptr(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_naptr);
@ -698,7 +698,7 @@ checkowner_naptr(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_naptr(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_naptr);
@ -709,7 +709,7 @@ checknames_naptr(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_naptr(ARGS_COMPARE) {
return (compare_naptr(rdata1, rdata2));
}

26
lib/dns/rdata/generic/nid_104.c
View file

@ -20,7 +20,7 @@
#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];
@ -49,7 +49,7 @@ fromtext_nid(ARGS_FROMTEXT) {
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")];
@ -76,7 +76,7 @@ totext_nid(ARGS_TOTEXT) {
return (str_totext(buf, target));
}
static inline isc_result_t
static isc_result_t
fromwire_nid(ARGS_FROMWIRE) {
isc_region_t sregion;
@ -95,7 +95,7 @@ fromwire_nid(ARGS_FROMWIRE) {
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);
@ -105,7 +105,7 @@ towire_nid(ARGS_TOWIRE) {
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;
@ -121,7 +121,7 @@ compare_nid(ARGS_COMPARE) {
return (isc_region_compare(&region1, &region2));
}
static inline isc_result_t
static isc_result_t
fromstruct_nid(ARGS_FROMSTRUCT) {
dns_rdata_nid_t *nid = source;
@ -137,7 +137,7 @@ fromstruct_nid(ARGS_FROMSTRUCT) {
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;
@ -158,7 +158,7 @@ tostruct_nid(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_nid(ARGS_FREESTRUCT) {
dns_rdata_nid_t *nid = source;
@ -168,7 +168,7 @@ freestruct_nid(ARGS_FREESTRUCT) {
return;
}
static inline isc_result_t
static isc_result_t
additionaldata_nid(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_nid);
REQUIRE(rdata->length == 10);
@ -181,7 +181,7 @@ additionaldata_nid(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_nid(ARGS_DIGEST) {
isc_region_t r;
@ -193,7 +193,7 @@ digest_nid(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_nid(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_nid);
@ -205,7 +205,7 @@ checkowner_nid(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_nid(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_nid);
REQUIRE(rdata->length == 10);
@ -217,7 +217,7 @@ checknames_nid(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_nid(ARGS_COMPARE) {
return (compare_nid(rdata1, rdata2));
}

26
lib/dns/rdata/generic/ninfo_56.c
View file

@ -16,14 +16,14 @@
#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);
@ -31,14 +31,14 @@ totext_ninfo(ARGS_TOTEXT) {
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);
@ -47,7 +47,7 @@ towire_ninfo(ARGS_TOWIRE) {
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;
@ -61,14 +61,14 @@ compare_ninfo(ARGS_COMPARE) {
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;
@ -82,7 +82,7 @@ tostruct_ninfo(ARGS_TOSTRUCT) {
return (generic_tostruct_txt(CALL_TOSTRUCT));
}
static inline void
static void
freestruct_ninfo(ARGS_FREESTRUCT) {
dns_rdata_ninfo_t *ninfo = source;
@ -92,7 +92,7 @@ freestruct_ninfo(ARGS_FREESTRUCT) {
generic_freestruct_txt(source);
}
static inline isc_result_t
static isc_result_t
additionaldata_ninfo(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_ninfo);
@ -104,7 +104,7 @@ additionaldata_ninfo(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_ninfo(ARGS_DIGEST) {
isc_region_t r;
@ -115,7 +115,7 @@ digest_ninfo(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_ninfo(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_ninfo);
@ -127,7 +127,7 @@ checkowner_ninfo(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_ninfo(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_ninfo);
@ -138,7 +138,7 @@ checknames_ninfo(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_ninfo(ARGS_COMPARE) {
return (compare_ninfo(rdata1, rdata2));
}

26
lib/dns/rdata/generic/ns_2.c
View file

@ -16,7 +16,7 @@
#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;
@ -51,7 +51,7 @@ fromtext_ns(ARGS_FROMTEXT) {
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;
@ -72,7 +72,7 @@ totext_ns(ARGS_TOTEXT) {
return (dns_name_totext(&prefix, sub, target));
}
static inline isc_result_t
static isc_result_t
fromwire_ns(ARGS_FROMWIRE) {
dns_name_t name;
@ -87,7 +87,7 @@ fromwire_ns(ARGS_FROMWIRE) {
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;
@ -105,7 +105,7 @@ towire_ns(ARGS_TOWIRE) {
return (dns_name_towire(&name, cctx, target));
}
static inline int
static int
compare_ns(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
@ -130,7 +130,7 @@ compare_ns(ARGS_COMPARE) {
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;
@ -147,7 +147,7 @@ fromstruct_ns(ARGS_FROMSTRUCT) {
return (isc_buffer_copyregion(target, &region));
}
static inline isc_result_t
static isc_result_t
tostruct_ns(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_ns_t *ns = target;
@ -170,7 +170,7 @@ tostruct_ns(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_ns(ARGS_FREESTRUCT) {
dns_rdata_ns_t *ns = source;
@ -184,7 +184,7 @@ freestruct_ns(ARGS_FREESTRUCT) {
ns->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_ns(ARGS_ADDLDATA) {
dns_name_t name;
dns_offsets_t offsets;
@ -201,7 +201,7 @@ additionaldata_ns(ARGS_ADDLDATA) {
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;
@ -215,7 +215,7 @@ digest_ns(ARGS_DIGEST) {
return (dns_name_digest(&name, digest, arg));
}
static inline bool
static bool
checkowner_ns(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_ns);
@ -227,7 +227,7 @@ checkowner_ns(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_ns(ARGS_CHECKNAMES) {
isc_region_t region;
dns_name_t name;
@ -248,7 +248,7 @@ checknames_ns(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_ns(ARGS_COMPARE) {
return (compare_ns(rdata1, rdata2));
}

26
lib/dns/rdata/generic/nsec3_50.c
View file

@ -37,7 +37,7 @@
#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;
@ -105,7 +105,7 @@ fromtext_nsec3(ARGS_FROMTEXT) {
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;
@ -181,7 +181,7 @@ totext_nsec3(ARGS_TOTEXT) {
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;
@ -226,7 +226,7 @@ fromwire_nsec3(ARGS_FROMWIRE) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
towire_nsec3(ARGS_TOWIRE) {
isc_region_t sr;
@ -239,7 +239,7 @@ towire_nsec3(ARGS_TOWIRE) {
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;
@ -255,7 +255,7 @@ compare_nsec3(ARGS_COMPARE) {
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;
@ -284,7 +284,7 @@ fromstruct_nsec3(ARGS_FROMSTRUCT) {
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;
@ -319,7 +319,7 @@ tostruct_nsec3(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_nsec3(ARGS_FREESTRUCT) {
dns_rdata_nsec3_t *nsec3 = source;
@ -342,7 +342,7 @@ freestruct_nsec3(ARGS_FREESTRUCT) {
nsec3->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_nsec3(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_nsec3);
@ -354,7 +354,7 @@ additionaldata_nsec3(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_nsec3(ARGS_DIGEST) {
isc_region_t r;
@ -364,7 +364,7 @@ digest_nsec3(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_nsec3(ARGS_CHECKOWNER) {
unsigned char owner[NSEC3_MAX_HASH_LENGTH];
isc_buffer_t buffer;
@ -389,7 +389,7 @@ checkowner_nsec3(ARGS_CHECKOWNER) {
return (false);
}
static inline bool
static bool
checknames_nsec3(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_nsec3);
@ -400,7 +400,7 @@ checknames_nsec3(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_nsec3(ARGS_COMPARE) {
return (compare_nsec3(rdata1, rdata2));
}

26
lib/dns/rdata/generic/nsec3param_51.c
View file

@ -37,7 +37,7 @@
#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;
@ -90,7 +90,7 @@ fromtext_nsec3param(ARGS_FROMTEXT) {
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;
@ -140,7 +140,7 @@ totext_nsec3param(ARGS_TOTEXT) {
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;
@ -171,7 +171,7 @@ fromwire_nsec3param(ARGS_FROMWIRE) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
towire_nsec3param(ARGS_TOWIRE) {
isc_region_t sr;
@ -184,7 +184,7 @@ towire_nsec3param(ARGS_TOWIRE) {
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;
@ -200,7 +200,7 @@ compare_nsec3param(ARGS_COMPARE) {
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;
@ -220,7 +220,7 @@ fromstruct_nsec3param(ARGS_FROMSTRUCT) {
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;
@ -249,7 +249,7 @@ tostruct_nsec3param(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_nsec3param(ARGS_FREESTRUCT) {
dns_rdata_nsec3param_t *nsec3param = source;
@ -266,7 +266,7 @@ freestruct_nsec3param(ARGS_FREESTRUCT) {
nsec3param->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_nsec3param(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_nsec3param);
@ -278,7 +278,7 @@ additionaldata_nsec3param(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_nsec3param(ARGS_DIGEST) {
isc_region_t r;
@ -288,7 +288,7 @@ digest_nsec3param(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_nsec3param(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_nsec3param);
@ -300,7 +300,7 @@ checkowner_nsec3param(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_nsec3param(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_nsec3param);
@ -311,7 +311,7 @@ checknames_nsec3param(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_nsec3param(ARGS_COMPARE) {
return (compare_nsec3param(rdata1, rdata2));
}

26
lib/dns/rdata/generic/nsec_47.c
View file

@ -24,7 +24,7 @@
(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;
@ -51,7 +51,7 @@ fromtext_nsec(ARGS_FROMTEXT) {
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;
@ -75,7 +75,7 @@ totext_nsec(ARGS_TOTEXT) {
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;
@ -97,7 +97,7 @@ fromwire_nsec(ARGS_FROMWIRE) {
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;
@ -116,7 +116,7 @@ towire_nsec(ARGS_TOWIRE) {
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;
@ -132,7 +132,7 @@ compare_nsec(ARGS_COMPARE) {
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;
@ -155,7 +155,7 @@ fromstruct_nsec(ARGS_FROMSTRUCT) {
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;
@ -182,7 +182,7 @@ tostruct_nsec(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_nsec(ARGS_FREESTRUCT) {
dns_rdata_nsec_t *nsec = source;
@ -200,7 +200,7 @@ freestruct_nsec(ARGS_FREESTRUCT) {
nsec->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_nsec(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_nsec);
@ -212,7 +212,7 @@ additionaldata_nsec(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_nsec(ARGS_DIGEST) {
isc_region_t r;
@ -222,7 +222,7 @@ digest_nsec(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_nsec(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_nsec);
@ -234,7 +234,7 @@ checkowner_nsec(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_nsec(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_nsec);
@ -245,7 +245,7 @@ checknames_nsec(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_nsec(ARGS_COMPARE) {
isc_region_t region1;
isc_region_t region2;

26
lib/dns/rdata/generic/null_10.c
View file

@ -16,7 +16,7 @@
#define RRTYPE_NULL_ATTRIBUTES (0)
static inline isc_result_t
static isc_result_t
fromtext_null(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_null);
@ -31,14 +31,14 @@ fromtext_null(ARGS_FROMTEXT) {
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;
@ -54,7 +54,7 @@ fromwire_null(ARGS_FROMWIRE) {
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);
@ -63,7 +63,7 @@ towire_null(ARGS_TOWIRE) {
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;
@ -77,7 +77,7 @@ compare_null(ARGS_COMPARE) {
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;
@ -93,7 +93,7 @@ fromstruct_null(ARGS_FROMSTRUCT) {
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;
@ -112,7 +112,7 @@ tostruct_null(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_null(ARGS_FREESTRUCT) {
dns_rdata_null_t *null = source;
@ -129,7 +129,7 @@ freestruct_null(ARGS_FREESTRUCT) {
null->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_null(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_null);
@ -141,7 +141,7 @@ additionaldata_null(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_null(ARGS_DIGEST) {
isc_region_t r;
@ -152,7 +152,7 @@ digest_null(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_null(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_null);
@ -164,7 +164,7 @@ checkowner_null(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_null(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_null);
@ -175,7 +175,7 @@ checknames_null(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_null(ARGS_COMPARE) {
return (compare_null(rdata1, rdata2));
}

26
lib/dns/rdata/generic/nxt_30.c
View file

@ -22,7 +22,7 @@
*/
#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;
@ -88,7 +88,7 @@ fromtext_nxt(ARGS_FROMTEXT) {
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;
@ -134,7 +134,7 @@ totext_nxt(ARGS_TOTEXT) {
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;
@ -160,7 +160,7 @@ fromwire_nxt(ARGS_FROMWIRE) {
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;
@ -179,7 +179,7 @@ towire_nxt(ARGS_TOWIRE) {
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;
@ -210,7 +210,7 @@ compare_nxt(ARGS_COMPARE) {
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;
@ -234,7 +234,7 @@ fromstruct_nxt(ARGS_FROMSTRUCT) {
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;
@ -261,7 +261,7 @@ tostruct_nxt(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_nxt(ARGS_FREESTRUCT) {
dns_rdata_nxt_t *nxt = source;
@ -279,7 +279,7 @@ freestruct_nxt(ARGS_FREESTRUCT) {
nxt->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_nxt(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_nxt);
@ -291,7 +291,7 @@ additionaldata_nxt(ARGS_ADDLDATA) {
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;
@ -311,7 +311,7 @@ digest_nxt(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_nxt(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_nxt);
@ -323,7 +323,7 @@ checkowner_nxt(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_nxt(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_nxt);
@ -334,7 +334,7 @@ checknames_nxt(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_nxt(ARGS_COMPARE) {
return (compare_nxt(rdata1, rdata2));
}

26
lib/dns/rdata/generic/openpgpkey_61.c
View file

@ -16,7 +16,7 @@
#define RRTYPE_OPENPGPKEY_ATTRIBUTES 0
static inline isc_result_t
static isc_result_t
fromtext_openpgpkey(ARGS_FROMTEXT) {
REQUIRE(type == dns_rdatatype_openpgpkey);
@ -32,7 +32,7 @@ fromtext_openpgpkey(ARGS_FROMTEXT) {
return (isc_base64_tobuffer(lexer, target, -2));
}
static inline isc_result_t
static isc_result_t
totext_openpgpkey(ARGS_TOTEXT) {
isc_region_t sr;
@ -66,7 +66,7 @@ totext_openpgpkey(ARGS_TOTEXT) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
fromwire_openpgpkey(ARGS_FROMWIRE) {
isc_region_t sr;
@ -88,7 +88,7 @@ fromwire_openpgpkey(ARGS_FROMWIRE) {
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;
@ -101,7 +101,7 @@ towire_openpgpkey(ARGS_TOWIRE) {
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;
@ -117,7 +117,7 @@ compare_openpgpkey(ARGS_COMPARE) {
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;
@ -136,7 +136,7 @@ fromstruct_openpgpkey(ARGS_FROMSTRUCT) {
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;
@ -160,7 +160,7 @@ tostruct_openpgpkey(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_openpgpkey(ARGS_FREESTRUCT) {
dns_rdata_openpgpkey_t *sig = (dns_rdata_openpgpkey_t *)source;
@ -177,7 +177,7 @@ freestruct_openpgpkey(ARGS_FREESTRUCT) {
sig->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_openpgpkey(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_openpgpkey);
@ -189,7 +189,7 @@ additionaldata_openpgpkey(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_openpgpkey(ARGS_DIGEST) {
isc_region_t r;
@ -200,7 +200,7 @@ digest_openpgpkey(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_openpgpkey(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_openpgpkey);
@ -212,7 +212,7 @@ checkowner_openpgpkey(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_openpgpkey(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_openpgpkey);
@ -223,7 +223,7 @@ checknames_openpgpkey(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_openpgpkey(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;

26
lib/dns/rdata/generic/opt_41.c
View file

@ -22,7 +22,7 @@
#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.
@ -41,7 +41,7 @@ fromtext_opt(ARGS_FROMTEXT) {
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 ;
@ -91,7 +91,7 @@ totext_opt(ARGS_TOTEXT) {
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;
@ -259,7 +259,7 @@ fromwire_opt(ARGS_FROMWIRE) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
towire_opt(ARGS_TOWIRE) {
REQUIRE(rdata->type == dns_rdatatype_opt);
@ -268,7 +268,7 @@ towire_opt(ARGS_TOWIRE) {
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;
@ -282,7 +282,7 @@ compare_opt(ARGS_COMPARE) {
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;
@ -315,7 +315,7 @@ fromstruct_opt(ARGS_FROMSTRUCT) {
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;
@ -335,7 +335,7 @@ tostruct_opt(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_opt(ARGS_FREESTRUCT) {
dns_rdata_opt_t *opt = source;
@ -352,7 +352,7 @@ freestruct_opt(ARGS_FREESTRUCT) {
opt->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_opt(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_opt);
@ -364,7 +364,7 @@ additionaldata_opt(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_opt(ARGS_DIGEST) {
/*
* OPT records are not digested.
@ -379,7 +379,7 @@ digest_opt(ARGS_DIGEST) {
return (ISC_R_NOTIMPLEMENTED);
}
static inline bool
static bool
checkowner_opt(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_opt);
@ -390,7 +390,7 @@ checkowner_opt(ARGS_CHECKOWNER) {
return (dns_name_equal(name, dns_rootname));
}
static inline bool
static bool
checknames_opt(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_opt);
@ -401,7 +401,7 @@ checknames_opt(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_opt(ARGS_COMPARE) {
return (compare_opt(rdata1, rdata2));
}

26
lib/dns/rdata/generic/proforma.c
View file

@ -16,7 +16,7 @@
#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 #);
@ -28,7 +28,7 @@ static inline isc_result_t fromtext_ #(ARGS_FROMTEXT) {
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 */
@ -36,7 +36,7 @@ static inline isc_result_t totext_ #(ARGS_TOTEXT) {
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 == #);
@ -46,7 +46,7 @@ static inline isc_result_t fromwire_ #(ARGS_FROMWIRE) {
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 */
@ -57,7 +57,7 @@ static inline isc_result_t towire_ #(ARGS_TOWIRE) {
return (ISC_R_NOTIMPLEMENTED);
}
static inline int compare_ #(ARGS_COMPARE) {
static int compare_ #(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;
@ -73,7 +73,7 @@ static inline int compare_ #(ARGS_COMPARE) {
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 #);
@ -85,7 +85,7 @@ static inline isc_result_t fromstruct_ #(ARGS_FROMSTRUCT) {
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 */
@ -93,7 +93,7 @@ static inline isc_result_t tostruct_ #(ARGS_TOSTRUCT) {
return (ISC_R_NOTIMPLEMENTED);
}
static inline void freestruct_ #(ARGS_FREESTRUCT) {
static void freestruct_ #(ARGS_FREESTRUCT) {
dns_rdata_ #_t *# = source;
REQUIRE(# != NULL);
@ -101,7 +101,7 @@ static inline void freestruct_ #(ARGS_FREESTRUCT) {
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 == #);
@ -112,7 +112,7 @@ static inline isc_result_t additionaldata_ #(ARGS_ADDLDATA) {
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 #);
@ -123,7 +123,7 @@ static inline isc_result_t digest_ #(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool checkowner_ #(ARGS_CHECKOWNER) {
static bool checkowner_ #(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_proforma.c #);
REQUIRE(rdclass == #);
@ -135,7 +135,7 @@ static inline bool checkowner_ #(ARGS_CHECKOWNER) {
return (true);
}
static inline bool checknames_ #(ARGS_CHECKNAMES) {
static bool checknames_ #(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_proforma.c #);
REQUIRE(rdata->rdclass == #);
@ -146,7 +146,7 @@ static inline bool checknames_ #(ARGS_CHECKNAMES) {
return (true);
}
static inline int casecompare_ #(ARGS_COMPARE) {
static int casecompare_ #(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;

26
lib/dns/rdata/generic/ptr_12.c
View file

@ -16,7 +16,7 @@
#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;
@ -53,7 +53,7 @@ fromtext_ptr(ARGS_FROMTEXT) {
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;
@ -74,7 +74,7 @@ totext_ptr(ARGS_TOTEXT) {
return (dns_name_totext(&prefix, sub, target));
}
static inline isc_result_t
static isc_result_t
fromwire_ptr(ARGS_FROMWIRE) {
dns_name_t name;
@ -89,7 +89,7 @@ fromwire_ptr(ARGS_FROMWIRE) {
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;
@ -107,7 +107,7 @@ towire_ptr(ARGS_TOWIRE) {
return (dns_name_towire(&name, cctx, target));
}
static inline int
static int
compare_ptr(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
@ -132,7 +132,7 @@ compare_ptr(ARGS_COMPARE) {
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;
@ -149,7 +149,7 @@ fromstruct_ptr(ARGS_FROMSTRUCT) {
return (isc_buffer_copyregion(target, &region));
}
static inline isc_result_t
static isc_result_t
tostruct_ptr(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_ptr_t *ptr = target;
@ -172,7 +172,7 @@ tostruct_ptr(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_ptr(ARGS_FREESTRUCT) {
dns_rdata_ptr_t *ptr = source;
@ -187,7 +187,7 @@ freestruct_ptr(ARGS_FREESTRUCT) {
ptr->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_ptr(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_ptr);
@ -199,7 +199,7 @@ additionaldata_ptr(ARGS_ADDLDATA) {
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;
@ -213,7 +213,7 @@ digest_ptr(ARGS_DIGEST) {
return (dns_name_digest(&name, digest, arg));
}
static inline bool
static bool
checkowner_ptr(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_ptr);
@ -240,7 +240,7 @@ static unsigned char in_addr_arpa_offsets[] = { 0, 8, 13 };
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;
@ -272,7 +272,7 @@ checknames_ptr(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_ptr(ARGS_COMPARE) {
return (compare_ptr(rdata1, rdata2));
}

26
lib/dns/rdata/generic/rkey_57.c
View file

@ -16,14 +16,14 @@
#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);
@ -31,14 +31,14 @@ totext_rkey(ARGS_TOTEXT) {
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;
@ -52,7 +52,7 @@ towire_rkey(ARGS_TOWIRE) {
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;
@ -70,14 +70,14 @@ compare_rkey(ARGS_COMPARE) {
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;
@ -92,7 +92,7 @@ tostruct_rkey(ARGS_TOSTRUCT) {
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;
@ -102,7 +102,7 @@ freestruct_rkey(ARGS_FREESTRUCT) {
generic_freestruct_key(source);
}
static inline isc_result_t
static isc_result_t
additionaldata_rkey(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_rkey);
@ -114,7 +114,7 @@ additionaldata_rkey(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_rkey(ARGS_DIGEST) {
isc_region_t r;
@ -126,7 +126,7 @@ digest_rkey(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_rkey(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_rkey);
@ -138,7 +138,7 @@ checkowner_rkey(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_rkey(ARGS_CHECKNAMES) {
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_rkey);
@ -150,7 +150,7 @@ checknames_rkey(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_rkey(ARGS_COMPARE) {
/*
* Treat ALG 253 (private DNS) subtype name case sensitively.

26
lib/dns/rdata/generic/rp_17.c
View file

@ -18,7 +18,7 @@
#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;
@ -57,7 +57,7 @@ fromtext_rp(ARGS_FROMTEXT) {
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;
@ -89,7 +89,7 @@ totext_rp(ARGS_TOTEXT) {
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;
@ -108,7 +108,7 @@ fromwire_rp(ARGS_FROMWIRE) {
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;
@ -136,7 +136,7 @@ towire_rp(ARGS_TOWIRE) {
return (dns_name_towire(&rmail, cctx, target));
}
static inline int
static int
compare_rp(ARGS_COMPARE) {
isc_region_t region1;
isc_region_t region2;
@ -176,7 +176,7 @@ compare_rp(ARGS_COMPARE) {
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;
@ -195,7 +195,7 @@ fromstruct_rp(ARGS_FROMSTRUCT) {
return (isc_buffer_copyregion(target, &region));
}
static inline isc_result_t
static isc_result_t
tostruct_rp(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_rp_t *rp = target;
@ -222,7 +222,7 @@ tostruct_rp(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_rp(ARGS_FREESTRUCT) {
dns_rdata_rp_t *rp = source;
@ -238,7 +238,7 @@ freestruct_rp(ARGS_FREESTRUCT) {
rp->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_rp(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_rp);
@ -250,7 +250,7 @@ additionaldata_rp(ARGS_ADDLDATA) {
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;
@ -270,7 +270,7 @@ digest_rp(ARGS_DIGEST) {
return (dns_name_digest(&name, digest, arg));
}
static inline bool
static bool
checkowner_rp(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_rp);
@ -282,7 +282,7 @@ checkowner_rp(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_rp(ARGS_CHECKNAMES) {
isc_region_t region;
dns_name_t name;
@ -303,7 +303,7 @@ checknames_rp(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_rp(ARGS_COMPARE) {
return (compare_rp(rdata1, rdata2));
}

28
lib/dns/rdata/generic/rrsig_46.c
View file

@ -20,7 +20,7 @@
(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;
@ -157,7 +157,7 @@ fromtext_rrsig(ARGS_FROMTEXT) {
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. */
@ -274,7 +274,7 @@ totext_rrsig(ARGS_TOTEXT) {
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;
@ -320,7 +320,7 @@ fromwire_rrsig(ARGS_FROMWIRE) {
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;
@ -357,7 +357,7 @@ towire_rrsig(ARGS_TOWIRE) {
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;
@ -373,7 +373,7 @@ compare_rrsig(ARGS_COMPARE) {
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;
@ -432,7 +432,7 @@ fromstruct_rrsig(ARGS_FROMSTRUCT) {
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;
@ -505,7 +505,7 @@ tostruct_rrsig(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_rrsig(ARGS_FREESTRUCT) {
dns_rdata_rrsig_t *sig = (dns_rdata_rrsig_t *)source;
@ -523,7 +523,7 @@ freestruct_rrsig(ARGS_FREESTRUCT) {
sig->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_rrsig(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_rrsig);
@ -535,7 +535,7 @@ additionaldata_rrsig(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_rrsig(ARGS_DIGEST) {
REQUIRE(rdata->type == dns_rdatatype_rrsig);
@ -546,7 +546,7 @@ digest_rrsig(ARGS_DIGEST) {
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;
@ -559,7 +559,7 @@ covers_rrsig(dns_rdata_t *rdata) {
return (type);
}
static inline bool
static bool
checkowner_rrsig(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_rrsig);
@ -571,7 +571,7 @@ checkowner_rrsig(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_rrsig(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_rrsig);
@ -582,7 +582,7 @@ checknames_rrsig(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_rrsig(ARGS_COMPARE) {
isc_region_t r1;
isc_region_t r2;

26
lib/dns/rdata/generic/rt_21.c
View file

@ -18,7 +18,7 @@
#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;
@ -60,7 +60,7 @@ fromtext_rt(ARGS_FROMTEXT) {
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;
@ -86,7 +86,7 @@ totext_rt(ARGS_TOTEXT) {
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;
@ -115,7 +115,7 @@ fromwire_rt(ARGS_FROMWIRE) {
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;
@ -141,7 +141,7 @@ towire_rt(ARGS_TOWIRE) {
return (dns_name_towire(&name, cctx, target));
}
static inline int
static int
compare_rt(ARGS_COMPARE) {
dns_name_t name1;
dns_name_t name2;
@ -175,7 +175,7 @@ compare_rt(ARGS_COMPARE) {
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;
@ -193,7 +193,7 @@ fromstruct_rt(ARGS_FROMSTRUCT) {
return (isc_buffer_copyregion(target, &region));
}
static inline isc_result_t
static isc_result_t
tostruct_rt(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_rt_t *rt = target;
@ -219,7 +219,7 @@ tostruct_rt(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_rt(ARGS_FREESTRUCT) {
dns_rdata_rt_t *rt = source;
@ -234,7 +234,7 @@ freestruct_rt(ARGS_FREESTRUCT) {
rt->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_rt(ARGS_ADDLDATA) {
dns_name_t name;
dns_offsets_t offsets;
@ -261,7 +261,7 @@ additionaldata_rt(ARGS_ADDLDATA) {
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;
@ -282,7 +282,7 @@ digest_rt(ARGS_DIGEST) {
return (dns_name_digest(&name, digest, arg));
}
static inline bool
static bool
checkowner_rt(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_rt);
@ -294,7 +294,7 @@ checkowner_rt(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_rt(ARGS_CHECKNAMES) {
isc_region_t region;
dns_name_t name;
@ -316,7 +316,7 @@ checknames_rt(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_rt(ARGS_COMPARE) {
return (compare_rt(rdata1, rdata2));
}

28
lib/dns/rdata/generic/sig_24.c
View file

@ -18,7 +18,7 @@
#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;
@ -121,7 +121,7 @@ fromtext_sig(ARGS_FROMTEXT) {
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")];
@ -237,7 +237,7 @@ totext_sig(ARGS_TOTEXT) {
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;
@ -283,7 +283,7 @@ fromwire_sig(ARGS_FROMWIRE) {
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;
@ -320,7 +320,7 @@ towire_sig(ARGS_TOWIRE) {
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;
@ -365,7 +365,7 @@ compare_sig(ARGS_COMPARE) {
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;
@ -424,7 +424,7 @@ fromstruct_sig(ARGS_FROMSTRUCT) {
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;
@ -497,7 +497,7 @@ tostruct_sig(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_sig(ARGS_FREESTRUCT) {
dns_rdata_sig_t *sig = (dns_rdata_sig_t *)source;
@ -515,7 +515,7 @@ freestruct_sig(ARGS_FREESTRUCT) {
sig->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_sig(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_sig);
@ -527,7 +527,7 @@ additionaldata_sig(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_sig(ARGS_DIGEST) {
REQUIRE(rdata->type == dns_rdatatype_sig);
@ -538,7 +538,7 @@ digest_sig(ARGS_DIGEST) {
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;
@ -551,7 +551,7 @@ covers_sig(dns_rdata_t *rdata) {
return (type);
}
static inline bool
static bool
checkowner_sig(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_sig);
@ -563,7 +563,7 @@ checkowner_sig(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_sig(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_sig);
@ -574,7 +574,7 @@ checknames_sig(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_sig(ARGS_COMPARE) {
return (compare_sig(rdata1, rdata2));
}

26
lib/dns/rdata/generic/sink_40.c
View file

@ -18,7 +18,7 @@
#define RRTYPE_SINK_ATTRIBUTES (0)
static inline isc_result_t
static isc_result_t
fromtext_sink(ARGS_FROMTEXT) {
isc_token_t token;
@ -57,7 +57,7 @@ fromtext_sink(ARGS_FROMTEXT) {
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")];
@ -103,7 +103,7 @@ totext_sink(ARGS_TOTEXT) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
fromwire_sink(ARGS_FROMWIRE) {
isc_region_t sr;
@ -124,7 +124,7 @@ fromwire_sink(ARGS_FROMWIRE) {
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);
@ -134,7 +134,7 @@ towire_sink(ARGS_TOWIRE) {
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;
@ -150,7 +150,7 @@ compare_sink(ARGS_COMPARE) {
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;
@ -175,7 +175,7 @@ fromstruct_sink(ARGS_FROMSTRUCT) {
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;
@ -209,7 +209,7 @@ tostruct_sink(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_sink(ARGS_FREESTRUCT) {
dns_rdata_sink_t *sink = (dns_rdata_sink_t *)source;
@ -226,7 +226,7 @@ freestruct_sink(ARGS_FREESTRUCT) {
sink->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_sink(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_sink);
@ -238,7 +238,7 @@ additionaldata_sink(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_sink(ARGS_DIGEST) {
isc_region_t r;
@ -249,7 +249,7 @@ digest_sink(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_sink(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_sink);
@ -261,7 +261,7 @@ checkowner_sink(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_sink(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_sink);
@ -272,7 +272,7 @@ checknames_sink(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_sink(ARGS_COMPARE) {
return (compare_sink(rdata1, rdata2));
}

26
lib/dns/rdata/generic/smimea_53.c
View file

@ -16,14 +16,14 @@
#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);
@ -31,14 +31,14 @@ totext_smimea(ARGS_TOTEXT) {
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;
@ -51,7 +51,7 @@ towire_smimea(ARGS_TOWIRE) {
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;
@ -67,14 +67,14 @@ compare_smimea(ARGS_COMPARE) {
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;
@ -89,7 +89,7 @@ tostruct_smimea(ARGS_TOSTRUCT) {
return (generic_tostruct_tlsa(CALL_TOSTRUCT));
}
static inline void
static void
freestruct_smimea(ARGS_FREESTRUCT) {
dns_rdata_smimea_t *smimea = source;
@ -99,7 +99,7 @@ freestruct_smimea(ARGS_FREESTRUCT) {
generic_freestruct_tlsa(source);
}
static inline isc_result_t
static isc_result_t
additionaldata_smimea(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_smimea);
@ -111,7 +111,7 @@ additionaldata_smimea(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_smimea(ARGS_DIGEST) {
isc_region_t r;
@ -122,7 +122,7 @@ digest_smimea(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_smimea(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_smimea);
@ -134,7 +134,7 @@ checkowner_smimea(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_smimea(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_smimea);
@ -145,7 +145,7 @@ checknames_smimea(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_smimea(ARGS_COMPARE) {
return (compare_smimea(rdata1, rdata2));
}

26
lib/dns/rdata/generic/soa_6.c
View file

@ -16,7 +16,7 @@
#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;
@ -79,7 +79,7 @@ fromtext_soa(ARGS_FROMTEXT) {
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;
@ -153,7 +153,7 @@ totext_soa(ARGS_TOTEXT) {
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;
@ -190,7 +190,7 @@ fromwire_soa(ARGS_FROMWIRE) {
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;
@ -227,7 +227,7 @@ towire_soa(ARGS_TOWIRE) {
return (ISC_R_SUCCESS);
}
static inline int
static int
compare_soa(ARGS_COMPARE) {
isc_region_t region1;
isc_region_t region2;
@ -275,7 +275,7 @@ compare_soa(ARGS_COMPARE) {
return (isc_region_compare(&region1, &region2));
}
static inline isc_result_t
static isc_result_t
fromstruct_soa(ARGS_FROMSTRUCT) {
dns_rdata_soa_t *soa = source;
isc_region_t region;
@ -299,7 +299,7 @@ fromstruct_soa(ARGS_FROMSTRUCT) {
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;
@ -344,7 +344,7 @@ tostruct_soa(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_soa(ARGS_FREESTRUCT) {
dns_rdata_soa_t *soa = source;
@ -360,7 +360,7 @@ freestruct_soa(ARGS_FREESTRUCT) {
soa->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_soa(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_soa);
@ -372,7 +372,7 @@ additionaldata_soa(ARGS_ADDLDATA) {
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;
@ -394,7 +394,7 @@ digest_soa(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_soa(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_soa);
@ -406,7 +406,7 @@ checkowner_soa(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_soa(ARGS_CHECKNAMES) {
isc_region_t region;
dns_name_t name;
@ -435,7 +435,7 @@ checknames_soa(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_soa(ARGS_COMPARE) {
return (compare_soa(rdata1, rdata2));
}

26
lib/dns/rdata/generic/spf_99.c
View file

@ -16,14 +16,14 @@
#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);
@ -31,14 +31,14 @@ totext_spf(ARGS_TOTEXT) {
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);
@ -47,7 +47,7 @@ towire_spf(ARGS_TOWIRE) {
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;
@ -61,14 +61,14 @@ compare_spf(ARGS_COMPARE) {
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;
@ -83,7 +83,7 @@ tostruct_spf(ARGS_TOSTRUCT) {
return (generic_tostruct_txt(CALL_TOSTRUCT));
}
static inline void
static void
freestruct_spf(ARGS_FREESTRUCT) {
dns_rdata_spf_t *spf = source;
@ -93,7 +93,7 @@ freestruct_spf(ARGS_FREESTRUCT) {
generic_freestruct_txt(source);
}
static inline isc_result_t
static isc_result_t
additionaldata_spf(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_spf);
@ -105,7 +105,7 @@ additionaldata_spf(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_spf(ARGS_DIGEST) {
isc_region_t r;
@ -116,7 +116,7 @@ digest_spf(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_spf(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_spf);
@ -128,7 +128,7 @@ checkowner_spf(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_spf(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_spf);
@ -139,7 +139,7 @@ checknames_spf(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_spf(ARGS_COMPARE) {
return (compare_spf(rdata1, rdata2));
}

26
lib/dns/rdata/generic/sshfp_44.c
View file

@ -18,7 +18,7 @@
#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;
@ -71,7 +71,7 @@ fromtext_sshfp(ARGS_FROMTEXT) {
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 ")];
@ -123,7 +123,7 @@ totext_sshfp(ARGS_TOTEXT) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
fromwire_sshfp(ARGS_FROMWIRE) {
isc_region_t sr;
@ -149,7 +149,7 @@ fromwire_sshfp(ARGS_FROMWIRE) {
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;
@ -162,7 +162,7 @@ towire_sshfp(ARGS_TOWIRE) {
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;
@ -178,7 +178,7 @@ compare_sshfp(ARGS_COMPARE) {
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;
@ -196,7 +196,7 @@ fromstruct_sshfp(ARGS_FROMSTRUCT) {
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;
@ -222,7 +222,7 @@ tostruct_sshfp(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_sshfp(ARGS_FREESTRUCT) {
dns_rdata_sshfp_t *sshfp = source;
@ -239,7 +239,7 @@ freestruct_sshfp(ARGS_FREESTRUCT) {
sshfp->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_sshfp(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_sshfp);
@ -251,7 +251,7 @@ additionaldata_sshfp(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_sshfp(ARGS_DIGEST) {
isc_region_t r;
@ -262,7 +262,7 @@ digest_sshfp(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_sshfp(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_sshfp);
@ -274,7 +274,7 @@ checkowner_sshfp(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_sshfp(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_sshfp);
@ -285,7 +285,7 @@ checknames_sshfp(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_sshfp(ARGS_COMPARE) {
return (compare_sshfp(rdata1, rdata2));
}

26
lib/dns/rdata/generic/ta_32768.c
View file

@ -18,28 +18,28 @@
#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;
@ -52,7 +52,7 @@ towire_ta(ARGS_TOWIRE) {
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;
@ -68,14 +68,14 @@ compare_ta(ARGS_COMPARE) {
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;
@ -92,7 +92,7 @@ tostruct_ta(ARGS_TOSTRUCT) {
return (generic_tostruct_ds(CALL_TOSTRUCT));
}
static inline void
static void
freestruct_ta(ARGS_FREESTRUCT) {
dns_rdata_ta_t *ds = source;
@ -109,7 +109,7 @@ freestruct_ta(ARGS_FREESTRUCT) {
ds->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_ta(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_ta);
@ -121,7 +121,7 @@ additionaldata_ta(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_ta(ARGS_DIGEST) {
isc_region_t r;
@ -132,7 +132,7 @@ digest_ta(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_ta(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_ta);
@ -144,7 +144,7 @@ checkowner_ta(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_ta(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_ta);
@ -155,7 +155,7 @@ checknames_ta(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_ta(ARGS_COMPARE) {
return (compare_ta(rdata1, rdata2));
}

26
lib/dns/rdata/generic/talink_58.c
View file

@ -16,7 +16,7 @@
#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;
@ -46,7 +46,7 @@ fromtext_talink(ARGS_FROMTEXT) {
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;
@ -78,7 +78,7 @@ totext_talink(ARGS_TOTEXT) {
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;
@ -97,7 +97,7 @@ fromwire_talink(ARGS_FROMWIRE) {
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;
@ -124,7 +124,7 @@ towire_talink(ARGS_TOWIRE) {
return (dns_name_towire(&next, cctx, target));
}
static inline int
static int
compare_talink(ARGS_COMPARE) {
isc_region_t region1;
isc_region_t region2;
@ -140,7 +140,7 @@ compare_talink(ARGS_COMPARE) {
return (isc_region_compare(&region1, &region2));
}
static inline isc_result_t
static isc_result_t
fromstruct_talink(ARGS_FROMSTRUCT) {
dns_rdata_talink_t *talink = source;
isc_region_t region;
@ -159,7 +159,7 @@ fromstruct_talink(ARGS_FROMSTRUCT) {
return (isc_buffer_copyregion(target, &region));
}
static inline isc_result_t
static isc_result_t
tostruct_talink(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_talink_t *talink = target;
@ -190,7 +190,7 @@ tostruct_talink(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_talink(ARGS_FREESTRUCT) {
dns_rdata_talink_t *talink = source;
@ -206,7 +206,7 @@ freestruct_talink(ARGS_FREESTRUCT) {
talink->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_talink(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_talink);
@ -218,7 +218,7 @@ additionaldata_talink(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_talink(ARGS_DIGEST) {
isc_region_t r;
@ -228,7 +228,7 @@ digest_talink(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_talink(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_talink);
@ -240,7 +240,7 @@ checkowner_talink(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_talink(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_talink);
@ -250,7 +250,7 @@ checknames_talink(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_talink(ARGS_COMPARE) {
return (compare_talink(rdata1, rdata2));
}

26
lib/dns/rdata/generic/tkey_249.c
View file

@ -18,7 +18,7 @@
#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;
@ -118,7 +118,7 @@ fromtext_tkey(ARGS_FROMTEXT) {
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 ")];
@ -242,7 +242,7 @@ totext_tkey(ARGS_TOTEXT) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
fromwire_tkey(ARGS_FROMWIRE) {
isc_region_t sr;
unsigned long n;
@ -303,7 +303,7 @@ fromwire_tkey(ARGS_FROMWIRE) {
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;
@ -325,7 +325,7 @@ towire_tkey(ARGS_TOWIRE) {
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;
@ -356,7 +356,7 @@ compare_tkey(ARGS_COMPARE) {
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;
@ -414,7 +414,7 @@ fromstruct_tkey(ARGS_FROMSTRUCT) {
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;
@ -491,7 +491,7 @@ tostruct_tkey(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_tkey(ARGS_FREESTRUCT) {
dns_rdata_tkey_t *tkey = (dns_rdata_tkey_t *)source;
@ -511,7 +511,7 @@ freestruct_tkey(ARGS_FREESTRUCT) {
tkey->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_tkey(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_tkey);
@ -523,7 +523,7 @@ additionaldata_tkey(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_tkey(ARGS_DIGEST) {
UNUSED(rdata);
UNUSED(digest);
@ -534,7 +534,7 @@ digest_tkey(ARGS_DIGEST) {
return (ISC_R_NOTIMPLEMENTED);
}
static inline bool
static bool
checkowner_tkey(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_tkey);
@ -546,7 +546,7 @@ checkowner_tkey(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_tkey(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_tkey);
@ -557,7 +557,7 @@ checknames_tkey(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_tkey(ARGS_COMPARE) {
return (compare_tkey(rdata1, rdata2));
}

38
lib/dns/rdata/generic/tlsa_52.c
View file

@ -18,7 +18,7 @@
#define RRTYPE_TLSA_ATTRIBUTES 0
static inline isc_result_t
static isc_result_t
generic_fromtext_tlsa(ARGS_FROMTEXT) {
isc_token_t token;
@ -64,7 +64,7 @@ generic_fromtext_tlsa(ARGS_FROMTEXT) {
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 ")];
@ -119,7 +119,7 @@ generic_totext_tlsa(ARGS_TOTEXT) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
generic_fromwire_tlsa(ARGS_FROMWIRE) {
isc_region_t sr;
@ -139,28 +139,28 @@ generic_fromwire_tlsa(ARGS_FROMWIRE) {
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;
@ -173,7 +173,7 @@ towire_tlsa(ARGS_TOWIRE) {
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;
@ -189,7 +189,7 @@ compare_tlsa(ARGS_COMPARE) {
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;
@ -207,7 +207,7 @@ generic_fromstruct_tlsa(ARGS_FROMSTRUCT) {
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;
@ -235,7 +235,7 @@ generic_tostruct_tlsa(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
generic_freestruct_tlsa(ARGS_FREESTRUCT) {
dns_rdata_tlsa_t *tlsa = source;
@ -251,14 +251,14 @@ generic_freestruct_tlsa(ARGS_FREESTRUCT) {
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;
@ -272,7 +272,7 @@ tostruct_tlsa(ARGS_TOSTRUCT) {
return (generic_tostruct_tlsa(CALL_TOSTRUCT));
}
static inline void
static void
freestruct_tlsa(ARGS_FREESTRUCT) {
dns_rdata_tlsa_t *tlsa = source;
@ -282,7 +282,7 @@ freestruct_tlsa(ARGS_FREESTRUCT) {
generic_freestruct_tlsa(source);
}
static inline isc_result_t
static isc_result_t
additionaldata_tlsa(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_tlsa);
@ -294,7 +294,7 @@ additionaldata_tlsa(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_tlsa(ARGS_DIGEST) {
isc_region_t r;
@ -305,7 +305,7 @@ digest_tlsa(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_tlsa(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_tlsa);
@ -317,7 +317,7 @@ checkowner_tlsa(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_tlsa(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_tlsa);
@ -328,7 +328,7 @@ checknames_tlsa(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_tlsa(ARGS_COMPARE) {
return (compare_tlsa(rdata1, rdata2));
}

38
lib/dns/rdata/generic/txt_16.c
View file

@ -16,7 +16,7 @@
#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;
@ -50,7 +50,7 @@ generic_fromtext_txt(ARGS_FROMTEXT) {
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;
@ -68,7 +68,7 @@ generic_totext_txt(ARGS_TOTEXT) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
generic_fromwire_txt(ARGS_FROMWIRE) {
isc_result_t result;
@ -86,14 +86,14 @@ generic_fromwire_txt(ARGS_FROMWIRE) {
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);
@ -101,14 +101,14 @@ totext_txt(ARGS_TOTEXT) {
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);
@ -117,7 +117,7 @@ towire_txt(ARGS_TOWIRE) {
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;
@ -131,7 +131,7 @@ compare_txt(ARGS_COMPARE) {
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;
@ -159,7 +159,7 @@ generic_fromstruct_txt(ARGS_FROMSTRUCT) {
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;
@ -177,7 +177,7 @@ generic_tostruct_txt(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
generic_freestruct_txt(ARGS_FREESTRUCT) {
dns_rdata_txt_t *txt = source;
@ -193,14 +193,14 @@ generic_freestruct_txt(ARGS_FREESTRUCT) {
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;
@ -214,7 +214,7 @@ tostruct_txt(ARGS_TOSTRUCT) {
return (generic_tostruct_txt(CALL_TOSTRUCT));
}
static inline void
static void
freestruct_txt(ARGS_FREESTRUCT) {
dns_rdata_txt_t *txt = source;
@ -224,7 +224,7 @@ freestruct_txt(ARGS_FREESTRUCT) {
generic_freestruct_txt(source);
}
static inline isc_result_t
static isc_result_t
additionaldata_txt(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_txt);
@ -236,7 +236,7 @@ additionaldata_txt(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_txt(ARGS_DIGEST) {
isc_region_t r;
@ -247,7 +247,7 @@ digest_txt(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_txt(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_txt);
@ -259,7 +259,7 @@ checkowner_txt(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_txt(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_txt);
@ -270,7 +270,7 @@ checknames_txt(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_txt(ARGS_COMPARE) {
return (compare_txt(rdata1, rdata2));
}

26
lib/dns/rdata/generic/uri_256.c
View file

@ -16,7 +16,7 @@
#define RRTYPE_URI_ATTRIBUTES (0)
static inline isc_result_t
static isc_result_t
fromtext_uri(ARGS_FROMTEXT) {
isc_token_t token;
@ -60,7 +60,7 @@ fromtext_uri(ARGS_FROMTEXT) {
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;
@ -96,7 +96,7 @@ totext_uri(ARGS_TOTEXT) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
fromwire_uri(ARGS_FROMWIRE) {
isc_region_t region;
@ -122,7 +122,7 @@ fromwire_uri(ARGS_FROMWIRE) {
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;
@ -135,7 +135,7 @@ towire_uri(ARGS_TOWIRE) {
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;
@ -173,7 +173,7 @@ compare_uri(ARGS_COMPARE) {
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;
@ -202,7 +202,7 @@ fromstruct_uri(ARGS_FROMSTRUCT) {
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;
@ -238,7 +238,7 @@ tostruct_uri(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_uri(ARGS_FREESTRUCT) {
dns_rdata_uri_t *uri = (dns_rdata_uri_t *)source;
@ -255,7 +255,7 @@ freestruct_uri(ARGS_FREESTRUCT) {
uri->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_uri(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_uri);
@ -267,7 +267,7 @@ additionaldata_uri(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_uri(ARGS_DIGEST) {
isc_region_t r;
@ -278,7 +278,7 @@ digest_uri(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_uri(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_uri);
@ -290,7 +290,7 @@ checkowner_uri(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_uri(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_uri);
@ -301,7 +301,7 @@ checknames_uri(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_uri(ARGS_COMPARE) {
return (compare_uri(rdata1, rdata2));
}

26
lib/dns/rdata/generic/x25_19.c
View file

@ -18,7 +18,7 @@
#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;
@ -46,7 +46,7 @@ fromtext_x25(ARGS_FROMTEXT) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
totext_x25(ARGS_TOTEXT) {
isc_region_t region;
@ -59,7 +59,7 @@ totext_x25(ARGS_TOTEXT) {
return (txt_totext(&region, true, target));
}
static inline isc_result_t
static isc_result_t
fromwire_x25(ARGS_FROMWIRE) {
isc_region_t sr;
unsigned int i;
@ -83,7 +83,7 @@ fromwire_x25(ARGS_FROMWIRE) {
return (txt_fromwire(source, target));
}
static inline isc_result_t
static isc_result_t
towire_x25(ARGS_TOWIRE) {
UNUSED(cctx);
@ -93,7 +93,7 @@ towire_x25(ARGS_TOWIRE) {
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;
@ -109,7 +109,7 @@ compare_x25(ARGS_COMPARE) {
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;
@ -137,7 +137,7 @@ fromstruct_x25(ARGS_FROMSTRUCT) {
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;
@ -158,7 +158,7 @@ tostruct_x25(ARGS_TOSTRUCT) {
return (ISC_R_SUCCESS);
}
static inline void
static void
freestruct_x25(ARGS_FREESTRUCT) {
dns_rdata_x25_t *x25 = source;
@ -175,7 +175,7 @@ freestruct_x25(ARGS_FREESTRUCT) {
x25->mctx = NULL;
}
static inline isc_result_t
static isc_result_t
additionaldata_x25(ARGS_ADDLDATA) {
REQUIRE(rdata->type == dns_rdatatype_x25);
@ -187,7 +187,7 @@ additionaldata_x25(ARGS_ADDLDATA) {
return (ISC_R_SUCCESS);
}
static inline isc_result_t
static isc_result_t
digest_x25(ARGS_DIGEST) {
isc_region_t r;
@ -198,7 +198,7 @@ digest_x25(ARGS_DIGEST) {
return ((digest)(arg, &r));
}
static inline bool
static bool
checkowner_x25(ARGS_CHECKOWNER) {
REQUIRE(type == dns_rdatatype_x25);
@ -210,7 +210,7 @@ checkowner_x25(ARGS_CHECKOWNER) {
return (true);
}
static inline bool
static bool
checknames_x25(ARGS_CHECKNAMES) {
REQUIRE(rdata->type == dns_rdatatype_x25);
@ -221,7 +221,7 @@ checknames_x25(ARGS_CHECKNAMES) {
return (true);
}
static inline int
static int
casecompare_x25(ARGS_COMPARE) {
return (compare_x25(rdata1, rdata2));
}

Some files were not shown because too many files have changed in this diff Show more