#include <config.h>
#include <stdio.h>
+#include <inttypes.h>
#ifdef _WIN32
#include <Winsock2.h>
isc_result_t
dump_zone(const char *zonename, dns_zone_t *zone, const char *filename,
dns_masterformat_t fileformat, const dns_master_style_t *style,
- const isc_uint32_t rawversion)
+ const uint32_t rawversion)
{
isc_result_t result;
FILE *output = stdout;
/*! \file */
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <isc/stdio.h>
#include <isc/types.h>
isc_result_t
dump_zone(const char *zonename, dns_zone_t *zone, const char *filename,
dns_masterformat_t fileformat, const dns_master_style_t *style,
- const isc_uint32_t rawversion);
+ const uint32_t rawversion);
#ifdef _WIN32
void InitSockets(void);
#include <config.h>
#include <stdlib.h>
+#include <inttypes.h>
#include <isc/app.h>
#include <isc/commandline.h>
dns_masterformat_t inputformat = dns_masterformat_text;
dns_masterformat_t outputformat = dns_masterformat_text;
dns_masterrawheader_t header;
- isc_uint32_t rawversion = 1, serialnum = 0;
+ uint32_t rawversion = 1, serialnum = 0;
dns_ttl_t maxttl = 0;
isc_boolean_t snset = ISC_FALSE;
isc_boolean_t logdump = ISC_FALSE;
#endif
#include <stdio.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
static isc_boolean_t typeset = ISC_FALSE;
static unsigned int styleflags = 0;
-static isc_uint32_t splitwidth = 0xffffffff;
+static uint32_t splitwidth = 0xffffffff;
static isc_boolean_t
showcomments = ISC_TRUE,
showdnssec = ISC_TRUE,
get_reverse(char *reverse, size_t len, char *value, isc_boolean_t strict);
static isc_result_t
-parse_uint(isc_uint32_t *uip, const char *value, isc_uint32_t max,
+parse_uint(uint32_t *uip, const char *value, uint32_t max,
const char *desc);
static void
static isc_result_t
key_fromconfig(const cfg_obj_t *key, dns_client_t *client) {
dns_rdata_dnskey_t keystruct;
- isc_uint32_t flags, proto, alg;
+ uint32_t flags, proto, alg;
const char *keystr, *keynamestr;
unsigned char keydata[4096];
isc_buffer_t keydatabuf;
if (alg > 0xff)
CHECK(ISC_R_RANGE);
- keystruct.flags = (isc_uint16_t)flags;
- keystruct.protocol = (isc_uint8_t)proto;
- keystruct.algorithm = (isc_uint8_t)alg;
+ keystruct.flags = (uint16_t)flags;
+ keystruct.protocol = (uint8_t)proto;
+ keystruct.algorithm = (uint8_t)alg;
isc_buffer_init(&keydatabuf, keydata, sizeof(keydata));
isc_buffer_init(&rrdatabuf, rrdata, sizeof(rrdata));
struct in6_addr in6;
isc_sockaddr_t *sa;
isc_sockaddrlist_t servers;
- isc_uint32_t destport;
+ uint32_t destport;
isc_result_t result;
dns_name_t *name = NULL;
irs_resconf_t *resconf = NULL;
isc_sockaddrlist_t *nameservers;
isc_sockaddr_t *sa, *next;
- isc_uint32_t destport;
+ uint32_t destport;
result = parse_uint(&destport, port, 0xffff, "port");
if (result != ISC_R_SUCCESS)
}
static isc_result_t
-parse_uint(isc_uint32_t *uip, const char *value, isc_uint32_t max,
+parse_uint(uint32_t *uip, const char *value, uint32_t max,
const char *desc) {
- isc_uint32_t n;
+ uint32_t n;
isc_result_t result = isc_parse_uint32(&n, value, 10);
if (result == ISC_R_SUCCESS && n > max)
result = ISC_R_RANGE;
struct in_addr in4;
struct in6_addr in6;
in_port_t srcport;
- isc_uint32_t num;
+ uint32_t num;
char *hash;
while (strpbrk(option, single_dash_opts) == &option[0]) {
/*! \file */
#include <config.h>
+
+#include <inttypes.h>
#include <stdlib.h>
#include <time.h>
#include <ctype.h>
-#include <inttypes.h>
#include <isc/app.h>
#include <isc/netaddr.h>
onesoa = ISC_FALSE, use_usec = ISC_FALSE,
nocrypto = ISC_FALSE, ttlunits = ISC_FALSE,
ipv4only = ISC_FALSE, ipv6only = ISC_FALSE;
-static isc_uint32_t splitwidth = 0xffffffff;
+static uint32_t splitwidth = 0xffffffff;
/*% rrcomments are neither explicitly enabled nor disabled by default */
static int rrcomments = 0;
*/
static void
received(unsigned int bytes, isc_sockaddr_t *from, dig_query_t *query) {
- isc_uint64_t diff;
+ uint64_t diff;
time_t tnow;
struct tm tmnow;
#ifdef WIN32
"from %s(%s) in %ld us\n\n",
query->lookup->doing_xfr
? query->byte_count
- : (isc_uint64_t)bytes,
+ : (uint64_t)bytes,
fromtext, query->userarg, (long) diff);
else
printf(";; Received %" PRIu64 " bytes "
"from %s(%s) in %ld ms\n\n",
query->lookup->doing_xfr
? query->byte_count
- : (isc_uint64_t)bytes,
+ : (uint64_t)bytes,
fromtext, query->userarg, (long) diff / 1000);
}
}
static isc_result_t
say_message(dns_rdata_t *rdata, dig_query_t *query, isc_buffer_t *buf) {
isc_result_t result;
- isc_uint64_t diff;
+ uint64_t diff;
char store[sizeof(" in 18446744073709551616 us.")];
unsigned int styleflags = 0;
isc_result_t result;
char option_store[256];
char *cmd, *value, *ptr, *code;
- isc_uint32_t num;
+ uint32_t num;
isc_boolean_t state = ISC_TRUE;
size_t n;
struct in6_addr in6;
in_port_t srcport;
char *hash, *cmd;
- isc_uint32_t num;
+ uint32_t num;
while (strpbrk(option, single_dash_opts) == &option[0]) {
/*
"extra type option\n");
}
if (rdtype == dns_rdatatype_ixfr) {
- isc_uint32_t serial;
+ uint32_t serial;
(*lookup)->rdtype = dns_rdatatype_ixfr;
(*lookup)->rdtypeset = ISC_TRUE;
result = parse_uint(&serial, &value[5],
"extra type option\n");
}
if (rdtype == dns_rdatatype_ixfr) {
- isc_uint32_t serial;
+ uint32_t serial;
lookup->rdtype =
dns_rdatatype_ixfr;
lookup->rdtypeset = ISC_TRUE;
*/
#include <config.h>
+
+#include <inttypes.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
}
static isc_result_t
-parse_uint_helper(isc_uint32_t *uip, const char *value, isc_uint32_t max,
+parse_uint_helper(uint32_t *uip, const char *value, uint32_t max,
const char *desc, int base) {
- isc_uint32_t n;
+ uint32_t n;
isc_result_t result = isc_parse_uint32(&n, value, base);
if (result == ISC_R_SUCCESS && n > max)
result = ISC_R_RANGE;
}
isc_result_t
-parse_uint(isc_uint32_t *uip, const char *value, isc_uint32_t max,
+parse_uint(uint32_t *uip, const char *value, uint32_t max,
const char *desc) {
return (parse_uint_helper(uip, value, max, desc, 10));
}
isc_result_t
-parse_xint(isc_uint32_t *uip, const char *value, isc_uint32_t max,
+parse_xint(uint32_t *uip, const char *value, uint32_t max,
const char *desc) {
return (parse_uint_helper(uip, value, max, desc, 0));
}
-static isc_uint32_t
-parse_bits(char *arg, const char *desc, isc_uint32_t max) {
+static uint32_t
+parse_bits(char *arg, const char *desc, uint32_t max) {
isc_result_t result;
- isc_uint32_t tmp;
+ uint32_t tmp;
result = parse_uint(&tmp, arg, max, desc);
if (result != ISC_R_SUCCESS)
isc_sockaddr_t *sa = NULL;
struct in_addr in4;
struct in6_addr in6;
- isc_uint32_t prefix_length = 0xffffffff;
+ uint32_t prefix_length = 0xffffffff;
char *slash = NULL;
isc_boolean_t parsed = ISC_FALSE;
isc_boolean_t prefix_parsed = ISC_FALSE;
}
typedef struct dig_ednsoptname {
- isc_uint32_t code;
+ uint32_t code;
const char *name;
} dig_ednsoptname_t;
void
save_opt(dig_lookup_t *lookup, char *code, char *value) {
isc_result_t result;
- isc_uint32_t num = 0;
+ uint32_t num = 0;
isc_buffer_t b;
isc_boolean_t found = ISC_FALSE;
unsigned int i;
* (e.g., NSID, COOKIE, client-subnet)
*/
static void
-add_opt(dns_message_t *msg, isc_uint16_t udpsize, isc_uint16_t edns,
+add_opt(dns_message_t *msg, uint16_t udpsize, uint16_t edns,
unsigned int flags, dns_ednsopt_t *opts, size_t count)
{
dns_rdataset_t *rdataset = NULL;
* Randomize the order the nameserver will be tried.
*/
if (numLookups > 1) {
- isc_uint32_t i, j;
+ uint32_t i, j;
dig_serverlist_t my_server_list;
dig_server_t *next;
isc_boolean_t
setup_lookup(dig_lookup_t *lookup) {
isc_result_t result;
- isc_uint32_t id;
+ uint32_t id;
unsigned int len;
dig_server_t *serv;
dig_query_t *query;
}
if (lookup->ecs_addr != NULL) {
- isc_uint8_t addr[16];
- isc_uint16_t family;
- isc_uint32_t plen;
+ uint8_t addr[16];
+ uint16_t family;
+ uint32_t plen;
struct sockaddr *sa;
struct sockaddr_in *sin;
struct sockaddr_in6 *sin6;
INSIST(i < MAXOPTS);
opts[i].code = DNS_OPT_CLIENT_SUBNET;
- opts[i].length = (isc_uint16_t) addrl + 4;
+ opts[i].length = (uint16_t) addrl + 4;
check_result(result, "isc_buffer_allocate");
/*
(unsigned)addrl);
}
- opts[i].value = (isc_uint8_t *) ecsbuf;
+ opts[i].value = (uint8_t *) ecsbuf;
i++;
}
isc_result_t result;
dig_query_t *query = NULL;
dig_lookup_t *l, *n;
- isc_uint16_t length;
+ uint16_t length;
REQUIRE(event->ev_type == ISC_SOCKEVENT_RECVDONE);
INSIST(!free_now);
isc_buffer_clear(&query->slbuf);
isc_buffer_clear(&query->lengthbuf);
- isc_buffer_putuint16(&query->slbuf, (isc_uint16_t) query->sendbuf.used);
+ isc_buffer_putuint16(&query->slbuf, (uint16_t) query->sendbuf.used);
ISC_LIST_INIT(query->sendlist);
ISC_LINK_INIT(&query->slbuf, link);
if (!query->first_soa_rcvd) {
dns_rdataset_t *rdataset = NULL;
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_soa_t soa;
- isc_uint32_t ixfr_serial = query->lookup->ixfr_serial, serial;
+ uint32_t ixfr_serial = query->lookup->ixfr_serial, serial;
isc_result_t result;
isc_boolean_t ixfr = query->lookup->rdtype == dns_rdatatype_ixfr;
isc_boolean_t axfr = query->lookup->rdtype == dns_rdatatype_axfr;
dns_rdata_t rdata;
isc_result_t result;
isc_buffer_t optbuf;
- isc_uint16_t optcode, optlen;
+ uint16_t optcode, optlen;
dns_rdataset_t *opt = msg->opt;
isc_boolean_t seen_cookie = ISC_FALSE;
/*! \file */
#include <config.h>
+
+#include <inttypes.h>
#include <stdlib.h>
#include <limits.h>
isc_result_t result = ISC_R_SUCCESS;
dns_rdatatype_t rdtype;
dns_rdataclass_t rdclass;
- isc_uint32_t serial = 0;
+ uint32_t serial = 0;
UNUSED(is_batchfile);
/*! \file */
+#include <inttypes.h>
+
#include <dns/rdatalist.h>
#include <dst/dst.h>
dig_serverlist_t my_server_list;
dig_searchlist_t *origin;
dig_query_t *xfr_q;
- isc_uint32_t retries;
+ uint32_t retries;
int nsfound;
- isc_uint16_t udpsize;
- isc_int16_t edns;
- isc_uint32_t ixfr_serial;
+ uint16_t udpsize;
+ int16_t edns;
+ uint32_t ixfr_serial;
isc_buffer_t rdatabuf;
char rdatastore[MXNAME];
dst_context_t *tsigctx;
isc_buffer_t *querysig;
- isc_uint32_t msgcounter;
+ uint32_t msgcounter;
dns_fixedname_t fdomain;
isc_sockaddr_t *ecs_addr;
char *cookie;
recv_made,
warn_id,
timedout;
- isc_uint32_t first_rr_serial;
- isc_uint32_t second_rr_serial;
- isc_uint32_t msg_count;
- isc_uint32_t rr_count;
+ uint32_t first_rr_serial;
+ uint32_t second_rr_serial;
+ uint32_t msg_count;
+ uint32_t rr_count;
isc_boolean_t ixfr_axfr;
char *servname;
char *userarg;
isc_sockaddr_t sockaddr;
isc_time_t time_sent;
isc_time_t time_recv;
- isc_uint64_t byte_count;
+ uint64_t byte_count;
isc_buffer_t sendbuf;
isc_timer_t *timer;
};
setup_system(isc_boolean_t ipv4only, isc_boolean_t ipv6only);
isc_result_t
-parse_uint(isc_uint32_t *uip, const char *value, isc_uint32_t max,
+parse_uint(uint32_t *uip, const char *value, uint32_t max,
const char *desc);
isc_result_t
-parse_xint(isc_uint32_t *uip, const char *value, isc_uint32_t max,
+parse_xint(uint32_t *uip, const char *value, uint32_t max,
const char *desc);
isc_result_t
#include <config.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <unistd.h>
static void
set_port(const char *value) {
- isc_uint32_t n;
+ uint32_t n;
isc_result_t result = parse_uint(&n, value, 65535, "port");
if (result == ISC_R_SUCCESS)
- port = (isc_uint16_t) n;
+ port = (uint16_t) n;
}
static void
set_timeout(const char *value) {
- isc_uint32_t n;
+ uint32_t n;
isc_result_t result = parse_uint(&n, value, UINT_MAX, "timeout");
if (result == ISC_R_SUCCESS)
timeout = n;
static void
set_tries(const char *value) {
- isc_uint32_t n;
+ uint32_t n;
isc_result_t result = parse_uint(&n, value, INT_MAX, "tries");
if (result == ISC_R_SUCCESS)
tries = n;
static void
set_ndots(const char *value) {
- isc_uint32_t n;
+ uint32_t n;
isc_result_t result = parse_uint(&n, value, 128, "ndots");
if (result == ISC_R_SUCCESS)
ndots = n;
#include <config.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <isc/buffer.h>
static dns_fixedname_t fixed;
static dns_name_t *name = NULL;
static isc_mem_t *mctx = NULL;
-static isc_uint32_t ttl;
+static uint32_t ttl;
static isc_boolean_t emitttl = ISC_FALSE;
static isc_result_t
#include <config.h>
#include <ctype.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <isc/buffer.h>
dst_key_t *key = NULL;
dns_fixedname_t fname;
dns_name_t *name;
- isc_uint16_t flags = 0, kskflag = 0, revflag = 0;
+ uint16_t flags = 0, kskflag = 0, revflag = 0;
dns_secalg_t alg;
isc_boolean_t oldstyle = ISC_FALSE;
isc_mem_t *mctx = NULL;
#include <config.h>
#include <ctype.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <unistd.h>
dst_key_t *key = NULL;
dns_fixedname_t fname;
dns_name_t *name;
- isc_uint16_t flags = 0, kskflag = 0, revflag = 0;
+ uint16_t flags = 0, kskflag = 0, revflag = 0;
dns_secalg_t alg;
isc_boolean_t conflict = ISC_FALSE, null_key = ISC_FALSE;
isc_boolean_t oldstyle = ISC_FALSE;
#include <config.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <unistd.h>
int ch;
isc_entropy_t *ectx = NULL;
dst_key_t *key = NULL;
- isc_uint32_t flags;
+ uint32_t flags;
isc_buffer_t buf;
isc_boolean_t force = ISC_FALSE;
isc_boolean_t removefile = ISC_FALSE;
#include <config.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
dns_name_t *name = NULL;
dns_secalg_t alg = 0;
unsigned int size = 0;
- isc_uint16_t flags = 0;
+ uint16_t flags = 0;
int prepub = -1;
dns_ttl_t ttl = 0;
isc_stdtime_t now;
static const dns_master_style_t *masterstyle;
static dns_masterformat_t inputformat = dns_masterformat_text;
static dns_masterformat_t outputformat = dns_masterformat_text;
-static isc_uint32_t rawversion = 1, serialnum = 0;
+static uint32_t rawversion = 1, serialnum = 0;
static isc_boolean_t snset = ISC_FALSE;
static unsigned int nsigned = 0, nretained = 0, ndropped = 0;
static unsigned int nverified = 0, nverifyfailed = 0;
* dnssec-signzone, and build DS records from that.
*/
static isc_result_t
-loadds(dns_name_t *name, isc_uint32_t ttl, dns_rdataset_t *dsset) {
+loadds(dns_name_t *name, uint32_t ttl, dns_rdataset_t *dsset) {
dns_db_t *db = NULL;
dns_dbversion_t *ver = NULL;
dns_dbnode_t *node = NULL;
* Increment (or set if nonzero) the SOA serial
*/
static isc_result_t
-setsoaserial(isc_uint32_t serial, dns_updatemethod_t method) {
+setsoaserial(uint32_t serial, dns_updatemethod_t method) {
isc_result_t result;
dns_dbnode_t *node = NULL;
dns_rdataset_t rdataset;
dns_rdata_t rdata = DNS_RDATA_INIT;
- isc_uint32_t old_serial, new_serial;
+ uint32_t old_serial, new_serial;
result = dns_db_getoriginnode(gdb, &node);
if (result != ISC_R_SUCCESS)
* Update / remove the DS RRset. Preserve RRSIG(DS) if possible.
*/
static void
-add_ds(dns_name_t *name, dns_dbnode_t *node, isc_uint32_t nsttl) {
+add_ds(dns_name_t *name, dns_dbnode_t *node, uint32_t nsttl) {
dns_rdataset_t dsset;
dns_rdataset_t sigdsset;
isc_result_t result;
dns_rdatatype_t type, covers;
isc_boolean_t done = ISC_FALSE;
isc_result_t result;
- isc_uint32_t nsttl = 0;
+ uint32_t nsttl = 0;
dns_rdataset_init(&rdataset);
name = dns_fixedname_initname(&fname);
isc_boolean_t active;
isc_boolean_t done = ISC_FALSE;
isc_result_t result;
- isc_uint32_t nsttl = 0;
+ uint32_t nsttl = 0;
unsigned int count, nlabels;
dns_rdataset_init(&rdataset);
unsigned char orig_salt[255];
size_t orig_saltlen;
dns_hash_t orig_hash;
- isc_uint16_t orig_iter;
+ uint16_t orig_iter;
dns_db_currentversion(gdb, &ver);
dns_rdataset_init(&rdataset);
print_stats(isc_time_t *timer_start, isc_time_t *timer_finish,
isc_time_t *sign_start, isc_time_t *sign_finish)
{
- isc_uint64_t time_us; /* Time in microseconds */
- isc_uint64_t time_ms; /* Time in milliseconds */
- isc_uint64_t sig_ms; /* Signatures per millisecond */
+ uint64_t time_us; /* Time in microseconds */
+ uint64_t time_ms; /* Time in milliseconds */
+ uint64_t sig_ms; /* Signatures per millisecond */
FILE *out = output_stdout ? stderr : stdout;
fprintf(out, "Signatures generated: %10u\n", nsigned);
(unsigned int) (time_ms / 1000),
(unsigned int) (time_ms % 1000));
if (time_us > 0) {
- sig_ms = ((isc_uint64_t)nsigned * 1000000000) / time_us;
+ sig_ms = ((uint64_t)nsigned * 1000000000) / time_us;
fprintf(out, "Signatures per second: %7u.%03u\n",
(unsigned int) sig_ms / 1000,
(unsigned int) sig_ms % 1000);
case 'n':
endp = NULL;
ntasks = strtol(isc_commandline_argument, &endp, 0);
- if (*endp != '\0' || ntasks > ISC_INT32_MAX)
+ if (*endp != '\0' || ntasks > INT32_MAX)
fatal("number of cpus must be numeric");
break;
#include <config.h>
+#include <inttypes.h>
#include <stdlib.h>
#ifdef _WIN32
static isc_heap_t *expected_chains, *found_chains;
struct nsec3_chain_fixed {
- isc_uint8_t hash;
- isc_uint8_t salt_length;
- isc_uint8_t next_length;
- isc_uint16_t iterations;
+ uint8_t hash;
+ uint8_t salt_length;
+ uint8_t next_length;
+ uint16_t iterations;
/* unsigned char salt[0]; */
/* unsigned char owner[0]; */
/* unsigned char next[0]; */
}
isc_stdtime_t
-strtotime(const char *str, isc_int64_t now, isc_int64_t base,
+strtotime(const char *str, int64_t now, int64_t base,
isc_boolean_t *setp)
{
- isc_int64_t val, offset;
+ int64_t val, offset;
isc_result_t result;
const char *orig = str;
char *endp;
isc_boolean_t conflict = ISC_FALSE;
dns_dnsseckeylist_t matchkeys;
dns_dnsseckey_t *key = NULL;
- isc_uint16_t id, oldid;
- isc_uint32_t rid, roldid;
+ uint16_t id, oldid;
+ uint32_t rid, roldid;
dns_secalg_t alg;
char filename[ISC_DIR_NAMEMAX];
isc_buffer_t fileb;
isc_boolean_t
is_delegation(dns_db_t *db, dns_dbversion_t *ver, dns_name_t *origin,
- dns_name_t *name, dns_dbnode_t *node, isc_uint32_t *ttlp)
+ dns_name_t *name, dns_dbnode_t *node, uint32_t *ttlp)
{
dns_rdataset_t nsset;
isc_result_t result;
#ifndef DNSSECTOOL_H
#define DNSSECTOOL_H 1
+#include <inttypes.h>
+
#include <isc/log.h>
#include <isc/stdtime.h>
#include <dns/rdatastruct.h>
dns_ttl_t strtottl(const char *str);
isc_stdtime_t
-strtotime(const char *str, isc_int64_t now, isc_int64_t base,
+strtotime(const char *str, int64_t now, int64_t base,
isc_boolean_t *setp);
dns_rdataclass_t
isc_boolean_t
is_delegation(dns_db_t *db, dns_dbversion_t *ver, dns_name_t *origin,
- dns_name_t *name, dns_dbnode_t *node, isc_uint32_t *ttlp);
+ dns_name_t *name, dns_dbnode_t *node, uint32_t *ttlp);
/*%
* Return ISC_TRUE if version 'ver' of database 'db' contains a DNAME RRset at
#include <config.h>
+#include <inttypes.h>
+
#include <isc/aes.h>
#include <isc/formatcheck.h>
#include <isc/hmacsha.h>
isc_socket_t *sock);
static inline isc_boolean_t
allowed(isc_netaddr_t *addr, dns_name_t *signer, isc_netaddr_t *ecs_addr,
- isc_uint8_t ecs_addrlen, isc_uint8_t *ecs_scope, dns_acl_t *acl);
-static void compute_cookie(ns_client_t *client, isc_uint32_t when,
- isc_uint32_t nonce, const unsigned char *secret,
+ uint8_t ecs_addrlen, uint8_t *ecs_scope, dns_acl_t *acl);
+static void compute_cookie(ns_client_t *client, uint32_t when,
+ uint32_t nonce, const unsigned char *secret,
isc_buffer_t *buf);
void
static isc_result_t
client_allocsendbuf(ns_client_t *client, isc_buffer_t *buffer,
- isc_buffer_t *tcpbuffer, isc_uint32_t length,
+ isc_buffer_t *tcpbuffer, uint32_t length,
unsigned char *sendbuf, unsigned char **datap)
{
unsigned char *data;
- isc_uint32_t bufsize;
+ uint32_t bufsize;
isc_result_t result;
INSIST(datap != NULL);
} else {
isc_buffer_init(buffer, data, TCP_BUFFER_SIZE);
INSIST(length <= 0xffff);
- isc_buffer_putuint16(buffer, (isc_uint16_t)length);
+ isc_buffer_putuint16(buffer, (uint16_t)length);
}
} else {
data = sendbuf;
if (TCP_CLIENT(client)) {
isc_buffer_usedregion(&buffer, &r);
- isc_buffer_putuint16(&tcpbuffer, (isc_uint16_t) r.length);
+ isc_buffer_putuint16(&tcpbuffer, (uint16_t) r.length);
isc_buffer_add(&tcpbuffer, r.length);
#ifdef HAVE_DNSTAP
if (client->view != NULL) {
*/
isc_time_t expire;
isc_interval_t i;
- isc_uint32_t flags = 0;
+ uint32_t flags = 0;
if ((message->flags & DNS_MESSAGEFLAG_CD) != 0)
flags = NS_FAILCACHE_CD;
isc_result_t result;
dns_view_t *view;
dns_resolver_t *resolver;
- isc_uint16_t udpsize;
+ uint16_t udpsize;
dns_ednsopt_t ednsopts[DNS_EDNSOPTIONS];
int count = 0;
unsigned int flags;
INSIST(count < DNS_EDNSOPTIONS);
ednsopts[count].code = DNS_OPT_NSID;
- ednsopts[count].length = (isc_uint16_t)strlen(nsidp);
+ ednsopts[count].length = (uint16_t)strlen(nsidp);
ednsopts[count].value = (unsigned char *)nsidp;
count++;
}
if ((client->attributes & NS_CLIENTATTR_WANTCOOKIE) != 0) {
isc_buffer_t buf;
isc_stdtime_t now;
- isc_uint32_t nonce;
+ uint32_t nonce;
isc_buffer_init(&buf, cookie, sizeof(cookie));
isc_stdtime_get(&now);
client->ecs_addr.family == AF_UNSPEC))
{
isc_buffer_t buf;
- isc_uint8_t addr[16];
- isc_uint32_t plen, addrl;
- isc_uint16_t family;
+ uint8_t addr[16];
+ uint32_t plen, addrl;
+ uint16_t family;
/* Add CLIENT-SUBNET option. */
static inline isc_boolean_t
allowed(isc_netaddr_t *addr, dns_name_t *signer,
- isc_netaddr_t *ecs_addr, isc_uint8_t ecs_addrlen,
- isc_uint8_t *ecs_scope, dns_acl_t *acl)
+ isc_netaddr_t *ecs_addr, uint8_t ecs_addrlen,
+ uint8_t *ecs_scope, dns_acl_t *acl)
{
int match;
isc_result_t result;
}
static void
-compute_cookie(ns_client_t *client, isc_uint32_t when, isc_uint32_t nonce,
+compute_cookie(ns_client_t *client, uint32_t when, uint32_t nonce,
const unsigned char *secret, isc_buffer_t *buf)
{
switch (ns_g_server->cookiealg) {
unsigned char dbuf[COOKIE_SIZE];
unsigned char *old;
isc_stdtime_t now;
- isc_uint32_t when;
- isc_uint32_t nonce;
+ uint32_t when;
+ uint32_t nonce;
isc_buffer_t db;
/*
static isc_result_t
process_ecs(ns_client_t *client, isc_buffer_t *buf, size_t optlen) {
- isc_uint16_t family;
- isc_uint8_t addrlen, addrbytes, scope, *paddr;
+ uint16_t family;
+ uint8_t addrlen, addrbytes, scope, *paddr;
isc_netaddr_t caddr;
/*
return (DNS_R_OPTERR);
}
- paddr = (isc_uint8_t *) &caddr.type;
+ paddr = (uint8_t *) &caddr.type;
if (addrbytes != 0U) {
memmove(paddr, isc_buffer_current(buf), addrbytes);
isc_buffer_forward(buf, addrbytes);
optlen -= addrbytes;
if ((addrlen % 8) != 0) {
- isc_uint8_t bits = ~0U << (8 - (addrlen % 8));
+ uint8_t bits = ~0U << (8 - (addrlen % 8));
bits &= paddr[addrbytes - 1];
if (bits != paddr[addrbytes - 1])
return (DNS_R_OPTERR);
client->keytag = isc_mem_get(client->mctx, optlen);
if (client->keytag != NULL) {
- client->keytag_len = (isc_uint16_t)optlen;
+ client->keytag_len = (uint16_t)optlen;
memmove(client->keytag, isc_buffer_current(buf), optlen);
}
isc_buffer_forward(buf, (unsigned int)optlen);
dns_rdata_t rdata;
isc_buffer_t optbuf;
isc_result_t result;
- isc_uint16_t optcode;
- isc_uint16_t optlen;
+ uint16_t optcode;
+ uint16_t optlen;
/*
* Set the client's UDP buffer size.
/*
* Get the flags out of the OPT record.
*/
- client->extflags = (isc_uint16_t)(opt->ttl & 0xFFFF);
+ client->extflags = (uint16_t)(opt->ttl & 0xFFFF);
/*
* Do we understand this version of EDNS?
{
dns_name_t *tsig = NULL;
isc_netaddr_t *addr = NULL;
- isc_uint8_t *scope = NULL;
+ uint8_t *scope = NULL;
sigresult = dns_message_rechecksig(client->message,
view);
*/
if (client->udpsize > 512) {
dns_peer_t *peer = NULL;
- isc_uint16_t udpsize = view->maxudp;
+ uint16_t udpsize = view->maxudp;
(void) dns_peerlist_peerbyaddr(view->peers, &netaddr, &peer);
if (peer != NULL)
dns_peer_getmaxudp(peer, &udpsize);
isc_result_t result;
isc_netaddr_t tmpnetaddr;
isc_netaddr_t *ecs_addr = NULL;
- isc_uint8_t ecs_addrlen = 0;
+ uint8_t ecs_addrlen = 0;
int match;
if (acl == NULL) {
#include <config.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <isc/buffer.h>
ns_config_getiplist(const cfg_obj_t *config, const cfg_obj_t *list,
in_port_t defport, isc_mem_t *mctx,
isc_sockaddr_t **addrsp, isc_dscp_t **dscpsp,
- isc_uint32_t *countp)
+ uint32_t *countp)
{
int count, i = 0;
const cfg_obj_t *addrlist;
portobj = cfg_tuple_get(list, "port");
if (cfg_obj_isuint32(portobj)) {
- isc_uint32_t val = cfg_obj_asuint32(portobj);
- if (val > ISC_UINT16_MAX) {
+ uint32_t val = cfg_obj_asuint32(portobj);
+ if (val > UINT16_MAX) {
cfg_obj_log(portobj, ns_g_lctx, ISC_LOG_ERROR,
"port '%u' out of range", val);
return (ISC_R_RANGE);
void
ns_config_putiplist(isc_mem_t *mctx, isc_sockaddr_t **addrsp,
- isc_dscp_t **dscpsp, isc_uint32_t count)
+ isc_dscp_t **dscpsp, uint32_t count)
{
INSIST(addrsp != NULL && *addrsp != NULL);
INSIST(dscpsp == NULL || *dscpsp != NULL);
ns_config_getipandkeylist(const cfg_obj_t *config, const cfg_obj_t *list,
isc_mem_t *mctx, dns_ipkeylist_t *ipkl)
{
- isc_uint32_t addrcount = 0, dscpcount = 0, keycount = 0, i = 0;
- isc_uint32_t listcount = 0, l = 0, j;
- isc_uint32_t stackcount = 0, pushed = 0;
+ uint32_t addrcount = 0, dscpcount = 0, keycount = 0, i = 0;
+ uint32_t listcount = 0, l = 0, j;
+ uint32_t stackcount = 0, pushed = 0;
isc_result_t result;
const cfg_listelt_t *element;
const cfg_obj_t *addrlist;
dscpobj = cfg_tuple_get(list, "dscp");
if (cfg_obj_isuint32(portobj)) {
- isc_uint32_t val = cfg_obj_asuint32(portobj);
- if (val > ISC_UINT16_MAX) {
+ uint32_t val = cfg_obj_asuint32(portobj);
+ if (val > UINT16_MAX) {
cfg_obj_log(portobj, ns_g_lctx, ISC_LOG_ERROR,
"port '%u' out of range", val);
result = ISC_R_RANGE;
/* Grow lists? */
if (listcount == l) {
void * tmp;
- isc_uint32_t newlen = listcount + 16;
+ uint32_t newlen = listcount + 16;
size_t newsize, oldsize;
newsize = newlen * sizeof(*lists);
/* Grow stack? */
if (stackcount == pushed) {
void * tmp;
- isc_uint32_t newlen = stackcount + 16;
+ uint32_t newlen = stackcount + 16;
size_t newsize, oldsize;
newsize = newlen * sizeof(*stack);
if (i == addrcount) {
void * tmp;
- isc_uint32_t newlen = addrcount + 16;
+ uint32_t newlen = addrcount + 16;
size_t newsize, oldsize;
newsize = newlen * sizeof(isc_sockaddr_t);
result = ns_config_get(maps, "port", &portobj);
INSIST(result == ISC_R_SUCCESS);
- if (cfg_obj_asuint32(portobj) >= ISC_UINT16_MAX) {
+ if (cfg_obj_asuint32(portobj) >= UINT16_MAX) {
cfg_obj_log(portobj, ns_g_lctx, ISC_LOG_ERROR,
"port '%u' out of range",
cfg_obj_asuint32(portobj));
enum { hmacnone, hmacmd5, hmacsha1, hmacsha224,
hmacsha256, hmacsha384, hmacsha512 } hmac;
unsigned int type;
- isc_uint16_t size;
+ uint16_t size;
} algorithms[] = {
#ifndef PK11_MD5_DISABLE
{ "hmac-md5", hmacmd5, DST_ALG_HMACMD5, 128 },
isc_result_t
ns_config_getkeyalgorithm(const char *str, dns_name_t **name,
- isc_uint16_t *digestbits)
+ uint16_t *digestbits)
{
return (ns_config_getkeyalgorithm2(str, name, NULL, digestbits));
}
isc_result_t
ns_config_getkeyalgorithm2(const char *str, dns_name_t **name,
- unsigned int *typep, isc_uint16_t *digestbits)
+ unsigned int *typep, uint16_t *digestbits)
{
int i;
size_t len = 0;
- isc_uint16_t bits;
+ uint16_t bits;
isc_result_t result;
for (i = 0; algorithms[i].str != NULL; i++) {
#include <config.h>
+#include <inttypes.h>
+
#include <isc/base64.h>
#include <isc/buffer.h>
#include <isc/event.h>
struct controlkey {
char * keyname;
- isc_uint32_t algorithm;
+ uint32_t algorithm;
isc_region_t secret;
ISC_LINK(controlkey_t) link;
};
isc_timer_t * timer;
isc_buffer_t * buffer;
controllistener_t * listener;
- isc_uint32_t nonce;
+ uint32_t nonce;
ISC_LINK(controlconnection_t) link;
};
controlkeylist_t keys;
controlconnectionlist_t connections;
isc_sockettype_t type;
- isc_uint32_t perm;
- isc_uint32_t owner;
- isc_uint32_t group;
+ uint32_t perm;
+ uint32_t owner;
+ uint32_t group;
isc_boolean_t readonly;
ISC_LINK(controllistener_t) link;
};
controlkey_t *key;
isccc_sexpr_t *request = NULL;
isccc_sexpr_t *response = NULL;
- isc_uint32_t algorithm;
+ uint32_t algorithm;
isccc_region_t secret;
isc_stdtime_t now;
isc_buffer_t b;
isccc_sexpr_t *_ctrl;
isccc_time_t sent;
isccc_time_t exp;
- isc_uint32_t nonce;
+ uint32_t nonce;
isccc_sexpr_t *data;
REQUIRE(event->ev_type == ISCCC_EVENT_CCMSG);
socktext, isc_result_totext(result));
if (result == ISC_R_SUCCESS && type == isc_sockettype_unix) {
- isc_uint32_t perm, owner, group;
+ uint32_t perm, owner, group;
perm = cfg_obj_asuint32(cfg_tuple_get(control, "perm"));
owner = cfg_obj_asuint32(cfg_tuple_get(control, "owner"));
group = cfg_obj_asuint32(cfg_tuple_get(control, "group"));
#include "config.h"
+#include <inttypes.h>
+
#include <named/fuzz.h>
#ifdef ENABLE_AFL
*** Imports
***/
+#include <inttypes.h>
+
#include <isc/buffer.h>
#include <isc/magic.h>
#include <isc/stdtime.h>
isc_socketevent_t * recvevent;
unsigned char * recvbuf;
dns_rdataset_t * opt;
- isc_uint16_t udpsize;
- isc_uint16_t extflags;
- isc_int16_t ednsversion; /* -1 noedns */
+ uint16_t udpsize;
+ uint16_t extflags;
+ int16_t ednsversion; /* -1 noedns */
void (*next)(ns_client_t *);
void (*shutdown)(void *arg, isc_result_t result);
void *shutdown_arg;
isc_sockaddr_t destsockaddr;
isc_netaddr_t ecs_addr; /*%< EDNS client subnet */
- isc_uint8_t ecs_addrlen;
- isc_uint8_t ecs_scope;
+ uint8_t ecs_addrlen;
+ uint8_t ecs_scope;
struct in6_pktinfo pktinfo;
isc_dscp_t dscp;
ISC_LINK(ns_client_t) rlink;
ISC_QLINK(ns_client_t) ilink;
unsigned char cookie[8];
- isc_uint32_t expire;
+ uint32_t expire;
unsigned char *keytag;
- isc_uint16_t keytag_len;
+ uint16_t keytag_len;
};
typedef ISC_QUEUE(ns_client_t) client_queue_t;
/*! \file */
+#include <inttypes.h>
+
#include <isccfg/cfg.h>
#include <dns/types.h>
ns_config_getiplist(const cfg_obj_t *config, const cfg_obj_t *list,
in_port_t defport, isc_mem_t *mctx,
isc_sockaddr_t **addrsp, isc_dscp_t **dscpsp,
- isc_uint32_t *countp);
+ uint32_t *countp);
void
ns_config_putiplist(isc_mem_t *mctx, isc_sockaddr_t **addrsp,
- isc_dscp_t **dscpsp, isc_uint32_t count);
+ isc_dscp_t **dscpsp, uint32_t count);
isc_result_t
ns_config_getipandkeylist(const cfg_obj_t *config, const cfg_obj_t *list,
isc_result_t
ns_config_getkeyalgorithm(const char *str, dns_name_t **name,
- isc_uint16_t *digestbits);
+ uint16_t *digestbits);
isc_result_t
ns_config_getkeyalgorithm2(const char *str, dns_name_t **name,
- unsigned int *typep, isc_uint16_t *digestbits);
+ unsigned int *typep, uint16_t *digestbits);
isc_result_t
ns_config_getdscp(const cfg_obj_t *config, isc_dscp_t *dscpp);
"/resolv.conf");
EXTERN isc_boolean_t ns_g_conffileset INIT(ISC_FALSE);
EXTERN isc_boolean_t lwresd_g_useresolvconf INIT(ISC_FALSE);
-EXTERN isc_uint16_t ns_g_udpsize INIT(4096);
+EXTERN uint16_t ns_g_udpsize INIT(4096);
EXTERN cfg_aclconfctx_t * ns_g_aclconfctx INIT(NULL);
/*
* Received data info.
*/
unsigned char buffer[LWRES_RECVLENGTH]; /*%< receive buffer */
- isc_uint32_t recvlength; /*%< length recv'd */
+ uint32_t recvlength; /*%< length recv'd */
lwres_lwpacket_t pkt;
/*%
* isn't our receive buffer) it will be freed to the lwres_context_t.
*/
unsigned char *sendbuf;
- isc_uint32_t sendlength;
+ uint32_t sendlength;
isc_buffer_t recv_buffer;
/*%
* we'd need to use "arg" above and allocate/destroy things.
*/
char *aliases[LWRES_MAX_ALIASES];
- isc_uint16_t aliaslen[LWRES_MAX_ALIASES];
+ uint16_t aliaslen[LWRES_MAX_ALIASES];
lwres_addr_t addrs[LWRES_MAX_ADDRS];
};
void ns_lwdclient_processgrbn(ns_lwdclient_t *, lwres_buffer_t *);
void ns_lwdclient_processnoop(ns_lwdclient_t *, lwres_buffer_t *);
-void ns_lwdclient_errorpktsend(ns_lwdclient_t *, isc_uint32_t);
+void ns_lwdclient_errorpktsend(ns_lwdclient_t *, uint32_t);
void ns_lwdclient_log(int level, const char *format, ...)
ISC_FORMAT_PRINTF(2, 3);
/*! \file */
+#include <inttypes.h>
+
#include <isc/log.h>
#include <isc/magic.h>
#include <isc/quota.h>
isc_timer_t * pps_timer;
isc_timer_t * tat_timer;
- isc_uint32_t interface_interval;
- isc_uint32_t heartbeat_interval;
+ uint32_t interface_interval;
+ uint32_t heartbeat_interval;
isc_mutex_t reload_event_lock;
isc_event_t * reload_event;
char *session_keyfile;
dns_name_t *session_keyname;
unsigned int session_keyalg;
- isc_uint16_t session_keybits;
+ uint16_t session_keybits;
isc_boolean_t interface_auto;
unsigned char secret[32]; /*%< Server Cookie Secret */
ns_altsecretlist_t altsecrets;
char * lockfile;
- isc_uint16_t transfer_tcp_message_size;
+ uint16_t transfer_tcp_message_size;
};
struct ns_altsecret {
#include <config.h>
+#include <inttypes.h>
+
#include <isc/file.h>
#include <isc/offset.h>
#include <isc/print.h>
const cfg_obj_t *sizeobj = cfg_tuple_get(fileobj, "size");
const cfg_obj_t *versionsobj =
cfg_tuple_get(fileobj, "versions");
- isc_int32_t versions = ISC_LOG_ROLLNEVER;
+ int32_t versions = ISC_LOG_ROLLNEVER;
isc_offset_t size = 0;
- isc_uint64_t maxoffset;
+ uint64_t maxoffset;
/*
* isc_offset_t is a signed integer type, so the maximum
* size we use, set the reply bit, and recompute any security information.
*/
void
-ns_lwdclient_errorpktsend(ns_lwdclient_t *client, isc_uint32_t _result) {
+ns_lwdclient_errorpktsend(ns_lwdclient_t *client, uint32_t _result) {
isc_result_t result;
int lwres;
isc_region_t r;
add_alias(ns_lwdclient_t *client) {
isc_buffer_t b;
isc_result_t result;
- isc_uint16_t naliases;
+ uint16_t naliases;
b = client->recv_buffer;
isc_region_t r;
isc_buffer_t b;
lwres_gnbaresponse_t *gnba;
- isc_uint16_t naliases;
+ uint16_t naliases;
UNUSED(task);
lwres_uint16_t *lens = NULL, *oldlens = NULL, *newlens = NULL;
dns_rdatasetiter_t *iter = NULL;
dns_rdataset_t set;
- dns_ttl_t ttl = ISC_INT32_MAX;
+ dns_ttl_t ttl = INT32_MAX;
lwres_uint32_t flags = LWRDATA_VALIDATED;
isc_result_t result = ISC_R_NOMEMORY;
char socktext[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_t *addrs = NULL;
ns_lwresd_t *lwresd = NULL;
- isc_uint32_t count = 0;
+ uint32_t count = 0;
REQUIRE(mctx != NULL);
REQUIRE(config != NULL);
CHECK(configure_listener(&address, lwresd, mctx,
&newlisteners));
} else {
- isc_uint32_t i;
+ uint32_t i;
CHECK(ns_config_getiplist(config, listenerslist,
port, mctx, &addrs, NULL,
#include <config.h>
#include <ctype.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
-#include <inttypes.h>
#include <isc/app.h>
#include <isc/backtrace.h>
client->query.authdbset = ISC_FALSE;
client->query.isreferral = ISC_FALSE;
client->query.dns64_options = 0;
- client->query.dns64_ttl = ISC_UINT32_MAX;
+ client->query.dns64_ttl = UINT32_MAX;
client->query.root_key_sentinel_keyid = 0;
client->query.root_key_sentinel_is_ta = ISC_FALSE;
client->query.root_key_sentinel_not_ta = ISC_FALSE;
dns_rdatalist_init(dns64_rdatalist);
dns64_rdatalist->rdclass = dns_rdataclass_in;
dns64_rdatalist->type = dns_rdatatype_aaaa;
- if (client->query.dns64_ttl != ISC_UINT32_MAX)
+ if (client->query.dns64_ttl != UINT32_MAX)
dns64_rdatalist->ttl = ISC_MIN(rdataset->ttl,
client->query.dns64_ttl);
else
if (result != ISC_R_SUCCESS)
goto cleanup;
- if (override_ttl != ISC_UINT32_MAX &&
+ if (override_ttl != UINT32_MAX &&
override_ttl < rdataset->ttl) {
rdataset->ttl = override_ttl;
if (sigrdataset != NULL)
{
unsigned char salt[256];
size_t salt_length;
- isc_uint16_t iterations;
+ uint16_t iterations;
isc_result_t result;
unsigned int dboptions;
dns_fixedname_t fixed;
}
#endif
-static isc_uint32_t
+static uint32_t
dns64_ttl(dns_db_t *db, dns_dbversion_t *version) {
dns_dbnode_t *node = NULL;
dns_rdata_soa_t soa;
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_t rdataset;
isc_result_t result;
- isc_uint32_t ttl = ISC_UINT32_MAX;
+ uint32_t ttl = UINT32_MAX;
dns_rdataset_init(&rdataset);
dns_section_t section;
dns_ttl_t ttl;
isc_boolean_t failcache;
- isc_uint32_t flags;
+ uint32_t flags;
#ifdef WANT_QUERYTRACE
char mbuf[BUFSIZ];
char qbuf[DNS_NAME_FORMATSIZE];
section = nxrewrite ? DNS_SECTION_ADDITIONAL :
DNS_SECTION_AUTHORITY;
- result = query_addsoa(client, db, version, ISC_UINT32_MAX,
+ result = query_addsoa(client, db, version, UINT32_MAX,
associated, section);
if (result != ISC_R_SUCCESS) {
QUERY_ERROR(result);
associated = dns_rdataset_isassociated(rdataset);
section = nxrewrite ? DNS_SECTION_ADDITIONAL :
DNS_SECTION_AUTHORITY;
- ttl = ISC_UINT32_MAX;
+ ttl = UINT32_MAX;
if (!nxrewrite && qtype == dns_rdatatype_soa &&
zone != NULL && dns_zone_getzeronosoattl(zone))
ttl = 0;
if (dns_zone_gettype(mayberaw) == dns_zone_slave) {
isc_time_t expiretime;
- isc_uint32_t secs;
+ uint32_t secs;
dns_zone_getexpiretime(zone, &expiretime);
secs = isc_time_seconds(&expiretime);
if (secs >= client->now &&
sizeof(classname));
if (client->query.qtype == dns_rdatatype_dnskey) {
- isc_uint16_t keytags = client->keytag_len / 2;
+ uint16_t keytags = client->keytag_len / 2;
size_t len = taglen = sizeof("65000") * keytags + 1;
char *cp = tags = isc_mem_get(client->mctx, taglen);
int i = 0;
if (tags != NULL) {
while (keytags-- > 0U) {
int n;
- isc_uint16_t keytag;
+ uint16_t keytag;
keytag = (client->keytag[i * 2] << 8) |
client->keytag[i * 2 + 1];
n = snprintf(cp, len, " %u", keytag);
#include <config.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <unistd.h>
#include <limits.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
-#include <inttypes.h>
#include <isc/aes.h>
#include <isc/app.h>
static isc_result_t
ns_listenelt_fromconfig(const cfg_obj_t *listener, const cfg_obj_t *config,
cfg_aclconfctx_t *actx, isc_mem_t *mctx,
- isc_uint16_t family, ns_listenelt_t **target);
+ uint16_t family, ns_listenelt_t **target);
static isc_result_t
ns_listenlist_fromconfig(const cfg_obj_t *listenlist, const cfg_obj_t *config,
cfg_aclconfctx_t *actx, isc_mem_t *mctx,
- isc_uint16_t family, ns_listenlist_t **target);
+ uint16_t family, ns_listenlist_t **target);
static isc_result_t
configure_forward(const cfg_obj_t *config, dns_view_t *view, dns_name_t *origin,
putmem(isc_buffer_t **b, const char *str, size_t len);
static isc_result_t
-putuint8(isc_buffer_t **b, isc_uint8_t val);
+putuint8(isc_buffer_t **b, uint8_t val);
static inline isc_result_t
putnull(isc_buffer_t **b);
{
dns_rdataclass_t viewclass;
dns_rdata_dnskey_t keystruct;
- isc_uint32_t flags, proto, alg;
+ uint32_t flags, proto, alg;
const char *keystr, *keynamestr;
unsigned char keydata[4096];
isc_buffer_t keydatabuf;
CHECKM(ISC_R_RANGE, "key protocol");
if (alg > 0xff)
CHECKM(ISC_R_RANGE, "key algorithm");
- keystruct.flags = (isc_uint16_t)flags;
- keystruct.protocol = (isc_uint8_t)proto;
- keystruct.algorithm = (isc_uint8_t)alg;
+ keystruct.flags = (uint16_t)flags;
+ keystruct.protocol = (uint8_t)proto;
+ keystruct.algorithm = (uint8_t)alg;
isc_buffer_init(&keydatabuf, keydata, sizeof(keydata));
isc_buffer_init(&rrdatabuf, rrdata, sizeof(rrdata));
obj = NULL;
(void)cfg_map_get(cpeer, "edns-udp-size", &obj);
if (obj != NULL) {
- isc_uint32_t udpsize = cfg_obj_asuint32(obj);
+ uint32_t udpsize = cfg_obj_asuint32(obj);
if (udpsize < 512)
udpsize = 512;
if (udpsize > 4096)
udpsize = 4096;
- CHECK(dns_peer_setudpsize(peer, (isc_uint16_t)udpsize));
+ CHECK(dns_peer_setudpsize(peer, (uint16_t)udpsize));
}
obj = NULL;
(void)cfg_map_get(cpeer, "edns-version", &obj);
if (obj != NULL) {
- isc_uint32_t ednsversion = cfg_obj_asuint32(obj);
+ uint32_t ednsversion = cfg_obj_asuint32(obj);
if (ednsversion > 255)
ednsversion = 255;
- CHECK(dns_peer_setednsversion(peer, (isc_uint8_t)ednsversion));
+ CHECK(dns_peer_setednsversion(peer, (uint8_t)ednsversion));
}
obj = NULL;
(void)cfg_map_get(cpeer, "max-udp-size", &obj);
if (obj != NULL) {
- isc_uint32_t udpsize = cfg_obj_asuint32(obj);
+ uint32_t udpsize = cfg_obj_asuint32(obj);
if (udpsize < 512)
udpsize = 512;
if (udpsize > 4096)
udpsize = 4096;
- CHECK(dns_peer_setmaxudp(peer, (isc_uint16_t)udpsize));
+ CHECK(dns_peer_setmaxudp(peer, (uint16_t)udpsize));
}
obj = NULL;
result = dns_secalg_fromtext(&alg, &r);
if (result != ISC_R_SUCCESS) {
- isc_uint8_t ui;
+ uint8_t ui;
result = isc_parse_uint8(&ui, r.base, 10);
alg = ui;
}
cache_sharable(dns_view_t *originview, dns_view_t *view,
isc_boolean_t new_zero_no_soattl,
unsigned int new_cleaning_interval,
- isc_uint64_t new_max_cache_size)
+ uint64_t new_max_cache_size)
{
/*
* If the cache cannot even reused for the same view, it cannot be
isc_result_t result;
unsigned int cleaning_interval;
size_t max_cache_size;
- isc_uint32_t max_cache_size_percent = 0;
+ uint32_t max_cache_size_percent = 0;
size_t max_acache_size;
size_t max_adb_size;
- isc_uint32_t lame_ttl, fail_ttl;
+ uint32_t lame_ttl, fail_ttl;
dns_tsig_keyring_t *ring = NULL;
dns_view_t *pview = NULL; /* Production view */
isc_mem_t *cmctx = NULL, *hmctx = NULL;
const char *str;
const char *cachename = NULL;
dns_order_t *order = NULL;
- isc_uint32_t udpsize;
- isc_uint32_t maxbits;
+ uint32_t udpsize;
+ uint32_t maxbits;
unsigned int resopts = 0;
dns_zone_t *zone = NULL;
- isc_uint32_t max_clients_per_query;
+ uint32_t max_clients_per_query;
isc_boolean_t empty_zones_enable;
const cfg_obj_t *disablelist = NULL;
isc_stats_t *resstats = NULL;
}
if (max_cache_size == SIZE_AS_PERCENT) {
- isc_uint64_t totalphys = isc_meminfo_totalphys();
+ uint64_t totalphys = isc_meminfo_totalphys();
max_cache_size =
(size_t) (totalphys * max_cache_size_percent/100);
"- setting to %" PRIu64 "MB "
"(out of %" PRIu64 "MB)",
max_cache_size_percent,
- (isc_uint64_t)(max_cache_size / (1024*1024)),
+ (uint64_t)(max_cache_size / (1024*1024)),
totalphys / (1024*1024));
}
}
* Set up ADB quotas
*/
{
- isc_uint32_t fps, freq;
+ uint32_t fps, freq;
double low, high, discount;
obj = NULL;
udpsize = 512;
if (udpsize > 4096)
udpsize = 4096;
- dns_resolver_setudpsize(view->resolver, (isc_uint16_t)udpsize);
+ dns_resolver_setudpsize(view->resolver, (uint16_t)udpsize);
/*
* Set the maximum UDP response size.
if (alternates != NULL) {
portobj = cfg_tuple_get(alternates, "port");
if (cfg_obj_isuint32(portobj)) {
- isc_uint32_t val = cfg_obj_asuint32(portobj);
- if (val > ISC_UINT16_MAX) {
+ uint32_t val = cfg_obj_asuint32(portobj);
+ if (val > UINT16_MAX) {
cfg_obj_log(portobj, ns_g_lctx, ISC_LOG_ERROR,
"port '%u' out of range", val);
return (ISC_R_RANGE);
portobj = cfg_tuple_get(alternate, "port");
if (cfg_obj_isuint32(portobj)) {
- isc_uint32_t val = cfg_obj_asuint32(portobj);
- if (val > ISC_UINT16_MAX) {
+ uint32_t val = cfg_obj_asuint32(portobj);
+ if (val > UINT16_MAX) {
cfg_obj_log(portobj, ns_g_lctx,
ISC_LOG_ERROR,
"port '%u' out of range",
if (forwarders != NULL) {
portobj = cfg_tuple_get(forwarders, "port");
if (cfg_obj_isuint32(portobj)) {
- isc_uint32_t val = cfg_obj_asuint32(portobj);
- if (val > ISC_UINT16_MAX) {
+ uint32_t val = cfg_obj_asuint32(portobj);
+ if (val > UINT16_MAX) {
cfg_obj_log(portobj, ns_g_lctx, ISC_LOG_ERROR,
"port '%u' out of range", val);
return (ISC_R_RANGE);
static int
cid(const void *a, const void *b) {
- const isc_uint16_t ida = *(const isc_uint16_t *)a;
- const isc_uint16_t idb = *(const isc_uint16_t *)b;
+ const uint16_t ida = *(const uint16_t *)a;
+ const uint16_t idb = *(const uint16_t *)b;
if (ida < idb)
return (-1);
else if (ida > idb)
dns_keynode_t *firstnode = keynode;
dns_keynode_t *nextnode;
unsigned int i, n = 0;
- isc_uint16_t ids[12];
+ uint16_t ids[12];
isc_textregion_t r;
char label[64];
int m;
generate_session_key(const char *filename, const char *keynamestr,
dns_name_t *keyname, const char *algstr,
dns_name_t *algname, unsigned int algtype,
- isc_uint16_t bits, isc_mem_t *mctx,
+ uint16_t bits, isc_mem_t *mctx,
dns_tsigkey_t **tsigkeyp)
{
isc_result_t result = ISC_R_SUCCESS;
dns_fixedname_t fname;
dns_name_t *keyname, *algname;
isc_buffer_t buffer;
- isc_uint16_t bits;
+ uint16_t bits;
const cfg_obj_t *obj;
isc_boolean_t need_deleteold = ISC_FALSE;
isc_boolean_t need_createnew = ISC_FALSE;
const cfg_obj_t *nz = NULL;
const cfg_obj_t *obj = NULL;
int i = 0;
- isc_uint64_t mapsize = 0ULL;
+ uint64_t mapsize = 0ULL;
REQUIRE(config != NULL);
isc_portset_t *v6portset = NULL;
isc_resourcevalue_t nfiles;
isc_result_t result, tresult;
- isc_uint32_t heartbeat_interval;
- isc_uint32_t interface_interval;
- isc_uint32_t reserved;
- isc_uint32_t udpsize;
- isc_uint32_t transfer_message_size;
+ uint32_t heartbeat_interval;
+ uint32_t interface_interval;
+ uint32_t reserved;
+ uint32_t udpsize;
+ uint32_t transfer_message_size;
ns_cache_t *nsc;
ns_cachelist_t cachelist, tmpcachelist;
ns_altsecret_t *altsecret;
ns_altsecretlist_t altsecrets, tmpaltsecrets;
unsigned int maxsocks;
- isc_uint32_t softquota = 0;
+ uint32_t softquota = 0;
ISC_LIST_INIT(viewlist);
ISC_LIST_INIT(builtin_viewlist);
if (udpsize > 4096) {
udpsize = 4096;
}
- ns_g_udpsize = (isc_uint16_t)udpsize;
+ ns_g_udpsize = (uint16_t)udpsize;
/* Set the transfer message size for TCP */
obj = NULL;
} else if (transfer_message_size > 65535) {
transfer_message_size = 65535;
}
- server->transfer_tcp_message_size = (isc_uint16_t) transfer_message_size;
+ server->transfer_tcp_message_size = (uint16_t) transfer_message_size;
/*
* Configure the zone manager.
static isc_result_t
ns_listenlist_fromconfig(const cfg_obj_t *listenlist, const cfg_obj_t *config,
cfg_aclconfctx_t *actx, isc_mem_t *mctx,
- isc_uint16_t family, ns_listenlist_t **target)
+ uint16_t family, ns_listenlist_t **target)
{
isc_result_t result;
const cfg_listelt_t *element;
static isc_result_t
ns_listenelt_fromconfig(const cfg_obj_t *listener, const cfg_obj_t *config,
cfg_aclconfctx_t *actx, isc_mem_t *mctx,
- isc_uint16_t family, ns_listenelt_t **target)
+ uint16_t family, ns_listenelt_t **target)
{
isc_result_t result;
const cfg_obj_t *portobj, *dscpobj;
return (result);
}
} else {
- if (cfg_obj_asuint32(portobj) >= ISC_UINT16_MAX) {
+ if (cfg_obj_asuint32(portobj) >= UINT16_MAX) {
cfg_obj_log(portobj, ns_g_lctx, ISC_LOG_ERROR,
"port value '%u' is out of range",
cfg_obj_asuint32(portobj));
isc_result_t result;
dns_zone_t *zone = NULL;
dns_zonetype_t type;
- isc_uint16_t keyopts;
+ uint16_t keyopts;
isc_boolean_t fullsign = ISC_FALSE;
char *ptr;
int i, n;
union {
unsigned char rnd[256];
- isc_uint32_t rnd32[64];
+ uint32_t rnd32[64];
} rnd;
unsigned char text[512 + 1];
isc_region_t r;
if (saltlen > 256U)
return (ISC_R_RANGE);
- n = (int) (saltlen + sizeof(isc_uint32_t) - 1) / sizeof(isc_uint32_t);
+ n = (int) (saltlen + sizeof(uint32_t) - 1) / sizeof(uint32_t);
for (i = 0; i < n; i++)
isc_random_get(&rnd.rnd32[i]);
isc_boolean_t list = ISC_FALSE, clear = ISC_FALSE;
isc_boolean_t chain = ISC_FALSE;
isc_boolean_t setserial = ISC_FALSE;
- isc_uint32_t serial = 0;
+ uint32_t serial = 0;
char keystr[DNS_SECALG_FORMATSIZE + 7]; /* <5-digit keyid>/<alg> */
unsigned short hash = 0, flags = 0, iter = 0, saltlen = 0;
unsigned char salt[255];
(void) putstr(text, "request queued");
(void) putnull(text);
} else if (chain) {
- CHECK(dns_zone_setnsec3param(zone, (isc_uint8_t)hash,
- (isc_uint8_t)flags, iter,
- (isc_uint8_t)saltlen, salt,
+ CHECK(dns_zone_setnsec3param(zone, (uint8_t)hash,
+ (uint8_t)flags, iter,
+ (uint8_t)saltlen, salt,
ISC_TRUE));
(void) putstr(text, "nsec3param request queued");
(void) putnull(text);
}
static isc_result_t
-putuint8(isc_buffer_t **b, isc_uint8_t val) {
+putuint8(isc_buffer_t **b, uint8_t val) {
isc_result_t result;
result = isc_buffer_reserve(b, 1);
dns_zone_t *zone = NULL, *raw = NULL, *mayberaw = NULL;
const char *type, *file;
char zonename[DNS_NAME_FORMATSIZE];
- isc_uint32_t serial, signed_serial, nodes;
+ uint32_t serial, signed_serial, nodes;
char serbuf[16], sserbuf[16], nodebuf[16];
char resignbuf[DNS_NAME_FORMATSIZE + DNS_RDATATYPE_FORMATSIZE + 2];
char lbuf[ISC_FORMATHTTPTIMESTAMP_SIZE];
dns_rdataset_t *kdset = NULL;
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_keydata_t kd;
- isc_uint32_t ttl;
+ uint32_t ttl;
dns_rriterator_current(&rrit, &name, &ttl, &kdset, NULL);
if (kdset == NULL || kdset->type != dns_rdatatype_keydata ||
void *arg; /* type dependent argument */
int ncounters; /* for general statistics */
int *counterindices; /* for general statistics */
- isc_uint64_t *countervalues; /* for general statistics */
+ uint64_t *countervalues; /* for general statistics */
isc_result_t result;
} stats_dumparg_t;
* Dump callback functions.
*/
static void
-generalstat_dump(isc_statscounter_t counter, isc_uint64_t val, void *arg) {
+generalstat_dump(isc_statscounter_t counter, uint64_t val, void *arg) {
stats_dumparg_t *dumparg = arg;
REQUIRE(counter < dumparg->ncounters);
static isc_result_t
dump_counters(isc_stats_t *stats, isc_statsformat_t type, void *arg,
const char *category, const char **desc, int ncounters,
- int *indices, isc_uint64_t *values, int options)
+ int *indices, uint64_t *values, int options)
{
int i, idx;
- isc_uint64_t value;
+ uint64_t value;
stats_dumparg_t dumparg;
FILE *fp;
#ifdef HAVE_LIBXML2
}
static void
-rdtypestat_dump(dns_rdatastatstype_t type, isc_uint64_t val, void *arg) {
+rdtypestat_dump(dns_rdatastatstype_t type, uint64_t val, void *arg) {
char typebuf[64];
const char *typestr;
stats_dumparg_t *dumparg = arg;
}
static void
-rdatasetstats_dump(dns_rdatastatstype_t type, isc_uint64_t val, void *arg) {
+rdatasetstats_dump(dns_rdatastatstype_t type, uint64_t val, void *arg) {
stats_dumparg_t *dumparg = arg;
FILE *fp;
char typebuf[64];
}
static void
-opcodestat_dump(dns_opcode_t code, isc_uint64_t val, void *arg) {
+opcodestat_dump(dns_opcode_t code, uint64_t val, void *arg) {
FILE *fp;
isc_buffer_t b;
char codebuf[64];
}
static void
-rcodestat_dump(dns_rcode_t code, isc_uint64_t val, void *arg) {
+rcodestat_dump(dns_rcode_t code, uint64_t val, void *arg) {
FILE *fp;
isc_buffer_t b;
char codebuf[64];
isc_result_t result;
char buf[1024 + 32]; /* sufficiently large for zone name and class */
dns_rdataclass_t rdclass;
- isc_uint32_t serial;
+ uint32_t serial;
xmlTextWriterPtr writer = arg;
isc_stats_t *zonestats;
dns_stats_t *rcvquerystats;
dns_zonestat_level_t statlevel;
- isc_uint64_t nsstat_values[dns_nsstatscounter_max];
+ uint64_t nsstat_values[dns_nsstatscounter_max];
int xmlrc;
stats_dumparg_t dumparg;
const char *ztype;
}
static isc_result_t
-generatexml(ns_server_t *server, isc_uint32_t flags,
+generatexml(ns_server_t *server, uint32_t flags,
int *buflen, xmlChar **buf)
{
char boottime[sizeof "yyyy-mm-ddThh:mm:ss.sssZ"];
dns_view_t *view;
stats_dumparg_t dumparg;
dns_stats_t *cacherrstats;
- isc_uint64_t nsstat_values[dns_nsstatscounter_max];
- isc_uint64_t resstat_values[dns_resstatscounter_max];
- isc_uint64_t adbstat_values[dns_adbstats_max];
- isc_uint64_t zonestat_values[dns_zonestatscounter_max];
- isc_uint64_t sockstat_values[isc_sockstatscounter_max];
- isc_uint64_t udpinsizestat_values[dns_sizecounter_in_max];
- isc_uint64_t udpoutsizestat_values[dns_sizecounter_out_max];
- isc_uint64_t tcpinsizestat_values[dns_sizecounter_in_max];
- isc_uint64_t tcpoutsizestat_values[dns_sizecounter_out_max];
+ uint64_t nsstat_values[dns_nsstatscounter_max];
+ uint64_t resstat_values[dns_resstatscounter_max];
+ uint64_t adbstat_values[dns_adbstats_max];
+ uint64_t zonestat_values[dns_zonestatscounter_max];
+ uint64_t sockstat_values[isc_sockstatscounter_max];
+ uint64_t udpinsizestat_values[dns_sizecounter_in_max];
+ uint64_t udpoutsizestat_values[dns_sizecounter_out_max];
+ uint64_t tcpinsizestat_values[dns_sizecounter_in_max];
+ uint64_t tcpoutsizestat_values[dns_sizecounter_out_max];
#ifdef HAVE_DNSTAP
- isc_uint64_t dnstapstat_values[dns_dnstapcounter_max];
+ uint64_t dnstapstat_values[dns_dnstapcounter_max];
#endif
isc_result_t result;
}
static isc_result_t
-render_xml(isc_uint32_t flags, const char *url, isc_httpdurl_t *urlinfo,
+render_xml(uint32_t flags, const char *url, isc_httpdurl_t *urlinfo,
const char *querystring, const char *headers, void *arg,
unsigned int *retcode, const char **retmsg,
const char **mimetype, isc_buffer_t *b,
static json_object *
addzone(char *name, char *classname, const char *ztype,
- isc_uint32_t serial, isc_boolean_t add_serial)
+ uint32_t serial, isc_boolean_t add_serial)
{
json_object *node = json_object_new_object();
char *zone_name_only = NULL;
char *class_only = NULL;
dns_rdataclass_t rdclass;
- isc_uint32_t serial;
- isc_uint64_t nsstat_values[dns_nsstatscounter_max];
+ uint32_t serial;
+ uint64_t nsstat_values[dns_nsstatscounter_max];
isc_stats_t *zonestats;
dns_stats_t *rcvquerystats;
json_object *zonearray = (json_object *) arg;
static isc_result_t
generatejson(ns_server_t *server, size_t *msglen,
- const char **msg, json_object **rootp, isc_uint32_t flags)
+ const char **msg, json_object **rootp, uint32_t flags)
{
dns_view_t *view;
isc_result_t result = ISC_R_SUCCESS;
json_object *tcpreq4 = NULL, *tcpresp4 = NULL;
json_object *udpreq6 = NULL, *udpresp6 = NULL;
json_object *tcpreq6 = NULL, *tcpresp6 = NULL;
- isc_uint64_t nsstat_values[dns_nsstatscounter_max];
- isc_uint64_t resstat_values[dns_resstatscounter_max];
- isc_uint64_t adbstat_values[dns_adbstats_max];
- isc_uint64_t zonestat_values[dns_zonestatscounter_max];
- isc_uint64_t sockstat_values[isc_sockstatscounter_max];
- isc_uint64_t udpinsizestat_values[dns_sizecounter_in_max];
- isc_uint64_t udpoutsizestat_values[dns_sizecounter_out_max];
- isc_uint64_t tcpinsizestat_values[dns_sizecounter_in_max];
- isc_uint64_t tcpoutsizestat_values[dns_sizecounter_out_max];
+ uint64_t nsstat_values[dns_nsstatscounter_max];
+ uint64_t resstat_values[dns_resstatscounter_max];
+ uint64_t adbstat_values[dns_adbstats_max];
+ uint64_t zonestat_values[dns_zonestatscounter_max];
+ uint64_t sockstat_values[isc_sockstatscounter_max];
+ uint64_t udpinsizestat_values[dns_sizecounter_in_max];
+ uint64_t udpoutsizestat_values[dns_sizecounter_out_max];
+ uint64_t tcpinsizestat_values[dns_sizecounter_in_max];
+ uint64_t tcpoutsizestat_values[dns_sizecounter_out_max];
#ifdef HAVE_DNSTAP
- isc_uint64_t dnstapstat_values[dns_dnstapcounter_max];
+ uint64_t dnstapstat_values[dns_dnstapcounter_max];
#endif
stats_dumparg_t dumparg;
char boottime[sizeof "yyyy-mm-ddThh:mm:ss.sssZ"];
}
static isc_result_t
-render_json(isc_uint32_t flags,
+render_json(uint32_t flags,
const char *url, isc_httpdurl_t *urlinfo,
const char *querystring, const char *headers,
void *arg, unsigned int *retcode, const char **retmsg,
dns_view_t *view;
dns_zone_t *zone, *next;
stats_dumparg_t dumparg;
- isc_uint64_t nsstat_values[dns_nsstatscounter_max];
- isc_uint64_t resstat_values[dns_resstatscounter_max];
- isc_uint64_t adbstat_values[dns_adbstats_max];
- isc_uint64_t zonestat_values[dns_zonestatscounter_max];
- isc_uint64_t sockstat_values[isc_sockstatscounter_max];
+ uint64_t nsstat_values[dns_nsstatscounter_max];
+ uint64_t resstat_values[dns_resstatscounter_max];
+ uint64_t adbstat_values[dns_adbstats_max];
+ uint64_t zonestat_values[dns_zonestatscounter_max];
+ uint64_t sockstat_values[isc_sockstatscounter_max];
RUNTIME_CHECK(isc_once_do(&once, init_desc) == ISC_R_SUCCESS);
#include <config.h>
+#include <inttypes.h>
+
#include <isc/buffer.h>
#include <isc/string.h> /* Required for HP/UX (and others?) */
#include <isc/mem.h>
isc_result_t result;
dns_tkeyctx_t *tctx = NULL;
const char *s;
- isc_uint32_t n;
+ uint32_t n;
dns_fixedname_t fname;
dns_name_t *name;
isc_buffer_t b;
#include <config.h>
+#include <inttypes.h>
+
#include <isc/base64.h>
#include <isc/buffer.h>
#include <isc/mem.h>
int secretlen = 0;
isc_result_t ret;
isc_stdtime_t now;
- isc_uint16_t bits;
+ uint16_t bits;
for (element = cfg_list_first(list);
element != NULL;
#include <config.h>
#include <stdio.h>
-#include <string.h>
+#include <inttypes.h>
#include <stdlib.h>
+#include <string.h>
#include <dlfcn.h>
#include <dns/log.h>
*/
static isc_boolean_t
dlopen_dlz_ssumatch(const char *signer, const char *name, const char *tcpaddr,
- const char *type, const char *key, isc_uint32_t keydatalen,
+ const char *type, const char *key, uint32_t keydatalen,
unsigned char *keydata, void *driverarg, void *dbdata)
{
dlopen_data_t *cd = (dlopen_data_t *) dbdata;
struct rr {
/* dns_name_t name; */
- isc_uint32_t ttl;
+ uint32_t ttl;
dns_rdata_t rdata;
};
{
dns_difftuple_t *deltuple = NULL;
dns_difftuple_t *addtuple = NULL;
- isc_uint32_t serial;
+ uint32_t serial;
isc_result_t result;
CHECK(dns_db_createsoatuple(db, ver, mctx, DNS_DIFFOP_DEL, &deltuple));
check_soa_increment(dns_db_t *db, dns_dbversion_t *ver,
dns_rdata_t *update_rdata, isc_boolean_t *ok)
{
- isc_uint32_t db_serial;
- isc_uint32_t update_serial;
+ uint32_t db_serial;
+ uint32_t update_serial;
isc_result_t result;
update_serial = dns_soa_getserial(update_rdata);
continue;
if (tuple->rdata.type == dns_rdatatype_dnskey) {
- isc_uint8_t alg;
+ uint8_t alg;
alg = tuple->rdata.data[3];
if (alg == DST_ALG_RSAMD5 || alg == DST_ALG_RSASHA1 ||
alg == DST_ALG_DSA || alg == DST_ALG_ECC) {
isc_boolean_t flag;
dns_name_t *name = dns_zone_getorigin(zone);
dns_rdatatype_t privatetype = dns_zone_getprivatetype(zone);
- isc_uint32_t ttl = 0;
+ uint32_t ttl = 0;
isc_boolean_t ttl_good = ISC_FALSE;
update_log(client, zone, ISC_LOG_DEBUG(3),
isc_boolean_t flag;
isc_region_t r;
isc_result_t result = ISC_R_SUCCESS;
- isc_uint16_t keyid;
+ uint16_t keyid;
unsigned char buf[5];
dns_name_t *name = dns_db_origin(db);
dns_diff_t temp_diff;
isc_boolean_t had_dnskey;
dns_rdatatype_t privatetype = dns_zone_getprivatetype(zone);
dns_ttl_t maxttl = 0;
- isc_uint32_t maxrecords;
- isc_uint64_t records;
+ uint32_t maxrecords;
+ uint64_t records;
INSIST(event->ev_type == DNS_EVENT_UPDATE);
CHECK(dns_nsec3param_deletechains(db, ver, zone,
ISC_TRUE, &diff));
} else if (has_dnskey && isdnssec(db, ver, privatetype)) {
- isc_uint32_t interval;
+ uint32_t interval;
dns_update_log_t log;
interval = dns_zone_getsigvalidityinterval(zone);
tuple = ISC_LIST_NEXT(tuple, link)) {
isc_region_t r;
dns_secalg_t algorithm;
- isc_uint16_t keyid;
+ uint16_t keyid;
if (tuple->rdata.type != dns_rdatatype_dnskey)
continue;
#include <windows.h>
#include <stdio.h>
-#include <string.h>
+#include <inttypes.h>
#include <stdlib.h>
+#include <string.h>
#include <dns/log.h>
#include <dns/result.h>
*/
static isc_boolean_t
dlopen_dlz_ssumatch(const char *signer, const char *name, const char *tcpaddr,
- const char *type, const char *key, isc_uint32_t keydatalen,
+ const char *type, const char *key, uint32_t keydatalen,
unsigned char *keydata, void *driverarg, void *dbdata)
{
dlopen_data_t *cd = (dlopen_data_t *) dbdata;
#include <config.h>
+#include <inttypes.h>
+
#include <isc/formatcheck.h>
#include <isc/mem.h>
#include <isc/timer.h>
/*% Log an RR (for debugging) */
static void
-log_rr(dns_name_t *name, dns_rdata_t *rdata, isc_uint32_t ttl) {
+log_rr(dns_name_t *name, dns_rdata_t *rdata, uint32_t ttl) {
isc_result_t result;
isc_buffer_t buf;
char mem[2000];
isc_result_t (*next)(rrstream_t *);
void (*current)(rrstream_t *,
dns_name_t **,
- isc_uint32_t *,
+ uint32_t *,
dns_rdata_t **);
void (*pause)(rrstream_t *);
void (*destroy)(rrstream_t **);
static isc_result_t
ixfr_rrstream_create(isc_mem_t *mctx,
const char *journal_filename,
- isc_uint32_t begin_serial,
- isc_uint32_t end_serial,
+ uint32_t begin_serial,
+ uint32_t end_serial,
rrstream_t **sp)
{
ixfr_rrstream_t *s;
static void
ixfr_rrstream_current(rrstream_t *rs,
- dns_name_t **name, isc_uint32_t *ttl,
+ dns_name_t **name, uint32_t *ttl,
dns_rdata_t **rdata)
{
ixfr_rrstream_t *s = (ixfr_rrstream_t *) rs;
/* Skip SOA records. */
for (;;) {
dns_name_t *name_dummy = NULL;
- isc_uint32_t ttl_dummy;
+ uint32_t ttl_dummy;
dns_rdata_t *rdata = NULL;
dns_rriterator_current(&s->it, &name_dummy,
&ttl_dummy, NULL, &rdata);
/* Skip SOA records. */
for (;;) {
dns_name_t *name_dummy = NULL;
- isc_uint32_t ttl_dummy;
+ uint32_t ttl_dummy;
dns_rdata_t *rdata = NULL;
result = dns_rriterator_next(&s->it);
if (result != ISC_R_SUCCESS)
}
static void
-axfr_rrstream_current(rrstream_t *rs, dns_name_t **name, isc_uint32_t *ttl,
+axfr_rrstream_current(rrstream_t *rs, dns_name_t **name, uint32_t *ttl,
dns_rdata_t **rdata)
{
axfr_rrstream_t *s = (axfr_rrstream_t *) rs;
}
static void
-soa_rrstream_current(rrstream_t *rs, dns_name_t **name, isc_uint32_t *ttl,
+soa_rrstream_current(rrstream_t *rs, dns_name_t **name, uint32_t *ttl,
dns_rdata_t **rdata)
{
soa_rrstream_t *s = (soa_rrstream_t *) rs;
}
static void
-compound_rrstream_current(rrstream_t *rs, dns_name_t **name, isc_uint32_t *ttl,
+compound_rrstream_current(rrstream_t *rs, dns_name_t **name, uint32_t *ttl,
dns_rdata_t **rdata)
{
compound_rrstream_t *s = (compound_rrstream_t *) rs;
isc_boolean_t is_poll = ISC_FALSE;
isc_boolean_t is_dlz = ISC_FALSE;
isc_boolean_t is_ixfr = ISC_FALSE;
- isc_uint32_t begin_serial = 0, current_serial;
+ uint32_t begin_serial = 0, current_serial;
switch (reqtype) {
case dns_rdatatype_axfr:
if ((client->attributes & NS_CLIENTATTR_WANTEXPIRE) != 0 &&
dns_zone_gettype(mayberaw) == dns_zone_slave) {
isc_time_t expiretime;
- isc_uint32_t secs;
+ uint32_t secs;
dns_zone_getexpiretime(zone, &expiretime);
secs = isc_time_seconds(&expiretime);
if (secs >= client->now && result == ISC_R_SUCCESS) {
*/
for (n_rrs = 0; ; n_rrs++) {
dns_name_t *name = NULL;
- isc_uint32_t ttl;
+ uint32_t ttl;
dns_rdata_t *rdata = NULL;
unsigned int size;
isc_buffer_usedregion(&xfr->txbuf, &used);
isc_buffer_putuint16(&xfr->txlenbuf,
- (isc_uint16_t)used.length);
+ (uint16_t)used.length);
region.base = xfr->txlenbuf.base;
region.length = 2 + used.length;
xfrout_log(xfr, ISC_LOG_DEBUG(8),
const char *filename = NULL;
const char *dupcheck;
dns_notifytype_t notifytype = dns_notifytype_yes;
- isc_uint32_t count;
+ uint32_t count;
unsigned int dbargc;
char **dbargv;
static char default_dbtype[] = "rbt";
dns_dialuptype_t dialup = dns_dialuptype_no;
dns_zonetype_t ztype;
int i;
- isc_int32_t journal_size;
+ int32_t journal_size;
isc_boolean_t multi;
isc_boolean_t alt;
dns_view_t *view;
if (cfg_obj_isstring(obj)) {
const char *str = cfg_obj_asstring(obj);
INSIST(strcasecmp(str, "unlimited") == 0);
- journal_size = ISC_UINT32_MAX / 2;
+ journal_size = UINT32_MAX / 2;
} else {
isc_resourcevalue_t value;
value = cfg_obj_asuint64(obj);
- if (value > ISC_UINT32_MAX / 2) {
+ if (value > UINT32_MAX / 2) {
cfg_obj_log(obj, ns_g_lctx,
ISC_LOG_ERROR,
"'max-journal-size "
value);
RETERR(ISC_R_RANGE);
}
- journal_size = (isc_uint32_t)value;
+ journal_size = (uint32_t)value;
}
if (raw != NULL)
dns_zone_setjournalsize(raw, journal_size);
if (cfg_obj_isstring(obj)) {
const char *str = cfg_obj_asstring(obj);
INSIST(strcasecmp(str, "unlimited") == 0);
- journal_size = ISC_UINT32_MAX / 2;
+ journal_size = UINT32_MAX / 2;
} else {
isc_resourcevalue_t value;
value = cfg_obj_asuint64(obj);
- if (value > ISC_UINT32_MAX / 2) {
+ if (value > UINT32_MAX / 2) {
cfg_obj_log(obj, ns_g_lctx,
ISC_LOG_ERROR,
"'max-journal-size "
value);
RETERR(ISC_R_RANGE);
}
- journal_size = (isc_uint32_t)value;
+ journal_size = (uint32_t)value;
}
dns_zone_setjournalsize(zone, journal_size);
}
#include <ctype.h>
#include <errno.h>
#include <limits.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <unistd.h>
/* Number of addresses to request from bind9_getaddresses() */
#define MAX_SERVERADDRS 4
-static isc_uint16_t dnsport = DNSDEFAULTPORT;
+static uint16_t dnsport = DNSDEFAULTPORT;
#ifndef RESOLV_CONF
#define RESOLV_CONF "/etc/resolv.conf"
static dns_rdataclass_t defaultclass = dns_rdataclass_in;
static dns_rdataclass_t zoneclass = dns_rdataclass_none;
static dns_message_t *answer = NULL;
-static isc_uint32_t default_ttl = 0;
+static uint32_t default_ttl = 0;
static isc_boolean_t default_ttl_set = ISC_FALSE;
static isc_boolean_t checknames = ISC_TRUE;
static void
error(const char *format, ...) ISC_FORMAT_PRINTF(1, 2);
-#define STATUS_MORE (isc_uint16_t)0
-#define STATUS_SEND (isc_uint16_t)1
-#define STATUS_QUIT (isc_uint16_t)2
-#define STATUS_SYNTAX (isc_uint16_t)3
+#define STATUS_MORE (uint16_t)0
+#define STATUS_SEND (uint16_t)1
+#define STATUS_QUIT (uint16_t)2
+#define STATUS_SYNTAX (uint16_t)3
typedef struct entropysource entropysource_t;
static isc_boolean_t
parse_hmac(dns_name_t **hmac, const char *hmacstr, size_t len,
- isc_uint16_t *digestbitsp)
+ uint16_t *digestbitsp)
{
- isc_uint16_t digestbits = 0;
+ uint16_t digestbits = 0;
isc_result_t result;
char buf[20];
dns_name_t *mykeyname;
char *name;
dns_name_t *hmacname = NULL;
- isc_uint16_t digestbits = 0;
+ uint16_t digestbits = 0;
mykeyname = dns_fixedname_initname(&fkeyname);
static void
parse_args(int argc, char **argv, isc_mem_t *mctx, isc_entropy_t **ectx) {
int ch;
- isc_uint32_t i;
+ uint32_t i;
isc_result_t result;
isc_boolean_t force_interactive = ISC_FALSE;
}
}
-static isc_uint16_t
+static uint16_t
parse_name(char **cmdlinep, dns_message_t *msg, dns_name_t **namep) {
isc_result_t result;
char *word;
return (STATUS_MORE);
}
-static isc_uint16_t
+static uint16_t
parse_rdata(char **cmdlinep, dns_rdataclass_t rdataclass,
dns_rdatatype_t rdatatype, dns_message_t *msg,
dns_rdata_t *rdata)
return (STATUS_MORE);
}
-static isc_uint16_t
+static uint16_t
make_prereq(char *cmdline, isc_boolean_t ispositive, isc_boolean_t isrrset) {
isc_result_t result;
char *word;
dns_rdataclass_t rdataclass;
dns_rdatatype_t rdatatype;
dns_rdata_t *rdata = NULL;
- isc_uint16_t retval;
+ uint16_t retval;
ddebug("make_prereq()");
return (STATUS_SYNTAX);
}
-static isc_uint16_t
+static uint16_t
evaluate_prereq(char *cmdline) {
char *word;
isc_boolean_t ispositive, isrrset;
return (make_prereq(cmdline, ispositive, isrrset));
}
-static isc_uint16_t
+static uint16_t
evaluate_server(char *cmdline) {
char *word, *server;
long port;
return (STATUS_MORE);
}
-static isc_uint16_t
+static uint16_t
evaluate_local(char *cmdline) {
char *word, *local;
long port;
return (STATUS_MORE);
}
-static isc_uint16_t
+static uint16_t
evaluate_key(char *cmdline) {
char *namestr;
char *secretstr;
unsigned char *secret = NULL;
isc_buffer_t secretbuf;
dns_name_t *hmacname = NULL;
- isc_uint16_t digestbits = 0;
+ uint16_t digestbits = 0;
char *n;
namestr = nsu_strsep(&cmdline, " \t\r\n");
return (STATUS_MORE);
}
-static isc_uint16_t
+static uint16_t
evaluate_zone(char *cmdline) {
char *word;
isc_buffer_t b;
return (STATUS_MORE);
}
-static isc_uint16_t
+static uint16_t
evaluate_realm(char *cmdline) {
#ifdef GSSAPI
char *word;
#endif
}
-static isc_uint16_t
+static uint16_t
evaluate_ttl(char *cmdline) {
char *word;
isc_result_t result;
- isc_uint32_t ttl;
+ uint32_t ttl;
word = nsu_strsep(&cmdline, " \t\r\n");
if (word == NULL || *word == 0) {
return (STATUS_MORE);
}
-static isc_uint16_t
+static uint16_t
evaluate_class(char *cmdline) {
char *word;
isc_textregion_t r;
return (STATUS_MORE);
}
-static isc_uint16_t
+static uint16_t
update_addordelete(char *cmdline, isc_boolean_t isdelete) {
isc_result_t result;
dns_name_t *name = NULL;
- isc_uint32_t ttl;
+ uint32_t ttl;
char *word;
dns_rdataclass_t rdataclass;
dns_rdatatype_t rdatatype;
dns_rdatalist_t *rdatalist = NULL;
dns_rdataset_t *rdataset = NULL;
isc_textregion_t region;
- isc_uint16_t retval;
+ uint16_t retval;
ddebug("update_addordelete()");
return (STATUS_SYNTAX);
}
-static isc_uint16_t
+static uint16_t
evaluate_update(char *cmdline) {
char *word;
isc_boolean_t isdelete;
return (update_addordelete(cmdline, isdelete));
}
-static isc_uint16_t
+static uint16_t
evaluate_checknames(char *cmdline) {
char *word;
isc_buffer_free(&buf);
}
-static isc_uint16_t
+static uint16_t
do_next_command(char *cmdline) {
char *word;
return (STATUS_SYNTAX);
}
-static isc_uint16_t
+static uint16_t
get_next_command(void) {
- isc_uint16_t result = STATUS_QUIT;
+ uint16_t result = STATUS_QUIT;
char cmdlinebuf[MAXCMD];
char *cmdline;
static isc_boolean_t
user_interaction(void) {
- isc_uint16_t result = STATUS_MORE;
+ uint16_t result = STATUS_MORE;
ddebug("user_interaction()");
while ((result == STATUS_MORE) || (result == STATUS_SYNTAX)) {
gss_ctx_id_t context;
isc_buffer_t buf;
isc_result_t result;
- isc_uint32_t val = 0;
+ uint32_t val = 0;
dns_message_t *rmsg = NULL;
dns_request_t *request = NULL;
dns_name_t *servname;
#include <config.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <isc/app.h>
static isc_socketmgr_t *socketmgr = NULL;
static isc_buffer_t *databuf;
static isccc_ccmsg_t ccmsg;
-static isc_uint32_t algorithm;
+static uint32_t algorithm;
static isccc_region_t secret;
static isc_boolean_t failed = ISC_FALSE;
static isc_boolean_t c_flag = ISC_FALSE;
static char *args;
static char program[256];
static isc_socket_t *sock = NULL;
-static isc_uint32_t serial;
+static uint32_t serial;
static isc_boolean_t quiet = ISC_FALSE;
static isc_boolean_t showresult = ISC_FALSE;
isccc_sexpr_t *_ctrl;
isccc_region_t source;
isc_result_t result;
- isc_uint32_t nonce;
+ uint32_t nonce;
isccc_sexpr_t *request = NULL;
isccc_time_t now;
isc_region_t r;
obj = cfg_tuple_get(address, "port");
if (cfg_obj_isuint32(obj)) {
myport = cfg_obj_asuint32(obj);
- if (myport > ISC_UINT16_MAX ||
+ if (myport > UINT16_MAX ||
myport == 0)
fatal("port %u out of range",
myport);
#include <config.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <isc/commandline.h>
}
if (time_lookups) {
- isc_uint64_t usec;
+ uint64_t usec;
TIME_NOW(&finish);
isc_keyboard_t *kbd = (isc_keyboard_t *)arg;
isc_result_t result;
isc_time_t t;
- isc_uint32_t sample;
- isc_uint32_t extra;
+ uint32_t sample;
+ uint32_t extra;
unsigned char c;
if (!blocking)
#include <config.h>
#include <stdio.h>
+#include <inttypes.h>
#include <isc/lfsr.h>
#include <isc/print.h>
#include <isc/util.h>
-isc_uint32_t state[1024 * 64];
+uint32_t state[1024 * 64];
int
main(int argc, char **argv) {
isc_lfsr_t lfsr1, lfsr2;
int i;
- isc_uint32_t temp;
+ uint32_t temp;
UNUSED(argc);
UNUSED(argv);
#include <config.h>
#include <stdio.h>
+#include <inttypes.h>
#include <isc/print.h>
#include <isc/serial.h>
int
main() {
- isc_uint32_t a, b;
+ uint32_t a, b;
char buf[1024];
char *s, *e;
#include <config.h>
#include <stdio.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <config.h>
#include <stdio.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <config.h>
#include <stdio.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <config.h>
#include <stdio.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <config.h>
#include <stdio.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <config.h>
#include <stdio.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <config.h>
#include <stdio.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <config.h>
#include <stdio.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <config.h>
#include <stdio.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <config.h>
#include <stdio.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <config.h>
#include <stdio.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <stdarg.h>
fmt_address(isc_sockaddr_t *addr, char *buffer, size_t size) {
char addr_buf[100];
const char *ret;
- isc_uint16_t port = 0;
+ uint16_t port = 0;
switch (addr->type.sa.sa_family) {
case AF_INET:
*/
isc_boolean_t
dlz_ssumatch(const char *signer, const char *name, const char *tcpaddr,
- const char *type, const char *key, isc_uint32_t keydatalen,
+ const char *type, const char *key, uint32_t keydatalen,
unsigned char *keydata, void *dbdata)
{
struct dlz_example_data *state = (struct dlz_example_data *)dbdata;
*/
#include <config.h>
+#include <inttypes.h>
+
#include <isc/string.h>
#include <isc/util.h>
static isc_result_t
getnsec3parameters(dns_db_t *db, dns_dbversion_t *version,
- dns_hash_t *hash, isc_uint8_t *flags,
- isc_uint16_t *iterations,
+ dns_hash_t *hash, uint8_t *flags,
+ uint16_t *iterations,
unsigned char *salt, size_t *salt_length)
{
sampledb_t *sampledb = (sampledb_t *) db;
#include <config.h>
+#include <inttypes.h>
+
#include <isc/util.h>
#include <dns/dyndb.h>
load_zone(dns_zone_t *zone) {
isc_result_t result;
isc_boolean_t zone_dynamic;
- isc_uint32_t serial;
+ uint32_t serial;
result = dns_zone_load(zone);
if (result != ISC_R_SUCCESS && result != DNS_R_UPTODATE
#include <config.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
unsigned int attrs, attrmask;
dns_dispatch_t *dispatchv4;
dns_view_t *view;
- isc_uint16_t port = PORT;
+ uint16_t port = PORT;
int c;
UNUSED(argv);
#include <config.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <isc/buffer.h>
isc_boolean_t tcp = ISC_FALSE;
isc_boolean_t rawdata = ISC_FALSE;
isc_result_t result;
- isc_uint8_t c;
+ uint8_t c;
FILE *f;
int ch;
while (fread(&c, 1, 1, f) != 0) {
result = isc_buffer_reserve(&input, 1);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
- isc_buffer_putuint8(input, (isc_uint8_t) c);
+ isc_buffer_putuint8(input, (uint8_t) c);
}
} else {
char s[BUFSIZ];
c += fromhex(*rp++);
result = isc_buffer_reserve(&input, 1);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
- isc_buffer_putuint8(input, (isc_uint8_t) c);
+ isc_buffer_putuint8(input, (uint8_t) c);
}
}
}
#include <config.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <isc/buffer.h>
for (;;) {
isc_region_t input;
- isc_uint8_t *data;
+ uint8_t *data;
size_t datalen;
result = dns_dt_getframe(handle, &data, &datalen);
static isc_boolean_t display_additional = ISC_TRUE;
static isc_boolean_t display_unknown_format = ISC_FALSE;
static isc_boolean_t continue_on_error = ISC_FALSE;
-static isc_uint32_t display_splitwidth = 0xffffffff;
+static uint32_t display_splitwidth = 0xffffffff;
static isc_sockaddr_t srcaddr;
static char *server;
static isc_sockaddr_t dstaddr;
isc_boolean_t nsid;
dns_rdatatype_t rdtype;
dns_rdataclass_t rdclass;
- isc_uint16_t udpsize;
- isc_int16_t edns;
+ uint16_t udpsize;
+ int16_t edns;
dns_ednsopt_t *ednsopts;
unsigned int ednsoptscnt;
unsigned int ednsflags;
* (e.g., NSID, COOKIE, client-subnet)
*/
static void
-add_opt(dns_message_t *msg, isc_uint16_t udpsize, isc_uint16_t edns,
+add_opt(dns_message_t *msg, uint16_t udpsize, uint16_t edns,
unsigned int flags, dns_ednsopt_t *opts, size_t count)
{
dns_rdataset_t *rdataset = NULL;
}
if (query->ecs_addr != NULL) {
- isc_uint8_t addr[16], family;
- isc_uint32_t plen;
+ uint8_t addr[16], family;
+ uint32_t plen;
struct sockaddr *sa;
struct sockaddr_in *sin;
struct sockaddr_in6 *sin6;
INSIST(i < DNS_EDNSOPTIONS);
opts[i].code = DNS_OPT_CLIENT_SUBNET;
- opts[i].length = (isc_uint16_t) addrl + 4;
+ opts[i].length = (uint16_t) addrl + 4;
CHECK("isc_buffer_allocate", result);
isc_buffer_init(&b, ecsbuf, sizeof(ecsbuf));
if (sa->sa_family == AF_INET) {
isc_buffer_putmem(&b, addr,
(unsigned)addrl);
- opts[i].value = (isc_uint8_t *) ecsbuf;
+ opts[i].value = (uint8_t *) ecsbuf;
i++;
}
}
static isc_result_t
-parse_uint_helper(isc_uint32_t *uip, const char *value, isc_uint32_t max,
+parse_uint_helper(uint32_t *uip, const char *value, uint32_t max,
const char *desc, int base) {
- isc_uint32_t n;
+ uint32_t n;
isc_result_t result = isc_parse_uint32(&n, value, base);
if (result == ISC_R_SUCCESS && n > max)
result = ISC_R_RANGE;
}
static isc_result_t
-parse_uint(isc_uint32_t *uip, const char *value, isc_uint32_t max,
+parse_uint(uint32_t *uip, const char *value, uint32_t max,
const char *desc) {
return (parse_uint_helper(uip, value, max, desc, 10));
}
static isc_result_t
-parse_xint(isc_uint32_t *uip, const char *value, isc_uint32_t max,
+parse_xint(uint32_t *uip, const char *value, uint32_t max,
const char *desc) {
return (parse_uint_helper(uip, value, max, desc, 0));
}
static void
save_opt(struct query *query, char *code, char *value) {
- isc_uint32_t num;
+ uint32_t num;
isc_buffer_t b;
isc_result_t result;
isc_sockaddr_t *sa = NULL;
struct in_addr in4;
struct in6_addr in6;
- isc_uint32_t netmask = 0xffffffff;
+ uint32_t netmask = 0xffffffff;
char *slash = NULL;
isc_boolean_t parsed = ISC_FALSE;
char buf[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:XXX.XXX.XXX.XXX/128")];
isc_result_t result;
char option_store[256];
char *cmd, *value, *ptr, *code;
- isc_uint32_t num;
+ uint32_t num;
isc_boolean_t state = ISC_TRUE;
size_t n;
struct in6_addr in6;
in_port_t srcport;
char *hash;
- isc_uint32_t num;
+ uint32_t num;
while (strpbrk(option, single_dash_opts) == &option[0]) {
/*
*/
#include <stdio.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
-#include <stdint.h>
#include "../modules/include/dlz_minimal.h"
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
-#include <stdint.h>
#include <db.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
-#include <stdint.h>
#include <stdlib.h>
#include <ctype.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
-#include <stdint.h>
#include <stdlib.h>
#include <sys/stat.h>
#ifndef DLZ_MINIMAL_H
#define DLZ_MINIMAL_H 1
+#include <inttypes.h>
#include <sys/types.h>
#include <sys/socket.h>
#ifdef ISC_PLATFORM_HAVESYSUNH
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
-#include <stdint.h>
#include <stdlib.h>
#include <dlz_minimal.h>
/*
* Copyright (C) 1999-2001, 2013, 2016 Internet Systems Consortium, Inc. ("ISC")
- *
+ *
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
-#include <stdint.h>
#include <stdlib.h>
#include <dlz_minimal.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
-#include <stdint.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
-#include <stdint.h>
#include <stdlib.h>
#include <dlz_minimal.h>
* This provides the externally loadable wildcard DLZ module.
*/
+#include <inttypes.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <ctype.h>
#include <time.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
unsigned int rdlen, totallen;
unsigned char tmpdata[512];
isc_buffer_t tmp;
- isc_uint32_t now;
+ uint32_t now;
unsigned char digest[ISC_SHA256_DIGESTLENGTH];
hmac_init(tsigkey, &hmac);
read_update_line(perf_dnsctx_t *ctx, const isc_textregion_t *line, char *str,
dns_name_t *zname, int want_ttl, int need_type,
int want_rdata, int need_rdata, dns_name_t *name,
- isc_uint32_t *ttlp, dns_rdatatype_t *typep,
+ uint32_t *ttlp, dns_rdatatype_t *typep,
dns_rdata_t *rdata, isc_buffer_t *rdatabuf)
{
char *curr_str;
int prereqs = 0;
dns_fixedname_t fzname, foname;
dns_name_t *zname, *oname;
- isc_uint32_t ttl;
+ uint32_t ttl;
dns_rdatatype_t rdtype;
dns_rdataclass_t rdclass;
dns_rdata_t rdata;
- isc_uint16_t rdlen;
+ uint16_t rdlen;
isc_result_t result;
/* Reset compression context */
isc_result_t
perf_dns_buildrequest(perf_dnsctx_t *ctx, const isc_textregion_t *record,
- isc_uint16_t qid,
+ uint16_t qid,
isc_boolean_t edns, isc_boolean_t dnssec,
perf_dnstsigkey_t *tsigkey, isc_buffer_t *msg)
{
* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
+#include <inttypes.h>
+
#include <isc/types.h>
#ifndef PERF_DNS_H
isc_result_t
perf_dns_buildrequest(perf_dnsctx_t *ctx, const isc_textregion_t *record,
- isc_uint16_t qid,
+ uint16_t qid,
isc_boolean_t edns, isc_boolean_t dnssec,
perf_dnstsigkey_t *tsigkey, isc_buffer_t *msg);
***/
#include <inttypes.h>
-
#include <errno.h>
#include <math.h>
#include <pthread.h>
int argc;
char **argv;
int family;
- isc_uint32_t clients;
- isc_uint32_t threads;
- isc_uint32_t maxruns;
- isc_uint64_t timelimit;
+ uint32_t clients;
+ uint32_t threads;
+ uint32_t maxruns;
+ uint64_t timelimit;
isc_sockaddr_t server_addr;
isc_sockaddr_t local_addr;
- isc_uint64_t timeout;
- isc_uint32_t bufsize;
+ uint64_t timeout;
+ uint32_t bufsize;
isc_boolean_t edns;
isc_boolean_t dnssec;
perf_dnstsigkey_t *tsigkey;
- isc_uint32_t max_outstanding;
- isc_uint32_t max_qps;
- isc_uint64_t stats_interval;
+ uint32_t max_outstanding;
+ uint32_t max_qps;
+ uint64_t stats_interval;
isc_boolean_t updates;
isc_boolean_t verbose;
} config_t;
typedef struct {
- isc_uint64_t start_time;
- isc_uint64_t end_time;
- isc_uint64_t stop_time;
+ uint64_t start_time;
+ uint64_t end_time;
+ uint64_t stop_time;
struct timespec stop_time_ns;
} times_t;
typedef struct {
- isc_uint64_t rcodecounts[16];
+ uint64_t rcodecounts[16];
- isc_uint64_t num_sent;
- isc_uint64_t num_interrupted;
- isc_uint64_t num_timedout;
- isc_uint64_t num_completed;
+ uint64_t num_sent;
+ uint64_t num_interrupted;
+ uint64_t num_timedout;
+ uint64_t num_completed;
- isc_uint64_t total_request_size;
- isc_uint64_t total_response_size;
+ uint64_t total_request_size;
+ uint64_t total_response_size;
- isc_uint64_t latency_sum;
- isc_uint64_t latency_sum_squares;
- isc_uint64_t latency_min;
- isc_uint64_t latency_max;
+ uint64_t latency_sum;
+ uint64_t latency_sum_squares;
+ uint64_t latency_min;
+ uint64_t latency_max;
} stats_t;
typedef ISC_LIST(struct query_info) query_list;
typedef struct query_info {
- isc_uint64_t timestamp;
+ uint64_t timestamp;
query_list *list;
char *desc;
int sock;
perf_dnsctx_t *dnsctx;
isc_boolean_t done_sending;
- isc_uint64_t done_send_time;
+ uint64_t done_send_time;
const config_t *config;
const times_t *times;
stats_t stats;
- isc_uint32_t max_outstanding;
- isc_uint32_t max_qps;
+ uint32_t max_outstanding;
+ uint32_t max_qps;
- isc_uint64_t last_recv;
+ uint64_t last_recv;
} threadinfo_t;
static threadinfo_t *threads;
}
static double
-stddev(isc_uint64_t sum_of_squares, isc_uint64_t sum, isc_uint64_t total)
+stddev(uint64_t sum_of_squares, uint64_t sum, uint64_t total)
{
double squared;
print_statistics(const config_t *config, const times_t *times, stats_t *stats)
{
const char *units;
- isc_uint64_t run_time;
+ uint64_t run_time;
isc_boolean_t first_rcode;
- isc_uint64_t latency_avg;
+ uint64_t latency_avg;
unsigned int i;
units = config->updates ? "Updates" : "Queries";
}
}
-static inline isc_uint64_t
+static inline uint64_t
num_outstanding(const stats_t *stats)
{
return stats->num_sent - stats->num_completed - stats->num_timedout;
stats_t *stats;
unsigned int max_packet_size;
isc_buffer_t msg;
- isc_uint64_t now, run_time, req_time;
+ uint64_t now, run_time, req_time;
char input_data[MAX_INPUT_DATA];
isc_buffer_t lines;
isc_region_t used;
q = ISC_LIST_HEAD(tinfo->unused_queries);
query_move(tinfo, q, prepend_outstanding);
- q->timestamp = ISC_UINT64_MAX;
+ q->timestamp = UINT64_MAX;
q->sock = tinfo->socks[tinfo->current_sock++ % tinfo->nsocks];
UNLOCK(&tinfo->lock);
}
static void
-process_timeouts(threadinfo_t *tinfo, isc_uint64_t now)
+process_timeouts(threadinfo_t *tinfo, uint64_t now)
{
struct query_info *q;
const config_t *config;
typedef struct {
int sock;
- isc_uint16_t qid;
- isc_uint16_t rcode;
+ uint16_t qid;
+ uint16_t rcode;
unsigned int size;
- isc_uint64_t when;
- isc_uint64_t sent;
+ uint64_t when;
+ uint64_t sent;
isc_boolean_t unexpected;
isc_boolean_t short_response;
char *desc;
unsigned char *packet_buffer, unsigned int packet_size,
received_query_t *recvd, int *saved_errnop)
{
- isc_uint16_t *packet_header;
+ uint16_t *packet_header;
int s;
- isc_uint64_t now;
+ uint64_t now;
int n;
- packet_header = (isc_uint16_t *) packet_buffer;
+ packet_header = (uint16_t *) packet_buffer;
s = tinfo->socks[which_sock];
n = recv(s, packet_buffer, packet_size, 0);
unsigned int nrecvd;
int saved_errno;
unsigned char socketbits[MAX_SOCKETS / 8];
- isc_uint64_t now, latency;
+ uint64_t now, latency;
query_info *q;
unsigned int current_socket, last_socket;
unsigned int i, j;
q = &tinfo->queries[recvd[i].qid];
if (q->list != &tinfo->outstanding_queries ||
- q->timestamp == ISC_UINT64_MAX ||
+ q->timestamp == UINT64_MAX ||
q->sock != recvd[i].sock)
{
recvd[i].unexpected = ISC_TRUE;
{
threadinfo_t *tinfo;
stats_t total;
- isc_uint64_t now;
- isc_uint64_t last_interval_time;
- isc_uint64_t last_completed;
- isc_uint64_t interval_time;
- isc_uint64_t num_completed;
+ uint64_t now;
+ uint64_t last_interval_time;
+ uint64_t last_completed;
+ uint64_t interval_time;
+ uint64_t num_completed;
double qps;
tinfo = arg;
break;
query_move(tinfo, q, append_unused);
- if (q->timestamp == ISC_UINT64_MAX)
+ if (q->timestamp == UINT64_MAX)
continue;
tinfo->stats.num_interrupted++;
}
}
-static isc_uint32_t
-per_thread(isc_uint32_t total, isc_uint32_t nthreads, unsigned int offset)
+static uint32_t
+per_thread(uint32_t total, uint32_t nthreads, unsigned int offset)
{
- isc_uint32_t value;
+ uint32_t value;
value = total / nthreads;
if (value % nthreads > offset)
if (config.timelimit > 0)
times.stop_time = times.start_time + config.timelimit;
else
- times.stop_time = ISC_UINT64_MAX;
+ times.stop_time = UINT64_MAX;
times.stop_time_ns.tv_sec = times.stop_time / MILLION;
times.stop_time_ns.tv_nsec = (times.stop_time % MILLION) * 1000;
#include <getopt.h>
#include <stdio.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
char **stringp;
isc_boolean_t *boolp;
unsigned int *uintp;
- isc_uint64_t *uint64p;
+ uint64_t *uint64p;
double *doublep;
in_port_t *portp;
} u;
}
}
-static isc_uint32_t
+static uint32_t
parse_uint(const char *desc, const char *str,
unsigned int min, unsigned int max)
{
- isc_uint32_t val;
+ uint32_t val;
isc_result_t result;
val = 0;
return val;
}
-static isc_uint64_t
+static uint64_t
parse_timeval(const char *desc, const char *str)
{
const char *s;
#include <errno.h>
#include <signal.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
}
isc_result_t
-perf_os_waituntilreadable(int fd, int pipe_fd, isc_int64_t timeout)
+perf_os_waituntilreadable(int fd, int pipe_fd, int64_t timeout)
{
fd_set read_fds;
int maxfd;
isc_result_t
perf_os_waituntilanyreadable(int *fds, unsigned int nfds, int pipe_fd,
- isc_int64_t timeout)
+ int64_t timeout)
{
fd_set read_fds;
unsigned int i;
#ifndef PERF_OS_H
#define PERF_OS_H 1
+#include <inttypes.h>
+
void
perf_os_blocksignal(int sig, isc_boolean_t block);
perf_os_handlesignal(int sig, void (*handler)(int));
isc_result_t
-perf_os_waituntilreadable(int fd, int pipe_fd, isc_int64_t timeout);
+perf_os_waituntilreadable(int fd, int pipe_fd, int64_t timeout);
isc_result_t
perf_os_waituntilanyreadable(int *fds, unsigned int nfds, int pipe_fd,
- isc_int64_t timeout);
+ int64_t timeout);
#endif
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
-#include <inttypes.h>
#include <sys/time.h>
typedef ISC_LIST(struct query_info) query_list;
typedef struct query_info {
- isc_uint64_t sent_timestamp;
+ uint64_t sent_timestamp;
/*
* This link links the query into the list of outstanding
* queries or the list of available query IDs.
static unsigned int nsocks;
static int *socks;
-static isc_uint64_t query_timeout;
+static uint64_t query_timeout;
static isc_boolean_t edns;
static isc_boolean_t dnssec;
/* The time period over which we ramp up traffic */
#define DEFAULT_RAMP_TIME 60
-static isc_uint64_t ramp_time;
+static uint64_t ramp_time;
/* How long to send constant traffic after the initial ramp-up */
#define DEFAULT_SUSTAIN_TIME 0
-static isc_uint64_t sustain_time;
+static uint64_t sustain_time;
/* How long to wait for responses after sending traffic */
-static isc_uint64_t wait_time = 40 * MILLION;
+static uint64_t wait_time = 40 * MILLION;
/* Total duration of the traffic-sending part of the test */
-static isc_uint64_t traffic_time;
+static uint64_t traffic_time;
/* Total duration of the test */
-static isc_uint64_t end_time;
+static uint64_t end_time;
/* Interval between plot data points, in microseconds */
#define DEFAULT_BUCKET_INTERVAL 0.5
-static isc_uint64_t bucket_interval;
+static uint64_t bucket_interval;
/* The number of plot data points */
static int n_buckets;
/* The maximum number of outstanding queries */
static unsigned int max_outstanding;
-static isc_uint64_t num_queries_sent;
-static isc_uint64_t num_queries_outstanding;
-static isc_uint64_t num_responses_received;
-static isc_uint64_t num_queries_timed_out;
-static isc_uint64_t rcodecounts[16];
+static uint64_t num_queries_sent;
+static uint64_t num_queries_outstanding;
+static uint64_t num_responses_received;
+static uint64_t num_queries_timed_out;
+static uint64_t rcodecounts[16];
-static isc_uint64_t time_now;
-static isc_uint64_t time_of_program_start;
-static isc_uint64_t time_of_end_of_run;
+static uint64_t time_now;
+static uint64_t time_of_program_start;
+static uint64_t time_of_end_of_run;
/*
* The last plot data point containing actual data; this can
static enum phase phase = PHASE_RAMP;
/* The time when the sustain/wait phase began */
-static isc_uint64_t sustain_phase_began, wait_phase_began;
+static uint64_t sustain_phase_began, wait_phase_began;
static perf_dnstsigkey_t *tsigkey;
/* Find the ramp_bucket for queries sent at time "when" */
static ramp_bucket *
-find_bucket(isc_uint64_t when) {
- isc_uint64_t sent_at = when - time_of_program_start;
+find_bucket(uint64_t when) {
+ uint64_t sent_at = when - time_of_program_start;
int i = (int) ((n_buckets * sent_at) / traffic_time);
/*
* Guard against array bounds violations due to roundoff
double max_throughput;
double loss_at_max_throughput;
isc_boolean_t first_rcode;
- isc_uint64_t run_time = time_of_end_of_run - time_of_program_start;
+ uint64_t run_time = time_of_end_of_run - time_of_program_start;
printf("\nStatistics:\n\n");
static void
try_process_response(unsigned int sockindex) {
unsigned char packet_buffer[MAX_EDNS_PACKET];
- isc_uint16_t *packet_header;
- isc_uint16_t qid, rcode;
+ uint16_t *packet_header;
+ uint16_t qid, rcode;
query_info *q;
double latency;
ramp_bucket *b;
int n;
- packet_header = (isc_uint16_t *) packet_buffer;
+ packet_header = (uint16_t *) packet_buffer;
n = recvfrom(socks[sockindex], packet_buffer, sizeof(packet_buffer),
0, NULL, NULL);
if (n < 0) {
}
static inline int
-num_scheduled(isc_uint64_t time_since_start)
+num_scheduled(uint64_t time_since_start)
{
if (phase == PHASE_RAMP) {
return 0.5 * max_qps *
current_sock = 0;
for (;;) {
int should_send;
- isc_uint64_t time_since_start = time_now -
+ uint64_t time_since_start = time_now -
time_of_program_start;
switch (phase) {
case PHASE_RAMP:
*/
#include <pthread.h>
+#include <inttypes.h>
#include <string.h>
#include <sys/time.h>
#ifndef PERF_UTIL_H
#define PERF_UTIL_H 1
-#define MILLION ((isc_uint64_t) 1000000)
+#define MILLION ((uint64_t) 1000000)
#define THREAD(thread, start, arg) do { \
int __n = pthread_create((thread), NULL, (start), (arg)); \
*res = ISC_TF(__n != 0); \
} while (0)
-static __inline__ isc_uint64_t
+static __inline__ uint64_t
get_time(void)
{
struct timeval tv;
#include <netdb.h>
#include <pthread.h>
#include <signal.h>
-#include <stdint.h>
+#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
isc_boolean_t
dns_compress_findglobal(dns_compress_t *cctx, dns_name_t *name,
dns_name_t *prefix, dns_name_t *suffix,
- isc_uint16_t *offset, isc_buffer_t *workspace);
+ uint16_t *offset, isc_buffer_t *workspace);
isc_boolean_t
dns_compress_findlocal(dns_compress_t *cctx, dns_name_t *name,
dns_name_t *prefix, dns_name_t *suffix,
- isc_uint16_t *offset, isc_buffer_t *workspace);
+ uint16_t *offset, isc_buffer_t *workspace);
Find the best best match in the global / local RBT. Returns prefix,
suffix and offset of the bestmatch. Findglobal(), findlocal()
void
dns_compress_add(dns_compress_t *cctx, dns_name_t *prefix,
- dns_name_t *suffix, isc_uint16_t offset);
+ dns_name_t *suffix, uint16_t offset);
Add compression pointers pointing to lebels (if any) in prefix.
The offset to the first label is passed in offset.
isc_sockaddr_t address; /*%< source address */
isc_time_t timestamp; /*%< timestamp of packet recv */
struct in6_pktinfo pktinfo; /*%< ipv6 pktinfo */
- isc_uint32_t attributes; /*%< see below */
+ uint32_t attributes; /*%< see below */
isc_eventdestructor_t destroy; /*%< original destructor */
unsigned int dscp; /*%< UDP dscp value */
};
struct dns_ixfr {
unsigned int magic; /* IXFR */
- isc_uint32_t serial;
+ uint32_t serial;
time_t expire;
unsigned int offset;
ISC_LINK(dns_ixfr_t) link;
dns_rdataclass_t class;
dns_zonetypes_t type;
dns_bt_t top;
- isc_uint32_t version;
- isc_uint32_t serial;
- isc_uint32_t refresh;
- isc_uint32_t retry;
- isc_uint32_t serial;
+ uint32_t version;
+ uint32_t serial;
+ uint32_t refresh;
+ uint32_t retry;
+ uint32_t serial;
char *masterfile;
dns_acl_t *access;
dns_acl_t *transfer;
Make `buffer` refer to the memory in `region` and make it active.
static dns_result_t
- uint32_tobuffer(isc_uint32_t value, isc_buffer_t *target);
+ uint32_tobuffer(uint32_t value, isc_buffer_t *target);
Write the 32 bit `value` in network order to `target`.
Returns `DNS_R_NOSPACE` and `DNS_R_SUCCESS`.
static dns_result_t
-uint16_tobuffer(isc_uint32_t value, isc_buffer_t *target);
+uint16_tobuffer(uint32_t value, isc_buffer_t *target);
Write them 16 bit `value` in network order to `target`.
Returns `ISC_R_RANGE`, `DNS_R_NOSPACE` and `DNS_R_SUCCESS`.
- static isc_uint32_t
+ static uint32_t
uint32_fromregion(isc_region_t *region);
Returns the 32 bit at the start of `region` in host byte order.
Requires `(region->length >= 4)`.
- static isc_uint16_t
+ static uint16_t
uint16_fromregion(isc_region_t *region);
Returns the 16 bit at the start of `region` in host byte order.
between signed and unsigned integers should be avoided; suppressing the
warnings with casts is not desireable.
-Typedefs are provided to specify particular sizes of integral variables,
-e.g., `isc_uint32_t` (unsigned 32-bit integer), `isc_int16_t` (signed
-16-bit integer). These may be used when `unsigned long` or `short` could
-be ambiguous.
+C99 standard integer types must be used when `unsigned long` or
+`short` could be ambiguous.
#### Clear Success or Failure
obj = cfg_tuple_get(alternates, "port");
if (cfg_obj_isuint32(obj)) {
- isc_uint32_t val = cfg_obj_asuint32(obj);
- if (val > ISC_UINT16_MAX) {
+ uint32_t val = cfg_obj_asuint32(obj);
+ if (val > UINT16_MAX) {
cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
"port '%u' out of range", val);
result = ISC_R_FAILURE;
}
obj = cfg_tuple_get(value, "port");
if (cfg_obj_isuint32(obj)) {
- isc_uint32_t val = cfg_obj_asuint32(obj);
- if (val > ISC_UINT16_MAX) {
+ uint32_t val = cfg_obj_asuint32(obj);
+ if (val > UINT16_MAX) {
cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
"port '%u' out of range", val);
result = ISC_R_FAILURE;
obj = NULL;
(void)cfg_map_get(options, "dscp", &obj);
if (obj != NULL) {
- isc_uint32_t dscp = cfg_obj_asuint32(obj);
+ uint32_t dscp = cfg_obj_asuint32(obj);
if (dscp >= 64) {
cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
"'dscp' out of range (0-63)");
const char *str;
dns_name_t *name;
isc_buffer_t b;
- isc_uint32_t lifetime = 3600;
+ uint32_t lifetime = 3600;
#if defined(HAVE_OPENSSL_AES) || defined(HAVE_OPENSSL_EVP_AES)
const char *ccalg = "aes";
#else
* have reasonable values.
*/
for (i = 0; i < sizeof(intervals) / sizeof(intervals[0]); i++) {
- isc_uint32_t val;
+ uint32_t val;
obj = NULL;
(void)cfg_map_get(options, intervals[i].name, &obj);
if (obj == NULL)
intervals[i].name, val,
intervals[i].max);
result = ISC_R_RANGE;
- } else if (val > (ISC_UINT32_MAX / intervals[i].scale)) {
+ } else if (val > (UINT32_MAX / intervals[i].scale)) {
cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
"%s '%d' is out of range",
intervals[i].name, val);
obj = NULL;
cfg_map_get(options, "max-rsa-exponent-size", &obj);
if (obj != NULL) {
- isc_uint32_t val;
+ uint32_t val;
val = cfg_obj_asuint32(obj);
if (val != 0 && (val < 35 || val > 4096)) {
obj = NULL;
cfg_map_get(options, "sig-validity-interval", &obj);
if (obj != NULL) {
- isc_uint32_t validity, resign = 0;
+ uint32_t validity, resign = 0;
validity = cfg_obj_asuint32(cfg_tuple_get(obj, "validity"));
resignobj = cfg_tuple_get(obj, "re-sign");
obj = NULL;
(void)cfg_map_get(options, "nta-recheck", &obj);
if (obj != NULL) {
- isc_uint32_t recheck = cfg_obj_asuint32(obj);
+ uint32_t recheck = cfg_obj_asuint32(obj);
if (recheck > 604800) { /* 7 days */
cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
"'nta-recheck' cannot exceed one week");
#ifdef HAVE_DNSTAP
for (i = 0; i < sizeof(fstrm) / sizeof(fstrm[0]); i++) {
- isc_uint32_t value;
+ uint32_t value;
obj = NULL;
(void) cfg_map_get(options, fstrm[i].name, &obj);
obj = NULL;
(void)cfg_map_get(options, "lmdb-mapsize", &obj);
if (obj != NULL) {
- isc_uint64_t mapsize = cfg_obj_asuint64(obj);
+ uint64_t mapsize = cfg_obj_asuint64(obj);
if (mapsize < (1ULL << 20)) { /* 1 megabyte */
cfg_obj_log(obj, logctx,
static isc_result_t
validate_masters(const cfg_obj_t *obj, const cfg_obj_t *config,
- isc_uint32_t *countp, isc_log_t *logctx, isc_mem_t *mctx)
+ uint32_t *countp, isc_log_t *logctx, isc_mem_t *mctx)
{
isc_result_t result = ISC_R_SUCCESS;
isc_result_t tresult;
- isc_uint32_t count = 0;
+ uint32_t count = 0;
isc_symtab_t *symtab = NULL;
isc_symvalue_t symvalue;
const cfg_listelt_t *element;
const cfg_listelt_t **stack = NULL;
- isc_uint32_t stackcount = 0, pushed = 0;
+ uint32_t stackcount = 0, pushed = 0;
const cfg_obj_t *list;
REQUIRE(countp != NULL);
/* Grow stack? */
if (stackcount == pushed) {
void * newstack;
- isc_uint32_t newlen = stackcount + 16;
+ uint32_t newlen = stackcount + 16;
size_t newsize, oldsize;
newsize = newlen * sizeof(*stack);
if (tresult != ISC_R_SUCCESS && goptions != NULL)
tresult = cfg_map_get(goptions, "also-notify", &obj);
if (tresult == ISC_R_SUCCESS && donotify) {
- isc_uint32_t count;
+ uint32_t count;
tresult = validate_masters(obj, config, &count,
logctx, mctx);
if (tresult != ISC_R_SUCCESS && result == ISC_R_SUCCESS)
znamestr);
result = ISC_R_FAILURE;
} else {
- isc_uint32_t count;
+ uint32_t count;
tresult = validate_masters(obj, config, &count,
logctx, mctx);
if (tresult != ISC_R_SUCCESS && result == ISC_R_SUCCESS)
obj = NULL;
res1 = cfg_map_get(zoptions, "sig-signing-type", &obj);
if (res1 == ISC_R_SUCCESS) {
- isc_uint32_t type = cfg_obj_asuint32(obj);
+ uint32_t type = cfg_obj_asuint32(obj);
if (type < 0xff00U || type > 0xffffU)
cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
"sig-signing-type: %u out of "
typedef struct keyalgorithms {
const char *name;
- isc_uint16_t size;
+ uint16_t size;
} algorithmtable;
isc_result_t
return (ISC_R_NOTFOUND);
}
if (algorithm[len] == '-') {
- isc_uint16_t digestbits;
+ uint16_t digestbits;
result = isc_parse_uint16(&digestbits, algorithm + len + 1, 10);
if (result == ISC_R_SUCCESS || result == ISC_R_RANGE) {
if (result == ISC_R_RANGE ||
isc_region_t r;
isc_result_t result = ISC_R_SUCCESS;
isc_result_t tresult;
- isc_uint32_t flags, proto, alg;
+ uint32_t flags, proto, alg;
unsigned char keydata[4096];
flags = cfg_obj_asuint32(cfg_tuple_get(key, "flags"));
const cfg_obj_t *unixcontrols;
const cfg_obj_t *keylist = NULL;
const char *path;
- isc_uint32_t perm, mask;
+ uint32_t perm, mask;
dns_acl_t *acl = NULL;
isc_sockaddr_t addr;
int i;
/*! \file */
#include <config.h>
+
+#include <inttypes.h>
#include <string.h>
#include <isc/net.h>
return (ISC_R_SUCCESS);
} else if (strlen(hostname) <= 127U) {
char tmpbuf[128], *d;
- isc_uint32_t zone = 0;
+ uint32_t zone = 0;
strlcpy(tmpbuf, hostname, sizeof(tmpbuf));
d = strchr(tmpbuf, '%');
memory_order_relaxed);
#else
#define acache_storetime(entry, t) \
- (isc_atomic_store((isc_int32_t *)&(entry)->lastused, (t)))
+ (isc_atomic_store((int32_t *)&(entry)->lastused, (t)))
#endif
#else
*/
if (cleaner->overmem) {
unsigned int passed;
- isc_uint32_t val;
+ uint32_t val;
if (isc_serial_ge(now32, entry->lastused))
passed = now32 - entry->lastused; /* <= interval */
{
dns_acacheentry_t *newentry;
isc_result_t result;
- isc_uint32_t r;
+ uint32_t r;
isc_stdtime_t tmptime;
REQUIRE(DNS_ACACHE_VALID(acache));
dns_acl_match2(const isc_netaddr_t *reqaddr,
const dns_name_t *reqsigner,
const isc_netaddr_t *ecs,
- isc_uint8_t ecslen,
- isc_uint8_t *scope,
+ uint8_t ecslen,
+ uint8_t *scope,
const dns_acl_t *acl,
const dns_aclenv_t *env,
int *match,
const dns_aclelement_t **matchelt)
{
- isc_uint16_t bitlen;
+ uint16_t bitlen;
isc_prefix_t pfx;
isc_radix_node_t *node = NULL;
const isc_netaddr_t *addr = reqaddr;
dns_aclelement_match2(const isc_netaddr_t *reqaddr,
const dns_name_t *reqsigner,
const isc_netaddr_t *ecs,
- isc_uint8_t ecslen,
- isc_uint8_t *scope,
+ uint8_t ecslen,
+ uint8_t *scope,
const dns_aclelement_t *e,
const dns_aclenv_t *env,
const dns_aclelement_t **matchelt)
#include <config.h>
#include <limits.h>
+#include <inttypes.h>
#include <isc/mutexblock.h>
#include <isc/netaddr.h>
isc_event_t grownames;
isc_boolean_t grownames_sent;
- isc_uint32_t quota;
- isc_uint32_t atr_freq;
+ uint32_t quota;
+ uint32_t atr_freq;
double atr_low;
double atr_high;
double atr_discount;
unsigned int flags;
unsigned int srtt;
- isc_uint16_t udpsize;
+ uint16_t udpsize;
unsigned int completed;
unsigned int timeouts;
unsigned char plain;
unsigned char edns;
unsigned char to4096; /* Our max. */
- isc_uint8_t mode;
- isc_uint32_t quota;
- isc_uint32_t active;
+ uint8_t mode;
+ uint32_t quota;
+ uint32_t active;
double atr;
/*
unsigned char to512; /* plain DNS */
isc_sockaddr_t sockaddr;
unsigned char * cookie;
- isc_uint16_t cookielen;
+ uint16_t cookielen;
isc_stdtime_t expires;
isc_stdtime_t lastage;
* Set adb-related statistics counters.
*/
static inline void
-set_adbstat(dns_adb_t *adb, isc_uint64_t val, isc_statscounter_t counter) {
+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 dns_adbentry_t *
new_adbentry(dns_adb_t *adb) {
dns_adbentry_t *e;
- isc_uint32_t r;
+ uint32_t r;
e = isc_mempool_get(adb->emp);
if (e == NULL)
adjustsrtt(dns_adbaddrinfo_t *addr, unsigned int rtt, unsigned int factor,
isc_stdtime_t now)
{
- isc_uint64_t new_srtt;
+ uint64_t new_srtt;
if (factor == DNS_ADB_RTTADJAGE) {
if (addr->entry->lastage != now) {
} else
new_srtt = addr->entry->srtt;
} else
- new_srtt = ((isc_uint64_t)addr->entry->srtt / 10 * factor)
- + ((isc_uint64_t)rtt / 10 * (10 - factor));
+ new_srtt = ((uint64_t)addr->entry->srtt / 10 * factor)
+ + ((uint64_t)rtt / 10 * (10 - factor));
addr->entry->srtt = (unsigned int) new_srtt;
addr->srtt = (unsigned int) new_srtt;
if (addr->entry->cookie == NULL && cookie != NULL && len != 0U) {
addr->entry->cookie = isc_mem_get(adb->mctx, len);
if (addr->entry->cookie != NULL)
- addr->entry->cookielen = (isc_uint16_t)len;
+ addr->entry->cookielen = (uint16_t)len;
}
if (addr->entry->cookie != NULL)
}
void
-dns_adb_setquota(dns_adb_t *adb, isc_uint32_t quota, isc_uint32_t freq,
+dns_adb_setquota(dns_adb_t *adb, uint32_t quota, uint32_t freq,
double low, double high, double discount)
{
REQUIRE(DNS_ADB_VALID(adb));
dns_bcentry_t * next;
dns_rdatatype_t type;
isc_time_t expire;
- isc_uint32_t flags;
+ uint32_t flags;
unsigned int hashval;
dns_name_t name;
};
void
dns_badcache_add(dns_badcache_t *bc, dns_name_t *name,
dns_rdatatype_t type, isc_boolean_t update,
- isc_uint32_t flags, isc_time_t *expire)
+ uint32_t flags, isc_time_t *expire)
{
isc_result_t result;
unsigned int i, hashval;
isc_boolean_t
dns_badcache_find(dns_badcache_t *bc, dns_name_t *name,
- dns_rdatatype_t type, isc_uint32_t *flagp,
+ dns_rdatatype_t type, uint32_t *flagp,
isc_time_t *now)
{
dns_bcentry_t *bad, *prev, *next;
dns_bcentry_t *bad, *next, *prev;
isc_time_t now;
unsigned int i;
- isc_uint64_t t;
+ uint64_t t;
REQUIRE(VALID_BADCACHE(bc));
REQUIRE(cachename != NULL);
#include <config.h>
#include <inttypes.h>
+#include <stdbool.h>
#include <isc/json.h>
#include <isc/mem.h>
void *arg; /* type dependent argument */
int ncounters; /* for general statistics */
int *counterindices; /* for general statistics */
- isc_uint64_t *countervalues; /* for general statistics */
+ uint64_t *countervalues; /* for general statistics */
isc_result_t result;
} cache_dumparg_t;
static void
-getcounter(isc_statscounter_t counter, isc_uint64_t val, void *arg) {
+getcounter(isc_statscounter_t counter, uint64_t val, void *arg) {
cache_dumparg_t *dumparg = arg;
REQUIRE(counter < dumparg->ncounters);
static void
getcounters(isc_stats_t *stats, isc_statsformat_t type, int ncounters,
- int *indices, isc_uint64_t *values)
+ int *indices, uint64_t *values)
{
cache_dumparg_t dumparg;
void
dns_cache_dumpstats(dns_cache_t *cache, FILE *fp) {
int indices[dns_cachestatscounter_max];
- isc_uint64_t values[dns_cachestatscounter_max];
+ uint64_t values[dns_cachestatscounter_max];
REQUIRE(VALID_CACHE(cache));
fprintf(fp, "%20u %s\n", dns_db_nodecount(cache->db),
"cache database nodes");
fprintf(fp, "%20" PRIu64 " %s\n",
- (isc_uint64_t) dns_db_hashsize(cache->db),
+ (uint64_t) dns_db_hashsize(cache->db),
"cache database hash buckets");
fprintf(fp, "%20" PRIu64 " %s\n",
- (isc_uint64_t) isc_mem_total(cache->mctx),
+ (uint64_t) isc_mem_total(cache->mctx),
"cache tree memory total");
fprintf(fp, "%20" PRIu64 " %s\n",
- (isc_uint64_t) isc_mem_inuse(cache->mctx),
+ (uint64_t) isc_mem_inuse(cache->mctx),
"cache tree memory in use");
fprintf(fp, "%20" PRIu64 " %s\n",
- (isc_uint64_t) isc_mem_maxinuse(cache->mctx),
+ (uint64_t) isc_mem_maxinuse(cache->mctx),
"cache tree highest memory in use");
fprintf(fp, "%20" PRIu64 " %s\n",
- (isc_uint64_t) isc_mem_total(cache->hmctx),
+ (uint64_t) isc_mem_total(cache->hmctx),
"cache heap memory total");
fprintf(fp, "%20" PRIu64 " %s\n",
- (isc_uint64_t) isc_mem_inuse(cache->hmctx),
+ (uint64_t) isc_mem_inuse(cache->hmctx),
"cache heap memory in use");
fprintf(fp, "%20" PRIu64 " %s\n",
- (isc_uint64_t) isc_mem_maxinuse(cache->hmctx),
+ (uint64_t) isc_mem_maxinuse(cache->hmctx),
"cache heap highest memory in use");
}
#ifdef HAVE_LIBXML2
#define TRY0(a) do { xmlrc = (a); if (xmlrc < 0) goto error; } while(0)
static int
-renderstat(const char *name, isc_uint64_t value, xmlTextWriterPtr writer) {
+renderstat(const char *name, uint64_t value, xmlTextWriterPtr writer) {
int xmlrc;
TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "counter"));
int
dns_cache_renderxml(dns_cache_t *cache, xmlTextWriterPtr writer) {
int indices[dns_cachestatscounter_max];
- isc_uint64_t values[dns_cachestatscounter_max];
+ uint64_t values[dns_cachestatscounter_max];
int xmlrc;
REQUIRE(VALID_CACHE(cache));
dns_cache_renderjson(dns_cache_t *cache, json_object *cstats) {
isc_result_t result = ISC_R_SUCCESS;
int indices[dns_cachestatscounter_max];
- isc_uint64_t values[dns_cachestatscounter_max];
+ uint64_t values[dns_cachestatscounter_max];
json_object *obj;
REQUIRE(VALID_CACHE(cache));
#include <config.h>
+#include <inttypes.h>
+
#include <isc/hex.h>
#include <isc/mem.h>
#include <isc/parseint.h>
dns_catz_options_t zoneoptions;
isc_time_t lastupdated;
isc_boolean_t updatepending;
- isc_uint32_t version;
+ uint32_t version;
dns_db_t *db;
dns_dbversion_t *dbversion;
&nentry->opts);
result = isc_ht_find(target->entries, key,
- (isc_uint32_t)keysize, (void **) &oentry);
+ (uint32_t)keysize, (void **) &oentry);
if (result != ISC_R_SUCCESS) {
- result = isc_ht_add(toadd, key, (isc_uint32_t)keysize,
+ result = isc_ht_add(toadd, key, (uint32_t)keysize,
nentry);
if (result != ISC_R_SUCCESS)
isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
}
if (dns_catz_entry_cmp(oentry, nentry) != ISC_TRUE) {
- result = isc_ht_add(tomod, key, (isc_uint32_t)keysize,
+ result = isc_ht_add(tomod, key, (uint32_t)keysize,
nentry);
if (result != ISC_R_SUCCESS)
isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
}
dns_catz_entry_detach(target, &oentry);
result = isc_ht_delete(target->entries, key,
- (isc_uint32_t)keysize);
+ (uint32_t)keysize);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
}
RUNTIME_CHECK(result == ISC_R_NOMORE);
dns_catz_options_init(&new_zone->zoneoptions);
new_zone->active = ISC_TRUE;
new_zone->db_registered = ISC_FALSE;
- new_zone->version = (isc_uint32_t)(-1);
+ new_zone->version = (uint32_t)(-1);
isc_refcount_init(&new_zone->refs, 1);
*zonep = new_zone;
dns_rdata_t rdata;
dns_rdata_txt_t rdatatxt;
dns_rdata_txt_string_t rdatastr;
- isc_uint32_t tversion;
+ uint32_t tversion;
char t[16];
REQUIRE(zone != NULL);
isc_buffer_t *buffer = NULL;
isc_region_t region;
isc_result_t result;
- isc_uint32_t i;
+ uint32_t i;
isc_netaddr_t netaddr;
char pbuf[sizeof("65535")]; /* used both for port number and DSCP */
char zname[DNS_NAME_FORMATSIZE];
dns_catz_zones_t *catzs;
dns_catz_zone_t *zone = NULL;
isc_time_t now;
- isc_uint64_t tdiff;
+ uint64_t tdiff;
isc_result_t result = ISC_R_SUCCESS;
isc_region_t r;
dns_rdataset_t rdataset;
char bname[DNS_NAME_FORMATSIZE];
isc_buffer_t ibname;
- isc_uint32_t vers;
+ uint32_t vers;
REQUIRE(DNS_DB_VALID(db));
REQUIRE(catzs != NULL);
*/
isc_boolean_t
dns_compress_findglobal(dns_compress_t *cctx, const dns_name_t *name,
- dns_name_t *prefix, isc_uint16_t *offset)
+ dns_name_t *prefix, uint16_t *offset)
{
dns_name_t tname, nname;
dns_compressnode_t *node = NULL;
void
dns_compress_add(dns_compress_t *cctx, const dns_name_t *name,
- const dns_name_t *prefix, isc_uint16_t offset)
+ const dns_name_t *prefix, uint16_t offset)
{
dns_name_t tname, xname;
unsigned int start;
dns_compressnode_t *node;
unsigned int length;
unsigned int tlength;
- isc_uint16_t toffset;
+ uint16_t toffset;
unsigned char *tmp;
isc_region_t r;
hash = dns_name_hash(&tname, ISC_FALSE) %
DNS_COMPRESS_TABLESIZE;
tlength = name_length(&tname);
- toffset = (isc_uint16_t)(offset + (length - tlength));
+ toffset = (uint16_t)(offset + (length - tlength));
if (toffset >= 0x4000)
break;
/*
toffset |= 0x8000;
node->offset = toffset;
dns_name_toregion(&tname, &node->r);
- node->labels = (isc_uint8_t)dns_name_countlabels(&tname);
+ node->labels = (uint8_t)dns_name_countlabels(&tname);
node->next = cctx->table[hash];
cctx->table[hash] = node;
start++;
}
void
-dns_compress_rollback(dns_compress_t *cctx, isc_uint16_t offset) {
+dns_compress_rollback(dns_compress_t *cctx, uint16_t offset) {
unsigned int i;
dns_compressnode_t *node;
#include <config.h>
+#include <inttypes.h>
+
#include <isc/buffer.h>
#include <isc/mem.h>
#include <isc/once.h>
}
isc_result_t
-dns_db_getsoaserial(dns_db_t *db, dns_dbversion_t *ver, isc_uint32_t *serialp)
+dns_db_getsoaserial(dns_db_t *db, dns_dbversion_t *ver, uint32_t *serialp)
{
isc_result_t result;
dns_dbnode_t *node = NULL;
isc_result_t
dns_db_getnsec3parameters(dns_db_t *db, dns_dbversion_t *version,
- dns_hash_t *hash, isc_uint8_t *flags,
- isc_uint16_t *iterations,
+ dns_hash_t *hash, uint8_t *flags,
+ uint16_t *iterations,
unsigned char *salt, size_t *salt_length)
{
REQUIRE(DNS_DB_VALID(db));
}
isc_result_t
-dns_db_getsize(dns_db_t *db, dns_dbversion_t *version, isc_uint64_t *records,
- isc_uint64_t *bytes)
+dns_db_getsize(dns_db_t *db, dns_dbversion_t *version, uint64_t *records,
+ uint64_t *bytes)
{
REQUIRE(DNS_DB_VALID(db));
REQUIRE(dns_db_iszone(db) == ISC_TRUE);
#include <config.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <isc/buffer.h>
setresign(dns_rdataset_t *modified) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_rrsig_t sig;
- isc_int64_t when;
+ int64_t when;
isc_result_t result;
result = dns_rdataset_first(modified);
#include <config.h>
+#include <inttypes.h>
+
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
static void udp_recv(isc_event_t *, dns_dispatch_t *, dispsocket_t *);
static void tcp_recv(isc_task_t *, isc_event_t *);
static isc_result_t startrecv(dns_dispatch_t *, dispsocket_t *);
-static isc_uint32_t dns_hash(dns_qid_t *, isc_sockaddr_t *, dns_messageid_t,
- in_port_t);
+static uint32_t dns_hash(dns_qid_t *, isc_sockaddr_t *, dns_messageid_t,
+ in_port_t);
static void free_buffer(dns_dispatch_t *disp, void *buf, unsigned int len);
static void *allocate_udp_buffer(dns_dispatch_t *disp);
static inline void free_devent(dns_dispatch_t *disp, dns_dispatchevent_t *ev);
/*
* Return a hash of the destination and message id.
*/
-static isc_uint32_t
+static uint32_t
dns_hash(dns_qid_t *qid, isc_sockaddr_t *dest, dns_messageid_t id,
in_port_t port)
{
- isc_uint32_t ret;
+ uint32_t ret;
ret = isc_sockaddr_hash(dest, ISC_TRUE);
- ret ^= ((isc_uint32_t)id << 16) | port;
+ ret ^= ((uint32_t)id << 16) | port;
ret %= qid->qid_nbuckets;
INSIST(ret < qid->qid_nbuckets);
in_port_t *portp)
{
int i;
- isc_uint32_t r;
+ uint32_t r;
dns_dispatchmgr_t *mgr = disp->mgr;
isc_socket_t *sock = NULL;
isc_result_t result = ISC_R_FAILURE;
#include <config.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <isc/buffer.h>
isc_result_t ret;
isc_buffer_t *databuf = NULL;
char data[256 + 8];
- isc_uint32_t flags;
+ uint32_t flags;
unsigned int sigsize;
dns_fixedname_t fnewname;
dns_fixedname_t fsigner;
isc_buffer_usedregion(&envbuf, &r);
for (i = 0; i < nrdatas; i++) {
- isc_uint16_t len;
+ uint16_t len;
isc_buffer_t lenbuf;
isc_region_t lenr;
*/
isc_buffer_init(&lenbuf, &len, sizeof(len));
INSIST(rdatas[i].length < 65536);
- isc_buffer_putuint16(&lenbuf, (isc_uint16_t)rdatas[i].length);
+ isc_buffer_putuint16(&lenbuf, (uint16_t)rdatas[i].length);
isc_buffer_usedregion(&lenbuf, &lenr);
ret = dst_context_adddata(ctx, &lenr);
if (ret != ISC_R_SUCCESS)
unsigned char data[300];
dst_context_t *ctx = NULL;
int labels = 0;
- isc_uint32_t flags;
+ uint32_t flags;
isc_boolean_t downcase = ISC_FALSE;
REQUIRE(name != NULL);
/*
* Is SIG temporally valid?
*/
- if (isc_serial_lt((isc_uint32_t)now, sig.timesigned)) {
+ if (isc_serial_lt((uint32_t)now, sig.timesigned)) {
inc_stat(dns_dnssecstats_fail);
return (DNS_R_SIGFUTURE);
- } else if (isc_serial_lt(sig.timeexpire, (isc_uint32_t)now)) {
+ } else if (isc_serial_lt(sig.timeexpire, (uint32_t)now)) {
inc_stat(dns_dnssecstats_fail);
return (DNS_R_SIGEXPIRED);
}
isc_buffer_usedregion(&envbuf, &r);
for (i = 0; i < nrdatas; i++) {
- isc_uint16_t len;
+ uint16_t len;
isc_buffer_t lenbuf;
isc_region_t lenr;
*/
isc_buffer_init(&lenbuf, &len, sizeof(len));
INSIST(rdatas[i].length < 65536);
- isc_buffer_putuint16(&lenbuf, (isc_uint16_t)rdatas[i].length);
+ isc_buffer_putuint16(&lenbuf, (uint16_t)rdatas[i].length);
isc_buffer_usedregion(&lenbuf, &lenr);
/*
* by named. Try loading the unrevoked version.
*/
if (result == ISC_R_FILENOTFOUND) {
- isc_uint32_t flags;
+ uint32_t flags;
flags = dst_key_flags(pubkey);
if ((flags & DNS_KEYFLAG_REVOKE) != 0) {
dst_key_setflags(pubkey,
dst_context_t *ctx = NULL;
isc_mem_t *mctx;
isc_result_t result;
- isc_uint16_t addcount, addcount_n;
+ uint16_t addcount, addcount_n;
isc_boolean_t signeedsfree = ISC_FALSE;
REQUIRE(source != NULL);
}
isc_stdtime_get(&now);
- if (isc_serial_lt((isc_uint32_t)now, sig.timesigned)) {
+ if (isc_serial_lt((uint32_t)now, sig.timesigned)) {
result = DNS_R_SIGFUTURE;
msg->sig0status = dns_tsigerror_badtime;
goto failure;
}
- else if (isc_serial_lt(sig.timeexpire, (isc_uint32_t)now)) {
+ else if (isc_serial_lt(sig.timeexpire, (uint32_t)now)) {
result = DNS_R_SIGEXPIRED;
msg->sig0status = dns_tsigerror_badtime;
goto failure;
*/
memmove(&addcount, &header[DNS_MESSAGE_HEADERLEN - 2], 2);
addcount_n = ntohs(addcount);
- addcount = htons((isc_uint16_t)(addcount_n - 1));
+ addcount = htons((uint16_t)(addcount_n - 1));
memmove(&header[DNS_MESSAGE_HEADERLEN - 2], &addcount, 2);
/*
* If it hasn't already been done, we should also revoke it now.
*/
if (key->hint_publish && (revset && revoke <= now)) {
- isc_uint32_t flags;
+ uint32_t flags;
key->hint_sign = ISC_TRUE;
flags = dst_key_flags(key->key);
if ((flags & DNS_KEYFLAG_REVOKE) == 0) {
for (key = ISC_LIST_HEAD(*keylist);
key != NULL;
key = ISC_LIST_NEXT(key, link)) {
- isc_uint16_t keyid, sigid;
+ uint16_t keyid, sigid;
dns_secalg_t keyalg, sigalg;
keyid = dst_key_id(key->key);
keyalg = dst_key_alg(key->key);
* by named. Try loading the unrevoked version.
*/
if (result == ISC_R_FILENOTFOUND) {
- isc_uint32_t flags;
+ uint32_t flags;
flags = dst_key_flags(pubkey);
if ((flags & DNS_KEYFLAG_REVOKE) != 0) {
dst_key_setflags(pubkey,
#error DNSTAP not configured.
#endif /* HAVE_DNSTAP */
+#include <inttypes.h>
#include <stdlib.h>
#include <isc/buffer.h>
static void
setaddr(dns_dtmsg_t *dm, isc_sockaddr_t *sa, isc_boolean_t tcp,
ProtobufCBinaryData *addr, protobuf_c_boolean *has_addr,
- isc_uint32_t *port, protobuf_c_boolean *has_port)
+ uint32_t *port, protobuf_c_boolean *has_port)
{
int family = isc_sockaddr_pf(sa);
*port = ntohs(sa->type.sin6.sin6_port);
} else {
dm->m.socket_family = DNSTAP__SOCKET_FAMILY__INET;
- addr->data = (isc_uint8_t *) &sa->type.sin.sin_addr.s_addr;
+ addr->data = (uint8_t *) &sa->type.sin.sin_addr.s_addr;
addr->len = 4;
*port = ntohs(sa->type.sin.sin_port);
}
dnstap_file(struct fstrm_reader *r) {
fstrm_res res;
const struct fstrm_control *control = NULL;
- const isc_uint8_t *rtype = NULL;
+ const uint8_t *rtype = NULL;
size_t dlen = strlen(DNSTAP_CONTENT_TYPE), rlen = 0;
size_t n = 0;
}
isc_result_t
-dns_dt_getframe(dns_dthandle_t *handle, isc_uint8_t **bufp, size_t *sizep) {
- const isc_uint8_t *data;
+dns_dt_getframe(dns_dthandle_t *handle, uint8_t **bufp, size_t *sizep) {
+ const uint8_t *data;
fstrm_res res;
REQUIRE(handle != NULL);
REQUIRE(bufp != NULL);
REQUIRE(sizep != NULL);
- data = (const isc_uint8_t *) *bufp;
+ data = (const uint8_t *) *bufp;
res = fstrm_reader_read(handle->reader, &data, sizep);
switch (res) {
#include <config.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <time.h>
if (isc_buffer_availablelength(target) < 4)
return (ISC_R_NOSPACE);
- isc_buffer_putuint16(target, (isc_uint16_t)(key->key_flags & 0xffff));
- isc_buffer_putuint8(target, (isc_uint8_t)key->key_proto);
- isc_buffer_putuint8(target, (isc_uint8_t)key->key_alg);
+ isc_buffer_putuint16(target, (uint16_t)(key->key_flags & 0xffff));
+ isc_buffer_putuint8(target, (uint8_t)key->key_proto);
+ isc_buffer_putuint8(target, (uint8_t)key->key_alg);
if (key->key_flags & DNS_KEYFLAG_EXTENDED) {
if (isc_buffer_availablelength(target) < 2)
return (ISC_R_NOSPACE);
isc_buffer_putuint16(target,
- (isc_uint16_t)((key->key_flags >> 16)
+ (uint16_t)((key->key_flags >> 16)
& 0xffff));
}
dst_key_fromdns(dns_name_t *name, dns_rdataclass_t rdclass,
isc_buffer_t *source, isc_mem_t *mctx, dst_key_t **keyp)
{
- isc_uint8_t alg, proto;
- isc_uint32_t flags, extflags;
+ uint8_t alg, proto;
+ uint32_t flags, extflags;
dst_key_t *key = NULL;
dns_keytag_t id, rid;
isc_region_t r;
}
isc_result_t
-dst_key_getnum(const dst_key_t *key, int type, isc_uint32_t *valuep)
+dst_key_getnum(const dst_key_t *key, int type, uint32_t *valuep)
{
REQUIRE(VALID_KEY(key));
REQUIRE(valuep != NULL);
}
void
-dst_key_setnum(dst_key_t *key, int type, isc_uint32_t value)
+dst_key_setnum(dst_key_t *key, int type, uint32_t value)
{
REQUIRE(VALID_KEY(key));
REQUIRE(type <= DST_MAX_NUMERIC);
* Set the flags on a key, then recompute the key ID
*/
isc_result_t
-dst_key_setflags(dst_key_t *key, isc_uint32_t flags) {
+dst_key_setflags(dst_key_t *key, uint32_t flags) {
REQUIRE(VALID_KEY(key));
key->key_flags = flags;
return (computeid(key));
unsigned int opt = ISC_LEXOPT_DNSMULTILINE;
dns_rdataclass_t rdclass = dns_rdataclass_in;
isc_lexspecials_t specials;
- isc_uint32_t ttl = 0;
+ uint32_t ttl = 0;
isc_result_t result;
dns_rdatatype_t keytype;
#ifndef DST_DST_INTERNAL_H
#define DST_DST_INTERNAL_H 1
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <isc/buffer.h>
-#include <isc/int.h>
#include <isc/magic.h>
#include <isc/region.h>
#include <isc/types.h>
unsigned int key_size; /*%< size of the key in bits */
unsigned int key_proto; /*%< protocols this key is used for */
unsigned int key_alg; /*%< algorithm of the key */
- isc_uint32_t key_flags; /*%< flags of the public key */
- isc_uint16_t key_id; /*%< identifier of the key */
- isc_uint16_t key_rid; /*%< identifier of the key when
+ uint32_t key_flags; /*%< flags of the public key */
+ uint16_t key_id; /*%< identifier of the key */
+ uint16_t key_rid; /*%< identifier of the key when
revoked */
- isc_uint16_t key_bits; /*%< hmac digest bits */
+ uint16_t key_bits; /*%< hmac digest bits */
dns_rdataclass_t key_class; /*%< class of the key record */
dns_ttl_t key_ttl; /*%< default/initial dnskey ttl */
isc_mem_t *mctx; /*%< memory context */
#include <config.h>
+#include <inttypes.h>
+
#include <isc/base64.h>
#include <isc/dir.h>
#include <isc/file.h>
char buffer[MAXFIELDSIZE * 2];
isc_fsaccess_t access;
isc_stdtime_t when;
- isc_uint32_t value;
+ uint32_t value;
isc_buffer_t b;
isc_region_t r;
int major, minor;
* family and addr6 fields are to be used IPv6 is added.
*/
typedef struct geoip_state {
- isc_uint16_t subtype;
+ uint16_t subtype;
unsigned int family;
- isc_uint32_t ipnum;
+ uint32_t ipnum;
geoipv6_t ipnum6;
- isc_uint8_t scope;
+ uint8_t scope;
GeoIPRecord *record;
GeoIPRegion *region;
const char *text;
}
static isc_result_t
-set_state(unsigned int family, isc_uint32_t ipnum, const geoipv6_t *ipnum6,
- isc_uint8_t scope, dns_geoip_subtype_t subtype, GeoIPRecord *record,
+set_state(unsigned int family, uint32_t ipnum, const geoipv6_t *ipnum6,
+ uint8_t scope, dns_geoip_subtype_t subtype, GeoIPRecord *record,
GeoIPRegion *region, char *name, const char *text, int id)
{
geoip_state_t *state = NULL;
}
static geoip_state_t *
-get_state_for(unsigned int family, isc_uint32_t ipnum,
+get_state_for(unsigned int family, uint32_t ipnum,
const geoipv6_t *ipnum6)
{
geoip_state_t *state;
static const char *
country_lookup(GeoIP *db, dns_geoip_subtype_t subtype,
unsigned int family,
- isc_uint32_t ipnum, const geoipv6_t *ipnum6,
- isc_uint8_t *scope)
+ uint32_t ipnum, const geoipv6_t *ipnum6,
+ uint8_t *scope)
{
geoip_state_t *prev_state = NULL;
const char *text = NULL;
*/
static GeoIPRecord *
city_lookup(GeoIP *db, dns_geoip_subtype_t subtype,
- unsigned int family, isc_uint32_t ipnum,
+ unsigned int family, uint32_t ipnum,
const geoipv6_t *ipnum6,
- isc_uint8_t *scope)
+ uint8_t *scope)
{
GeoIPRecord *record = NULL;
geoip_state_t *prev_state = NULL;
*/
static GeoIPRegion *
region_lookup(GeoIP *db, dns_geoip_subtype_t subtype,
- isc_uint32_t ipnum, isc_uint8_t *scope)
+ uint32_t ipnum, uint8_t *scope)
{
GeoIPRegion *region = NULL;
geoip_state_t *prev_state = NULL;
*/
static char *
name_lookup(GeoIP *db, dns_geoip_subtype_t subtype,
- isc_uint32_t ipnum, isc_uint8_t *scope)
+ uint32_t ipnum, uint8_t *scope)
{
char *name = NULL;
geoip_state_t *prev_state = NULL;
*/
static int
netspeed_lookup(GeoIP *db, dns_geoip_subtype_t subtype,
- isc_uint32_t ipnum, isc_uint8_t *scope)
+ uint32_t ipnum, uint8_t *scope)
{
geoip_state_t *prev_state = NULL;
isc_boolean_t found = ISC_FALSE;
#endif /* HAVE_GEOIP */
isc_boolean_t
-dns_geoip_match(const isc_netaddr_t *reqaddr, isc_uint8_t *scope,
+dns_geoip_match(const isc_netaddr_t *reqaddr, uint8_t *scope,
const dns_geoip_databases_t *geoip,
const dns_geoip_elem_t *elt)
{
GeoIPRecord *record;
GeoIPRegion *region;
dns_geoip_subtype_t subtype;
- isc_uint32_t ipnum = 0;
+ uint32_t ipnum = 0;
int maxlen = 0, id, family;
const char *cs;
char *s;
#include <config.h>
#include <ctype.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
* call chain for reporting to the user.
*/
static void
-gss_err_message(isc_mem_t *mctx, isc_uint32_t major, isc_uint32_t minor,
+gss_err_message(isc_mem_t *mctx, uint32_t major, uint32_t minor,
char **err_message)
{
char buf[1024];
}
char *
-gss_error_tostring(isc_uint32_t major, isc_uint32_t minor,
+gss_error_tostring(uint32_t major, uint32_t minor,
char *buf, size_t buflen) {
#ifdef GSSAPI
gss_buffer_desc msg_minor = GSS_C_EMPTY_BUFFER,
dns_acl_match2(const isc_netaddr_t *reqaddr,
const dns_name_t *reqsigner,
const isc_netaddr_t *ecs,
- isc_uint8_t ecslen,
- isc_uint8_t *scope,
+ uint8_t ecslen,
+ uint8_t *scope,
const dns_acl_t *acl,
const dns_aclenv_t *env,
int *match,
dns_aclelement_match2(const isc_netaddr_t *reqaddr,
const dns_name_t *reqsigner,
const isc_netaddr_t *ecs,
- isc_uint8_t ecslen,
- isc_uint8_t *scope,
+ uint8_t ecslen,
+ uint8_t *scope,
const dns_aclelement_t *e,
const dns_aclenv_t *env,
const dns_aclelement_t **matchelt);
*** Imports
***/
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <isc/magic.h>
#include <isc/mem.h>
*/
void
-dns_adb_setquota(dns_adb_t *adb, isc_uint32_t quota, isc_uint32_t freq,
+dns_adb_setquota(dns_adb_t *adb, uint32_t quota, uint32_t freq,
double low, double high, double discount);
/*%<
* Set the baseline ADB quota, and configure parameters for the
*** Imports
***/
+#include <inttypes.h>
+
#include <dns/types.h>
ISC_LANG_BEGINDECLS
void
dns_badcache_add(dns_badcache_t *bc, dns_name_t *name,
dns_rdatatype_t type, isc_boolean_t update,
- isc_uint32_t flags, isc_time_t *expire);
+ uint32_t flags, isc_time_t *expire);
/*%
* Adds a badcache entry to the badcache 'bc' for name 'name' and
* type 'type'. If an entry already exists, then it will be updated if
isc_boolean_t
dns_badcache_find(dns_badcache_t *bc, dns_name_t *name,
- dns_rdatatype_t type, isc_uint32_t *flagp,
+ dns_rdatatype_t type, uint32_t *flagp,
isc_time_t *now);
/*%
* Returns ISC_TRUE if a record is found in the badcache 'bc' matching
/*! \file dns/bit.h */
-#include <isc/int.h>
-#include <isc/boolean.h>
+#include <inttypes.h>
-typedef isc_uint64_t dns_bitset_t;
+typedef uint64_t dns_bitset_t;
#define DNS_BIT_SET(bit, bitset) \
(*(bitset) |= ((dns_bitset_t)1 << (bit)))
#ifndef DNS_CATZ_H
#define DNS_CATZ_H 1
+#include <inttypes.h>
+
#include <isc/ht.h>
#include <isc/lang.h>
#include <isc/refcount.h>
* of catalog zone is received before this time the update will be
* postponed. This is a global option for the whole catalog zone.
*/
- isc_uint32_t min_update_interval;
+ uint32_t min_update_interval;
};
void
***** Imports
*****/
+#include <inttypes.h>
+
#include <isc/sockaddr.h>
#include <isc/types.h>
#define DNS_CLIENTINFO_VERSION 2
typedef struct dns_clientinfo {
- isc_uint16_t version;
+ uint16_t version;
void *data;
void *dbversion;
} dns_clientinfo_t;
#define DNS_CLIENTINFOMETHODS_AGE 0
typedef struct dns_clientinfomethods {
- isc_uint16_t version;
- isc_uint16_t age;
+ uint16_t version;
+ uint16_t age;
dns_clientinfo_sourceip_t sourceip;
} dns_clientinfomethods_t;
#ifndef DNS_COMPRESS_H
#define DNS_COMPRESS_H 1
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <isc/region.h>
struct dns_compressnode {
isc_region_t r;
- isc_uint16_t offset;
- isc_uint16_t count;
- isc_uint8_t labels;
+ uint16_t offset;
+ uint16_t count;
+ uint8_t labels;
dns_compressnode_t *next;
};
dns_compressnode_t *table[DNS_COMPRESS_TABLESIZE];
/*% Preallocated nodes for the table. */
dns_compressnode_t initialnodes[DNS_COMPRESS_INITIALNODES];
- isc_uint16_t count; /*%< Number of nodes. */
+ uint16_t count; /*%< Number of nodes. */
isc_mem_t *mctx; /*%< Memory context. */
};
isc_boolean_t
dns_compress_findglobal(dns_compress_t *cctx, const dns_name_t *name,
- dns_name_t *prefix, isc_uint16_t *offset);
+ dns_name_t *prefix, uint16_t *offset);
/*%<
* Finds longest possible match of 'name' in the global compression table.
*
*\li 'cctx' to be initialized.
*\li 'name' to be a absolute name.
*\li 'prefix' to be initialized.
- *\li 'offset' to point to an isc_uint16_t.
+ *\li 'offset' to point to an uint16_t.
*
* Ensures:
*\li 'prefix' and 'offset' are valid if ISC_TRUE is returned.
void
dns_compress_add(dns_compress_t *cctx, const dns_name_t *name,
- const dns_name_t *prefix, isc_uint16_t offset);
+ const dns_name_t *prefix, uint16_t offset);
/*%<
* Add compression pointers for 'name' to the compression table,
* not replacing existing pointers.
*/
void
-dns_compress_rollback(dns_compress_t *cctx, isc_uint16_t offset);
+dns_compress_rollback(dns_compress_t *cctx, uint16_t offset);
/*%<
* Remove any compression pointers from global table >= offset.
***** Imports
*****/
+#include <inttypes.h>
+
#include <isc/deprecated.h>
#include <isc/lang.h>
#include <isc/magic.h>
isc_result_t (*getnsec3parameters)(dns_db_t *db,
dns_dbversion_t *version,
dns_hash_t *hash,
- isc_uint8_t *flags,
- isc_uint16_t *iterations,
+ uint8_t *flags,
+ uint16_t *iterations,
unsigned char *salt,
size_t *salt_len);
isc_result_t (*findnsec3node)(dns_db_t *db, dns_name_t *name,
isc_result_t (*nodefullname)(dns_db_t *db, dns_dbnode_t *node,
dns_name_t *name);
isc_result_t (*getsize)(dns_db_t *db, dns_dbversion_t *version,
- isc_uint64_t *records, isc_uint64_t *bytes);
+ uint64_t *records, uint64_t *bytes);
} dns_dbmethods_t;
typedef isc_result_t
unsigned int magic;
unsigned int impmagic;
dns_dbmethods_t * methods;
- isc_uint16_t attributes;
+ uint16_t attributes;
dns_rdataclass_t rdclass;
dns_name_t origin;
isc_ondestroy_t ondest;
*/
isc_result_t
-dns_db_getsoaserial(dns_db_t *db, dns_dbversion_t *ver, isc_uint32_t *serialp);
+dns_db_getsoaserial(dns_db_t *db, dns_dbversion_t *ver, uint32_t *serialp);
/*%<
* Get the current SOA serial number from a zone database.
*
isc_result_t
dns_db_getnsec3parameters(dns_db_t *db, dns_dbversion_t *version,
- dns_hash_t *hash, isc_uint8_t *flags,
- isc_uint16_t *interations,
+ dns_hash_t *hash, uint8_t *flags,
+ uint16_t *interations,
unsigned char *salt, size_t *salt_length);
/*%<
* Get the NSEC3 parameters that are associated with this zone.
*/
isc_result_t
-dns_db_getsize(dns_db_t *db, dns_dbversion_t *version, isc_uint64_t *records,
- isc_uint64_t *bytes);
+dns_db_getsize(dns_db_t *db, dns_dbversion_t *version, uint64_t *records,
+ uint64_t *bytes);
/*%<
* Get the number of records in the given version of the database as well
* as the number bytes used to store those records.
struct dns_dispatchevent {
ISC_EVENT_COMMON(dns_dispatchevent_t); /*%< standard event common */
isc_result_t result; /*%< result code */
- isc_int32_t id; /*%< message id */
+ int32_t id; /*%< message id */
isc_sockaddr_t addr; /*%< address recv'd from */
struct in6_pktinfo pktinfo; /*%< reply info for v6 */
isc_buffer_t buffer; /*%< data buffer */
- isc_uint32_t attributes; /*%< mirrored from socket.h */
+ uint32_t attributes; /*%< mirrored from socket.h */
};
/*%
dns_dispatch_addresponse3(dns_dispatch_t *disp, unsigned int options,
isc_sockaddr_t *dest, isc_task_t *task,
isc_taskaction_t action, void *arg,
- isc_uint16_t *idp, dns_dispentry_t **resp,
+ uint16_t *idp, dns_dispentry_t **resp,
isc_socketmgr_t *sockmgr);
isc_result_t
dns_dispatch_addresponse2(dns_dispatch_t *disp, isc_sockaddr_t *dest,
isc_task_t *task, isc_taskaction_t action, void *arg,
- isc_uint16_t *idp, dns_dispentry_t **resp,
+ uint16_t *idp, dns_dispentry_t **resp,
isc_socketmgr_t *sockmgr);
isc_result_t
dns_dispatch_addresponse(dns_dispatch_t *disp, isc_sockaddr_t *dest,
isc_task_t *task, isc_taskaction_t action, void *arg,
- isc_uint16_t *idp, dns_dispentry_t **resp);
+ uint16_t *idp, dns_dispentry_t **resp);
/*%<
* Add a response entry for this dispatch.
*
#ifndef DLZ_DLOPEN_H
#define DLZ_DLOPEN_H
+#include <inttypes.h>
+
#include <dns/sdlz.h>
ISC_LANG_BEGINDECLS
const char *tcpaddr,
const char *type,
const char *key,
- isc_uint32_t keydatalen,
+ uint32_t keydatalen,
unsigned char *keydata,
void *dbdata);
* file dnstap.proto, which is compiled to dnstap.pb-c.c and dnstap.pb-c.h.
*/
+#include <inttypes.h>
+
#ifdef HAVE_DNSTAP
#include <fstrm.h>
#include <protobuf-c/protobuf-c.h>
isc_region_t qaddr;
isc_region_t raddr;
- isc_uint32_t qport;
- isc_uint32_t rport;
+ uint32_t qport;
+ uint32_t rport;
isc_region_t msgdata;
dns_message_t *msg;
*/
isc_result_t
-dns_dt_getframe(dns_dthandle_t *handle, isc_uint8_t **bufp, size_t *sizep);
+dns_dt_getframe(dns_dthandle_t *handle, uint8_t **bufp, size_t *sizep);
/*%<
* Read a dnstap frame from the framstream reader in 'handle', storing
* a pointer to it in '*bufp' and its size in '*sizep'.
ISC_LANG_BEGINDECLS
isc_boolean_t
-dns_geoip_match(const isc_netaddr_t *reqaddr, isc_uint8_t *scope,
+dns_geoip_match(const isc_netaddr_t *reqaddr, uint8_t *scope,
const dns_geoip_databases_t *geoip,
const dns_geoip_elem_t *elt);
#ifndef DNS_IPKEYLIST_H
#define DNS_IPKEYLIST_H 1
+#include <inttypes.h>
+
#include <isc/types.h>
#include <dns/types.h>
isc_dscp_t *dscps;
dns_name_t **keys;
dns_name_t **labels;
- isc_uint32_t count;
- isc_uint32_t allocated;
+ uint32_t count;
+ uint32_t allocated;
};
void
isc_result_t
dns_iptable_addprefix(dns_iptable_t *tab, isc_netaddr_t *addr,
- isc_uint16_t bitlen, isc_boolean_t pos);
+ uint16_t bitlen, isc_boolean_t pos);
isc_result_t
dns_iptable_addprefix2(dns_iptable_t *tab, isc_netaddr_t *addr,
- isc_uint16_t bitlen, isc_boolean_t pos,
+ uint16_t bitlen, isc_boolean_t pos,
isc_boolean_t is_ecs);
/*
* Add an IP prefix to an existing IP table
*** Imports
***/
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <isc/magic.h>
* Reading transactions from journals.
*/
-isc_uint32_t
+uint32_t
dns_journal_first_serial(dns_journal_t *j);
-isc_uint32_t
+uint32_t
dns_journal_last_serial(dns_journal_t *j);
/*%<
* Get the first and last addressable serial number in the journal.
isc_result_t
dns_journal_iter_init(dns_journal_t *j,
- isc_uint32_t begin_serial, isc_uint32_t end_serial);
+ uint32_t begin_serial, uint32_t end_serial);
/*%<
* Prepare to iterate over the transactions that will bring the database
* from SOA serial number 'begin_serial' to 'end_serial'.
/*@}*/
void
-dns_journal_current_rr(dns_journal_t *j, dns_name_t **name, isc_uint32_t *ttl,
+dns_journal_current_rr(dns_journal_t *j, dns_name_t **name, uint32_t *ttl,
dns_rdata_t **rdata);
/*%<
* Get the name, ttl, and rdata of the current journal RR.
*/
isc_result_t
-dns_journal_compact(isc_mem_t *mctx, char *filename, isc_uint32_t serial,
- isc_uint32_t target_size);
+dns_journal_compact(isc_mem_t *mctx, char *filename, uint32_t serial,
+ uint32_t target_size);
/*%<
* Attempt to compact the journal if it is greater that 'target_size'.
* Changes from 'serial' onwards will be preserved. If the journal
*/
isc_boolean_t
-dns_journal_get_sourceserial(dns_journal_t *j, isc_uint32_t *sourceserial);
+dns_journal_get_sourceserial(dns_journal_t *j, uint32_t *sourceserial);
void
-dns_journal_set_sourceserial(dns_journal_t *j, isc_uint32_t sourceserial);
+dns_journal_set_sourceserial(dns_journal_t *j, uint32_t sourceserial);
/*%<
* Get and set source serial.
*
*** Imports
***/
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <isc/types.h>
isc_result_t
dns_keydata_fromdnskey(dns_rdata_keydata_t *keydata,
dns_rdata_dnskey_t *dnskey,
- isc_uint32_t refresh, isc_uint32_t addhd,
- isc_uint32_t removehd, isc_mem_t *mctx);
+ uint32_t refresh, uint32_t addhd,
+ uint32_t removehd, isc_mem_t *mctx);
ISC_LANG_ENDDECLS
/* Common header */
struct dns_masterrawheader {
- isc_uint32_t format; /* must be
+ uint32_t format; /* must be
* dns_masterformat_raw
* or
* dns_masterformat_map */
- isc_uint32_t version; /* compatibility for future
+ uint32_t version; /* compatibility for future
* extensions */
- isc_uint32_t dumptime; /* timestamp on creation
+ uint32_t dumptime; /* timestamp on creation
* (currently unused) */
- isc_uint32_t flags; /* Flags */
- isc_uint32_t sourceserial; /* Source serial number (used
+ uint32_t flags; /* Flags */
+ uint32_t sourceserial; /* Source serial number (used
* by inline-signing zones) */
- isc_uint32_t lastxfrin; /* timestamp of last transfer
+ uint32_t lastxfrin; /* timestamp of last transfer
* (used by slave zones) */
};
/* The structure for each RRset */
typedef struct {
- isc_uint32_t totallen; /* length of the data for this
+ uint32_t totallen; /* length of the data for this
* RRset, including the
* "header" part */
dns_rdataclass_t rdclass; /* 16-bit class */
dns_rdatatype_t type; /* 16-bit type */
dns_rdatatype_t covers; /* same as type */
dns_ttl_t ttl; /* 32-bit TTL */
- isc_uint32_t nrdata; /* number of RRs in this set */
+ uint32_t nrdata; /* number of RRs in this set */
/* followed by encoded owner name, and then rdata */
} dns_masterrawrdataset_t;
dns_name_t *origin,
dns_rdataclass_t zclass,
unsigned int options,
- isc_uint32_t resign,
+ uint32_t resign,
dns_rdatacallbacks_t *callbacks,
isc_mem_t *mctx,
dns_masterformat_t format);
dns_name_t *origin,
dns_rdataclass_t zclass,
unsigned int options,
- isc_uint32_t resign,
+ uint32_t resign,
dns_rdatacallbacks_t *callbacks,
dns_masterincludecb_t include_cb,
void *include_arg, isc_mem_t *mctx,
dns_name_t *origin,
dns_rdataclass_t zclass,
unsigned int options,
- isc_uint32_t resign,
+ uint32_t resign,
dns_rdatacallbacks_t *callbacks,
dns_masterincludecb_t include_cb,
void *include_arg, isc_mem_t *mctx,
dns_name_t *origin,
dns_rdataclass_t zclass,
unsigned int options,
- isc_uint32_t resign,
+ uint32_t resign,
dns_rdatacallbacks_t *callbacks,
isc_task_t *task,
dns_loaddonefunc_t done, void *done_arg,
dns_name_t *origin,
dns_rdataclass_t zclass,
unsigned int options,
- isc_uint32_t resign,
+ uint32_t resign,
dns_rdatacallbacks_t *callbacks,
isc_task_t *task,
dns_loaddonefunc_t done, void *done_arg,
dns_name_t *origin,
dns_rdataclass_t zclass,
unsigned int options,
- isc_uint32_t resign,
+ uint32_t resign,
dns_rdatacallbacks_t *callbacks,
isc_task_t *task,
dns_loaddonefunc_t done, void *done_arg,
dns_loadctx_t **ctxp,
dns_masterincludecb_t include_cb, void *include_arg,
isc_mem_t *mctx, dns_masterformat_t format,
- isc_uint32_t maxttl);
+ uint32_t maxttl);
isc_result_t
dns_master_loadstreaminc(FILE *stream,
*** Imports
***/
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <isc/magic.h>
#define DNS_MESSAGE_REPLYPRESERVE (DNS_MESSAGEFLAG_RD|DNS_MESSAGEFLAG_CD)
#define DNS_MESSAGEEXTFLAG_REPLYPRESERVE (DNS_MESSAGEEXTFLAG_DO)
-#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 isc_uint16_t's */
+#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */
#define DNS_MESSAGE_MAGIC ISC_MAGIC('M','S','G','@')
#define DNS_MESSAGE_VALID(msg) ISC_MAGIC_VALID(msg, DNS_MESSAGE_MAGIC)
};
struct dns_ednsopt {
- isc_uint16_t code;
- isc_uint16_t length;
+ uint16_t code;
+ uint16_t length;
unsigned char *value;
};
isc_result_t
dns_message_buildopt(dns_message_t *msg, dns_rdataset_t **opt,
- unsigned int version, isc_uint16_t udpsize,
+ unsigned int version, uint16_t udpsize,
unsigned int flags, dns_ednsopt_t *ednsopts, size_t count);
/*%<
* Built a opt record.
***/
#include <stdio.h>
+#include <inttypes.h>
#include <isc/boolean.h>
#include <isc/lang.h>
* DNSSEC validation.
*/
+#include <inttypes.h>
+
#include <isc/buffer.h>
#include <isc/lang.h>
#include <isc/magic.h>
isc_timermgr_t *timermgr;
isc_task_t *task;
/* Locked by rwlock. */
- isc_uint32_t references;
+ uint32_t references;
dns_rbt_t *table;
};
isc_result_t
dns_ntatable_add(dns_ntatable_t *ntatable, dns_name_t *name,
isc_boolean_t force, isc_stdtime_t now,
- isc_uint32_t lifetime);
+ uint32_t lifetime);
/*%<
* Add a negative trust anchor to 'ntatable' for name 'name',
* which will expire at time 'now' + 'lifetime'. If 'force' is ISC_FALSE,
*** Imports
***/
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <isc/magic.h>
#include <isc/netaddr.h>
struct dns_peerlist {
unsigned int magic;
- isc_uint32_t refs;
+ uint32_t refs;
isc_mem_t *mem;
struct dns_peer {
unsigned int magic;
- isc_uint32_t refs;
+ uint32_t refs;
isc_mem_t *mem;
unsigned int prefixlen;
isc_boolean_t bogus;
dns_transfer_format_t transfer_format;
- isc_uint32_t transfers;
+ uint32_t transfers;
isc_boolean_t support_ixfr;
isc_boolean_t provide_ixfr;
isc_boolean_t request_ixfr;
isc_dscp_t notify_dscp;
isc_sockaddr_t *query_source;
isc_dscp_t query_dscp;
- isc_uint16_t udpsize; /* receive size */
- isc_uint16_t maxudp; /* transmit size */
- isc_uint8_t ednsversion; /* edns version */
+ uint16_t udpsize; /* receive size */
+ uint16_t maxudp; /* transmit size */
+ uint8_t ednsversion; /* edns version */
- isc_uint32_t bitflags;
+ uint32_t bitflags;
ISC_LINK(dns_peer_t) next;
};
dns_peer_getsupportedns(dns_peer_t *peer, isc_boolean_t *retval);
isc_result_t
-dns_peer_settransfers(dns_peer_t *peer, isc_uint32_t newval);
+dns_peer_settransfers(dns_peer_t *peer, uint32_t newval);
isc_result_t
-dns_peer_gettransfers(dns_peer_t *peer, isc_uint32_t *retval);
+dns_peer_gettransfers(dns_peer_t *peer, uint32_t *retval);
isc_result_t
dns_peer_settransferformat(dns_peer_t *peer, dns_transfer_format_t newval);
dns_peer_gettransfersource(dns_peer_t *peer, isc_sockaddr_t *transfer_source);
isc_result_t
-dns_peer_setudpsize(dns_peer_t *peer, isc_uint16_t udpsize);
+dns_peer_setudpsize(dns_peer_t *peer, uint16_t udpsize);
isc_result_t
-dns_peer_getudpsize(dns_peer_t *peer, isc_uint16_t *udpsize);
+dns_peer_getudpsize(dns_peer_t *peer, uint16_t *udpsize);
isc_result_t
-dns_peer_setmaxudp(dns_peer_t *peer, isc_uint16_t maxudp);
+dns_peer_setmaxudp(dns_peer_t *peer, uint16_t maxudp);
isc_result_t
-dns_peer_getmaxudp(dns_peer_t *peer, isc_uint16_t *maxudp);
+dns_peer_getmaxudp(dns_peer_t *peer, uint16_t *maxudp);
isc_result_t
dns_peer_setnotifysource(dns_peer_t *peer, const isc_sockaddr_t *notify_source);
dns_peer_getquerydscp(dns_peer_t *peer, isc_dscp_t *dscpp);
isc_result_t
-dns_peer_setednsversion(dns_peer_t *peer, isc_uint8_t ednsversion);
+dns_peer_setednsversion(dns_peer_t *peer, uint8_t ednsversion);
isc_result_t
-dns_peer_getednsversion(dns_peer_t *peer, isc_uint8_t *ednsversion);
+dns_peer_getednsversion(dns_peer_t *peer, uint8_t *ednsversion);
ISC_LANG_ENDDECLS
#endif /* DNS_PEER_H */
/*! \file dns/rbt.h */
+#include <inttypes.h>
+
#include <isc/assertions.h>
#include <isc/crc64.h>
#include <isc/lang.h>
typedef isc_result_t (*dns_rbtdatawriter_t)(FILE *file,
unsigned char *data,
void *arg,
- isc_uint64_t *crc);
+ uint64_t *crc);
typedef isc_result_t (*dns_rbtdatafixer_t)(dns_rbtnode_t *rbtnode,
void *base, size_t offset,
- void *arg, isc_uint64_t *crc);
+ void *arg, uint64_t *crc);
typedef void (*dns_rbtdeleter_t)(void *, void *);
*\li None.
*/
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <isc/magic.h>
#include <isc/stdtime.h>
unsigned int attributes;
/*%
* the counter provides the starting point in the "cyclic" order.
- * The value ISC_UINT32_MAX has a special meaning of "picking up a
+ * The value UINT32_MAX has a special meaning of "picking up a
* random value." in order to take care of databases that do not
* increment the counter.
*/
- isc_uint32_t count;
+ uint32_t count;
/*
* This RRSIG RRset should be re-generated around this time.
* Only valid if DNS_RDATASETATTR_RESIGN is set in attributes.
*\li Drafts: TBS
*/
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <isc/socket.h>
#include <isc/stats.h>
dns_rdatatype_t type,
dns_name_t *domain, dns_rdataset_t *nameservers,
dns_forwarders_t *forwarders,
- isc_sockaddr_t *client, isc_uint16_t id,
+ isc_sockaddr_t *client, uint16_t id,
unsigned int options, isc_task_t *task,
isc_taskaction_t action, void *arg,
dns_rdataset_t *rdataset,
dns_rdatatype_t type,
dns_name_t *domain, dns_rdataset_t *nameservers,
dns_forwarders_t *forwarders,
- isc_sockaddr_t *client, isc_uint16_t id,
+ isc_sockaddr_t *client, uint16_t id,
unsigned int options, unsigned int depth,
isc_counter_t *qc, isc_task_t *task,
isc_taskaction_t action, void *arg,
isc_taskmgr_t *
dns_resolver_taskmgr(dns_resolver_t *resolver);
-isc_uint32_t
+uint32_t
dns_resolver_getlamettl(dns_resolver_t *resolver);
/*%<
* Get the resolver's lame-ttl. zero => no lame processing.
*/
void
-dns_resolver_setlamettl(dns_resolver_t *resolver, isc_uint32_t lame_ttl);
+dns_resolver_setlamettl(dns_resolver_t *resolver, uint32_t lame_ttl);
/*%<
* Set the resolver's lame-ttl. zero => no lame processing.
*
*/
void
-dns_resolver_setudpsize(dns_resolver_t *resolver, isc_uint16_t udpsize);
+dns_resolver_setudpsize(dns_resolver_t *resolver, uint16_t udpsize);
/*%<
* Set the EDNS UDP buffer size advertised by the server.
*/
-isc_uint16_t
+uint16_t
dns_resolver_getudpsize(dns_resolver_t *resolver);
/*%<
* Get the current EDNS UDP buffer size.
void
dns_resolver_setclientsperquery(dns_resolver_t *resolver,
- isc_uint32_t min, isc_uint32_t max);
+ uint32_t min, uint32_t max);
void
-dns_resolver_setfetchesperzone(dns_resolver_t *resolver, isc_uint32_t clients);
+dns_resolver_setfetchesperzone(dns_resolver_t *resolver, uint32_t clients);
void
-dns_resolver_getclientsperquery(dns_resolver_t *resolver, isc_uint32_t *cur,
- isc_uint32_t *min, isc_uint32_t *max);
+dns_resolver_getclientsperquery(dns_resolver_t *resolver, uint32_t *cur,
+ uint32_t *min, uint32_t *max);
isc_boolean_t
dns_resolver_getzeronosoattl(dns_resolver_t *resolver);
#define DNS_RPZ_TCP_ONLY_NAME DNS_RPZ_PREFIX"tcp-only"
-typedef isc_uint8_t dns_rpz_prefix_t;
+typedef uint8_t dns_rpz_prefix_t;
typedef enum {
DNS_RPZ_TYPE_BAD,
DNS_RPZ_POLICY_ERROR
} dns_rpz_policy_t;
-typedef isc_uint8_t dns_rpz_num_t;
+typedef uint8_t dns_rpz_num_t;
#define DNS_RPZ_MAX_ZONES 32
#if DNS_RPZ_MAX_ZONES > 32
# if DNS_RPZ_MAX_ZONES > 64
# error "rpz zone bit masks must fit in a word"
# endif
-typedef isc_uint64_t dns_rpz_zbits_t;
+typedef uint64_t dns_rpz_zbits_t;
#else
-typedef isc_uint32_t dns_rpz_zbits_t;
+typedef uint32_t dns_rpz_zbits_t;
#endif
#define DNS_RPZ_ALL_ZBITS ((dns_rpz_zbits_t)-1)
ISC_LANG_ENDDECLS
#endif /* DNS_RPZ_H */
-
***** Imports
*****/
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <isc/magic.h>
#include <isc/ondestroy.h>
void
dns_rriterator_current(dns_rriterator_t *it, dns_name_t **name,
- isc_uint32_t *ttl, dns_rdataset_t **rdataset,
+ uint32_t *ttl, dns_rdataset_t **rdataset,
dns_rdata_t **rdata);
/*%<
* Make '*name' refer to the current name. If 'rdataset' is not NULL,
* Rate limit DNS responses.
*/
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <dns/fixedname.h>
#define DNS_RRL_MAX_PREFIX 64
typedef union dns_rrl_key dns_rrl_key_t;
struct dns__rrl_key {
- isc_uint32_t ip[DNS_RRL_MAX_PREFIX/32];
- isc_uint32_t qname_hash;
+ uint32_t ip[DNS_RRL_MAX_PREFIX/32];
+ uint32_t qname_hash;
dns_rdatatype_t qtype;
- isc_uint8_t qclass;
+ uint8_t qclass;
unsigned int rtype :4; /* dns_rrl_rtype_t */
unsigned int ipv6 :1;
};
union dns_rrl_key {
struct dns__rrl_key s;
- isc_uint16_t w[sizeof(struct dns__rrl_key)/sizeof(isc_uint16_t)];
+ uint16_t w[sizeof(struct dns__rrl_key)/sizeof(uint16_t)];
};
/*
isc_stdtime_t ts_bases[DNS_RRL_TS_BASES];
int ipv4_prefixlen;
- isc_uint32_t ipv4_mask;
+ uint32_t ipv4_mask;
int ipv6_prefixlen;
- isc_uint32_t ipv6_mask[4];
+ uint32_t ipv6_mask[4];
isc_stdtime_t log_stops_time;
dns_rrl_entry_t *last_logged;
*** Imports
***/
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <dns/clientinfo.h>
isc_result_t
dns_sdb_putsoa(dns_sdblookup_t *lookup, const char *mname, const char *rname,
- isc_uint32_t serial);
+ uint32_t serial);
/*%<
* This function may optionally be called from the 'authority' callback
* to simplify construction of the SOA record for 'zone'. It will
#ifndef SDLZ_H
#define SDLZ_H 1
+#include <inttypes.h>
+
#include <dns/clientinfo.h>
#include <dns/dlz.h>
const char *tcpaddr,
const char *type,
const char *key,
- isc_uint32_t keydatalen,
+ uint32_t keydatalen,
unsigned char *keydata,
void *driverarg,
void *dbdata);
typedef isc_result_t dns_sdlz_putsoa_t(dns_sdlzlookup_t *lookup,
const char *mname,
const char *rname,
- isc_uint32_t serial);
+ uint32_t serial);
dns_sdlz_putsoa_t dns_sdlz_putsoa;
/*%<
* This function may optionally be called from the 'authority'
*** Imports
***/
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <isc/types.h>
isc_result_t
dns_soa_buildrdata(dns_name_t *origin, dns_name_t *contact,
dns_rdataclass_t rdclass,
- isc_uint32_t serial, isc_uint32_t refresh,
- isc_uint32_t retry, isc_uint32_t expire,
- isc_uint32_t minimum, unsigned char *buffer,
+ uint32_t serial, uint32_t refresh,
+ uint32_t retry, uint32_t expire,
+ uint32_t minimum, unsigned char *buffer,
dns_rdata_t *rdata);
/*%<
* Build the rdata of an SOA record.
* refers to 'buffer'.
*/
-isc_uint32_t
+uint32_t
dns_soa_getserial(dns_rdata_t *rdata);
-isc_uint32_t
+uint32_t
dns_soa_getrefresh(dns_rdata_t *rdata);
-isc_uint32_t
+uint32_t
dns_soa_getretry(dns_rdata_t *rdata);
-isc_uint32_t
+uint32_t
dns_soa_getexpire(dns_rdata_t *rdata);
-isc_uint32_t
+uint32_t
dns_soa_getminimum(dns_rdata_t *rdata);
/*
* Extract an integer field from the rdata of a SOA record.
*/
void
-dns_soa_setserial(isc_uint32_t val, dns_rdata_t *rdata);
+dns_soa_setserial(uint32_t val, dns_rdata_t *rdata);
void
-dns_soa_setrefresh(isc_uint32_t val, dns_rdata_t *rdata);
+dns_soa_setrefresh(uint32_t val, dns_rdata_t *rdata);
void
-dns_soa_setretry(isc_uint32_t val, dns_rdata_t *rdata);
+dns_soa_setretry(uint32_t val, dns_rdata_t *rdata);
void
-dns_soa_setexpire(isc_uint32_t val, dns_rdata_t *rdata);
+dns_soa_setexpire(uint32_t val, dns_rdata_t *rdata);
void
-dns_soa_setminimum(isc_uint32_t val, dns_rdata_t *rdata);
+dns_soa_setminimum(uint32_t val, dns_rdata_t *rdata);
/*
* Change an integer field of a SOA record by modifying the
* rdata in-place.
/*! \file dns/stats.h */
+#include <inttypes.h>
+
#include <dns/types.h>
/*%
/*%<
* Types of dump callbacks.
*/
-typedef void (*dns_generalstats_dumper_t)(isc_statscounter_t, isc_uint64_t,
+typedef void (*dns_generalstats_dumper_t)(isc_statscounter_t, uint64_t,
void *);
-typedef void (*dns_rdatatypestats_dumper_t)(dns_rdatastatstype_t, isc_uint64_t,
+typedef void (*dns_rdatatypestats_dumper_t)(dns_rdatastatstype_t, uint64_t,
void *);
-typedef void (*dns_opcodestats_dumper_t)(dns_opcode_t, isc_uint64_t, void *);
+typedef void (*dns_opcodestats_dumper_t)(dns_opcode_t, uint64_t, void *);
-typedef void (*dns_rcodestats_dumper_t)(dns_rcode_t, isc_uint64_t, void *);
+typedef void (*dns_rcodestats_dumper_t)(dns_rcode_t, uint64_t, void *);
ISC_LANG_BEGINDECLS
*/
isc_result_t
-dns_stats_alloccounters(isc_mem_t *mctx, isc_uint64_t **ctrp);
+dns_stats_alloccounters(isc_mem_t *mctx, uint64_t **ctrp);
/*%<
* Allocate an array of query statistics counters from the memory
* context 'mctx'.
*/
void
-dns_stats_freecounters(isc_mem_t *mctx, isc_uint64_t **ctrp);
+dns_stats_freecounters(isc_mem_t *mctx, uint64_t **ctrp);
/*%<
* Free an array of query statistics counters allocated from the memory
* context 'mctx'.
/*! \file dns/tcpmsg.h */
+#include <inttypes.h>
+
#include <isc/buffer.h>
#include <isc/lang.h>
#include <isc/socket.h>
typedef struct dns_tcpmsg {
/* private (don't touch!) */
unsigned int magic;
- isc_uint16_t size;
+ uint16_t size;
isc_buffer_t buffer;
unsigned int maxsize;
isc_mem_t *mctx;
*** Imports
***/
+#include <inttypes.h>
+
#include <isc/buffer.h>
#include <isc/lang.h>
***/
isc_result_t
-dns_time64_fromtext(const char *source, isc_int64_t *target);
+dns_time64_fromtext(const char *source, int64_t *target);
/*%<
* Convert a date and time in YYYYMMDDHHMMSS text format at 'source'
* into to a 64-bit count of seconds since Jan 1 1970 0:00 GMT.
*/
isc_result_t
-dns_time32_fromtext(const char *source, isc_uint32_t *target);
+dns_time32_fromtext(const char *source, uint32_t *target);
/*%<
* Like dns_time64_fromtext, but returns the second count modulo 2^32
* as per RFC2535.
isc_result_t
-dns_time64_totext(isc_int64_t value, isc_buffer_t *target);
+dns_time64_totext(int64_t value, isc_buffer_t *target);
/*%<
* Convert a 64-bit count of seconds since Jan 1 1970 0:00 GMT into
* a YYYYMMDDHHMMSS text representation and append it to 'target'.
*/
isc_result_t
-dns_time32_totext(isc_uint32_t value, isc_buffer_t *target);
+dns_time32_totext(uint32_t value, isc_buffer_t *target);
/*%<
* Like dns_time64_totext, but for a 32-bit cyclic time value.
* Of those dates whose counts of seconds since Jan 1 1970 0:00 GMT
* current date is chosen.
*/
-isc_int64_t
-dns_time64_from32(isc_uint32_t value);
+int64_t
+dns_time64_from32(uint32_t value);
/*%<
* Covert a 32-bit cyclic time value into a 64 bit time stamp.
*/
/*! \file dns/tkey.h */
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <dns/types.h>
isc_result_t
dns_tkey_builddhquery(dns_message_t *msg, dst_key_t *key, dns_name_t *name,
dns_name_t *algorithm, isc_buffer_t *nonce,
- isc_uint32_t lifetime);
+ uint32_t lifetime);
/*%<
* Builds a query containing a TKEY that will generate a shared
* secret using a Diffie-Hellman key exchange. The shared key
isc_result_t
dns_tkey_buildgssquery(dns_message_t *msg, dns_name_t *name, dns_name_t *gname,
- isc_buffer_t *intoken, isc_uint32_t lifetime,
+ isc_buffer_t *intoken, uint32_t lifetime,
gss_ctx_id_t *context, isc_boolean_t win2k,
isc_mem_t *mctx, char **err_message);
/*%<
***/
isc_result_t
-dns_ttl_totext(isc_uint32_t src, isc_boolean_t verbose,
+dns_ttl_totext(uint32_t src, isc_boolean_t verbose,
isc_buffer_t *target);
isc_result_t
-dns_ttl_totext2(isc_uint32_t src, isc_boolean_t verbose,
+dns_ttl_totext2(uint32_t src, isc_boolean_t verbose,
isc_boolean_t upcase, isc_buffer_t *target);
/*%<
* Output a TTL or other time interval in a human-readable form.
*/
isc_result_t
-dns_counter_fromtext(isc_textregion_t *source, isc_uint32_t *ttl);
+dns_counter_fromtext(isc_textregion_t *source, uint32_t *ttl);
/*%<
* Converts a counter from either a plain number or a BIND 8 style value.
*
*/
isc_result_t
-dns_ttl_fromtext(isc_textregion_t *source, isc_uint32_t *ttl);
+dns_ttl_fromtext(isc_textregion_t *source, uint32_t *ttl);
/*%<
* Converts a ttl from either a plain number or a BIND 8 style value.
*
*/
#include <stdio.h>
+#include <inttypes.h>
#include <isc/types.h>
typedef void dns_clientreqtrans_t;
typedef void dns_clientupdatetrans_t;
typedef struct dns_cache dns_cache_t;
-typedef isc_uint16_t dns_cert_t;
+typedef uint16_t dns_cert_t;
typedef struct dns_compress dns_compress_t;
typedef struct dns_db dns_db_t;
typedef struct dns_dbimplementation dns_dbimplementation_t;
typedef ISC_LIST(dns_dns64_t) dns_dns64list_t;
typedef struct dns_dnsseckey dns_dnsseckey_t;
typedef ISC_LIST(dns_dnsseckey_t) dns_dnsseckeylist_t;
-typedef isc_uint8_t dns_dsdigest_t;
+typedef uint8_t dns_dsdigest_t;
typedef struct dns_dtdata dns_dtdata_t;
typedef struct dns_dtenv dns_dtenv_t;
typedef struct dns_dtmsg dns_dtmsg_t;
-typedef isc_uint16_t dns_dtmsgtype_t;
+typedef uint16_t dns_dtmsgtype_t;
typedef struct dns_dumpctx dns_dumpctx_t;
typedef struct dns_ednsopt dns_ednsopt_t;
typedef struct dns_fetch dns_fetch_t;
typedef struct dns_forwarder dns_forwarder_t;
typedef struct dns_fwdtable dns_fwdtable_t;
typedef struct dns_iptable dns_iptable_t;
-typedef isc_uint32_t dns_iterations_t;
-typedef isc_uint16_t dns_keyflags_t;
+typedef uint32_t dns_iterations_t;
+typedef uint16_t dns_keyflags_t;
typedef struct dns_keynode dns_keynode_t;
typedef ISC_LIST(dns_keynode_t) dns_keynodelist_t;
typedef struct dns_keytable dns_keytable_t;
-typedef isc_uint16_t dns_keytag_t;
+typedef uint16_t dns_keytag_t;
typedef struct dns_loadctx dns_loadctx_t;
typedef struct dns_loadmgr dns_loadmgr_t;
typedef struct dns_masterrawheader dns_masterrawheader_t;
-typedef isc_uint64_t dns_masterstyle_flags_t;
+typedef uint64_t dns_masterstyle_flags_t;
typedef struct dns_message dns_message_t;
-typedef isc_uint16_t dns_messageid_t;
+typedef uint16_t dns_messageid_t;
typedef isc_region_t dns_label_t;
typedef struct dns_lookup dns_lookup_t;
typedef struct dns_name dns_name_t;
typedef ISC_LIST(dns_name_t) dns_namelist_t;
typedef struct dns_nta dns_nta_t;
typedef struct dns_ntatable dns_ntatable_t;
-typedef isc_uint16_t dns_opcode_t;
+typedef uint16_t dns_opcode_t;
typedef unsigned char dns_offsets_t[128];
typedef struct dns_order dns_order_t;
typedef struct dns_peer dns_peer_t;
typedef struct dns_peerlist dns_peerlist_t;
typedef struct dns_portlist dns_portlist_t;
typedef struct dns_rbt dns_rbt_t;
-typedef isc_uint16_t dns_rcode_t;
+typedef uint16_t dns_rcode_t;
typedef struct dns_rdata dns_rdata_t;
typedef struct dns_rdatacallbacks dns_rdatacallbacks_t;
-typedef isc_uint16_t dns_rdataclass_t;
+typedef uint16_t dns_rdataclass_t;
typedef struct dns_rdatalist dns_rdatalist_t;
typedef struct dns_rdataset dns_rdataset_t;
typedef ISC_LIST(dns_rdataset_t) dns_rdatasetlist_t;
typedef struct dns_rdatasetiter dns_rdatasetiter_t;
-typedef isc_uint16_t dns_rdatatype_t;
+typedef uint16_t dns_rdatatype_t;
typedef struct dns_request dns_request_t;
typedef struct dns_requestmgr dns_requestmgr_t;
typedef struct dns_resolver dns_resolver_t;
typedef struct dns_sdbimplementation dns_sdbimplementation_t;
-typedef isc_uint8_t dns_secalg_t;
-typedef isc_uint8_t dns_secproto_t;
+typedef uint8_t dns_secalg_t;
+typedef uint8_t dns_secproto_t;
typedef struct dns_signature dns_signature_t;
typedef struct dns_ssurule dns_ssurule_t;
typedef struct dns_ssutable dns_ssutable_t;
typedef struct dns_stats dns_stats_t;
-typedef isc_uint32_t dns_rdatastatstype_t;
+typedef uint32_t dns_rdatastatstype_t;
typedef struct dns_tkeyctx dns_tkeyctx_t;
-typedef isc_uint16_t dns_trust_t;
+typedef uint16_t dns_trust_t;
typedef struct dns_tsec dns_tsec_t;
typedef struct dns_tsig_keyring dns_tsig_keyring_t;
typedef struct dns_tsigkey dns_tsigkey_t;
-typedef isc_uint32_t dns_ttl_t;
+typedef uint32_t dns_ttl_t;
typedef struct dns_update_state dns_update_state_t;
typedef struct dns_validator dns_validator_t;
typedef struct dns_view dns_view_t;
*** Imports
***/
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <dns/types.h>
*** Functions
***/
-isc_uint32_t
-dns_update_soaserial(isc_uint32_t serial, dns_updatemethod_t method);
+uint32_t
+dns_update_soaserial(uint32_t serial, dns_updatemethod_t method);
/*%<
* Return the next serial number after 'serial', depending on the
* update method 'method':
isc_result_t
dns_update_signatures(dns_update_log_t *log, dns_zone_t *zone, dns_db_t *db,
dns_dbversion_t *oldver, dns_dbversion_t *newver,
- dns_diff_t *diff, isc_uint32_t sigvalidityinterval);
+ dns_diff_t *diff, uint32_t sigvalidityinterval);
isc_result_t
dns_update_signaturesinc(dns_update_log_t *log, dns_zone_t *zone, dns_db_t *db,
dns_dbversion_t *oldver, dns_dbversion_t *newver,
- dns_diff_t *diff, isc_uint32_t sigvalidityinterval,
+ dns_diff_t *diff, uint32_t sigvalidityinterval,
dns_update_state_t **state);
ISC_LANG_ENDDECLS
*/
#include <stdio.h>
+#include <inttypes.h>
#include <isc/lang.h>
#include <isc/magic.h>
isc_boolean_t sendcookie;
dns_ttl_t maxcachettl;
dns_ttl_t maxncachettl;
- isc_uint32_t nta_lifetime;
- isc_uint32_t nta_recheck;
+ uint32_t nta_lifetime;
+ uint32_t nta_recheck;
char *nta_file;
dns_ttl_t prefetch_trigger;
dns_ttl_t prefetch_eligible;
isc_boolean_t checknames;
dns_name_t * dlv;
dns_fixedname_t dlv_fixed;
- isc_uint16_t maxudp;
- isc_uint16_t nocookieudp;
+ uint16_t maxudp;
+ uint16_t nocookieudp;
unsigned int maxbits;
dns_aaaa_t v4_aaaa;
dns_aaaa_t v6_aaaa;
dns_catz_zones_t *catzs;
dns_dlzdblist_t dlz_searched;
dns_dlzdblist_t dlz_unsearched;
- isc_uint32_t fail_ttl;
+ uint32_t fail_ttl;
dns_badcache_t *failcache;
/*
char * new_zone_file;
char * new_zone_db;
void * new_zone_dbenv;
- isc_uint64_t new_zone_mapsize;
+ uint64_t new_zone_mapsize;
void * new_zone_config;
void (*cfg_destroy)(void **);
isc_mutex_t new_zone_lock;
isc_result_t
dns_view_setnewzones(dns_view_t *view, isc_boolean_t allow, void *cfgctx,
- void (*cfg_destroy)(void **), isc_uint64_t mapsize);
+ void (*cfg_destroy)(void **), uint64_t mapsize);
/*%<
* Set whether or not to allow zones to be created or deleted at runtime.
*
* \li 'dbp' is not NULL and *dbp is NULL.
*/
-isc_uint32_t
+uint32_t
dns_view_getfailttl(dns_view_t *view);
/*%<
* Get the view's servfail-ttl. zero => no servfail caching.
*/
void
-dns_view_setfailttl(dns_view_t *view, isc_uint32_t failttl);
+dns_view_setfailttl(dns_view_t *view, uint32_t failttl);
/*%<
* Set the view's servfail-ttl. zero => no servfail caching.
*
*/
isc_result_t
-dns_zone_getserial2(dns_zone_t *zone, isc_uint32_t *serialp);
+dns_zone_getserial2(dns_zone_t *zone, uint32_t *serialp);
-isc_uint32_t
+uint32_t
dns_zone_getserial(dns_zone_t *zone);
/*%<
* Returns the current serial number of the zone. On success, the SOA
*/
void
-dns_zone_setmaxrecords(dns_zone_t *zone, isc_uint32_t records);
+dns_zone_setmaxrecords(dns_zone_t *zone, uint32_t records);
/*%<
* Sets the maximim number of records permitted in a zone.
* 0 implies unlimited.
*\li void
*/
-isc_uint32_t
+uint32_t
dns_zone_getmaxrecords(dns_zone_t *zone);
/*%<
* Gets the maximim number of records permitted in a zone.
*\li 'zone' to be valid initialised zone.
*
* Returns:
- *\li isc_uint32_t maxrecords.
+ *\li uint32_t maxrecords.
*/
void
-dns_zone_setmaxttl(dns_zone_t *zone, isc_uint32_t maxttl);
+dns_zone_setmaxttl(dns_zone_t *zone, uint32_t maxttl);
/*%<
* Sets the max ttl of the zone.
*
isc_result_t
dns_zone_dumptostream3(dns_zone_t *zone, FILE *fd, dns_masterformat_t format,
const dns_master_style_t *style,
- const isc_uint32_t rawversion);
+ const uint32_t rawversion);
/*%<
* Write the zone to stream 'fd' in the specified 'format'.
* If the 'format' is dns_masterformat_text (RFC1035), 'style' also
isc_result_t
dns_zone_setmasters(dns_zone_t *zone, const isc_sockaddr_t *masters,
- isc_uint32_t count);
+ uint32_t count);
isc_result_t
dns_zone_setmasterswithkeys(dns_zone_t *zone,
const isc_sockaddr_t *masters,
dns_name_t **keynames,
- isc_uint32_t count);
+ uint32_t count);
/*%<
* Set the list of master servers for the zone.
*
isc_result_t
dns_zone_setalsonotify(dns_zone_t *zone, const isc_sockaddr_t *notify,
- isc_uint32_t count);
+ uint32_t count);
isc_result_t
dns_zone_setalsonotifywithkeys(dns_zone_t *zone, const isc_sockaddr_t *notify,
- dns_name_t **keynames, isc_uint32_t count);
+ dns_name_t **keynames, uint32_t count);
isc_result_t
dns_zone_setalsonotifydscpkeys(dns_zone_t *zone, const isc_sockaddr_t *notify,
const isc_dscp_t *dscps, dns_name_t **keynames,
- isc_uint32_t count);
+ uint32_t count);
/*%<
* Set the list of additional servers to be notified when
* a zone changes. To clear the list use 'count = 0'.
*/
void
-dns_zone_setminrefreshtime(dns_zone_t *zone, isc_uint32_t val);
+dns_zone_setminrefreshtime(dns_zone_t *zone, uint32_t val);
/*%<
* Set the minimum refresh time.
*
*/
void
-dns_zone_setmaxrefreshtime(dns_zone_t *zone, isc_uint32_t val);
+dns_zone_setmaxrefreshtime(dns_zone_t *zone, uint32_t val);
/*%<
* Set the maximum refresh time.
*
*/
void
-dns_zone_setminretrytime(dns_zone_t *zone, isc_uint32_t val);
+dns_zone_setminretrytime(dns_zone_t *zone, uint32_t val);
/*%<
* Set the minimum retry time.
*
*/
void
-dns_zone_setmaxretrytime(dns_zone_t *zone, isc_uint32_t val);
+dns_zone_setmaxretrytime(dns_zone_t *zone, uint32_t val);
/*%<
* Set the maximum retry time.
*
*/
void
-dns_zone_setjournalsize(dns_zone_t *zone, isc_int32_t size);
+dns_zone_setjournalsize(dns_zone_t *zone, int32_t size);
/*%<
* Sets the journal size for the zone.
*
*\li 'zone' to be a valid zone.
*/
-isc_int32_t
+int32_t
dns_zone_getjournalsize(dns_zone_t *zone);
/*%<
* Return the journal size as set with a previous call to
*/
void
-dns_zone_setmaxxfrin(dns_zone_t *zone, isc_uint32_t maxxfrin);
+dns_zone_setmaxxfrin(dns_zone_t *zone, uint32_t maxxfrin);
/*%<
* Set the maximum time (in seconds) that a zone transfer in (AXFR/IXFR)
* of this zone will use before being aborted.
* \li 'zone' to be valid initialised zone.
*/
-isc_uint32_t
+uint32_t
dns_zone_getmaxxfrin(dns_zone_t *zone);
/*%<
* Returns the maximum transfer time for this zone. This will be
*/
void
-dns_zone_setmaxxfrout(dns_zone_t *zone, isc_uint32_t maxxfrout);
+dns_zone_setmaxxfrout(dns_zone_t *zone, uint32_t maxxfrout);
/*%<
* Set the maximum time (in seconds) that a zone transfer out (AXFR/IXFR)
* of this zone will use before being aborted.
* \li 'zone' to be valid initialised zone.
*/
-isc_uint32_t
+uint32_t
dns_zone_getmaxxfrout(dns_zone_t *zone);
/*%<
* Returns the maximum transfer time for this zone. This will be
* Others
*/
-isc_uint32_t
+uint32_t
dns_zone_getidlein(dns_zone_t *zone);
/*%<
* Requires:
*/
void
-dns_zone_setidlein(dns_zone_t *zone, isc_uint32_t idlein);
+dns_zone_setidlein(dns_zone_t *zone, uint32_t idlein);
/*%<
* \li Set the idle timeout for transfer the.
* \li Zero set the default value, 1 hour.
* \li 'zone' to be a valid zone.
*/
-isc_uint32_t
+uint32_t
dns_zone_getidleout(dns_zone_t *zone);
/*%<
*
*/
void
-dns_zone_setidleout(dns_zone_t *zone, isc_uint32_t idleout);
+dns_zone_setidleout(dns_zone_t *zone, uint32_t idleout);
/*%<
* \li Set the idle timeout for transfers out.
* \li Zero set the default value, 1 hour.
*/
void
-dns_zone_setsigvalidityinterval(dns_zone_t *zone, isc_uint32_t interval);
+dns_zone_setsigvalidityinterval(dns_zone_t *zone, uint32_t interval);
/*%<
* Set the zone's RRSIG validity interval. This is the length of time
* for which DNSSEC signatures created as a result of dynamic updates
* \li 'zone' to be a valid zone.
*/
-isc_uint32_t
+uint32_t
dns_zone_getsigvalidityinterval(dns_zone_t *zone);
/*%<
* Get the zone's RRSIG validity interval.
*/
void
-dns_zone_setsigresigninginterval(dns_zone_t *zone, isc_uint32_t interval);
+dns_zone_setsigresigninginterval(dns_zone_t *zone, uint32_t interval);
/*%<
* Set the zone's RRSIG re-signing interval. A dynamic zone's RRSIG's
* will be re-signed 'interval' amount of time before they expire.
* \li 'zone' to be a valid zone.
*/
-isc_uint32_t
+uint32_t
dns_zone_getsigresigninginterval(dns_zone_t *zone);
/*%<
* Get the zone's RRSIG re-signing interval.
*/
void
-dns_zonemgr_settransfersin(dns_zonemgr_t *zmgr, isc_uint32_t value);
+dns_zonemgr_settransfersin(dns_zonemgr_t *zmgr, uint32_t value);
/*%<
* Set the maximum number of simultaneous transfers in allowed by
* the zone manager.
*\li 'zmgr' to be a valid zone manager.
*/
-isc_uint32_t
+uint32_t
dns_zonemgr_getttransfersin(dns_zonemgr_t *zmgr);
/*%<
* Return the maximum number of simultaneous transfers in allowed.
*/
void
-dns_zonemgr_settransfersperns(dns_zonemgr_t *zmgr, isc_uint32_t value);
+dns_zonemgr_settransfersperns(dns_zonemgr_t *zmgr, uint32_t value);
/*%<
* Set the number of zone transfers allowed per nameserver.
*
*\li 'zmgr' to be a valid zone manager
*/
-isc_uint32_t
+uint32_t
dns_zonemgr_getttransfersperns(dns_zonemgr_t *zmgr);
/*%<
* Return the number of transfers allowed per nameserver.
*/
void
-dns_zonemgr_setiolimit(dns_zonemgr_t *zmgr, isc_uint32_t iolimit);
+dns_zonemgr_setiolimit(dns_zonemgr_t *zmgr, uint32_t iolimit);
/*%<
* Set the number of simultaneous file descriptors available for
* reading and writing masterfiles.
*\li 'iolimit' to be positive.
*/
-isc_uint32_t
+uint32_t
dns_zonemgr_getiolimit(dns_zonemgr_t *zmgr);
/*%<
* Get the number of simultaneous file descriptors available for
* This function is obsoleted by dns_zone_setrequeststats().
*/
-isc_uint64_t *
+uint64_t *
dns_zone_getstatscounters(dns_zone_t *zone);
/*%<
* This function is obsoleted by dns_zone_getrequeststats().
*/
void
-dns_zone_setnotifydelay(dns_zone_t *zone, isc_uint32_t delay);
+dns_zone_setnotifydelay(dns_zone_t *zone, uint32_t delay);
/*%<
* Set the minimum delay between sets of notify messages.
*
* 'zone' to be valid.
*/
-isc_uint32_t
+uint32_t
dns_zone_getnotifydelay(dns_zone_t *zone);
/*%<
* Get the minimum delay between sets of notify messages.
*/
void
-dns_zone_setnodes(dns_zone_t *zone, isc_uint32_t nodes);
+dns_zone_setnodes(dns_zone_t *zone, uint32_t nodes);
/*%<
* Set the number of nodes that will be checked per quantum.
*/
void
-dns_zone_setsignatures(dns_zone_t *zone, isc_uint32_t signatures);
+dns_zone_setsignatures(dns_zone_t *zone, uint32_t signatures);
/*%<
* Set the number of signatures that will be generated per quantum.
*/
-isc_uint32_t
+uint32_t
dns_zone_getsignatures(dns_zone_t *zone);
/*%<
* Get the number of signatures that will be generated per quantum.
isc_result_t
dns_zone_signwithkey(dns_zone_t *zone, dns_secalg_t algorithm,
- isc_uint16_t keyid, isc_boolean_t deleteit);
+ uint16_t keyid, isc_boolean_t deleteit);
/*%<
* Initiate/resume signing of the entire zone with the zone DNSKEY(s)
* that match the given algorithm and keyid.
*/
isc_result_t
-dns_zone_setrefreshkeyinterval(dns_zone_t *zone, isc_uint32_t interval);
+dns_zone_setrefreshkeyinterval(dns_zone_t *zone, uint32_t interval);
/*%
* Sets the frequency, in minutes, with which the key repository will be
* checked to see if the keys for this zone have been updated. Any value
dns_zone_keydone(dns_zone_t *zone, const char *data);
isc_result_t
-dns_zone_setnsec3param(dns_zone_t *zone, isc_uint8_t hash, isc_uint8_t flags,
- isc_uint16_t iter, isc_uint8_t saltlen,
+dns_zone_setnsec3param(dns_zone_t *zone, uint8_t hash, uint8_t flags,
+ uint16_t iter, uint8_t saltlen,
unsigned char *salt, isc_boolean_t replace);
/*%
* Set the NSEC3 parameters for the zone.
*/
isc_result_t
-dns_zone_setserial(dns_zone_t *zone, isc_uint32_t serial);
+dns_zone_setserial(dns_zone_t *zone, uint32_t serial);
/*%
* Set the zone's serial to 'serial'.
*/
/*! \file dst/dst.h */
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <isc/stdtime.h>
unsigned int
dst_key_alg(const dst_key_t *key);
-isc_uint32_t
+uint32_t
dst_key_flags(const dst_key_t *key);
dns_keytag_t
*\li "n" stores the size of a generated shared secret
*/
-isc_uint16_t
+uint16_t
dst_region_computeid(const isc_region_t *source, unsigned int alg);
-isc_uint16_t
+uint16_t
dst_region_computerid(const isc_region_t *source, unsigned int alg);
/*%<
* Computes the (revoked) key id of the key stored in the provided
*\li the key id
*/
-isc_uint16_t
+uint16_t
dst_key_getbits(const dst_key_t *key);
/*%<
* Get the number of digest bits required (0 == MAX).
*/
void
-dst_key_setbits(dst_key_t *key, isc_uint16_t bits);
+dst_key_setbits(dst_key_t *key, uint16_t bits);
/*%<
* Set the number of digest bits required (0 == MAX).
*
*/
isc_result_t
-dst_key_setflags(dst_key_t *key, isc_uint32_t flags);
+dst_key_setflags(dst_key_t *key, uint32_t flags);
/*
* Set the key flags, and recompute the key ID.
*
*/
isc_result_t
-dst_key_getnum(const dst_key_t *key, int type, isc_uint32_t *valuep);
+dst_key_getnum(const dst_key_t *key, int type, uint32_t *valuep);
/*%<
* Get a member of the numeric metadata array and place it in '*valuep'.
*
*/
void
-dst_key_setnum(dst_key_t *key, int type, isc_uint32_t value);
+dst_key_setnum(dst_key_t *key, int type, uint32_t value);
/*%<
* Set a member of the numeric metadata array.
*
/*! \file dst/gssapi.h */
+#include <inttypes.h>
+
#include <isc/formatcheck.h>
#include <isc/lang.h>
#include <isc/platform.h>
*/
char *
-gss_error_tostring(isc_uint32_t major, isc_uint32_t minor,
+gss_error_tostring(uint32_t major, uint32_t minor,
char *buf, size_t buflen);
/*
* Render a GSS major status/minor status pair into a string
#include <config.h>
+#include <inttypes.h>
#include <string.h>
#include <isc/mem.h>
void
dns_ipkeylist_clear(isc_mem_t *mctx, dns_ipkeylist_t *ipkl) {
- isc_uint32_t i;
+ uint32_t i;
REQUIRE(ipkl != NULL);
dns_ipkeylist_t *dst)
{
isc_result_t result = ISC_R_SUCCESS;
- isc_uint32_t i;
+ uint32_t i;
REQUIRE(dst != NULL);
/* dst might be preallocated, we don't care, but it must be empty */
#include <config.h>
+#include <inttypes.h>
+
#include <isc/mem.h>
#include <isc/radix.h>
#include <isc/util.h>
*/
isc_result_t
dns_iptable_addprefix(dns_iptable_t *tab, isc_netaddr_t *addr,
- isc_uint16_t bitlen, isc_boolean_t pos)
+ uint16_t bitlen, isc_boolean_t pos)
{
return(dns_iptable_addprefix2(tab, addr, bitlen, pos, ISC_FALSE));
}
isc_result_t
dns_iptable_addprefix2(dns_iptable_t *tab, isc_netaddr_t *addr,
- isc_uint16_t bitlen, isc_boolean_t pos,
+ uint16_t bitlen, isc_boolean_t pos,
isc_boolean_t is_ecs)
{
isc_result_t result;
#include <config.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
static isc_result_t index_to_disk(dns_journal_t *);
-static inline isc_uint32_t
+static inline uint32_t
decode_uint32(unsigned char *p) {
return ((p[0] << 24) +
(p[1] << 16) +
}
static inline void
-encode_uint32(isc_uint32_t val, unsigned char *p) {
- p[0] = (isc_uint8_t)(val >> 24);
- p[1] = (isc_uint8_t)(val >> 16);
- p[2] = (isc_uint8_t)(val >> 8);
- p[3] = (isc_uint8_t)(val >> 0);
+encode_uint32(uint32_t val, unsigned char *p) {
+ p[0] = (uint8_t)(val >> 24);
+ p[1] = (uint8_t)(val >> 16);
+ p[2] = (uint8_t)(val >> 8);
+ p[3] = (uint8_t)(val >> 0);
}
isc_result_t
* The in-core representation of the journal header.
*/
typedef struct {
- isc_uint32_t serial;
+ uint32_t serial;
isc_offset_t offset;
} journal_pos_t;
unsigned char format[16];
journal_pos_t begin;
journal_pos_t end;
- isc_uint32_t index_size;
- isc_uint32_t sourceserial;
+ uint32_t index_size;
+ uint32_t sourceserial;
isc_boolean_t serialset;
} journal_header_t;
*/
typedef struct {
- isc_uint32_t size;
- isc_uint32_t serial0;
- isc_uint32_t serial1;
+ uint32_t size;
+ uint32_t serial0;
+ uint32_t serial1;
} journal_xhdr_t;
/*%
* The in-core representation of the RR header.
*/
typedef struct {
- isc_uint32_t size;
+ uint32_t size;
} journal_rrhdr_t;
journal_pos_t bpos; /*%< Position before first, */
journal_pos_t epos; /*%< and after last transaction */
/* The rest is iterator state. */
- isc_uint32_t current_serial; /*%< Current SOA serial */
+ uint32_t current_serial; /*%< Current SOA serial */
isc_buffer_t source; /*%< Data from disk */
isc_buffer_t target; /*%< Data from _fromwire check */
dns_decompress_t dctx; /*%< Dummy decompression ctx */
dns_name_t name; /*%< Current domain name */
dns_rdata_t rdata; /*%< Current rdata */
- isc_uint32_t ttl; /*%< Current TTL */
+ uint32_t ttl; /*%< Current TTL */
unsigned int xsize; /*%< Size of transaction data */
unsigned int xpos; /*%< Current position in it */
isc_result_t result; /*%< Result of last call */
* Journal file I/O subroutines, with error checking and reporting.
*/
static isc_result_t
-journal_seek(dns_journal_t *j, isc_uint32_t offset) {
+journal_seek(dns_journal_t *j, uint32_t offset) {
isc_result_t result;
result = isc_stdio_seek(j->fp, (off_t)offset, SEEK_SET);
}
static isc_result_t
-journal_write_xhdr(dns_journal_t *j, isc_uint32_t size,
- isc_uint32_t serial0, isc_uint32_t serial1)
+journal_write_xhdr(dns_journal_t *j, uint32_t size,
+ uint32_t serial0, uint32_t serial1)
{
journal_rawxhdr_t raw;
encode_uint32(size, raw.size);
* but not greater than 'serial'.
*/
static void
-index_find(dns_journal_t *j, isc_uint32_t serial, journal_pos_t *best_guess) {
+index_find(dns_journal_t *j, uint32_t serial, journal_pos_t *best_guess) {
unsigned int i;
if (j->index == NULL)
return;
* ambiguous when a new transaction with number 'serial' is added.
*/
static void
-index_invalidate(dns_journal_t *j, isc_uint32_t serial) {
+index_invalidate(dns_journal_t *j, uint32_t serial) {
unsigned int i;
if (j->index == NULL)
return;
*
*/
static isc_result_t
-journal_find(dns_journal_t *j, isc_uint32_t serial, journal_pos_t *pos) {
+journal_find(dns_journal_t *j, uint32_t serial, journal_pos_t *pos) {
isc_result_t result;
journal_pos_t current_pos;
REQUIRE(DNS_JOURNAL_VALID(j));
isc_result_t
dns_journal_begin_transaction(dns_journal_t *j) {
- isc_uint32_t offset;
+ uint32_t offset;
isc_result_t result;
journal_rawxhdr_t hdr;
dns_difftuple_t *t;
isc_buffer_t buffer;
void *mem = NULL;
- isc_uint64_t size;
+ uint64_t size;
isc_result_t result;
isc_region_t used;
size += t->rdata.length;
}
- if (size >= ISC_INT32_MAX) {
+ if (size >= INT32_MAX) {
isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
"dns_journal_writediff: %s: journal entry "
"too big to be stored: %" PRIu64 " bytes",
isc_buffer_putuint16(&buffer, t->rdata.rdclass);
isc_buffer_putuint32(&buffer, t->ttl);
INSIST(t->rdata.length < 65536);
- isc_buffer_putuint16(&buffer, (isc_uint16_t)t->rdata.length);
+ isc_buffer_putuint16(&buffer, (uint16_t)t->rdata.length);
INSIST(isc_buffer_availablelength(&buffer) >= t->rdata.length);
isc_buffer_putmem(&buffer, t->rdata.data, t->rdata.length);
}
dns_journal_commit(dns_journal_t *j) {
isc_result_t result;
journal_rawheader_t rawheader;
- isc_uint64_t total;
+ uint64_t total;
REQUIRE(DNS_JOURNAL_VALID(j));
REQUIRE(j->state == JOURNAL_STATE_TRANSACTION ||
* We currently don't support huge journal entries.
*/
total = j->x.pos[1].offset - j->x.pos[0].offset;
- if (total >= ISC_INT32_MAX) {
+ if (total >= INT32_MAX) {
isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
"transaction too big to be stored in journal: "
"%" PRIu64 "b (max is %" PRIu64 "b)", total,
- (isc_uint64_t)ISC_INT32_MAX);
+ (uint64_t)INT32_MAX);
return (ISC_R_UNEXPECTED);
}
roll_forward(dns_journal_t *j, dns_db_t *db, unsigned int options) {
isc_buffer_t source; /* Transaction data from disk */
isc_buffer_t target; /* Ditto after _fromwire check */
- isc_uint32_t db_serial; /* Database SOA serial */
- isc_uint32_t end_serial; /* Last journal SOA serial */
+ uint32_t db_serial; /* Database SOA serial */
+ uint32_t end_serial; /* Last journal SOA serial */
isc_result_t result;
dns_dbversion_t *ver = NULL;
journal_pos_t pos;
result = dns_journal_next_rr(j))
{
dns_name_t *name;
- isc_uint32_t ttl;
+ uint32_t ttl;
dns_rdata_t *rdata;
dns_difftuple_t *tuple = NULL;
dns_journal_t *j;
isc_buffer_t source; /* Transaction data from disk */
isc_buffer_t target; /* Ditto after _fromwire check */
- isc_uint32_t start_serial; /* Database SOA serial */
- isc_uint32_t end_serial; /* Last journal SOA serial */
+ uint32_t start_serial; /* Database SOA serial */
+ uint32_t end_serial; /* Last journal SOA serial */
isc_result_t result;
dns_diff_t diff;
unsigned int n_soa = 0;
result = dns_journal_next_rr(j))
{
dns_name_t *name;
- isc_uint32_t ttl;
+ uint32_t ttl;
dns_rdata_t *rdata;
dns_difftuple_t *tuple = NULL;
/*
* Miscellaneous accessors.
*/
-isc_uint32_t
+uint32_t
dns_journal_first_serial(dns_journal_t *j) {
return (j->header.begin.serial);
}
-isc_uint32_t
+uint32_t
dns_journal_last_serial(dns_journal_t *j) {
return (j->header.end.serial);
}
void
-dns_journal_set_sourceserial(dns_journal_t *j, isc_uint32_t sourceserial) {
+dns_journal_set_sourceserial(dns_journal_t *j, uint32_t sourceserial) {
REQUIRE(j->state == JOURNAL_STATE_WRITE ||
j->state == JOURNAL_STATE_INLINE ||
}
isc_boolean_t
-dns_journal_get_sourceserial(dns_journal_t *j, isc_uint32_t *sourceserial) {
+dns_journal_get_sourceserial(dns_journal_t *j, uint32_t *sourceserial) {
REQUIRE(sourceserial != NULL);
if (!j->header.serialset)
isc_result_t
dns_journal_iter_init(dns_journal_t *j,
- isc_uint32_t begin_serial, isc_uint32_t end_serial)
+ uint32_t begin_serial, uint32_t end_serial)
{
isc_result_t result;
dns_rdatatype_t rdtype;
dns_rdataclass_t rdclass;
unsigned int rdlen;
- isc_uint32_t ttl;
+ uint32_t ttl;
journal_xhdr_t xhdr;
journal_rrhdr_t rrhdr;
}
void
-dns_journal_current_rr(dns_journal_t *j, dns_name_t **name, isc_uint32_t *ttl,
+dns_journal_current_rr(dns_journal_t *j, dns_name_t **name, uint32_t *ttl,
dns_rdata_t **rdata)
{
REQUIRE(j->it.result == ISC_R_SUCCESS);
}
isc_result_t
-dns_journal_compact(isc_mem_t *mctx, char *filename, isc_uint32_t serial,
- isc_uint32_t target_size)
+dns_journal_compact(isc_mem_t *mctx, char *filename, uint32_t serial,
+ uint32_t target_size)
{
unsigned int i;
journal_pos_t best_guess;
/*
* See if there is any work to do.
*/
- if ((isc_uint32_t) j1->header.end.offset < target_size) {
+ if ((uint32_t) j1->header.end.offset < target_size) {
dns_journal_destroy(&j1);
return (ISC_R_SUCCESS);
}
for (i = 0; i < j1->header.index_size; i++) {
if (POS_VALID(j1->index[i]) &&
DNS_SERIAL_GE(serial, j1->index[i].serial) &&
- ((isc_uint32_t)(j1->header.end.offset - j1->index[i].offset)
+ ((uint32_t)(j1->header.end.offset - j1->index[i].offset)
>= target_size / 2) &&
j1->index[i].offset > best_guess.offset)
best_guess = j1->index[i];
break;
if (DNS_SERIAL_GE(serial, current_pos.serial) &&
- ((isc_uint32_t)(j1->header.end.offset - current_pos.offset)
+ ((uint32_t)(j1->header.end.offset - current_pos.offset)
>= (target_size / 2)) &&
current_pos.offset > best_guess.offset)
best_guess = current_pos;
#include <config.h>
#include <stddef.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <isc/region.h>
#include "dst_internal.h"
-isc_uint16_t
+uint16_t
dst_region_computeid(const isc_region_t *source, unsigned int alg) {
- isc_uint32_t ac;
+ uint32_t ac;
const unsigned char *p;
int size;
ac += ((*p) << 8);
ac += (ac >> 16) & 0xffff;
- return ((isc_uint16_t)(ac & 0xffff));
+ return ((uint16_t)(ac & 0xffff));
}
-isc_uint16_t
+uint16_t
dst_region_computerid(const isc_region_t *source, unsigned int alg) {
- isc_uint32_t ac;
+ uint32_t ac;
const unsigned char *p;
int size;
ac += ((*p) << 8);
ac += (ac >> 16) & 0xffff;
- return ((isc_uint16_t)(ac & 0xffff));
+ return ((uint16_t)(ac & 0xffff));
}
dns_name_t *
return (key->key_alg);
}
-isc_uint32_t
+uint32_t
dst_key_flags(const dst_key_t *key) {
REQUIRE(VALID_KEY(key));
return (key->key_flags);
}
void
-dst_key_setbits(dst_key_t *key, isc_uint16_t bits) {
+dst_key_setbits(dst_key_t *key, uint16_t bits) {
unsigned int maxbits;
REQUIRE(VALID_KEY(key));
if (bits != 0) {
key->key_bits = bits;
}
-isc_uint16_t
+uint16_t
dst_key_getbits(const dst_key_t *key) {
REQUIRE(VALID_KEY(key));
return (key->key_bits);
#include <config.h>
+#include <inttypes.h>
#include <isc/buffer.h>
#include <isc/mem.h>
isc_result_t
dns_keydata_fromdnskey(dns_rdata_keydata_t *keydata,
dns_rdata_dnskey_t *dnskey,
- isc_uint32_t refresh, isc_uint32_t addhd,
- isc_uint32_t removehd, isc_mem_t *mctx)
+ uint32_t refresh, uint32_t addhd,
+ uint32_t removehd, isc_mem_t *mctx)
{
REQUIRE(keydata != NULL && dnskey != NULL);
isc_result_t (*load)(dns_loadctx_t *lctx);
/* Members used by all formats */
- isc_uint32_t maxttl;
+ uint32_t maxttl;
/* Members specific to the text format: */
isc_lex_t *lex;
isc_boolean_t warn_tcr;
isc_boolean_t warn_sigexpired;
isc_boolean_t seen_include;
- isc_uint32_t ttl;
- isc_uint32_t default_ttl;
+ uint32_t ttl;
+ uint32_t default_ttl;
dns_rdataclass_t zclass;
dns_fixedname_t fixed_top;
dns_name_t *top; /*%< top of zone */
isc_mutex_t lock;
isc_result_t result;
/* locked by lock */
- isc_uint32_t references;
+ uint32_t references;
dns_incctx_t *inc;
- isc_uint32_t resign;
+ uint32_t resign;
isc_stdtime_t now;
dns_masterincludecb_t include_cb;
static isc_result_t
loadctx_create(dns_masterformat_t format, isc_mem_t *mctx,
- unsigned int options, isc_uint32_t resign, dns_name_t *top,
+ unsigned int options, uint32_t resign, dns_name_t *top,
dns_rdataclass_t zclass, dns_name_t *origin,
dns_rdatacallbacks_t *callbacks, isc_task_t *task,
dns_loaddonefunc_t done, void *done_arg,
static void
limit_ttl(dns_rdatacallbacks_t *callbacks, const char *source,
- unsigned int line, isc_uint32_t *ttlp)
+ unsigned int line, uint32_t *ttlp)
{
if (*ttlp > 0x7fffffffUL) {
(callbacks->warn)(callbacks,
load_text(dns_loadctx_t *lctx) {
dns_rdataclass_t rdclass;
dns_rdatatype_t type, covers;
- isc_uint32_t ttl_offset = 0;
+ uint32_t ttl_offset = 0;
dns_name_t *new_name;
isc_boolean_t current_has_delegation = ISC_FALSE;
isc_boolean_t done = ISC_FALSE;
finish_include = ISC_TRUE;
} else if (strcasecmp(DNS_AS_STR(token),
"$DATE") == 0) {
- isc_int64_t dump_time64;
+ int64_t dump_time64;
isc_stdtime_t dump_time, current_time;
GETTOKEN(lctx->lex, 0, &token, ISC_FALSE);
isc_stdtime_get(¤t_time);
*/
static inline isc_result_t
read_and_check(isc_boolean_t do_read, isc_buffer_t *buffer,
- size_t len, FILE *f, isc_uint32_t *totallen)
+ size_t len, FILE *f, uint32_t *totallen)
{
isc_result_t result;
isc_buffer_add(buffer, (unsigned int)len);
if (*totallen < len)
return (ISC_R_RANGE);
- *totallen -= (isc_uint32_t)len;
+ *totallen -= (uint32_t)len;
} else if (isc_buffer_remaininglength(buffer) < len)
return (ISC_R_RANGE);
(lctx->loop_cnt == 0 || loop_cnt < lctx->loop_cnt);
loop_cnt++) {
unsigned int i, rdcount;
- isc_uint16_t namelen;
- isc_uint32_t totallen;
+ uint16_t namelen;
+ uint32_t totallen;
size_t minlen, readlen;
isc_boolean_t sequential_read = ISC_FALSE;
* Validation: the input data must at least contain the common
* header.
*/
- minlen = sizeof(totallen) + sizeof(isc_uint16_t) +
- sizeof(isc_uint16_t) + sizeof(isc_uint16_t) +
- sizeof(isc_uint32_t) + sizeof(isc_uint32_t);
+ minlen = sizeof(totallen) + sizeof(uint16_t) +
+ sizeof(uint16_t) + sizeof(uint16_t) +
+ sizeof(uint32_t) + sizeof(uint32_t);
if (totallen < minlen) {
result = ISC_R_RANGE;
goto cleanup;
if (result != ISC_R_SUCCESS)
goto cleanup;
isc_buffer_add(&target, (unsigned int)readlen);
- totallen -= (isc_uint32_t)readlen;
+ totallen -= (uint32_t)readlen;
/* Construct RRset headers */
dns_rdatalist_init(&rdatalist);
continue_read:
for (i = 0; i < rdcount; i++) {
- isc_uint16_t rdlen;
+ uint16_t rdlen;
dns_rdata_init(&rdata[i]);
isc_result_t
dns_master_loadfile3(const char *master_file, dns_name_t *top,
dns_name_t *origin, dns_rdataclass_t zclass,
- unsigned int options, isc_uint32_t resign,
+ unsigned int options, uint32_t resign,
dns_rdatacallbacks_t *callbacks, isc_mem_t *mctx,
dns_masterformat_t format)
{
isc_result_t
dns_master_loadfile4(const char *master_file, dns_name_t *top,
dns_name_t *origin, dns_rdataclass_t zclass,
- unsigned int options, isc_uint32_t resign,
+ unsigned int options, uint32_t resign,
dns_rdatacallbacks_t *callbacks,
dns_masterincludecb_t include_cb, void *include_arg,
isc_mem_t *mctx, dns_masterformat_t format)
isc_result_t
dns_master_loadfile5(const char *master_file, dns_name_t *top,
dns_name_t *origin, dns_rdataclass_t zclass,
- unsigned int options, isc_uint32_t resign,
+ unsigned int options, uint32_t resign,
dns_rdatacallbacks_t *callbacks,
dns_masterincludecb_t include_cb, void *include_arg,
isc_mem_t *mctx, dns_masterformat_t format,
isc_result_t
dns_master_loadfileinc3(const char *master_file, dns_name_t *top,
dns_name_t *origin, dns_rdataclass_t zclass,
- unsigned int options, isc_uint32_t resign,
+ unsigned int options, uint32_t resign,
dns_rdatacallbacks_t *callbacks, isc_task_t *task,
dns_loaddonefunc_t done, void *done_arg,
dns_loadctx_t **lctxp, isc_mem_t *mctx,
isc_result_t
dns_master_loadfileinc4(const char *master_file, dns_name_t *top,
dns_name_t *origin, dns_rdataclass_t zclass,
- unsigned int options, isc_uint32_t resign,
+ unsigned int options, uint32_t resign,
dns_rdatacallbacks_t *callbacks,
isc_task_t *task, dns_loaddonefunc_t done,
void *done_arg, dns_loadctx_t **lctxp,
isc_result_t
dns_master_loadfileinc5(const char *master_file, dns_name_t *top,
dns_name_t *origin, dns_rdataclass_t zclass,
- unsigned int options, isc_uint32_t resign,
+ unsigned int options, uint32_t resign,
dns_rdatacallbacks_t *callbacks,
isc_task_t *task, dns_loaddonefunc_t done,
void *done_arg, dns_loadctx_t **lctxp,
dns_masterincludecb_t include_cb, void *include_arg,
isc_mem_t *mctx, dns_masterformat_t format,
- isc_uint32_t maxttl)
+ uint32_t maxttl)
{
dns_loadctx_t *lctx = NULL;
isc_result_t result;
return (newlist);
}
-static isc_uint32_t
+static uint32_t
resign_fromlist(dns_rdatalist_t *this, dns_loadctx_t *lctx) {
dns_rdata_t *rdata;
dns_rdata_rrsig_t sig;
- isc_uint32_t when;
+ uint32_t when;
rdata = ISC_LIST_HEAD(this->rdata);
INSIST(rdata != NULL);
#include <config.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <isc/buffer.h>
dns_name_t * origin;
dns_name_t * neworigin;
dns_fixedname_t origin_fixname;
- isc_uint32_t current_ttl;
+ uint32_t current_ttl;
isc_boolean_t current_ttl_valid;
} dns_totext_ctx_t;
isc_result_t result;
unsigned int column;
isc_boolean_t first = ISC_TRUE;
- isc_uint32_t current_ttl;
+ uint32_t current_ttl;
isc_boolean_t current_ttl_valid;
dns_rdatatype_t type;
unsigned int type_start;
char buf[sizeof("YYYYMMDDHHMMSS")];
memset(buf, 0, sizeof(buf));
isc_buffer_init(&b, buf, sizeof(buf) - 1);
- dns_time64_totext((isc_uint64_t)rds->resign, &b);
+ dns_time64_totext((uint64_t)rds->resign, &b);
if ((ctx->style.flags & DNS_STYLEFLAG_INDENT) != 0 ||
(ctx->style.flags & DNS_STYLEFLAG_YAML) != 0)
{
isc_buffer_t *buffer, FILE *f)
{
isc_result_t result;
- isc_uint32_t totallen;
- isc_uint16_t dlen;
+ uint32_t totallen;
+ uint16_t dlen;
isc_region_t r, r_hdr;
REQUIRE(buffer->length > 0);
dns_name_toregion(name, &r);
INSIST(isc_buffer_availablelength(buffer) >=
(sizeof(dlen) + r.length));
- dlen = (isc_uint16_t)r.length;
+ dlen = (uint16_t)r.length;
isc_buffer_putuint16(buffer, dlen);
isc_buffer_copyregion(buffer, &r);
totallen += sizeof(dlen) + r.length;
dns_rdataset_current(rdataset, &rdata);
dns_rdata_toregion(&rdata, &r);
INSIST(r.length <= 0xffffU);
- dlen = (isc_uint16_t)r.length;
+ dlen = (uint16_t)r.length;
/*
* Copy the rdata into the buffer. If the buffer is too small,
char *bufmem;
isc_region_t r;
dns_masterrawheader_t rawheader;
- isc_uint32_t rawversion, now32;
+ uint32_t rawversion, now32;
bufmem = isc_mem_get(dctx->mctx, initial_buffer_length);
if (bufmem == NULL)
if (dctx->nodes != 0 && result == ISC_R_SUCCESS) {
unsigned int pps = dns_pps; /* packets per second */
unsigned int interval;
- isc_uint64_t usecs;
+ uint64_t usecs;
isc_time_t end;
isc_time_now(&end);
#include <config.h>
#include <ctype.h>
+#include <inttypes.h>
#include <isc/buffer.h>
#include <isc/mem.h>
isc_region_t r;
dns_decompress_t dctx;
isc_result_t ret;
- isc_uint16_t tmpflags;
+ uint16_t tmpflags;
isc_buffer_t origsource;
isc_boolean_t seen_problem;
isc_boolean_t ignore_tc;
if (result != ISC_R_SUCCESS) {
INSIST(st.used < 65536);
dns_compress_rollback(msg->cctx,
- (isc_uint16_t)st.used);
+ (uint16_t)st.used);
*(msg->buffer) = st; /* rollback */
msg->buffer->length += msg->reserved;
msg->counts[sectionid] += total;
if (result != ISC_R_SUCCESS) {
INSIST(st.used < 65536);
dns_compress_rollback(msg->cctx,
- (isc_uint16_t)st.used);
+ (uint16_t)st.used);
*(msg->buffer) = st; /* rollback */
msg->buffer->length += msg->reserved;
msg->counts[sectionid] += total;
void
dns_message_renderheader(dns_message_t *msg, isc_buffer_t *target) {
- isc_uint16_t tmp;
+ uint16_t tmp;
isc_region_t r;
REQUIRE(DNS_MESSAGE_VALID(msg));
isc_buffer_putuint16(target, tmp);
isc_buffer_putuint16(target,
- (isc_uint16_t)msg->counts[DNS_SECTION_QUESTION]);
+ (uint16_t)msg->counts[DNS_SECTION_QUESTION]);
isc_buffer_putuint16(target,
- (isc_uint16_t)msg->counts[DNS_SECTION_ANSWER]);
+ (uint16_t)msg->counts[DNS_SECTION_ANSWER]);
isc_buffer_putuint16(target,
- (isc_uint16_t)msg->counts[DNS_SECTION_AUTHORITY]);
+ (uint16_t)msg->counts[DNS_SECTION_AUTHORITY]);
isc_buffer_putuint16(target,
- (isc_uint16_t)msg->counts[DNS_SECTION_ADDITIONAL]);
+ (uint16_t)msg->counts[DNS_SECTION_ADDITIONAL]);
}
isc_result_t
render_ecs(isc_buffer_t *ecsbuf, isc_buffer_t *target) {
int i;
char addr[16], addr_text[64];
- isc_uint16_t family;
- isc_uint8_t addrlen, addrbytes, scopelen;
+ uint16_t family;
+ uint8_t addrlen, addrbytes, scopelen;
isc_result_t result;
/*
dns_name_t *name = NULL;
isc_result_t result = ISC_R_SUCCESS;
char buf[sizeof("1234567890")];
- isc_uint32_t mbz;
+ uint32_t mbz;
dns_rdata_t rdata;
isc_buffer_t optbuf;
- isc_uint16_t optcode, optlen;
+ uint16_t optcode, optlen;
unsigned char *optdata;
unsigned int saveindent = dns_master_indent;
ADD_STRING(target, "\n");
} else if (optcode == DNS_OPT_EXPIRE) {
if (optlen == 4) {
- isc_uint32_t secs;
+ uint32_t secs;
secs = isc_buffer_getuint32(&optbuf);
INDENT(style);
ADD_STRING(target, "EXPIRE: ");
ADD_STRING(target, "KEY-TAG");
if (optlen > 0U && (optlen % 2U) == 0U) {
const char *sep = ": ";
- isc_uint16_t id;
+ uint16_t id;
while (optlen > 0U) {
id = isc_buffer_getuint16(&optbuf);
snprintf(buf, sizeof(buf), "%s%u",
dns_name_t *name = NULL;
isc_result_t result;
char buf[sizeof("1234567890")];
- isc_uint32_t mbz;
+ uint32_t mbz;
dns_rdata_t rdata;
isc_buffer_t optbuf;
- isc_uint16_t optcode, optlen;
+ uint16_t optcode, optlen;
unsigned char *optdata;
REQUIRE(DNS_MESSAGE_VALID(msg));
}
} else if (optcode == DNS_OPT_EXPIRE) {
if (optlen == 4) {
- isc_uint32_t secs;
+ uint32_t secs;
secs = isc_buffer_getuint32(&optbuf);
ADD_STRING(target, "; EXPIRE: ");
snprintf(buf, sizeof(buf), "%u", secs);
ADD_STRING(target, "; KEY-TAG");
if (optlen > 0U && (optlen % 2U) == 0U) {
const char *sep = ": ";
- isc_uint16_t id;
+ uint16_t id;
while (optlen > 0U) {
id = isc_buffer_getuint16(&optbuf);
snprintf(buf, sizeof(buf), "%s%u",
isc_result_t
dns_message_buildopt(dns_message_t *message, dns_rdataset_t **rdatasetp,
- unsigned int version, isc_uint16_t udpsize,
+ unsigned int version, uint16_t udpsize,
unsigned int flags, dns_ednsopt_t *ednsopts, size_t count)
{
dns_rdataset_t *rdataset = NULL;
#include <config.h>
#include <ctype.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <isc/buffer.h>
isc_buffer_t *target)
{
unsigned int methods;
- isc_uint16_t offset;
+ uint16_t offset;
dns_name_t gp; /* Global compression prefix */
isc_boolean_t gf; /* Global compression target found */
- isc_uint16_t go; /* Global compression offset */
+ uint16_t go; /* Global compression offset */
dns_offsets_t clo;
dns_name_t clname;
#include <config.h>
+#include <inttypes.h>
+
#include <isc/buffer.h>
#include <isc/util.h>
return (ISC_R_NOSPACE);
count = dns_rdataset_count(rdataset);
INSIST(count <= 65535);
- isc_buffer_putuint16(buffer, (isc_uint16_t)count);
+ isc_buffer_putuint16(buffer, (uint16_t)count);
result = dns_rdataset_first(rdataset);
while (result == ISC_R_SUCCESS) {
/*
* Copy the rdata length to the buffer.
*/
- isc_buffer_putuint16(buffer, (isc_uint16_t)r.length);
+ isc_buffer_putuint16(buffer, (uint16_t)r.length);
/*
* Copy the rdata to the buffer.
*/
INSIST((target->used >= rdlen.used + 2) &&
(target->used - rdlen.used - 2 < 65536));
isc_buffer_putuint16(&rdlen,
- (isc_uint16_t)(target->used -
+ (uint16_t)(target->used -
rdlen.used - 2));
count++;
rollback:
INSIST(savedbuffer.used < 65536);
- dns_compress_rollback(cctx, (isc_uint16_t)savedbuffer.used);
+ dns_compress_rollback(cctx, (uint16_t)savedbuffer.used);
*countp = 0;
*target = savedbuffer;
#include <config.h>
+#include <inttypes.h>
+
#include <isc/base32.h>
#include <isc/buffer.h>
#include <isc/hex.h>
int pass;
isc_boolean_t exists = ISC_FALSE;
isc_boolean_t maybe_remove_unsecure = ISC_FALSE;
- isc_uint8_t flags;
+ uint8_t flags;
isc_buffer_t buffer;
isc_result_t result;
unsigned char *old_next;
#include <config.h>
+#include <inttypes.h>
+
#include <isc/buffer.h>
#include <isc/log.h>
#include <isc/mem.h>
}
static isc_result_t
-settimer(dns_ntatable_t *ntatable, dns_nta_t *nta, isc_uint32_t lifetime) {
+settimer(dns_ntatable_t *ntatable, dns_nta_t *nta, uint32_t lifetime) {
isc_result_t result;
isc_interval_t interval;
dns_view_t *view;
isc_result_t
dns_ntatable_add(dns_ntatable_t *ntatable, dns_name_t *name,
isc_boolean_t force, isc_stdtime_t now,
- isc_uint32_t lifetime)
+ uint32_t lifetime)
{
isc_result_t result;
dns_nta_t *nta = NULL;
#ifndef PK11_DH_DISABLE
#include <ctype.h>
+#include <inttypes.h>
#include <isc/mem.h>
#include <isc/safe.h>
}
static void
-uint16_toregion(isc_uint16_t val, isc_region_t *region) {
+uint16_toregion(uint16_t val, isc_region_t *region) {
*region->base = (val & 0xff00) >> 8;
isc_region_consume(region, 1);
*region->base = (val & 0x00ff);
isc_region_consume(region, 1);
}
-static isc_uint16_t
+static uint16_t
uint16_fromregion(isc_region_t *region) {
- isc_uint16_t val;
+ uint16_t val;
unsigned char *cp = region->base;
val = ((unsigned int)(cp[0])) << 8;
DH *dh;
const BIGNUM *pub_key = NULL, *p = NULL, *g = NULL;
isc_region_t r;
- isc_uint16_t dnslen, plen, glen, publen;
+ uint16_t dnslen, plen, glen, publen;
REQUIRE(key->keydata.dh != NULL);
DH *dh;
BIGNUM *pub_key = NULL, *p = NULL, *g = NULL;
isc_region_t r;
- isc_uint16_t plen, glen, publen;
+ uint16_t plen, glen, publen;
int special = 0;
isc_buffer_remainingregion(data, &r);
if (e_bytes < 256) { /*%< key exponent is <= 2040 bits */
if (r.length < 1)
DST_RET(ISC_R_NOSPACE);
- isc_buffer_putuint8(data, (isc_uint8_t) e_bytes);
+ isc_buffer_putuint8(data, (uint8_t) e_bytes);
isc_region_consume(&r, 1);
} else {
if (r.length < 3)
DST_RET(ISC_R_NOSPACE);
isc_buffer_putuint8(data, 0);
- isc_buffer_putuint16(data, (isc_uint16_t) e_bytes);
+ isc_buffer_putuint16(data, (uint16_t) e_bytes);
isc_region_consume(&r, 3);
}
#include <config.h>
+#include <inttypes.h>
+
#include <isc/mem.h>
#include <isc/string.h>
#include <isc/util.h>
}
isc_result_t
-dns_peer_settransfers(dns_peer_t *peer, isc_uint32_t newval) {
+dns_peer_settransfers(dns_peer_t *peer, uint32_t newval) {
isc_boolean_t existed;
REQUIRE(DNS_PEER_VALID(peer));
}
isc_result_t
-dns_peer_gettransfers(dns_peer_t *peer, isc_uint32_t *retval) {
+dns_peer_gettransfers(dns_peer_t *peer, uint32_t *retval) {
REQUIRE(DNS_PEER_VALID(peer));
REQUIRE(retval != NULL);
}
isc_result_t
-dns_peer_setudpsize(dns_peer_t *peer, isc_uint16_t udpsize) {
+dns_peer_setudpsize(dns_peer_t *peer, uint16_t udpsize) {
isc_boolean_t existed;
REQUIRE(DNS_PEER_VALID(peer));
}
isc_result_t
-dns_peer_getudpsize(dns_peer_t *peer, isc_uint16_t *udpsize) {
+dns_peer_getudpsize(dns_peer_t *peer, uint16_t *udpsize) {
REQUIRE(DNS_PEER_VALID(peer));
REQUIRE(udpsize != NULL);
}
isc_result_t
-dns_peer_setmaxudp(dns_peer_t *peer, isc_uint16_t maxudp) {
+dns_peer_setmaxudp(dns_peer_t *peer, uint16_t maxudp) {
isc_boolean_t existed;
REQUIRE(DNS_PEER_VALID(peer));
}
isc_result_t
-dns_peer_getmaxudp(dns_peer_t *peer, isc_uint16_t *maxudp) {
+dns_peer_getmaxudp(dns_peer_t *peer, uint16_t *maxudp) {
REQUIRE(DNS_PEER_VALID(peer));
REQUIRE(maxudp != NULL);
}
isc_result_t
-dns_peer_setednsversion(dns_peer_t *peer, isc_uint8_t ednsversion) {
+dns_peer_setednsversion(dns_peer_t *peer, uint8_t ednsversion) {
REQUIRE(DNS_PEER_VALID(peer));
peer->ednsversion = ednsversion;
}
isc_result_t
-dns_peer_getednsversion(dns_peer_t *peer, isc_uint8_t *ednsversion) {
+dns_peer_getednsversion(dns_peer_t *peer, uint8_t *ednsversion) {
REQUIRE(DNS_PEER_VALID(peer));
REQUIRE(ednsversion != NULL);
}
static void
-uint16_toregion(isc_uint16_t val, isc_region_t *region) {
+uint16_toregion(uint16_t val, isc_region_t *region) {
*region->base = (val & 0xff00) >> 8;
isc_region_consume(region, 1);
*region->base = (val & 0x00ff);
isc_region_consume(region, 1);
}
-static isc_uint16_t
+static uint16_t
uint16_fromregion(isc_region_t *region) {
- isc_uint16_t val;
+ uint16_t val;
unsigned char *cp = region->base;
val = ((unsigned int)(cp[0])) << 8;
pk11_object_t *dh;
CK_ATTRIBUTE *attr;
isc_region_t r;
- isc_uint16_t dnslen, plen = 0, glen = 0, publen = 0;
+ uint16_t dnslen, plen = 0, glen = 0, publen = 0;
CK_BYTE *prime = NULL, *base = NULL, *pub = NULL;
REQUIRE(key->keydata.pkey != NULL);
switch (attr->type) {
case CKA_VALUE:
pub = (CK_BYTE *) attr->pValue;
- publen = (isc_uint16_t) attr->ulValueLen;
+ publen = (uint16_t) attr->ulValueLen;
break;
case CKA_PRIME:
prime = (CK_BYTE *) attr->pValue;
- plen = (isc_uint16_t) attr->ulValueLen;
+ plen = (uint16_t) attr->ulValueLen;
break;
case CKA_BASE:
base = (CK_BYTE *) attr->pValue;
- glen = (isc_uint16_t) attr->ulValueLen;
+ glen = (uint16_t) attr->ulValueLen;
break;
}
REQUIRE((prime != NULL) && (base != NULL) && (pub != NULL));
pkcs11dh_fromdns(dst_key_t *key, isc_buffer_t *data) {
pk11_object_t *dh = NULL;
isc_region_t r;
- isc_uint16_t plen, glen, plen_, glen_, publen;
+ uint16_t plen, glen, plen_, glen_, publen;
CK_BYTE *prime = NULL, *base = NULL, *pub = NULL;
CK_ATTRIBUTE *attr;
int special = 0;
if (e_bytes < 256) { /*%< key exponent is <= 2040 bits */
if (r.length < 1)
return (ISC_R_NOSPACE);
- isc_buffer_putuint8(data, (isc_uint8_t) e_bytes);
+ isc_buffer_putuint8(data, (uint8_t) e_bytes);
isc_region_consume(&r, 1);
} else {
if (r.length < 3)
return (ISC_R_NOSPACE);
isc_buffer_putuint8(data, 0);
- isc_buffer_putuint16(data, (isc_uint16_t) e_bytes);
+ isc_buffer_putuint16(data, (uint16_t) e_bytes);
isc_region_consume(&r, 3);
}
#include <config.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <isc/magic.h>
typedef struct dns_element {
in_port_t port;
- isc_uint16_t flags;
+ uint16_t flags;
} dns_element_t;
struct dns_portlist {
struct file_header {
char version1[32];
- isc_uint64_t first_node_offset; /* usually 1024 */
+ uint64_t first_node_offset; /* usually 1024 */
/*
* information about the system on which the map file was generated
* will be used to tell if we can load the map file or not
*/
- isc_uint32_t ptrsize;
+ uint32_t ptrsize;
unsigned int bigendian:1; /* big or little endian system */
unsigned int rdataset_fixed:1; /* compiled with --enable-rrset-fixed */
unsigned int nodecount; /* shadow from rbt structure */
- isc_uint64_t crc;
+ uint64_t crc;
char version2[32]; /* repeated; must match version1 */
};
dns_rbt_zero_header(FILE *file);
static isc_result_t
-write_header(FILE *file, dns_rbt_t *rbt, isc_uint64_t first_node_offset,
- isc_uint64_t crc);
+write_header(FILE *file, dns_rbt_t *rbt, uint64_t first_node_offset,
+ uint64_t crc);
static isc_boolean_t
match_header_version(file_header_t *header);
static isc_result_t
serialize_node(FILE *file, dns_rbtnode_t *node, uintptr_t left,
uintptr_t right, uintptr_t down, uintptr_t parent,
- uintptr_t data, isc_uint64_t *crc);
+ uintptr_t data, uint64_t *crc);
static isc_result_t
serialize_nodes(FILE *file, dns_rbtnode_t *node, uintptr_t parent,
dns_rbtdatawriter_t datawriter, void *writer_arg,
- uintptr_t *where, isc_uint64_t *crc);
+ uintptr_t *where, uint64_t *crc);
/*
* The following functions allow you to get the actual address of a pointer
* without having to use an if statement to check to see if that address is
treefix(dns_rbt_t *rbt, void *base, size_t size,
dns_rbtnode_t *n, dns_name_t *name,
dns_rbtdatafixer_t datafixer, void *fixer_arg,
- isc_uint64_t *crc);
+ uint64_t *crc);
static void
deletetreeflat(dns_rbt_t *rbt, unsigned int quantum, isc_boolean_t unhash,
* here.
*/
static isc_result_t
-write_header(FILE *file, dns_rbt_t *rbt, isc_uint64_t first_node_offset,
- isc_uint64_t crc)
+write_header(FILE *file, dns_rbt_t *rbt, uint64_t first_node_offset,
+ uint64_t crc)
{
file_header_t header;
isc_result_t result;
memmove(header.version1, FILE_VERSION, sizeof(header.version1));
memmove(header.version2, FILE_VERSION, sizeof(header.version2));
header.first_node_offset = first_node_offset;
- header.ptrsize = (isc_uint32_t) sizeof(void *);
+ header.ptrsize = (uint32_t) sizeof(void *);
header.bigendian = (1 == htonl(1)) ? 1 : 0;
#ifdef DNS_RDATASET_FIXED
static isc_result_t
serialize_node(FILE *file, dns_rbtnode_t *node, uintptr_t left,
uintptr_t right, uintptr_t down, uintptr_t parent,
- uintptr_t data, isc_uint64_t *crc)
+ uintptr_t data, uint64_t *crc)
{
dns_rbtnode_t temp_node;
off_t file_position;
hexdump("node data", node_data, datasize);
#endif
- isc_crc64_update(crc, (const isc_uint8_t *) &temp_node,
+ isc_crc64_update(crc, (const uint8_t *) &temp_node,
sizeof(dns_rbtnode_t));
- isc_crc64_update(crc, (const isc_uint8_t *) node_data, datasize);
+ isc_crc64_update(crc, (const uint8_t *) node_data, datasize);
cleanup:
return (result);
static isc_result_t
serialize_nodes(FILE *file, dns_rbtnode_t *node, uintptr_t parent,
dns_rbtdatawriter_t datawriter, void *writer_arg,
- uintptr_t *where, isc_uint64_t *crc)
+ uintptr_t *where, uint64_t *crc)
{
uintptr_t left = 0, right = 0, down = 0, data = 0;
off_t location = 0, offset_adjust;
{
isc_result_t result;
off_t header_position, node_position, end_position;
- isc_uint64_t crc;
+ uint64_t crc;
REQUIRE(file != NULL);
static isc_result_t
treefix(dns_rbt_t *rbt, void *base, size_t filesize, dns_rbtnode_t *n,
dns_name_t *name, dns_rbtdatafixer_t datafixer,
- void *fixer_arg, isc_uint64_t *crc)
+ void *fixer_arg, uint64_t *crc)
{
isc_result_t result = ISC_R_SUCCESS;
dns_fixedname_t fixed;
sizeof(dns_rbtnode_t));
hexdump("node data", node_data, datasize);
#endif
- isc_crc64_update(crc, (const isc_uint8_t *) &header,
+ isc_crc64_update(crc, (const uint8_t *) &header,
sizeof(dns_rbtnode_t));
- isc_crc64_update(crc, (const isc_uint8_t *) node_data,
+ isc_crc64_update(crc, (const uint8_t *) node_data,
datasize);
cleanup:
isc_result_t result = ISC_R_SUCCESS;
file_header_t *header;
dns_rbt_t *rbt = NULL;
- isc_uint64_t crc;
+ uint64_t crc;
unsigned int host_big_endian;
REQUIRE(originp == NULL || *originp == NULL);
}
#endif
- if (header->ptrsize != (isc_uint32_t) sizeof(void *)) {
+ if (header->ptrsize != (uint32_t) sizeof(void *)) {
result = ISC_R_INVALIDFILE;
goto cleanup;
}
struct rbtdb_file_header {
char version1[32];
- isc_uint32_t ptrsize;
+ uint32_t ptrsize;
unsigned int bigendian:1;
- isc_uint64_t tree;
- isc_uint64_t nsec;
- isc_uint64_t nsec3;
+ uint64_t tree;
+ uint64_t nsec;
+ uint64_t nsec3;
char version2[32]; /* repeated; must match version1 */
};
(rbtdb)->common.impmagic == RBTDB_MAGIC)
#ifdef DNS_RBTDB_VERSION64
-typedef isc_uint64_t rbtdb_serial_t;
+typedef uint64_t rbtdb_serial_t;
/*%
* Make casting easier in symbolic debuggers by using different names
* for the 64 bit version.
#define zone_zonecut_callback zone_zonecut_callback64
#else
-typedef isc_uint32_t rbtdb_serial_t;
+typedef uint32_t rbtdb_serial_t;
#endif
-typedef isc_uint32_t rbtdb_rdatatype_t;
+typedef uint32_t rbtdb_rdatatype_t;
#define RBTDB_RDATATYPE_BASE(type) ((dns_rdatatype_t)((type) & 0xFFFF))
#define RBTDB_RDATATYPE_EXT(type) ((dns_rdatatype_t)((type) >> 16))
-#define RBTDB_RDATATYPE_VALUE(base, ext) ((rbtdb_rdatatype_t)(((isc_uint32_t)ext) << 16) | (((isc_uint32_t)base) & 0xffff))
+#define RBTDB_RDATATYPE_VALUE(base, ext) ((rbtdb_rdatatype_t)(((uint32_t)ext) << 16) | (((uint32_t)base) & 0xffff))
#define RBTDB_RDATATYPE_SIGNSEC \
RBTDB_RDATATYPE_VALUE(dns_rdatatype_rrsig, dns_rdatatype_nsec)
rbtdb_serial_t serial;
dns_ttl_t rdh_ttl;
rbtdb_rdatatype_t type;
- isc_uint16_t attributes;
+ uint16_t attributes;
dns_trust_t trust;
struct noqname *noqname;
struct noqname *closest;
* this rdataset.
*/
- isc_uint32_t count;
+ uint32_t count;
/*%<
* Monotonously increased every time this rdataset is bound so that
* it is used as the base of the starting point in DNS responses
isc_boolean_t havensec3;
/* NSEC3 parameters */
dns_hash_t hash;
- isc_uint8_t flags;
- isc_uint16_t iterations;
- isc_uint8_t salt_length;
+ uint8_t flags;
+ uint16_t iterations;
+ uint8_t salt_length;
unsigned char salt[DNS_NSEC3_SALTSIZE];
/*
* records and bytes are covered by rwlock.
*/
isc_rwlock_t rwlock;
- isc_uint64_t records;
- isc_uint64_t bytes;
+ uint64_t records;
+ uint64_t bytes;
} rbtdb_version_t;
typedef ISC_LIST(rbtdb_version_t) rbtdb_versionlist_t;
* We don't lock this as we don't care about simultaneous updates.
*
* Note:
- * Both init_count and header->count can be ISC_UINT32_MAX.
+ * Both init_count and header->count can be UINT32_MAX.
* The count on the returned rdataset however can't be as
* that indicates that the database does not implement cyclic
* processing.
adjust_quantum(unsigned int old, isc_time_t *start) {
unsigned int pps = dns_pps; /* packets per second */
unsigned int interval;
- isc_uint64_t usecs;
+ uint64_t usecs;
isc_time_t end;
unsigned int nodes;
newh->node = (dns_rbtnode_t *)p;
}
if (CASESET(old)) {
- isc_uint16_t attr;
+ uint16_t attr;
memmove(newh->upper, old->upper, sizeof(old->upper));
attr = old->attributes & (RDATASET_ATTR_CASESET |
raw = (unsigned char *)header + sizeof(*header);
rdataset->private3 = raw;
rdataset->count = header->count++;
- if (rdataset->count == ISC_UINT32_MAX)
+ if (rdataset->count == UINT32_MAX)
rdataset->count = 0;
/*
isc_stdtime_get(&now);
if (isc_mem_isovermem(rbtdb->common.mctx)) {
- isc_uint32_t val;
+ uint32_t val;
isc_random_get(&val);
/*
static isc_result_t
rbt_datafixer(dns_rbtnode_t *rbtnode, void *base, size_t filesize,
- void *arg, isc_uint64_t *crc)
+ void *arg, uint64_t *crc)
{
isc_result_t result;
dns_rbtdb_t *rbtdb = (dns_rbtdb_t *) arg;
*/
static isc_result_t
rbt_datawriter(FILE *rbtfile, unsigned char *data, void *arg,
- isc_uint64_t *crc)
+ uint64_t *crc)
{
rbtdb_version_t *version = (rbtdb_version_t *) arg;
rbtdb_serial_t serial;
memset(&header, 0, sizeof(rbtdb_file_header_t));
memmove(header.version1, FILE_VERSION, sizeof(header.version1));
memmove(header.version2, FILE_VERSION, sizeof(header.version2));
- header.ptrsize = (isc_uint32_t) sizeof(void *);
+ header.ptrsize = (uint32_t) sizeof(void *);
header.bigendian = (1 == htonl(1)) ? 1 : 0;
- header.tree = (isc_uint64_t) tree_location;
- header.nsec = (isc_uint64_t) nsec_location;
- header.nsec3 = (isc_uint64_t) nsec3_location;
+ header.tree = (uint64_t) tree_location;
+ header.nsec = (uint64_t) nsec_location;
+ header.nsec3 = (uint64_t) nsec3_location;
result = isc_stdio_write(&header, 1, sizeof(rbtdb_file_header_t),
rbtfile, NULL);
fflush(rbtfile);
static isc_result_t
getnsec3parameters(dns_db_t *db, dns_dbversion_t *version, dns_hash_t *hash,
- isc_uint8_t *flags, isc_uint16_t *iterations,
+ uint8_t *flags, uint16_t *iterations,
unsigned char *salt, size_t *salt_length)
{
dns_rbtdb_t *rbtdb;
}
static isc_result_t
-getsize(dns_db_t *db, dns_dbversion_t *version, isc_uint64_t *records,
- isc_uint64_t *bytes)
+getsize(dns_db_t *db, dns_dbversion_t *version, uint64_t *records,
+ uint64_t *bytes)
{
dns_rbtdb_t *rbtdb;
isc_result_t result = ISC_R_SUCCESS;
#include <config.h>
#include <ctype.h>
+#include <inttypes.h>
#include <isc/buffer.h>
#include <isc/parseint.h>
unsigned int max, isc_boolean_t hex_allowed)
{
isc_result_t result;
- isc_uint32_t n;
+ uint32_t n;
char buffer[NUMBERSIZE];
if (! isdigit(source->base[0] & 0xff) ||
/*! \file */
#include <config.h>
+
#include <ctype.h>
+#include <inttypes.h>
#include <isc/base64.h>
#include <isc/hex.h>
buffer_fromregion(isc_buffer_t *buffer, isc_region_t *region);
static isc_result_t
-uint32_tobuffer(isc_uint32_t, isc_buffer_t *target);
+uint32_tobuffer(uint32_t, isc_buffer_t *target);
static isc_result_t
-uint16_tobuffer(isc_uint32_t, isc_buffer_t *target);
+uint16_tobuffer(uint32_t, isc_buffer_t *target);
static isc_result_t
-uint8_tobuffer(isc_uint32_t, isc_buffer_t *target);
+uint8_tobuffer(uint32_t, isc_buffer_t *target);
static isc_result_t
name_tobuffer(dns_name_t *name, isc_buffer_t *target);
-static isc_uint32_t
+static uint32_t
uint32_fromregion(isc_region_t *region);
-static isc_uint16_t
+static uint16_t
uint16_fromregion(isc_region_t *region);
-static isc_uint8_t
+static uint8_t
uint8_fromregion(isc_region_t *region);
-static isc_uint8_t
+static uint8_t
uint8_consume_fromregion(isc_region_t *region);
static isc_result_t
warn_badmx(isc_token_t *token, isc_lex_t *lexer,
dns_rdatacallbacks_t *callbacks);
-static isc_uint16_t
+static uint16_t
uint16_consume_fromregion(isc_region_t *region);
static isc_result_t
isc_buffer_t ss;
isc_buffer_t st;
isc_boolean_t use_default = ISC_FALSE;
- isc_uint32_t activelength;
+ uint32_t activelength;
unsigned int length;
REQUIRE(dctx != NULL);
if (result != ISC_R_SUCCESS) {
*target = st;
INSIST(target->used < 65536);
- dns_compress_rollback(cctx, (isc_uint16_t)target->used);
+ dns_compress_rollback(cctx, (uint16_t)target->used);
}
return (result);
}
}
static isc_result_t
-uint32_tobuffer(isc_uint32_t value, isc_buffer_t *target) {
+uint32_tobuffer(uint32_t value, isc_buffer_t *target) {
isc_region_t region;
isc_buffer_availableregion(target, ®ion);
}
static isc_result_t
-uint16_tobuffer(isc_uint32_t value, isc_buffer_t *target) {
+uint16_tobuffer(uint32_t value, isc_buffer_t *target) {
isc_region_t region;
if (value > 0xffff)
isc_buffer_availableregion(target, ®ion);
if (region.length < 2)
return (ISC_R_NOSPACE);
- isc_buffer_putuint16(target, (isc_uint16_t)value);
+ isc_buffer_putuint16(target, (uint16_t)value);
return (ISC_R_SUCCESS);
}
static isc_result_t
-uint8_tobuffer(isc_uint32_t value, isc_buffer_t *target) {
+uint8_tobuffer(uint32_t value, isc_buffer_t *target) {
isc_region_t region;
if (value > 0xff)
isc_buffer_availableregion(target, ®ion);
if (region.length < 1)
return (ISC_R_NOSPACE);
- isc_buffer_putuint8(target, (isc_uint8_t)value);
+ isc_buffer_putuint8(target, (uint8_t)value);
return (ISC_R_SUCCESS);
}
return (isc_buffer_copyregion(target, &r));
}
-static isc_uint32_t
+static uint32_t
uint32_fromregion(isc_region_t *region) {
- isc_uint32_t value;
+ uint32_t value;
REQUIRE(region->length >= 4);
- value = (isc_uint32_t)region->base[0] << 24;
- value |= (isc_uint32_t)region->base[1] << 16;
- value |= (isc_uint32_t)region->base[2] << 8;
- value |= (isc_uint32_t)region->base[3];
+ value = (uint32_t)region->base[0] << 24;
+ value |= (uint32_t)region->base[1] << 16;
+ value |= (uint32_t)region->base[2] << 8;
+ value |= (uint32_t)region->base[3];
return(value);
}
-static isc_uint16_t
+static uint16_t
uint16_consume_fromregion(isc_region_t *region) {
- isc_uint16_t r = uint16_fromregion(region);
+ uint16_t r = uint16_fromregion(region);
isc_region_consume(region, 2);
return r;
}
-static isc_uint16_t
+static uint16_t
uint16_fromregion(isc_region_t *region) {
REQUIRE(region->length >= 2);
return ((region->base[0] << 8) | region->base[1]);
}
-static isc_uint8_t
+static uint8_t
uint8_fromregion(isc_region_t *region) {
REQUIRE(region->length >= 1);
return (region->base[0]);
}
-static isc_uint8_t
+static uint8_t
uint8_consume_fromregion(isc_region_t *region) {
- isc_uint8_t r = uint8_fromregion(region);
+ uint8_t r = uint8_fromregion(region);
isc_region_consume(region, 1);
return r;
struct state {
- isc_int32_t Ceor;
- isc_int32_t Csum;
- isc_int32_t Crot;
- isc_int32_t word;
- isc_int32_t bcount;
+ int32_t Ceor;
+ int32_t Csum;
+ int32_t Crot;
+ int32_t word;
+ int32_t bcount;
};
#define Ceor state->Ceor
}
} else if ((s = strchr(atob_digits, c)) != NULL) {
if (bcount == 0) {
- word = (isc_int32_t)(s - atob_digits);
+ word = (int32_t)(s - atob_digits);
++bcount;
} else if (bcount < 4) {
word = times85(word);
- word += (isc_int32_t)(s - atob_digits);
+ word += (int32_t)(s - atob_digits);
++bcount;
} else {
word = times85(word);
- word += (isc_int32_t)(s - atob_digits);
+ word += (int32_t)(s - atob_digits);
RETERR(putbyte((word >> 24) & 0xff, target, state));
RETERR(putbyte((word >> 16) & 0xff, target, state));
RETERR(putbyte((word >> 8) & 0xff, target, state));
isc_buffer_add(target, 1);
} else {
register int tmp = 0;
- register isc_int32_t tmpword = word;
+ register int32_t tmpword = word;
if (tmpword < 0) {
/*
* Because some don't support u_long.
*/
tmp = 32;
- tmpword -= (isc_int32_t)(85 * 85 * 85 * 85 * 32);
+ tmpword -= (int32_t)(85 * 85 * 85 * 85 * 32);
}
if (tmpword < 0) {
tmp = 64;
- tmpword -= (isc_int32_t)(85 * 85 * 85 * 85 * 32);
+ tmpword -= (int32_t)(85 * 85 * 85 * 85 * 32);
}
if (tr.length < 5)
return (ISC_R_NOSPACE);
tr.base[0] = atob_digits[(tmpword /
- (isc_int32_t)(85 * 85 * 85 * 85))
+ (int32_t)(85 * 85 * 85 * 85))
+ tmp];
- tmpword %= (isc_int32_t)(85 * 85 * 85 * 85);
+ tmpword %= (int32_t)(85 * 85 * 85 * 85);
tr.base[1] = atob_digits[tmpword / (85 * 85 * 85)];
tmpword %= (85 * 85 * 85);
tr.base[2] = atob_digits[tmpword / (85 * 85)];
fromtext_any_tsig(ARGS_FROMTEXT) {
isc_token_t token;
dns_name_t name;
- isc_uint64_t sigtime;
+ uint64_t sigtime;
isc_buffer_t buffer;
dns_rcode_t rcode;
long i;
RETTOK(DNS_R_SYNTAX);
if ((sigtime >> 48) != 0)
RETTOK(ISC_R_RANGE);
- RETERR(uint16_tobuffer((isc_uint16_t)(sigtime >> 32), target));
- RETERR(uint32_tobuffer((isc_uint32_t)(sigtime & 0xffffffffU), target));
+ RETERR(uint16_tobuffer((uint16_t)(sigtime >> 32), target));
+ RETERR(uint32_tobuffer((uint32_t)(sigtime & 0xffffffffU), target));
/*
* Fudge.
dns_name_t name;
dns_name_t prefix;
isc_boolean_t sub;
- isc_uint64_t sigtime;
+ uint64_t sigtime;
unsigned short n;
REQUIRE(rdata->type == dns_rdatatype_tsig);
/*
* Time Signed.
*/
- sigtime = ((isc_uint64_t)sr.base[0] << 40) |
- ((isc_uint64_t)sr.base[1] << 32) |
- ((isc_uint64_t)sr.base[2] << 24) |
- ((isc_uint64_t)sr.base[3] << 16) |
- ((isc_uint64_t)sr.base[4] << 8) |
- (isc_uint64_t)sr.base[5];
+ sigtime = ((uint64_t)sr.base[0] << 40) |
+ ((uint64_t)sr.base[1] << 32) |
+ ((uint64_t)sr.base[2] << 24) |
+ ((uint64_t)sr.base[3] << 16) |
+ ((uint64_t)sr.base[4] << 8) |
+ (uint64_t)sr.base[5];
isc_region_consume(&sr, 6);
bufp = &buf[sizeof(buf) - 1];
*bufp-- = 0;
/*
* Time Signed: 48 bits.
*/
- RETERR(uint16_tobuffer((isc_uint16_t)(tsig->timesigned >> 32),
+ RETERR(uint16_tobuffer((uint16_t)(tsig->timesigned >> 32),
target));
- RETERR(uint32_tobuffer((isc_uint32_t)(tsig->timesigned & 0xffffffffU),
+ RETERR(uint32_tobuffer((uint32_t)(tsig->timesigned & 0xffffffffU),
target));
/*
* Time Signed.
*/
INSIST(sr.length >= 6);
- tsig->timesigned = ((isc_uint64_t)sr.base[0] << 40) |
- ((isc_uint64_t)sr.base[1] << 32) |
- ((isc_uint64_t)sr.base[2] << 24) |
- ((isc_uint64_t)sr.base[3] << 16) |
- ((isc_uint64_t)sr.base[4] << 8) |
- (isc_uint64_t)sr.base[5];
+ tsig->timesigned = ((uint64_t)sr.base[0] << 40) |
+ ((uint64_t)sr.base[1] << 32) |
+ ((uint64_t)sr.base[2] << 24) |
+ ((uint64_t)sr.base[3] << 16) |
+ ((uint64_t)sr.base[4] << 8) |
+ (uint64_t)sr.base[5];
isc_region_consume(&sr, 6);
/*
dns_rdatacommon_t common;
isc_mem_t * mctx;
dns_name_t algorithm;
- isc_uint64_t timesigned;
- isc_uint16_t fudge;
- isc_uint16_t siglen;
+ uint64_t timesigned;
+ uint16_t fudge;
+ uint16_t siglen;
unsigned char * signature;
- isc_uint16_t originalid;
- isc_uint16_t error;
- isc_uint16_t otherlen;
+ uint16_t originalid;
+ uint16_t error;
+ uint16_t otherlen;
unsigned char * other;
} dns_rdata_any_tsig_t;
dns_name_t prefix;
isc_boolean_t sub;
char buf[sizeof("0177777")];
- isc_uint16_t addr;
+ uint16_t addr;
REQUIRE(rdata->type == dns_rdatatype_a);
REQUIRE(rdata->rdclass == dns_rdataclass_ch); /* 3 */
#ifndef CH_3_A_1_H
#define CH_3_A_1_H 1
-typedef isc_uint16_t ch_addr_t;
+typedef uint16_t ch_addr_t;
typedef struct dns_rdata_ch_a {
dns_rdatacommon_t common;
typedef struct dns_rdata_afsdb {
dns_rdatacommon_t common;
isc_mem_t *mctx;
- isc_uint16_t subtype;
+ uint16_t subtype;
dns_name_t server;
} dns_rdata_afsdb_t;
dns_rdatacommon_t common;
isc_mem_t *mctx;
unsigned char *data;
- isc_uint16_t length;
+ uint16_t length;
/* private */
- isc_uint16_t offset;
+ uint16_t offset;
} dns_rdata_avc_t;
/*
fromtext_caa(ARGS_FROMTEXT) {
isc_token_t token;
isc_textregion_t tr;
- isc_uint8_t flags;
+ uint8_t flags;
unsigned int i;
REQUIRE(type == dns_rdatatype_caa);
ISC_FALSE));
if (token.value.as_ulong > 255U)
RETTOK(ISC_R_RANGE);
- flags = (isc_uint8_t)(token.value.as_ulong & 255U);
+ flags = (uint8_t)(token.value.as_ulong & 255U);
RETERR(uint8_tobuffer(flags, target));
/*
static inline isc_result_t
totext_caa(ARGS_TOTEXT) {
isc_region_t region;
- isc_uint8_t flags;
+ uint8_t flags;
char buf[256];
UNUSED(tctx);
typedef struct dns_rdata_caa {
dns_rdatacommon_t common;
isc_mem_t * mctx;
- isc_uint8_t flags;
+ uint8_t flags;
unsigned char * tag;
- isc_uint8_t tag_len;
+ uint8_t tag_len;
unsigned char *value;
- isc_uint16_t value_len;
+ uint16_t value_len;
} dns_rdata_caa_t;
#endif /* GENERIC_CAA_257_H */
typedef struct dns_rdata_cert {
dns_rdatacommon_t common;
isc_mem_t *mctx;
- isc_uint16_t type;
- isc_uint16_t key_tag;
- isc_uint8_t algorithm;
- isc_uint16_t length;
+ uint16_t type;
+ uint16_t key_tag;
+ uint8_t algorithm;
+ uint16_t length;
unsigned char *certificate;
} dns_rdata_cert_t;
typedef struct dns_rdata_csync {
dns_rdatacommon_t common;
isc_mem_t *mctx;
- isc_uint32_t serial;
- isc_uint16_t flags;
+ uint32_t serial;
+ uint16_t flags;
unsigned char *typebits;
- isc_uint16_t len;
+ uint16_t len;
} dns_rdata_csync_t;
#endif /* GENERIC_CSYNC_62_H */
totext_doa(ARGS_TOTEXT) {
char buf[sizeof("4294967295 ")];
isc_region_t region;
- isc_uint32_t n;
+ uint32_t n;
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_doa);
isc_mem_t * mctx;
unsigned char * mediatype;
unsigned char * data;
- isc_uint32_t enterprise;
- isc_uint32_t type;
- isc_uint16_t data_len;
- isc_uint8_t location;
- isc_uint8_t mediatype_len;
+ uint32_t enterprise;
+ uint32_t type;
+ uint16_t data_len;
+ uint8_t location;
+ uint8_t mediatype_len;
} dns_rdata_doa_t;
#endif /* GENERIC_DOA_259_H */
typedef struct dns_rdata_ds {
dns_rdatacommon_t common;
isc_mem_t *mctx;
- isc_uint16_t key_tag;
- isc_uint8_t algorithm;
- isc_uint8_t digest_type;
- isc_uint16_t length;
+ uint16_t key_tag;
+ uint8_t algorithm;
+ uint8_t digest_type;
+ uint16_t length;
unsigned char *digest;
} dns_rdata_ds_t;
char *longitude;
char *latitude;
char *altitude;
- isc_uint8_t long_len;
- isc_uint8_t lat_len;
- isc_uint8_t alt_len;
+ uint8_t long_len;
+ uint8_t lat_len;
+ uint8_t alt_len;
} dns_rdata_gpos_t;
#endif /* GENERIC_GPOS_27_H */
isc_mem_t *mctx;
char *cpu;
char *os;
- isc_uint8_t cpu_len;
- isc_uint8_t os_len;
+ uint8_t cpu_len;
+ uint8_t os_len;
} dns_rdata_hinfo_t;
#endif /* GENERIC_HINFO_13_H */
len = (unsigned char *)isc_buffer_used(target) - start;
if (len > 0xffU)
RETTOK(ISC_R_RANGE);
- RETERR(uint8_tobuffer((isc_uint32_t)len, &hit_len));
+ RETERR(uint8_tobuffer((uint32_t)len, &hit_len));
/*
* Public key (base64).
len = (unsigned char *)isc_buffer_used(target) - start;
if (len > 0xffffU)
RETTOK(ISC_R_RANGE);
- RETERR(uint16_tobuffer((isc_uint32_t)len, &key_len));
+ RETERR(uint16_tobuffer((uint32_t)len, &key_len));
if (origin == NULL)
origin = dns_rootname;
fromwire_hip(ARGS_FROMWIRE) {
isc_region_t region, rr;
dns_name_t name;
- isc_uint8_t hit_len;
- isc_uint16_t key_len;
+ uint8_t hit_len;
+ uint16_t key_len;
REQUIRE(type == dns_rdatatype_hip);
dns_name_t name1;
dns_name_t name2;
int order;
- isc_uint8_t hit_len;
- isc_uint16_t key_len;
+ uint8_t hit_len;
+ uint16_t key_len;
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
unsigned char * hit;
unsigned char * key;
unsigned char * servers;
- isc_uint8_t algorithm;
- isc_uint8_t hit_len;
- isc_uint16_t key_len;
- isc_uint16_t servers_len;
+ uint8_t algorithm;
+ uint8_t hit_len;
+ uint16_t key_len;
+ uint16_t servers_len;
/* Private */
- isc_uint16_t offset;
+ uint16_t offset;
} dns_rdata_hip_t;
isc_result_t
fromstruct_ipseckey(ARGS_FROMSTRUCT) {
dns_rdata_ipseckey_t *ipseckey = source;
isc_region_t region;
- isc_uint32_t n;
+ uint32_t n;
REQUIRE(type == dns_rdatatype_ipseckey);
REQUIRE(source != NULL);
isc_region_t region;
dns_rdata_ipseckey_t *ipseckey = target;
dns_name_t name;
- isc_uint32_t n;
+ uint32_t n;
REQUIRE(rdata->type == dns_rdatatype_ipseckey);
REQUIRE(target != NULL);
typedef struct dns_rdata_ipseckey {
dns_rdatacommon_t common;
isc_mem_t *mctx;
- isc_uint8_t precedence;
- isc_uint8_t gateway_type;
- isc_uint8_t algorithm;
+ uint8_t precedence;
+ uint8_t gateway_type;
+ uint8_t algorithm;
struct in_addr in_addr; /* gateway type 1 */
struct in6_addr in6_addr; /* gateway type 2 */
dns_name_t gateway; /* gateway type 3 */
unsigned char *key;
- isc_uint16_t keylength;
+ uint16_t keylength;
} dns_rdata_ipseckey_t;
#endif /* GENERIC_IPSECKEY_45_H */
isc_mem_t *mctx;
char *isdn;
char *subaddress;
- isc_uint8_t isdn_len;
- isc_uint8_t subaddress_len;
+ uint8_t isdn_len;
+ uint8_t subaddress_len;
} dns_rdata_isdn_t;
#endif /* GENERIC_ISDN_20_H */
typedef struct dns_rdata_key {
dns_rdatacommon_t common;
isc_mem_t * mctx;
- isc_uint16_t flags;
- isc_uint8_t protocol;
- isc_uint8_t algorithm;
- isc_uint16_t datalen;
+ uint16_t flags;
+ uint8_t protocol;
+ uint8_t algorithm;
+ uint16_t datalen;
unsigned char * data;
} dns_rdata_key_t;
dns_secalg_t alg;
dns_secproto_t proto;
dns_keyflags_t flags;
- isc_uint32_t refresh, addhd, removehd;
+ uint32_t refresh, addhd, removehd;
REQUIRE(type == dns_rdatatype_keydata);
typedef struct dns_rdata_keydata {
dns_rdatacommon_t common;
isc_mem_t * mctx;
- isc_uint32_t refresh; /* Timer for refreshing data */
- isc_uint32_t addhd; /* Hold-down timer for adding */
- isc_uint32_t removehd; /* Hold-down timer for removing */
- isc_uint16_t flags; /* Copy of DNSKEY_48 */
- isc_uint8_t protocol;
- isc_uint8_t algorithm;
- isc_uint16_t datalen;
+ uint32_t refresh; /* Timer for refreshing data */
+ uint32_t addhd; /* Hold-down timer for adding */
+ uint32_t removehd; /* Hold-down timer for removing */
+ uint16_t flags; /* Copy of DNSKEY_48 */
+ uint8_t protocol;
+ uint8_t algorithm;
+ uint16_t datalen;
unsigned char * data;
} dns_rdata_keydata_t;
static inline isc_result_t
fromstruct_l32(ARGS_FROMSTRUCT) {
dns_rdata_l32_t *l32 = source;
- isc_uint32_t n;
+ uint32_t n;
REQUIRE(type == dns_rdatatype_l32);
REQUIRE(source != NULL);
tostruct_l32(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_l32_t *l32 = target;
- isc_uint32_t n;
+ uint32_t n;
REQUIRE(rdata->type == dns_rdatatype_l32);
REQUIRE(target != NULL);
typedef struct dns_rdata_l32 {
dns_rdatacommon_t common;
- isc_uint16_t pref;
+ uint16_t pref;
struct in_addr l32;
} dns_rdata_l32_t;
typedef struct dns_rdata_l64 {
dns_rdatacommon_t common;
- isc_uint16_t pref;
+ uint16_t pref;
unsigned char l64[8];
} dns_rdata_l64_t;
static inline isc_result_t
fromstruct_loc(ARGS_FROMSTRUCT) {
dns_rdata_loc_t *loc = source;
- isc_uint8_t c;
+ uint8_t c;
REQUIRE(type == dns_rdatatype_loc);
REQUIRE(source != NULL);
tostruct_loc(ARGS_TOSTRUCT) {
dns_rdata_loc_t *loc = target;
isc_region_t r;
- isc_uint8_t version;
+ uint8_t version;
REQUIRE(rdata->type == dns_rdatatype_loc);
REQUIRE(target != NULL);
* \brief Per RFC1876 */
typedef struct dns_rdata_loc_0 {
- isc_uint8_t version; /* must be first and zero */
- isc_uint8_t size;
- isc_uint8_t horizontal;
- isc_uint8_t vertical;
- isc_uint32_t latitude;
- isc_uint32_t longitude;
- isc_uint32_t altitude;
+ uint8_t version; /* must be first and zero */
+ uint8_t size;
+ uint8_t horizontal;
+ uint8_t vertical;
+ uint32_t latitude;
+ uint32_t longitude;
+ uint32_t altitude;
} dns_rdata_loc_0_t;
typedef struct dns_rdata_loc {
typedef struct dns_rdata_lp {
dns_rdatacommon_t common;
isc_mem_t *mctx;
- isc_uint16_t pref;
+ uint16_t pref;
dns_name_t lp;
} dns_rdata_lp_t;
typedef struct dns_rdata_mx {
dns_rdatacommon_t common;
isc_mem_t *mctx;
- isc_uint16_t pref;
+ uint16_t pref;
dns_name_t mx;
} dns_rdata_mx_t;
typedef struct dns_rdata_naptr {
dns_rdatacommon_t common;
isc_mem_t *mctx;
- isc_uint16_t order;
- isc_uint16_t preference;
+ uint16_t order;
+ uint16_t preference;
char *flags;
- isc_uint8_t flags_len;
+ uint8_t flags_len;
char *service;
- isc_uint8_t service_len;
+ uint8_t service_len;
char *regexp;
- isc_uint8_t regexp_len;
+ uint8_t regexp_len;
dns_name_t replacement;
} dns_rdata_naptr_t;
typedef struct dns_rdata_nid {
dns_rdatacommon_t common;
- isc_uint16_t pref;
+ uint16_t pref;
unsigned char nid[8];
} dns_rdata_nid_t;
unsigned char hash;
unsigned char flags;
char buf[sizeof("TYPE65535")];
- isc_uint32_t iterations;
+ uint32_t iterations;
REQUIRE(rdata->type == dns_rdatatype_nsec3);
REQUIRE(rdata->length != 0);
dns_iterations_t iterations;
unsigned char salt_length;
unsigned char next_length;
- isc_uint16_t len;
+ uint16_t len;
unsigned char *salt;
unsigned char *next;
unsigned char *typebits;
unsigned char hash;
unsigned char flags;
char buf[sizeof("65535 ")];
- isc_uint32_t iterations;
+ uint32_t iterations;
REQUIRE(rdata->type == dns_rdatatype_nsec3param);
REQUIRE(rdata->length != 0);
isc_mem_t *mctx;
dns_name_t next;
unsigned char *typebits;
- isc_uint16_t len;
+ uint16_t len;
} dns_rdata_nsec_t;
#endif /* GENERIC_NSEC_47_H */
typedef struct dns_rdata_null {
dns_rdatacommon_t common;
isc_mem_t *mctx;
- isc_uint16_t length;
+ uint16_t length;
unsigned char *data;
} dns_rdata_null_t;
isc_mem_t *mctx;
dns_name_t next;
unsigned char *typebits;
- isc_uint16_t len;
+ uint16_t len;
} dns_rdata_nxt_t;
#endif /* GENERIC_NXT_30_H */
typedef struct dns_rdata_openpgpkey {
dns_rdatacommon_t common;
isc_mem_t * mctx;
- isc_uint16_t length;
+ uint16_t length;
unsigned char * keyring;
} dns_rdata_openpgpkey_t;
totext_opt(ARGS_TOTEXT) {
isc_region_t r;
isc_region_t or;
- isc_uint16_t option;
- isc_uint16_t length;
+ uint16_t option;
+ uint16_t length;
char buf[sizeof("64000 64000")];
/*
fromwire_opt(ARGS_FROMWIRE) {
isc_region_t sregion;
isc_region_t tregion;
- isc_uint16_t opt;
- isc_uint16_t length;
+ uint16_t opt;
+ uint16_t length;
unsigned int total;
REQUIRE(type == dns_rdatatype_opt);
return (ISC_R_UNEXPECTEDEND);
switch (opt) {
case DNS_OPT_CLIENT_SUBNET: {
- isc_uint16_t family;
- isc_uint8_t addrlen;
- isc_uint8_t scope;
- isc_uint8_t addrbytes;
+ uint16_t family;
+ uint8_t addrlen;
+ uint8_t scope;
+ uint8_t addrbytes;
if (length < 4)
return (DNS_R_OPTERR);
return (DNS_R_OPTERR);
if (addrbytes != 0U && (addrlen % 8) != 0) {
- isc_uint8_t bits = ~0U << (8 - (addrlen % 8));
+ uint8_t bits = ~0U << (8 - (addrlen % 8));
bits &= sregion.base[addrbytes - 1];
if (bits != sregion.base[addrbytes - 1])
return (DNS_R_OPTERR);
fromstruct_opt(ARGS_FROMSTRUCT) {
dns_rdata_opt_t *opt = source;
isc_region_t region;
- isc_uint16_t length;
+ uint16_t length;
REQUIRE(type == dns_rdatatype_opt);
REQUIRE(source != NULL);
isc_result_t
dns_rdata_opt_next(dns_rdata_opt_t *opt) {
isc_region_t r;
- isc_uint16_t length;
+ uint16_t length;
REQUIRE(opt != NULL);
REQUIRE(opt->common.rdtype == dns_rdatatype_opt);
* \brief Per RFC2671 */
typedef struct dns_rdata_opt_opcode {
- isc_uint16_t opcode;
- isc_uint16_t length;
+ uint16_t opcode;
+ uint16_t length;
unsigned char *data;
} dns_rdata_opt_opcode_t;
dns_rdatacommon_t common;
isc_mem_t *mctx;
unsigned char *options;
- isc_uint16_t length;
+ uint16_t length;
/* private */
- isc_uint16_t offset;
+ uint16_t offset;
} dns_rdata_opt_t;
/*
isc_result_t result;
dns_name_t name;
isc_buffer_t buffer;
- isc_uint32_t time_signed, time_expire;
+ uint32_t time_signed, time_expire;
REQUIRE(type == dns_rdatatype_rrsig);
*DNS_AS_STR(token) != '-' && *DNS_AS_STR(token) != '+') {
char *end;
unsigned long u;
- isc_uint64_t u64;
+ uint64_t u64;
u64 = u = strtoul(DNS_AS_STR(token), &end, 10);
if (u == ULONG_MAX || *end != 0)
*DNS_AS_STR(token) != '-' && *DNS_AS_STR(token) != '+') {
char *end;
unsigned long u;
- isc_uint64_t u64;
+ uint64_t u64;
u64 = u = strtoul(DNS_AS_STR(token), &end, 10);
if (u == ULONG_MAX || *end != 0)
isc_mem_t * mctx;
dns_rdatatype_t covered;
dns_secalg_t algorithm;
- isc_uint8_t labels;
- isc_uint32_t originalttl;
- isc_uint32_t timeexpire;
- isc_uint32_t timesigned;
- isc_uint16_t keyid;
+ uint8_t labels;
+ uint32_t originalttl;
+ uint32_t timeexpire;
+ uint32_t timesigned;
+ uint16_t keyid;
dns_name_t signer;
- isc_uint16_t siglen;
+ uint16_t siglen;
unsigned char * signature;
} dns_rdata_rrsig_t;
typedef struct dns_rdata_rt {
dns_rdatacommon_t common;
isc_mem_t *mctx;
- isc_uint16_t preference;
+ uint16_t preference;
dns_name_t host;
} dns_rdata_rt_t;
isc_result_t result;
dns_name_t name;
isc_buffer_t buffer;
- isc_uint32_t time_signed, time_expire;
+ uint32_t time_signed, time_expire;
REQUIRE(type == dns_rdatatype_sig);
isc_mem_t * mctx;
dns_rdatatype_t covered;
dns_secalg_t algorithm;
- isc_uint8_t labels;
- isc_uint32_t originalttl;
- isc_uint32_t timeexpire;
- isc_uint32_t timesigned;
- isc_uint16_t keyid;
+ uint8_t labels;
+ uint32_t originalttl;
+ uint32_t timeexpire;
+ uint32_t timesigned;
+ uint16_t keyid;
dns_name_t signer;
- isc_uint16_t siglen;
+ uint16_t siglen;
unsigned char * signature;
} dns_rdata_sig_t;
totext_sink(ARGS_TOTEXT) {
isc_region_t sr;
char buf[sizeof("255 255 255")];
- isc_uint8_t meaning, coding, subcoding;
+ uint8_t meaning, coding, subcoding;
REQUIRE(rdata->type == dns_rdatatype_sink);
REQUIRE(rdata->length >= 3);
typedef struct dns_rdata_sink_t {
dns_rdatacommon_t common;
isc_mem_t * mctx;
- isc_uint8_t meaning;
- isc_uint8_t coding;
- isc_uint8_t subcoding;
- isc_uint16_t datalen;
+ uint8_t meaning;
+ uint8_t coding;
+ uint8_t subcoding;
+ uint16_t datalen;
unsigned char * data;
} dns_rdata_sink_t;
dns_name_t name;
isc_buffer_t buffer;
int i;
- isc_uint32_t n;
+ uint32_t n;
isc_boolean_t ok;
REQUIRE(type == dns_rdatatype_soa);
isc_mem_t *mctx;
dns_name_t origin;
dns_name_t contact;
- isc_uint32_t serial; /*%< host order */
- isc_uint32_t refresh; /*%< host order */
- isc_uint32_t retry; /*%< host order */
- isc_uint32_t expire; /*%< host order */
- isc_uint32_t minimum; /*%< host order */
+ uint32_t serial; /*%< host order */
+ uint32_t refresh; /*%< host order */
+ uint32_t retry; /*%< host order */
+ uint32_t expire; /*%< host order */
+ uint32_t minimum; /*%< host order */
} dns_rdata_soa_t;
typedef struct dns_rdata_spf_string {
- isc_uint8_t length;
+ uint8_t length;
unsigned char *data;
} dns_rdata_spf_string_t;
dns_rdatacommon_t common;
isc_mem_t *mctx;
unsigned char *txt;
- isc_uint16_t txt_len;
+ uint16_t txt_len;
/* private */
- isc_uint16_t offset;
+ uint16_t offset;
} dns_rdata_spf_t;
/*
typedef struct dns_rdata_sshfp {
dns_rdatacommon_t common;
isc_mem_t *mctx;
- isc_uint8_t algorithm;
- isc_uint8_t digest_type;
- isc_uint16_t length;
+ uint8_t algorithm;
+ uint8_t digest_type;
+ uint16_t length;
unsigned char *digest;
} dns_rdata_sshfp_t;
dns_rdatacommon_t common;
isc_mem_t * mctx;
dns_name_t algorithm;
- isc_uint32_t inception;
- isc_uint32_t expire;
- isc_uint16_t mode;
- isc_uint16_t error;
- isc_uint16_t keylen;
+ uint32_t inception;
+ uint32_t expire;
+ uint16_t mode;
+ uint16_t error;
+ uint16_t keylen;
unsigned char * key;
- isc_uint16_t otherlen;
+ uint16_t otherlen;
unsigned char * other;
} dns_rdata_tkey_t;
typedef struct dns_rdata_tlsa {
dns_rdatacommon_t common;
isc_mem_t *mctx;
- isc_uint8_t usage;
- isc_uint8_t selector;
- isc_uint8_t match;
- isc_uint16_t length;
+ uint8_t usage;
+ uint8_t selector;
+ uint8_t match;
+ uint16_t length;
unsigned char *data;
} dns_rdata_tlsa_t;
generic_fromstruct_txt(ARGS_FROMSTRUCT) {
dns_rdata_txt_t *txt = source;
isc_region_t region;
- isc_uint8_t length;
+ uint8_t length;
REQUIRE(source != NULL);
REQUIRE(txt->common.rdtype == type);
static isc_result_t
generic_txt_next(dns_rdata_txt_t *txt) {
isc_region_t r;
- isc_uint8_t length;
+ uint8_t length;
REQUIRE(txt != NULL);
REQUIRE(txt->txt != NULL && txt->txt_len != 0);
typedef struct dns_rdata_txt_string {
- isc_uint8_t length;
+ uint8_t length;
unsigned char *data;
} dns_rdata_txt_string_t;
dns_rdatacommon_t common;
isc_mem_t *mctx;
unsigned char *txt;
- isc_uint16_t txt_len;
+ uint16_t txt_len;
/* private */
- isc_uint16_t offset;
+ uint16_t offset;
} dns_rdata_txt_t;
/*
dns_rdatacommon_t common;
isc_mem_t *mctx;
unsigned char *data;
- isc_uint16_t datalen;
+ uint16_t datalen;
} dns_rdata_unspec_t;
#endif /* GENERIC_UNSPEC_103_H */
typedef struct dns_rdata_uri {
dns_rdatacommon_t common;
isc_mem_t * mctx;
- isc_uint16_t priority;
- isc_uint16_t weight;
+ uint16_t priority;
+ uint16_t weight;
unsigned char * target;
- isc_uint16_t tgt_len;
+ uint16_t tgt_len;
} dns_rdata_uri_t;
#endif /* GENERIC_URI_256_H */
static inline isc_result_t
fromstruct_x25(ARGS_FROMSTRUCT) {
dns_rdata_x25_t *x25 = source;
- isc_uint8_t i;
+ uint8_t i;
REQUIRE(type == dns_rdatatype_x25);
REQUIRE(source != NULL);
dns_rdatacommon_t common;
isc_mem_t *mctx;
unsigned char *x25;
- isc_uint8_t x25_len;
+ uint8_t x25_len;
} dns_rdata_x25_t;
#endif /* GENERIC_X25_19_H */
static inline isc_result_t
fromstruct_hs_a(ARGS_FROMSTRUCT) {
dns_rdata_hs_a_t *a = source;
- isc_uint32_t n;
+ uint32_t n;
REQUIRE(type == dns_rdatatype_a);
REQUIRE(rdclass == dns_rdataclass_hs);
static inline isc_result_t
tostruct_hs_a(ARGS_TOSTRUCT) {
dns_rdata_hs_a_t *a = target;
- isc_uint32_t n;
+ uint32_t n;
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_a);
dns_rdata_in_a6_t *a6 = source;
isc_region_t region;
int octets;
- isc_uint8_t bits;
- isc_uint8_t first;
- isc_uint8_t mask;
+ uint8_t bits;
+ uint8_t first;
+ uint8_t mask;
REQUIRE(type == dns_rdatatype_a6);
REQUIRE(rdclass == dns_rdataclass_in);
dns_rdatacommon_t common;
isc_mem_t *mctx;
dns_name_t prefix;
- isc_uint8_t prefixlen;
+ uint8_t prefixlen;
struct in6_addr in6_addr;
} dns_rdata_in_a6_t;
static inline isc_result_t
fromstruct_in_a(ARGS_FROMSTRUCT) {
dns_rdata_in_a_t *a = source;
- isc_uint32_t n;
+ uint32_t n;
REQUIRE(type == dns_rdatatype_a);
REQUIRE(rdclass == dns_rdataclass_in);
static inline isc_result_t
tostruct_in_a(ARGS_TOSTRUCT) {
dns_rdata_in_a_t *a = target;
- isc_uint32_t n;
+ uint32_t n;
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_a);
isc_token_t token;
unsigned char addr[16];
unsigned long afi;
- isc_uint8_t prefix;
- isc_uint8_t len;
+ uint8_t prefix;
+ uint8_t len;
isc_boolean_t neg;
char *cp, *ap, *slash;
int n;
totext_in_apl(ARGS_TOTEXT) {
isc_region_t sr;
isc_region_t ir;
- isc_uint16_t afi;
- isc_uint8_t prefix;
- isc_uint8_t len;
+ uint16_t afi;
+ uint8_t prefix;
+ uint8_t len;
isc_boolean_t neg;
unsigned char buf[16];
char txt[sizeof(" !64000:")];
fromwire_in_apl(ARGS_FROMWIRE) {
isc_region_t sr, sr2;
isc_region_t tr;
- isc_uint16_t afi;
- isc_uint8_t prefix;
- isc_uint8_t len;
+ uint16_t afi;
+ uint8_t prefix;
+ uint8_t len;
REQUIRE(type == dns_rdatatype_apl);
REQUIRE(rdclass == dns_rdataclass_in);
isc_result_t
dns_rdata_apl_first(dns_rdata_in_apl_t *apl) {
- isc_uint32_t length;
+ uint32_t length;
REQUIRE(apl != NULL);
REQUIRE(apl->common.rdtype == dns_rdatatype_apl);
isc_result_t
dns_rdata_apl_next(dns_rdata_in_apl_t *apl) {
- isc_uint32_t length;
+ uint32_t length;
REQUIRE(apl != NULL);
REQUIRE(apl->common.rdtype == dns_rdatatype_apl);
isc_result_t
dns_rdata_apl_current(dns_rdata_in_apl_t *apl, dns_rdata_apl_ent_t *ent) {
- isc_uint32_t length;
+ uint32_t length;
REQUIRE(apl != NULL);
REQUIRE(apl->common.rdtype == dns_rdatatype_apl);
typedef struct dns_rdata_apl_ent {
isc_boolean_t negative;
- isc_uint16_t family;
- isc_uint8_t prefix;
- isc_uint8_t length;
+ uint16_t family;
+ uint8_t prefix;
+ uint8_t length;
unsigned char *data;
} dns_rdata_apl_ent_t;
isc_mem_t *mctx;
/* type & class specific elements */
unsigned char *apl;
- isc_uint16_t apl_len;
+ uint16_t apl_len;
/* private */
- isc_uint16_t offset;
+ uint16_t offset;
} dns_rdata_in_apl_t;
/*
typedef struct dns_rdata_in_kx {
dns_rdatacommon_t common;
isc_mem_t *mctx;
- isc_uint16_t preference;
+ uint16_t preference;
dns_name_t exchange;
} dns_rdata_in_kx_t;
dns_rdatacommon_t common;
isc_mem_t *mctx;
unsigned char *nsap;
- isc_uint16_t nsap_len;
+ uint16_t nsap_len;
} dns_rdata_in_nsap_t;
#endif /* IN_1_NSAP_22_H */
typedef struct dns_rdata_in_px {
dns_rdatacommon_t common;
isc_mem_t *mctx;
- isc_uint16_t preference;
+ uint16_t preference;
dns_name_t map822;
dns_name_t mapx400;
} dns_rdata_in_px_t;
dns_name_t name;
dns_offsets_t offsets;
isc_region_t region;
- isc_uint16_t port;
+ uint16_t port;
isc_result_t result;
REQUIRE(rdata->type == dns_rdatatype_srv);
typedef struct dns_rdata_in_srv {
dns_rdatacommon_t common;
isc_mem_t *mctx;
- isc_uint16_t priority;
- isc_uint16_t weight;
- isc_uint16_t port;
+ uint16_t priority;
+ uint16_t weight;
+ uint16_t port;
dns_name_t target;
} dns_rdata_in_srv_t;
static inline isc_result_t
fromstruct_in_wks(ARGS_FROMSTRUCT) {
dns_rdata_in_wks_t *wks = source;
- isc_uint32_t a;
+ uint32_t a;
REQUIRE(type == dns_rdatatype_wks);
REQUIRE(rdclass == dns_rdataclass_in);
static inline isc_result_t
tostruct_in_wks(ARGS_TOSTRUCT) {
dns_rdata_in_wks_t *wks = target;
- isc_uint32_t n;
+ uint32_t n;
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_wks);
dns_rdatacommon_t common;
isc_mem_t *mctx;
struct in_addr in_addr;
- isc_uint16_t protocol;
+ uint16_t protocol;
unsigned char *map;
- isc_uint16_t map_len;
+ uint16_t map_len;
} dns_rdata_in_wks_t;
#endif /* IN_1_WKS_11_H */
#include <config.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <isc/buffer.h>
rdataset->trust = 0;
rdataset->covers = 0;
rdataset->attributes = 0;
- rdataset->count = ISC_UINT32_MAX;
+ rdataset->count = UINT32_MAX;
rdataset->private1 = NULL;
rdataset->private2 = NULL;
rdataset->private3 = NULL;
rdataset->trust = 0;
rdataset->covers = 0;
rdataset->attributes = 0;
- rdataset->count = ISC_UINT32_MAX;
+ rdataset->count = UINT32_MAX;
rdataset->private1 = NULL;
rdataset->private2 = NULL;
rdataset->private3 = NULL;
rdataset->trust = 0;
rdataset->covers = 0;
rdataset->attributes = 0;
- rdataset->count = ISC_UINT32_MAX;
+ rdataset->count = UINT32_MAX;
rdataset->private1 = NULL;
rdataset->private2 = NULL;
rdataset->private3 = NULL;
* 'Random' order.
*/
for (i = 0; i < count; i++) {
- isc_uint32_t val;
+ uint32_t val;
isc_random_get(&val);
choice = i + (val % (count - i));
/*
* "Cyclic" order.
*/
- isc_uint32_t val;
+ uint32_t val;
unsigned int j;
val = rdataset->count;
- if (val == ISC_UINT32_MAX)
+ if (val == UINT32_MAX)
isc_random_get(&val);
j = val % count;
for (i = 0; i < count; i++) {
INSIST((target->used >= rdlen.used + 2) &&
(target->used - rdlen.used - 2 < 65536));
isc_buffer_putuint16(&rdlen,
- (isc_uint16_t)(target->used -
+ (uint16_t)(target->used -
rdlen.used - 2));
added++;
}
rollback:
if (partial && result == ISC_R_NOSPACE) {
INSIST(rrbuffer.used < 65536);
- dns_compress_rollback(cctx, (isc_uint16_t)rrbuffer.used);
+ dns_compress_rollback(cctx, (uint16_t)rrbuffer.used);
*countp += added;
*target = rrbuffer;
goto cleanup;
}
INSIST(savedbuffer.used < 65536);
- dns_compress_rollback(cctx, (isc_uint16_t)savedbuffer.used);
+ dns_compress_rollback(cctx, (uint16_t)savedbuffer.used);
*countp = 0;
*target = savedbuffer;
dns_rdata_rrsig_t *rrsig, isc_stdtime_t now,
isc_boolean_t acceptexpired)
{
- isc_uint32_t ttl = 0;
+ uint32_t ttl = 0;
REQUIRE(DNS_RDATASET_VALID(rdataset));
REQUIRE(DNS_RDATASET_VALID(sigrdataset));
#include <config.h>
+#include <inttypes.h>
+
#include <isc/magic.h>
#include <isc/mem.h>
#include <isc/task.h>
isc_mem_t *mctx;
/* locked */
- isc_int32_t eref;
- isc_int32_t iref;
+ int32_t eref;
+ int32_t iref;
isc_timermgr_t *timermgr;
isc_socketmgr_t *socketmgr;
isc_taskmgr_t *taskmgr;
unsigned int magic;
unsigned int hash;
isc_mem_t *mctx;
- isc_int32_t flags;
+ int32_t flags;
ISC_LINK(dns_request_t) link;
isc_buffer_t *query;
isc_buffer_t *answer;
if (result != ISC_R_SUCCESS)
goto cleanup;
if (tcp)
- isc_buffer_putuint16(request->query, (isc_uint16_t)r.length);
+ isc_buffer_putuint16(request->query, (uint16_t)r.length);
result = isc_buffer_copyregion(request->query, &r);
if (result != ISC_R_SUCCESS)
goto cleanup;
if (result != ISC_R_SUCCESS)
goto cleanup;
if (tcp)
- isc_buffer_putuint16(buf2, (isc_uint16_t)r.length);
+ isc_buffer_putuint16(buf2, (uint16_t)r.length);
result = isc_buffer_copyregion(buf2, &r);
if (result != ISC_R_SUCCESS)
goto cleanup;
dns_db_t * cache;
dns_adb_t * adb;
isc_boolean_t ns_ttl_ok;
- isc_uint32_t ns_ttl;
+ uint32_t ns_ttl;
isc_counter_t * qc;
/*%
/*%
* Random numbers to use for mixing up server addresses.
*/
- isc_uint32_t rand_buf;
- isc_uint32_t rand_bits;
+ uint32_t rand_buf;
+ uint32_t rand_bits;
/*%
* Fetch-local statistics for detailed logging.
isc_result_t vresult; /*%< validation result */
int exitline;
isc_time_t start;
- isc_uint64_t duration;
+ uint64_t duration;
isc_boolean_t logged;
unsigned int querysent;
unsigned int referrals;
struct fctxcount {
dns_fixedname_t fdname;
dns_name_t *domain;
- isc_uint32_t count;
- isc_uint32_t allowed;
- isc_uint32_t dropped;
+ uint32_t count;
+ uint32_t allowed;
+ uint32_t dropped;
isc_stdtime_t logged;
ISC_LINK(fctxcount_t) link;
};
unsigned int nbuckets;
fctxbucket_t * buckets;
zonebucket_t * dbuckets;
- isc_uint32_t lame_ttl;
+ uint32_t lame_ttl;
ISC_LIST(alternate_t) alternates;
- isc_uint16_t udpsize;
+ uint16_t udpsize;
#if USE_ALGLOCK
isc_rwlock_t alglock;
#endif
dns_resstatscounter_queryrtt5);
}
} else {
- isc_uint32_t value;
- isc_uint32_t mask;
+ uint32_t value;
+ uint32_t mask;
if ((query->options & DNS_FETCHOPT_NOEDNS0) == 0)
dns_adb_ednsto(fctx->adb, query->addrinfo,
static inline isc_result_t
fctx_addopt(dns_message_t *message, unsigned int version,
- isc_uint16_t udpsize, dns_ednsopt_t *ednsopts, size_t count)
+ uint16_t udpsize, dns_ednsopt_t *ednsopts, size_t count)
{
dns_rdataset_t *rdataset = NULL;
isc_result_t result;
isc_boolean_t tcp = ISC_TF((query->options & DNS_FETCHOPT_TCP) != 0);
dns_ednsopt_t ednsopts[DNS_EDNSOPTIONS];
unsigned ednsopt = 0;
- isc_uint16_t hint = 0, udpsize = 0; /* No EDNS */
+ uint16_t hint = 0, udpsize = 0; /* No EDNS */
#ifdef HAVE_DNSTAP
isc_sockaddr_t localaddr, *la = NULL;
unsigned char zone[DNS_NAME_MAXWIRE];
/* Request NSID/COOKIE/VERSION for current peer? */
if (peer != NULL) {
- isc_uint8_t ednsversion;
+ uint8_t ednsversion;
(void) dns_peer_getrequestnsid(peer, &reqnsid);
(void) dns_peer_getsendcookie(peer,
&sendcookie);
if (sendcookie) {
INSIST(ednsopt < DNS_EDNSOPTIONS);
ednsopts[ednsopt].code = DNS_OPT_COOKIE;
- ednsopts[ednsopt].length = (isc_uint16_t)
+ ednsopts[ednsopt].length = (uint16_t)
dns_adb_getcookie(fctx->adb,
query->addrinfo,
cookie,
*/
if (tcp) {
isc_buffer_usedregion(&query->buffer, &r);
- isc_buffer_putuint16(&tcpbuffer, (isc_uint16_t)r.length);
+ isc_buffer_putuint16(&tcpbuffer, (uint16_t)r.length);
isc_buffer_add(&tcpbuffer, r.length);
}
isc_result_t eresult = ISC_R_SUCCESS;
isc_result_t result = ISC_R_SUCCESS;
isc_stdtime_t now;
- isc_uint32_t ttl;
+ uint32_t ttl;
unsigned options;
- isc_uint32_t bucketnum;
+ uint32_t bucketnum;
UNUSED(task); /* for now */
isc_boolean_t need_validation, secure_domain;
dns_name_t *aname;
dns_fetchevent_t *event;
- isc_uint32_t ttl;
+ uint32_t ttl;
unsigned int valoptions = 0;
isc_boolean_t checknta = ISC_TRUE;
{
static const char hex[17] = "0123456789abcdef";
char addrbuf[ISC_SOCKADDR_FORMATSIZE];
- isc_uint16_t buflen, i;
+ uint16_t buflen, i;
unsigned char *p, *nsid;
unsigned char *buf = NULL, *pbuf = NULL;
/* Allocate buffer for storing hex version of the NSID */
- buflen = (isc_uint16_t)nsid_len * 2 + 1;
+ buflen = (uint16_t)nsid_len * 2 + 1;
buf = isc_mem_get(mctx, buflen);
if (buf == NULL)
goto cleanup;
dns_rdata_t rdata;
isc_buffer_t optbuf;
isc_result_t result;
- isc_uint16_t optcode;
- isc_uint16_t optlen;
+ uint16_t optcode;
+ uint16_t optlen;
unsigned char *optvalue;
dns_adbaddrinfo_t *addrinfo;
unsigned char cookie[8];
return (resolver->taskmgr);
}
-isc_uint32_t
+uint32_t
dns_resolver_getlamettl(dns_resolver_t *resolver) {
REQUIRE(VALID_RESOLVER(resolver));
return (resolver->lame_ttl);
}
void
-dns_resolver_setlamettl(dns_resolver_t *resolver, isc_uint32_t lame_ttl) {
+dns_resolver_setlamettl(dns_resolver_t *resolver, uint32_t lame_ttl) {
REQUIRE(VALID_RESOLVER(resolver));
resolver->lame_ttl = lame_ttl;
}
}
void
-dns_resolver_setudpsize(dns_resolver_t *resolver, isc_uint16_t udpsize) {
+dns_resolver_setudpsize(dns_resolver_t *resolver, uint16_t udpsize) {
REQUIRE(VALID_RESOLVER(resolver));
resolver->udpsize = udpsize;
}
-isc_uint16_t
+uint16_t
dns_resolver_getudpsize(dns_resolver_t *resolver) {
REQUIRE(VALID_RESOLVER(resolver));
return (resolver->udpsize);
}
void
-dns_resolver_getclientsperquery(dns_resolver_t *resolver, isc_uint32_t *cur,
- isc_uint32_t *min, isc_uint32_t *max)
+dns_resolver_getclientsperquery(dns_resolver_t *resolver, uint32_t *cur,
+ uint32_t *min, uint32_t *max)
{
REQUIRE(VALID_RESOLVER(resolver));
}
void
-dns_resolver_setclientsperquery(dns_resolver_t *resolver, isc_uint32_t min,
- isc_uint32_t max)
+dns_resolver_setclientsperquery(dns_resolver_t *resolver, uint32_t min,
+ uint32_t max)
{
REQUIRE(VALID_RESOLVER(resolver));
}
void
-dns_resolver_setfetchesperzone(dns_resolver_t *resolver, isc_uint32_t clients)
+dns_resolver_setfetchesperzone(dns_resolver_t *resolver, uint32_t clients)
{
REQUIRE(VALID_RESOLVER(resolver));
* Use a private definition of IPv6 addresses because s6_addr32 is not
* always defined and our IPv6 addresses are in non-standard byte order
*/
-typedef isc_uint32_t dns_rpz_cidr_word_t;
+typedef uint32_t dns_rpz_cidr_word_t;
#define DNS_RPZ_CIDR_WORD_BITS ((int)sizeof(dns_rpz_cidr_word_t)*8)
#define DNS_RPZ_CIDR_KEY_BITS ((int)sizeof(dns_rpz_cidr_key_t)*8)
#define DNS_RPZ_CIDR_WORDS (128/DNS_RPZ_CIDR_WORD_BITS)
isc_log_write(dns_lctx, DNS_LOGCATEGORY_RPZ, DNS_LOGMODULE_RBTDB,
DNS_RPZ_DEBUG_QUIET,
"computed RPZ qname_skip_recurse mask=0x%" PRIx64,
- (isc_uint64_t) mask);
+ (uint64_t) mask);
rpzs->have.qname_skip_recurse = mask;
}
#include <config.h>
+#include <inttypes.h>
+
#include <isc/string.h>
#include <isc/util.h>
void
dns_rriterator_current(dns_rriterator_t *it, dns_name_t **name,
- isc_uint32_t *ttl, dns_rdataset_t **rdataset,
+ uint32_t *ttl, dns_rdataset_t **rdataset,
dns_rdata_t **rdata)
{
REQUIRE(name != NULL && *name == NULL);
/* #define ISC_LIST_CHECKINIT */
#include <config.h>
+
+#include <inttypes.h>
+
#include <isc/mem.h>
#include <isc/net.h>
#include <isc/netaddr.h>
*/
static int
hash_divisor(unsigned int initial) {
- static isc_uint16_t primes[] = {
+ static uint16_t primes[] = {
3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97,
#if 0
};
int divisions, tries;
unsigned int result;
- isc_uint16_t *pp, p;
+ uint16_t *pp, p;
result = initial;
return (ISC_FALSE);
}
-static inline isc_uint32_t
+static inline uint32_t
hash_key(const dns_rrl_key_t *key) {
- isc_uint32_t hval;
+ uint32_t hval;
int i;
hval = key->w[0];
char *log_buf, unsigned int log_buf_len)
{
dns_rrl_key_t key;
- isc_uint32_t hval;
+ uint32_t hval;
dns_rrl_entry_t *e;
dns_rrl_hash_t *hash;
dns_rrl_bin_t *new_bin, *old_bin;
*/
if (rrl->num_logged > 0)
- log_stops(rrl, 0, ISC_INT32_MAX, log_buf, sizeof(log_buf));
+ log_stops(rrl, 0, INT32_MAX, log_buf, sizeof(log_buf));
for (i = 0; i < DNS_RRL_QNAMES; ++i) {
if (rrl->qnames[i] == NULL)
#include <config.h>
+#include <inttypes.h>
#include <string.h>
#include <isc/buffer.h>
isc_result_t
dns_sdb_putsoa(dns_sdblookup_t *lookup, const char *mname, const char *rname,
- isc_uint32_t serial)
+ uint32_t serial)
{
char str[2 * DNS_NAME_MAXTEXT + 5 * (sizeof("2147483647")) + 7];
int n;
/*! \file */
#include <config.h>
+
+#include <inttypes.h>
#include <string.h>
#include <isc/buffer.h>
char b_key[DST_KEY_FORMATSIZE];
isc_buffer_t *tkey_token = NULL;
isc_region_t token_region = { NULL, 0 };
- isc_uint32_t token_len = 0;
+ uint32_t token_len = 0;
isc_boolean_t ret;
REQUIRE(driverarg != NULL);
isc_result_t
dns_sdlz_putsoa(dns_sdlzlookup_t *lookup, const char *mname, const char *rname,
- isc_uint32_t serial)
+ uint32_t serial)
{
char str[2 * DNS_NAME_MAXTEXT + 5 * (sizeof("2147483647")) + 7];
int n;
/*! \file */
#include <config.h>
+
+#include <inttypes.h>
#include <string.h>
#include <isc/buffer.h>
#include <dns/rdatastruct.h>
#include <dns/soa.h>
-static inline isc_uint32_t
+static inline uint32_t
decode_uint32(unsigned char *p) {
return ((p[0] << 24) +
(p[1] << 16) +
}
static inline void
-encode_uint32(isc_uint32_t val, unsigned char *p) {
- p[0] = (isc_uint8_t)(val >> 24);
- p[1] = (isc_uint8_t)(val >> 16);
- p[2] = (isc_uint8_t)(val >> 8);
- p[3] = (isc_uint8_t)(val >> 0);
+encode_uint32(uint32_t val, unsigned char *p) {
+ p[0] = (uint8_t)(val >> 24);
+ p[1] = (uint8_t)(val >> 16);
+ p[2] = (uint8_t)(val >> 8);
+ p[3] = (uint8_t)(val >> 0);
}
-static isc_uint32_t
+static uint32_t
soa_get(dns_rdata_t *rdata, int offset) {
INSIST(rdata->type == dns_rdatatype_soa);
/*
isc_result_t
dns_soa_buildrdata(dns_name_t *origin, dns_name_t *contact,
dns_rdataclass_t rdclass,
- isc_uint32_t serial, isc_uint32_t refresh,
- isc_uint32_t retry, isc_uint32_t expire,
- isc_uint32_t minimum, unsigned char *buffer,
+ uint32_t serial, uint32_t refresh,
+ uint32_t retry, uint32_t expire,
+ uint32_t minimum, unsigned char *buffer,
dns_rdata_t *rdata) {
dns_rdata_soa_t soa;
isc_buffer_t rdatabuf;
&soa, &rdatabuf));
}
-isc_uint32_t
+uint32_t
dns_soa_getserial(dns_rdata_t *rdata) {
return soa_get(rdata, 0);
}
-isc_uint32_t
+uint32_t
dns_soa_getrefresh(dns_rdata_t *rdata) {
return soa_get(rdata, 4);
}
-isc_uint32_t
+uint32_t
dns_soa_getretry(dns_rdata_t *rdata) {
return soa_get(rdata, 8);
}
-isc_uint32_t
+uint32_t
dns_soa_getexpire(dns_rdata_t *rdata) {
return soa_get(rdata, 12);
}
-isc_uint32_t
+uint32_t
dns_soa_getminimum(dns_rdata_t *rdata) {
return soa_get(rdata, 16);
}
static void
-soa_set(dns_rdata_t *rdata, isc_uint32_t val, int offset) {
+soa_set(dns_rdata_t *rdata, uint32_t val, int offset) {
INSIST(rdata->type == dns_rdatatype_soa);
INSIST(rdata->length >= 20);
INSIST(offset >= 0 && offset <= 16);
}
void
-dns_soa_setserial(isc_uint32_t val, dns_rdata_t *rdata) {
+dns_soa_setserial(uint32_t val, dns_rdata_t *rdata) {
soa_set(rdata, val, 0);
}
void
-dns_soa_setrefresh(isc_uint32_t val, dns_rdata_t *rdata) {
+dns_soa_setrefresh(uint32_t val, dns_rdata_t *rdata) {
soa_set(rdata, val, 4);
}
void
-dns_soa_setretry(isc_uint32_t val, dns_rdata_t *rdata) {
+dns_soa_setretry(uint32_t val, dns_rdata_t *rdata) {
soa_set(rdata, val, 8);
}
void
-dns_soa_setexpire(isc_uint32_t val, dns_rdata_t *rdata) {
+dns_soa_setexpire(uint32_t val, dns_rdata_t *rdata) {
soa_set(rdata, val, 12);
}
void
-dns_soa_setminimum(isc_uint32_t val, dns_rdata_t *rdata) {
+dns_soa_setminimum(uint32_t val, dns_rdata_t *rdata) {
soa_set(rdata, val, 16);
}
#include "spnego_asn1.c"
/*
- * Force the oid arrays to be isc_uint64_t aligned to silence warnings
+ * Force the oid arrays to be uint64_t aligned to silence warnings
* about the arrays not being properly aligned for (void *).
*/
-typedef union { unsigned char b[8]; isc_uint64_t _align; } aligned8;
-typedef union { unsigned char b[16]; isc_uint64_t _align[2]; } aligned16;
+typedef union { unsigned char b[8]; uint64_t _align; } aligned8;
+typedef union { unsigned char b[16]; uint64_t _align[2]; } aligned16;
static aligned16 gss_krb5_mech_oid_bytes = {
{ 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x12, 0x01, 0x02, 0x02 }
*/
#include <config.h>
+
#include <errno.h>
+#include <inttypes.h>
#include <unistd.h>
#ifdef ISC_PLATFORM_HAVESYSUNH
isc_region_t token_region = {NULL, 0};
unsigned char *data;
isc_buffer_t buf;
- isc_uint32_t token_len = 0;
- isc_uint32_t reply;
+ uint32_t token_len = 0;
+ uint32_t reply;
ssize_t ret;
/* The identity contains local:/path/to/socket */
dns_rdatatype_format(type, b_type, sizeof(b_type));
/* Work out how big the request will be */
- req_len = sizeof(isc_uint32_t) + /* Format version */
- sizeof(isc_uint32_t) + /* Length */
+ req_len = sizeof(uint32_t) + /* Format version */
+ sizeof(uint32_t) + /* Length */
strlen(b_signer) + 1 + /* Signer */
strlen(b_name) + 1 + /* Name */
strlen(b_addr) + 1 + /* Address */
strlen(b_type) + 1 + /* Type */
strlen(b_key) + 1 + /* Key */
- sizeof(isc_uint32_t) + /* tkey_token length */
+ sizeof(uint32_t) + /* tkey_token length */
token_len; /* tkey_token */
}
/* Receive the reply */
- ret = read(fd, &reply, sizeof(isc_uint32_t));
- if (ret != (ssize_t) sizeof(isc_uint32_t)) {
+ ret = read(fd, &reply, sizeof(uint32_t));
+ if (ret != (ssize_t) sizeof(uint32_t)) {
char strbuf[ISC_STRERRORSIZE];
isc__strerror(errno, strbuf, sizeof(strbuf));
ssu_e_log(3, "ssu_external: unable to receive reply - %s",
#include <config.h>
+#include <inttypes.h>
+
#include <isc/magic.h>
#include <isc/mem.h>
#include <isc/stats.h>
}
static void
-dump_rdentry(int rdcounter, isc_uint64_t value, dns_rdatastatstype_t attributes,
+dump_rdentry(int rdcounter, uint64_t value, dns_rdatastatstype_t attributes,
dns_rdatatypestats_dumper_t dump_fn, void * arg)
{
dns_rdatatype_t rdtype = dns_rdatatype_none; /* sentinel */
}
static void
-rdatatype_dumpcb(isc_statscounter_t counter, isc_uint64_t value, void *arg) {
+rdatatype_dumpcb(isc_statscounter_t counter, uint64_t value, void *arg) {
rdatadumparg_t *rdatadumparg = arg;
dump_rdentry(counter, value, 0, rdatadumparg->fn, rdatadumparg->arg);
}
static void
-rdataset_dumpcb(isc_statscounter_t counter, isc_uint64_t value, void *arg) {
+rdataset_dumpcb(isc_statscounter_t counter, uint64_t value, void *arg) {
rdatadumparg_t *rdatadumparg = arg;
unsigned int attributes;
}
static void
-opcode_dumpcb(isc_statscounter_t counter, isc_uint64_t value, void *arg) {
+opcode_dumpcb(isc_statscounter_t counter, uint64_t value, void *arg) {
opcodedumparg_t *opcodearg = arg;
opcodearg->fn((dns_opcode_t)counter, value, opcodearg->arg);
}
static void
-rcode_dumpcb(isc_statscounter_t counter, isc_uint64_t value, void *arg) {
+rcode_dumpcb(isc_statscounter_t counter, uint64_t value, void *arg) {
rcodedumparg_t *rcodearg = arg;
rcodearg->fn((dns_rcode_t)counter, value, rcodearg->arg);
};
isc_result_t
-dns_stats_alloccounters(isc_mem_t *mctx, isc_uint64_t **ctrp) {
+dns_stats_alloccounters(isc_mem_t *mctx, uint64_t **ctrp) {
int i;
- isc_uint64_t *p =
- isc_mem_get(mctx, DNS_STATS_NCOUNTERS * sizeof(isc_uint64_t));
+ uint64_t *p =
+ isc_mem_get(mctx, DNS_STATS_NCOUNTERS * sizeof(uint64_t));
if (p == NULL)
return (ISC_R_NOMEMORY);
for (i = 0; i < DNS_STATS_NCOUNTERS; i++)
}
void
-dns_stats_freecounters(isc_mem_t *mctx, isc_uint64_t **ctrp) {
- isc_mem_put(mctx, *ctrp, DNS_STATS_NCOUNTERS * sizeof(isc_uint64_t));
+dns_stats_freecounters(isc_mem_t *mctx, uint64_t **ctrp) {
+ isc_mem_put(mctx, *ctrp, DNS_STATS_NCOUNTERS * sizeof(uint64_t));
*ctrp = NULL;
}
#include <config.h>
+#include <inttypes.h>
+
#include <isc/mem.h>
#include <isc/print.h>
#include <isc/task.h>
NULL, NULL);
region.base = (unsigned char *)&tcpmsg->size;
- region.length = 2; /* isc_uint16_t */
+ region.length = 2; /* uint16_t */
result = isc_socket_recv(tcpmsg->sock, ®ion, 0,
tcpmsg->task, recv_length, tcpmsg);
#include <config.h>
-#include <atf-c.h>
-
+#include <inttypes.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
+#include <atf-c.h>
+
#include <isc/file.h>
#include <isc/result.h>
#include <isc/serial.h>
getnsec3parameters(isc_assertioncallback_t callback) {
isc_result_t result;
dns_hash_t hash;
- isc_uint8_t flags;
- isc_uint16_t iterations;
+ uint8_t flags;
+ uint16_t iterations;
unsigned char salt[DNS_NSEC3_SALTSIZE];
size_t salt_length = sizeof(salt);
#include <config.h>
-#include <atf-c.h>
-
+#include <inttypes.h>
#include <unistd.h>
+#include <atf-c.h>
+
#include <isc/app.h>
#include <isc/buffer.h>
#include <isc/socket.h>
isc_result_t result;
isc_socket_t *sock = NULL;
isc_task_t *task = NULL;
- isc_uint16_t id;
+ uint16_t id;
struct in_addr ina;
unsigned char message[12];
unsigned int attrs;
#include <atf-c.h>
#include <unistd.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <isc/buffer.h>
isc_result_t result;
dns_dtenv_t *dtenv = NULL;
dns_dthandle_t *handle = NULL;
- isc_uint8_t *data;
+ uint8_t *data;
size_t dsize;
unsigned char zone[DNS_NAME_MAXWIRE];
unsigned char qambuffer[4096], rambuffer[4096];
ATF_TC_BODY(totext, tc) {
isc_result_t result;
dns_dthandle_t *handle = NULL;
- isc_uint8_t *data;
+ uint8_t *data;
size_t dsize;
FILE *fp = NULL;
#include <atf-c.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
* Sleep for 'usec' microseconds.
*/
void
-dns_test_nap(isc_uint32_t usec) {
+dns_test_nap(uint32_t usec) {
#ifdef HAVE_NANOSLEEP
struct timespec ts;
#include <config.h>
+#include <inttypes.h>
+
#include <isc/buffer.h>
#include <isc/entropy.h>
#include <isc/hash.h>
dns_test_closezonemgr(void);
void
-dns_test_nap(isc_uint32_t usec);
+dns_test_nap(uint32_t usec);
isc_result_t
dns_test_loaddb(dns_db_t **db, dns_dbtype_t dbtype, const char *origin,
}
static isc_boolean_t
-do_lookup_string(const char *addr, isc_uint8_t *scope,
+do_lookup_string(const char *addr, uint8_t *scope,
dns_geoip_subtype_t subtype, const char *string)
{
dns_geoip_elem_t elt;
}
static isc_boolean_t
-do_lookup_string_v6(const char *addr, isc_uint8_t *scope,
+do_lookup_string_v6(const char *addr, uint8_t *scope,
dns_geoip_subtype_t subtype, const char *string)
{
dns_geoip_elem_t elt;
}
static isc_boolean_t
-do_lookup_int(const char *addr, isc_uint8_t *scope,
+do_lookup_int(const char *addr, uint8_t *scope,
dns_geoip_subtype_t subtype, int id)
{
dns_geoip_elem_t elt;
ATF_TC_BODY(country, tc) {
isc_result_t result;
isc_boolean_t match;
- isc_uint8_t scope;
+ uint8_t scope;
UNUSED(tc);
ATF_TC_BODY(country_v6, tc) {
isc_result_t result;
isc_boolean_t match;
- isc_uint8_t scope;
+ uint8_t scope;
UNUSED(tc);
ATF_REQUIRE(result == ISC_R_SUCCESS);
for(i = 0; i < testcase->repeats; i++) {
result = isc_gost_update(&gost,
- (const isc_uint8_t *) testcase->input,
+ (const uint8_t *) testcase->input,
testcase->input_len);
ATF_REQUIRE(result == ISC_R_SUCCESS);
}
#include <unistd.h>
#include <stdio.h>
+#include <inttypes.h>
+#include <unistd.h>
#if defined(OPENSSL) || defined(PKCS11CRYPTO)
}
static void
-create_key(isc_uint16_t flags, isc_uint8_t proto, isc_uint8_t alg,
+create_key(uint16_t flags, uint8_t proto, uint8_t alg,
const char *keynamestr, const char *keystr, dst_key_t **target)
{
dns_rdata_dnskey_t keystruct;
#include <config.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
static void *
fromwire_thread(void *arg) {
unsigned int maxval = 32000000;
- isc_uint8_t data[] = {
+ uint8_t data[] = {
3, 'w', 'w', 'w',
7, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
7, 'i', 'n', 'v', 'a', 'l', 'i', 'd',
#include <atf-c.h>
+#include <inttypes.h>
#include <unistd.h>
#include <isc/buffer.h>
dns_rdata_t nsec3param = DNS_RDATA_INIT;
unsigned char bufdata[BUFSIZ];
isc_buffer_t buf;
- isc_uint32_t salt;
+ uint32_t salt;
unsigned char *sp;
int slen = 4;
/* ! \file */
#include <config.h>
+
#include <atf-c.h>
-#include <isc/mem.h>
-#include <isc/print.h>
-#include <isc/random.h>
-#include <isc/string.h>
+
+#include <inttypes.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
-#include <inttypes.h> /* uintptr_t */
+#include <isc/mem.h>
+#include <isc/print.h>
+#include <isc/random.h>
+#include <isc/string.h>
#include <dns/rbt.h>
#include <dns/fixedname.h>
}
static isc_result_t
-write_data(FILE *file, unsigned char *datap, void *arg, isc_uint64_t *crc) {
+write_data(FILE *file, unsigned char *datap, void *arg, uint64_t *crc) {
isc_result_t result;
size_t ret = 0;
data_holder_t *data = (data_holder_t *)datap;
static isc_result_t
fix_data(dns_rbtnode_t *p, void *base, size_t max, void *arg,
- isc_uint64_t *crc)
+ uint64_t *crc)
{
data_holder_t *data = p->data;
size_t size;
int fd;
off_t filesize = 0;
char *base, *p, *q;
- isc_uint32_t r;
+ uint32_t r;
int i;
UNUSED(tc);
dns_name_t *name;
for (j = 0; j < 32; j++) {
- isc_uint32_t v;
+ uint32_t v;
isc_random_get(&v);
namebuf[j] = 'a' + (v % 26);
}
static void
insert_nodes(dns_rbt_t *mytree, char **names,
- size_t *names_count, isc_uint32_t num_names)
+ size_t *names_count, uint32_t num_names)
{
- isc_uint32_t i;
+ uint32_t i;
dns_rbtnode_t *node;
for (i = 0; i < num_names; i++) {
isc_result_t result;
for (j = 0; j < 32; j++) {
- isc_uint32_t v;
+ uint32_t v;
isc_random_get(&v);
namebuf[j] = 'a' + (v % 26);
}
static void
remove_nodes(dns_rbt_t *mytree, char **names,
- size_t *names_count, isc_uint32_t num_names)
+ size_t *names_count, uint32_t num_names)
{
- isc_uint32_t i;
+ uint32_t i;
UNUSED(mytree);
for (i = 0; i < num_names; i++) {
- isc_uint32_t node;
+ uint32_t node;
dns_fixedname_t fname;
dns_name_t *name;
isc_result_t result;
/* Repeat the insert/remove test some 4096 times */
for (i = 0; i < 4096; i++) {
- isc_uint32_t num_names;
+ uint32_t num_names;
isc_random_get(&num_names);
if (names_count < 1024) {
#include <atf-c.h>
+#include <inttypes.h>
#include <unistd.h>
#include <isc/print.h>
#define ATTRIBUTE_SET(y) ((attributes & (y)) != 0)
static void
-checkit1(dns_rdatastatstype_t which, isc_uint64_t value, void *arg) {
+checkit1(dns_rdatastatstype_t which, uint64_t value, void *arg) {
unsigned int attributes;
#if debug
unsigned int type;
}
static void
-checkit2(dns_rdatastatstype_t which, isc_uint64_t value, void *arg) {
+checkit2(dns_rdatastatstype_t which, uint64_t value, void *arg) {
unsigned int attributes;
#if debug
unsigned int type;
#include <atf-c.h>
+#include <inttypes.h>
#include <unistd.h>
#include <dns/time.h>
}
ATF_TC_BODY(epoch_minus_one, tc) {
const char *test_text = "19691231235959";
- const isc_uint32_t test_time = 0xffffffff;
+ const uint32_t test_time = 0xffffffff;
isc_result_t result;
isc_buffer_t target;
- isc_uint32_t when;
+ uint32_t when;
char buf[128];
UNUSED(tc);
}
ATF_TC_BODY(epoch, tc) {
const char *test_text = "19700101000000";
- const isc_uint32_t test_time = 0x00000000;
+ const uint32_t test_time = 0x00000000;
isc_result_t result;
isc_buffer_t target;
- isc_uint32_t when;
+ uint32_t when;
char buf[128];
UNUSED(tc);
}
ATF_TC_BODY(half_maxint, tc) {
const char *test_text = "20380119031407";
- const isc_uint32_t test_time = 0x7fffffff;
+ const uint32_t test_time = 0x7fffffff;
isc_result_t result;
isc_buffer_t target;
- isc_uint32_t when;
+ uint32_t when;
char buf[128];
UNUSED(tc);
}
ATF_TC_BODY(half_plus_one, tc) {
const char *test_text = "20380119031408";
- const isc_uint32_t test_time = 0x80000000;
+ const uint32_t test_time = 0x80000000;
isc_result_t result;
isc_buffer_t target;
- isc_uint32_t when;
+ uint32_t when;
char buf[128];
UNUSED(tc);
ATF_TC_BODY(fifty_before, tc) {
isc_result_t result;
const char *test_text = "19610307130000";
- const isc_uint32_t test_time = 0xef68f5d0;
+ const uint32_t test_time = 0xef68f5d0;
isc_buffer_t target;
- isc_uint32_t when;
+ uint32_t when;
char buf[128];
UNUSED(tc);
}
ATF_TC_BODY(some_ago, tc) {
const char *test_text = "20110307130000";
- const isc_uint32_t test_time = 0x4d74d6d0;
+ const uint32_t test_time = 0x4d74d6d0;
isc_result_t result;
isc_buffer_t target;
- isc_uint32_t when;
+ uint32_t when;
char buf[128];
UNUSED(tc);
#include <atf-c.h>
+#include <inttypes.h>
#include <unistd.h>
#include <time.h>
#include "dnstest.h"
-static isc_uint32_t mystdtime;
+static uint32_t mystdtime;
static void set_mystdtime(int year, int month, int day) {
struct tm tm;
atf_tc_set_md_var(tc, "descr", "simple increment by 1");
}
ATF_TC_BODY(increment, tc) {
- isc_uint32_t old = 50;
- isc_uint32_t serial;
+ uint32_t old = 50;
+ uint32_t serial;
isc_result_t result;
UNUSED(tc);
atf_tc_set_md_var(tc, "descr", "increment past zero, ffffffff -> 1");
}
ATF_TC_BODY(increment_past_zero, tc) {
- isc_uint32_t old = 0xffffffffu;
- isc_uint32_t serial;
+ uint32_t old = 0xffffffffu;
+ uint32_t serial;
isc_result_t result;
UNUSED(tc);
atf_tc_set_md_var(tc, "descr", "past to unixtime");
}
ATF_TC_BODY(past_to_unix, tc) {
- isc_uint32_t old;
- isc_uint32_t serial;
+ uint32_t old;
+ uint32_t serial;
isc_result_t result;
UNUSED(tc);
atf_tc_set_md_var(tc, "descr", "now to unixtime");
}
ATF_TC_BODY(now_to_unix, tc) {
- isc_uint32_t old;
- isc_uint32_t serial;
+ uint32_t old;
+ uint32_t serial;
isc_result_t result;
UNUSED(tc);
atf_tc_set_md_var(tc, "descr", "future to unixtime");
}
ATF_TC_BODY(future_to_unix, tc) {
- isc_uint32_t old;
- isc_uint32_t serial;
+ uint32_t old;
+ uint32_t serial;
isc_result_t result;
UNUSED(tc);
atf_tc_set_md_var(tc, "descr", "undefined plus 1 to unixtime");
}
ATF_TC_BODY(undefined_plus1_to_unix, tc) {
- isc_uint32_t old;
- isc_uint32_t serial;
+ uint32_t old;
+ uint32_t serial;
isc_result_t result;
UNUSED(tc);
atf_tc_set_md_var(tc, "descr", "undefined minus 1 to unixtime");
}
ATF_TC_BODY(undefined_minus1_to_unix, tc) {
- isc_uint32_t old;
- isc_uint32_t serial;
+ uint32_t old;
+ uint32_t serial;
isc_result_t result;
UNUSED(tc);
atf_tc_set_md_var(tc, "descr", "undefined to unixtime");
}
ATF_TC_BODY(undefined_to_unix, tc) {
- isc_uint32_t old;
- isc_uint32_t serial;
+ uint32_t old;
+ uint32_t serial;
isc_result_t result;
UNUSED(tc);
atf_tc_set_md_var(tc, "descr", "handle unixtime being zero");
}
ATF_TC_BODY(unixtime_zero, tc) {
- isc_uint32_t old;
- isc_uint32_t serial;
+ uint32_t old;
+ uint32_t serial;
isc_result_t result;
UNUSED(tc);
atf_tc_set_md_var(tc, "descr", "past to date");
}
ATF_TC_BODY(past_to_date, tc) {
- isc_uint32_t old, serial;
+ uint32_t old, serial;
isc_result_t result;
UNUSED(tc);
atf_tc_set_md_var(tc, "descr", "now to date");
}
ATF_TC_BODY(now_to_date, tc) {
- isc_uint32_t old;
- isc_uint32_t serial;
+ uint32_t old;
+ uint32_t serial;
isc_result_t result;
UNUSED(tc);
atf_tc_set_md_var(tc, "descr", "future to date");
}
ATF_TC_BODY(future_to_date, tc) {
- isc_uint32_t old;
- isc_uint32_t serial;
+ uint32_t old;
+ uint32_t serial;
isc_result_t result;
UNUSED(tc);
#include <config.h>
#include <stdio.h>
+#include <inttypes.h>
#include <isc/string.h> /* Required for HP/UX (and others?) */
#include <time.h>
#include <ctype.h>
static const int days[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
isc_result_t
-dns_time64_totext(isc_int64_t t, isc_buffer_t *target) {
+dns_time64_totext(int64_t t, isc_buffer_t *target) {
struct tm tm;
char buf[sizeof("!!!!!!YYYY!!!!!!!!MM!!!!!!!!DD!!!!!!!!HH!!!!!!!!MM!!!!!!!!SS")];
int secs;
return (ISC_R_SUCCESS);
}
-isc_int64_t
-dns_time64_from32(isc_uint32_t value) {
+int64_t
+dns_time64_from32(uint32_t value) {
isc_stdtime_t now;
- isc_int64_t start;
- isc_int64_t t;
+ int64_t start;
+ int64_t t;
/*
* Adjust the time to the closest epoch. This should be changed
* 2106.
*/
isc_stdtime_get(&now);
- start = (isc_int64_t) now;
+ start = (int64_t) now;
if (isc_serial_gt(value, now))
t = start + (value - now);
else
}
isc_result_t
-dns_time32_totext(isc_uint32_t value, isc_buffer_t *target) {
+dns_time32_totext(uint32_t value, isc_buffer_t *target) {
return (dns_time64_totext(dns_time64_from32(value), target));
}
isc_result_t
-dns_time64_fromtext(const char *source, isc_int64_t *target) {
+dns_time64_fromtext(const char *source, int64_t *target) {
int year, month, day, hour, minute, second;
- isc_int64_t value;
+ int64_t value;
int secs;
int i;
}
isc_result_t
-dns_time32_fromtext(const char *source, isc_uint32_t *target) {
- isc_int64_t value64;
+dns_time32_fromtext(const char *source, uint32_t *target) {
+ int64_t value64;
isc_result_t result;
result = dns_time64_fromtext(source, &value64);
if (result != ISC_R_SUCCESS)
return (result);
- *target = (isc_uint32_t)value64;
+ *target = (uint32_t)value64;
return (ISC_R_SUCCESS);
}
/*! \file */
#include <config.h>
+#include <inttypes.h>
+
#include <isc/buffer.h>
#include <isc/entropy.h>
#include <isc/md5.h>
static isc_result_t
add_rdata_to_list(dns_message_t *msg, dns_name_t *name, dns_rdata_t *rdata,
- isc_uint32_t ttl, dns_namelist_t *namelist)
+ uint32_t ttl, dns_namelist_t *namelist)
{
isc_result_t result;
isc_region_t r, newr;
#ifdef GSSAPI
OM_uint32 gret, minor, lifetime;
#endif
- isc_uint32_t expire;
+ uint32_t expire;
RETERR(dst_key_fromgssapi(name, gss_ctx, ring->mctx,
&dstkey, &intoken));
isc_result_t
dns_tkey_builddhquery(dns_message_t *msg, dst_key_t *key, dns_name_t *name,
dns_name_t *algorithm, isc_buffer_t *nonce,
- isc_uint32_t lifetime)
+ uint32_t lifetime)
{
dns_rdata_tkey_t tkey;
dns_rdata_t *rdata = NULL;
isc_result_t
dns_tkey_buildgssquery(dns_message_t *msg, dns_name_t *name, dns_name_t *gname,
- isc_buffer_t *intoken, isc_uint32_t lifetime,
+ isc_buffer_t *intoken, uint32_t lifetime,
gss_ctx_id_t *context, isc_boolean_t win2k,
isc_mem_t *mctx, char **err_message)
{
*/
/*! \file */
#include <config.h>
+
+#include <inttypes.h>
#include <stdlib.h>
#include <isc/buffer.h>
{
unsigned char header[DNS_MESSAGE_HEADERLEN];
isc_buffer_t headerbuf;
- isc_uint16_t digestbits;
+ uint16_t digestbits;
/*
* If it is a response, we assume that the request MAC
unsigned char header[DNS_MESSAGE_HEADERLEN];
dst_context_t *ctx = NULL;
isc_mem_t *mctx;
- isc_uint16_t addcount, id;
+ uint16_t addcount, id;
unsigned int siglen;
unsigned int alg;
isc_boolean_t response;
}
if (tsig.siglen > 0) {
- isc_uint16_t addcount_n;
+ uint16_t addcount_n;
sig_r.base = tsig.signature;
sig_r.length = tsig.siglen;
*/
memmove(&addcount, &header[DNS_MESSAGE_HEADERLEN - 2], 2);
addcount_n = ntohs(addcount);
- addcount = htons((isc_uint16_t)(addcount_n - 1));
+ addcount = htons((uint16_t)(addcount_n - 1));
memmove(&header[DNS_MESSAGE_HEADERLEN - 2], &addcount, 2);
/*
alg == DST_ALG_HMACSHA224 || alg == DST_ALG_HMACSHA256 ||
alg == DST_ALG_HMACSHA384 || alg == DST_ALG_HMACSHA512)
{
- isc_uint16_t digestbits = dst_key_getbits(key);
+ uint16_t digestbits = dst_key_getbits(key);
/*
* XXXRAY: Is this correct? What is the expected
dns_tsigkey_t *tsigkey;
dst_key_t *key = NULL;
unsigned char header[DNS_MESSAGE_HEADERLEN];
- isc_uint16_t addcount, id;
+ uint16_t addcount, id;
isc_boolean_t has_tsig = ISC_FALSE;
isc_mem_t *mctx;
unsigned int siglen;
* Decrement the additional field counter if necessary.
*/
if (has_tsig) {
- isc_uint16_t addcount_n;
+ uint16_t addcount_n;
memmove(&addcount, &header[DNS_MESSAGE_HEADERLEN - 2], 2);
addcount_n = ntohs(addcount);
- addcount = htons((isc_uint16_t)(addcount_n - 1));
+ addcount = htons((uint16_t)(addcount_n - 1));
memmove(&header[DNS_MESSAGE_HEADERLEN - 2], &addcount, 2);
/*
alg == DST_ALG_HMACSHA384 ||
alg == DST_ALG_HMACSHA512)
{
- isc_uint16_t digestbits = dst_key_getbits(key);
+ uint16_t digestbits = dst_key_getbits(key);
/*
* XXXRAY: Is this correct? What is the
} while (0)
-static isc_result_t bind_ttl(isc_textregion_t *source, isc_uint32_t *ttl);
+static isc_result_t bind_ttl(isc_textregion_t *source, uint32_t *ttl);
/*
* Helper for dns_ttl_totext().
* Derived from bind8 ns_format_ttl().
*/
isc_result_t
-dns_ttl_totext(isc_uint32_t src, isc_boolean_t verbose, isc_buffer_t *target) {
+dns_ttl_totext(uint32_t src, isc_boolean_t verbose, isc_buffer_t *target) {
return (dns_ttl_totext2(src, verbose, ISC_TRUE, target));
}
isc_result_t
-dns_ttl_totext2(isc_uint32_t src, isc_boolean_t verbose,
+dns_ttl_totext2(uint32_t src, isc_boolean_t verbose,
isc_boolean_t upcase, isc_buffer_t *target)
{
unsigned secs, mins, hours, days, weeks, x;
}
isc_result_t
-dns_counter_fromtext(isc_textregion_t *source, isc_uint32_t *ttl) {
+dns_counter_fromtext(isc_textregion_t *source, uint32_t *ttl) {
return (bind_ttl(source, ttl));
}
isc_result_t
-dns_ttl_fromtext(isc_textregion_t *source, isc_uint32_t *ttl) {
+dns_ttl_fromtext(isc_textregion_t *source, uint32_t *ttl) {
isc_result_t result;
result = bind_ttl(source, ttl);
}
static isc_result_t
-bind_ttl(isc_textregion_t *source, isc_uint32_t *ttl) {
- isc_uint64_t tmp = 0ULL;
- isc_uint32_t n;
+bind_ttl(isc_textregion_t *source, uint32_t *ttl) {
+ uint64_t tmp = 0ULL;
+ uint32_t n;
char *s;
char buf[64];
char nbuf[64]; /* Number buffer */
switch (*s) {
case 'w':
case 'W':
- tmp += (isc_uint64_t) n * 7 * 24 * 3600;
+ tmp += (uint64_t) n * 7 * 24 * 3600;
s++;
break;
case 'd':
case 'D':
- tmp += (isc_uint64_t) n * 24 * 3600;
+ tmp += (uint64_t) n * 24 * 3600;
s++;
break;
case 'h':
case 'H':
- tmp += (isc_uint64_t) n * 3600;
+ tmp += (uint64_t) n * 3600;
s++;
break;
case 'm':
case 'M':
- tmp += (isc_uint64_t) n * 60;
+ tmp += (uint64_t) n * 60;
s++;
break;
case 's':
case 'S':
- tmp += (isc_uint64_t) n;
+ tmp += (uint64_t) n;
s++;
break;
case '\0':
if (tmp > 0xffffffffULL)
return (ISC_R_RANGE);
- *ttl = (isc_uint32_t)(tmp & 0xffffffffUL);
+ *ttl = (uint32_t)(tmp & 0xffffffffUL);
return (ISC_R_SUCCESS);
}
#include <config.h>
+#include <inttypes.h>
#include <time.h>
#include <isc/log.h>
struct rr {
/* dns_name_t name; */
- isc_uint32_t ttl;
+ uint32_t ttl;
dns_rdata_t rdata;
};
isc_result_t
dns_update_signatures(dns_update_log_t *log, dns_zone_t *zone, dns_db_t *db,
dns_dbversion_t *oldver, dns_dbversion_t *newver,
- dns_diff_t *diff, isc_uint32_t sigvalidityinterval)
+ dns_diff_t *diff, uint32_t sigvalidityinterval)
{
return (dns_update_signaturesinc(log, zone, db, oldver, newver, diff,
sigvalidityinterval, NULL));
isc_result_t
dns_update_signaturesinc(dns_update_log_t *log, dns_zone_t *zone, dns_db_t *db,
dns_dbversion_t *oldver, dns_dbversion_t *newver,
- dns_diff_t *diff, isc_uint32_t sigvalidityinterval,
+ dns_diff_t *diff, uint32_t sigvalidityinterval,
dns_update_state_t **statep)
{
isc_result_t result = ISC_R_SUCCESS;
((tm->tm_mon + 1) * 100) + tm->tm_mday);
}
-isc_uint32_t
-dns_update_soaserial(isc_uint32_t serial, dns_updatemethod_t method) {
+uint32_t
+dns_update_soaserial(uint32_t serial, dns_updatemethod_t method) {
isc_stdtime_t now;
- isc_uint32_t new_serial;
+ uint32_t new_serial;
switch (method) {
case dns_updatemethod_none:
#include <config.h>
+#include <inttypes.h>
+
#include <isc/base32.h>
#include <isc/mem.h>
#include <isc/print.h>
*/
static isc_result_t
verify(dns_validator_t *val, dst_key_t *key, dns_rdata_t *rdata,
- isc_uint16_t keyid)
+ uint16_t keyid)
{
isc_result_t result;
dns_fixedname_t fixed;
* (val->event->rdataset).
*/
static isc_result_t
-checkkey(dns_validator_t *val, dns_rdata_t *keyrdata, isc_uint16_t keyid,
+checkkey(dns_validator_t *val, dns_rdata_t *keyrdata, uint16_t keyid,
dns_secalg_t algorithm)
{
dns_rdata_rrsig_t sig;
*/
static isc_result_t
keyfromds(dns_validator_t *val, dns_rdataset_t *rdataset, dns_rdata_t *dsrdata,
- isc_uint8_t digest, isc_uint16_t keyid, dns_secalg_t algorithm,
+ uint8_t digest, uint16_t keyid, dns_secalg_t algorithm,
dns_rdata_t *keyrdata)
{
dns_keytag_t keytag;
#include <config.h>
#include <limits.h>
+#include <inttypes.h>
#ifdef HAVE_LMDB
#include <lmdb.h>
dns_view_adddelegationonly(dns_view_t *view, dns_name_t *name) {
isc_result_t result;
dns_name_t *item;
- isc_uint32_t hash;
+ uint32_t hash;
REQUIRE(DNS_VIEW_VALID(view));
dns_view_excludedelegationonly(dns_view_t *view, dns_name_t *name) {
isc_result_t result;
dns_name_t *item;
- isc_uint32_t hash;
+ uint32_t hash;
REQUIRE(DNS_VIEW_VALID(view));
isc_boolean_t
dns_view_isdelegationonly(dns_view_t *view, dns_name_t *name) {
dns_name_t *item;
- isc_uint32_t hash;
+ uint32_t hash;
REQUIRE(DNS_VIEW_VALID(view));
isc_result_t
dns_view_setnewzones(dns_view_t *view, isc_boolean_t allow, void *cfgctx,
- void (*cfg_destroy)(void **), isc_uint64_t mapsize)
+ void (*cfg_destroy)(void **), uint64_t mapsize)
{
isc_result_t result = ISC_R_SUCCESS;
char buffer[1024];
return (ISC_R_NOTFOUND);
}
-isc_uint32_t
+uint32_t
dns_view_getfailttl(dns_view_t *view) {
REQUIRE(DNS_VIEW_VALID(view));
return (view->fail_ttl);
}
void
-dns_view_setfailttl(dns_view_t *view, isc_uint32_t fail_ttl) {
+dns_view_setfailttl(dns_view_t *view, uint32_t fail_ttl) {
REQUIRE(DNS_VIEW_VALID(view));
view->fail_ttl = fail_ttl;
}
int difflen; /*%< Number of pending tuples */
xfrin_state_t state;
- isc_uint32_t end_serial;
+ uint32_t end_serial;
isc_boolean_t is_ixfr;
unsigned int nmsg; /*%< Number of messages recvd */
unsigned int nrecs; /*%< Number of records recvd */
- isc_uint64_t nbytes; /*%< Number of bytes received */
+ uint64_t nbytes; /*%< Number of bytes received */
unsigned int maxrecords; /*%< The maximum number of
records set for the zone */
dns_rdatacallbacks_t axfr;
struct {
- isc_uint32_t request_serial;
- isc_uint32_t current_serial;
+ uint32_t request_serial;
+ uint32_t current_serial;
dns_journal_t *journal;
} ixfr;
static isc_result_t ixfr_commit(dns_xfrin_ctx_t *xfr);
static isc_result_t xfr_rr(dns_xfrin_ctx_t *xfr, dns_name_t *name,
- isc_uint32_t ttl, dns_rdata_t *rdata);
+ uint32_t ttl, dns_rdata_t *rdata);
static isc_result_t xfrin_start(dns_xfrin_ctx_t *xfr);
static isc_result_t
axfr_apply(dns_xfrin_ctx_t *xfr) {
isc_result_t result;
- isc_uint64_t records;
+ uint64_t records;
CHECK(dns_diff_load(&xfr->diff, xfr->axfr.add, xfr->axfr.add_private));
xfr->difflen = 0;
static isc_result_t
ixfr_apply(dns_xfrin_ctx_t *xfr) {
isc_result_t result;
- isc_uint64_t records;
+ uint64_t records;
if (xfr->ver == NULL) {
CHECK(dns_db_newversion(xfr->db, &xfr->ver));
* state.
*/
static isc_result_t
-xfr_rr(dns_xfrin_ctx_t *xfr, dns_name_t *name, isc_uint32_t ttl,
+xfr_rr(dns_xfrin_ctx_t *xfr, dns_name_t *name, uint32_t ttl,
dns_rdata_t *rdata)
{
isc_result_t result;
case XFRST_IXFR_DEL:
if (rdata->type == dns_rdatatype_soa) {
- isc_uint32_t soa_serial = dns_soa_getserial(rdata);
+ uint32_t soa_serial = dns_soa_getserial(rdata);
xfr->state = XFRST_IXFR_ADDSOA;
xfr->ixfr.current_serial = soa_serial;
goto redo;
case XFRST_IXFR_ADD:
if (rdata->type == dns_rdatatype_soa) {
- isc_uint32_t soa_serial = dns_soa_getserial(rdata);
+ uint32_t soa_serial = dns_soa_getserial(rdata);
if (soa_serial == xfr->end_serial) {
CHECK(ixfr_commit(xfr));
xfr->state = XFRST_IXFR_END;
{
dns_xfrin_ctx_t *xfr = NULL;
isc_result_t result;
- isc_uint32_t tmp;
+ uint32_t tmp;
xfr = isc_mem_get(mctx, sizeof(*xfr));
if (xfr == NULL)
xfr->rdclass = rdclass;
isc_random_get(&tmp);
xfr->checkid = ISC_TRUE;
- xfr->id = (isc_uint16_t)(tmp & 0xffff);
+ xfr->id = (uint16_t)(tmp & 0xffff);
xfr->reqtype = reqtype;
xfr->dscp = dscp;
static void
maybe_free(dns_xfrin_ctx_t *xfr) {
- isc_uint64_t msecs;
- isc_uint64_t persec;
+ uint64_t msecs;
+ uint64_t persec;
const char *result_str;
REQUIRE(VALID_XFRIN(xfr));
dns_masterformat_t masterformat;
const dns_master_style_t *masterstyle;
char *journal;
- isc_int32_t journalsize;
+ int32_t journalsize;
dns_rdataclass_t rdclass;
dns_zonetype_t type;
unsigned int flags;
isc_time_t signingtime;
isc_time_t nsec3chaintime;
isc_time_t refreshkeytime;
- isc_uint32_t refreshkeyinterval;
- isc_uint32_t refreshkeycount;
- isc_uint32_t refresh;
- isc_uint32_t retry;
- isc_uint32_t expire;
- isc_uint32_t minimum;
+ uint32_t refreshkeyinterval;
+ uint32_t refreshkeycount;
+ uint32_t refresh;
+ uint32_t retry;
+ uint32_t expire;
+ uint32_t minimum;
isc_stdtime_t key_expiry;
isc_stdtime_t log_key_expired_timer;
char *keydirectory;
- isc_uint32_t maxrefresh;
- isc_uint32_t minrefresh;
- isc_uint32_t maxretry;
- isc_uint32_t minretry;
+ uint32_t maxrefresh;
+ uint32_t minrefresh;
+ uint32_t maxretry;
+ uint32_t minretry;
- isc_uint32_t maxrecords;
+ uint32_t maxrecords;
isc_sockaddr_t *masters;
isc_dscp_t *masterdscps;
dns_io_t *readio;
dns_dumpctx_t *dctx;
dns_io_t *writeio;
- isc_uint32_t maxxfrin;
- isc_uint32_t maxxfrout;
- isc_uint32_t idlein;
- isc_uint32_t idleout;
+ uint32_t maxxfrin;
+ uint32_t maxxfrout;
+ uint32_t idlein;
+ uint32_t idleout;
isc_event_t ctlevent;
dns_ssutable_t *ssutable;
- isc_uint32_t sigvalidityinterval;
- isc_uint32_t sigresigninginterval;
+ uint32_t sigvalidityinterval;
+ uint32_t sigresigninginterval;
dns_view_t *view;
dns_view_t *prev_view;
dns_acache_t *acache;
isc_boolean_t requeststats_on;
isc_stats_t *requeststats;
dns_stats_t *rcvquerystats;
- isc_uint32_t notifydelay;
+ uint32_t notifydelay;
dns_isselffunc_t isself;
void *isselfarg;
/*%
* Serial number for deferred journal compaction.
*/
- isc_uint32_t compact_serial;
+ uint32_t compact_serial;
/*%
* Keys that are signing the zone for the first time.
*/
/*%
* Signing / re-signing quantum stopping parameters.
*/
- isc_uint32_t signatures;
- isc_uint32_t nodes;
+ uint32_t signatures;
+ uint32_t nodes;
dns_rdatatype_t privatetype;
/*%
* Autosigning/key-maintenance options
*/
- isc_uint32_t keyopts;
+ uint32_t keyopts;
/*%
* True if added by "rndc addzone"
dns_zone_t *secure;
isc_boolean_t sourceserialset;
- isc_uint32_t sourceserial;
+ uint32_t sourceserial;
/*%
* maximum zone ttl
struct dns_unreachable {
isc_sockaddr_t remote;
isc_sockaddr_t local;
- isc_uint32_t expire;
- isc_uint32_t last;
- isc_uint32_t count;
+ uint32_t expire;
+ uint32_t last;
+ uint32_t count;
};
struct dns_zonemgr {
dns_zonelist_t xfrin_in_progress;
/* Configuration data. */
- isc_uint32_t transfersin;
- isc_uint32_t transfersperns;
+ uint32_t transfersin;
+ uint32_t transfersperns;
unsigned int notifyrate;
unsigned int startupnotifyrate;
unsigned int serialqueryrate;
unsigned int startupserialqueryrate;
/* Locked by iolock */
- isc_uint32_t iolimit;
- isc_uint32_t ioactive;
+ uint32_t iolimit;
+ uint32_t ioactive;
dns_iolist_t high;
dns_iolist_t low;
dns_zone_t *zone;
isc_buffer_t *msgbuf;
dns_request_t *request;
- isc_uint32_t which;
+ uint32_t which;
isc_sockaddr_t addr;
dns_updatecallback_t callback;
void *callback_arg;
dns_db_t *db;
dns_dbiterator_t *dbiterator;
dns_secalg_t algorithm;
- isc_uint16_t keyid;
+ uint16_t keyid;
isc_boolean_t deleteit;
isc_boolean_t done;
ISC_LINK(dns_signing_t) link;
static void zone_rdclass_tostr(dns_zone_t *zone, char *buf, size_t length);
static void zone_viewname_tostr(dns_zone_t *zone, char *buf, size_t length);
static isc_result_t zone_send_secureserial(dns_zone_t *zone,
- isc_uint32_t serial);
+ uint32_t serial);
#if 0
/* ondestroy example */
static isc_result_t
zone_get_from_db(dns_zone_t *zone, dns_db_t *db, unsigned int *nscount,
- unsigned int *soacount, isc_uint32_t *serial,
- isc_uint32_t *refresh, isc_uint32_t *retry,
- isc_uint32_t *expire, isc_uint32_t *minimum,
+ unsigned int *soacount, uint32_t *serial,
+ uint32_t *refresh, uint32_t *retry,
+ uint32_t *expire, uint32_t *minimum,
unsigned int *errors);
static void zone_freedbargs(dns_zone_t *zone);
static void zone_notify(dns_zone_t *zone, isc_time_t *now);
static void dump_done(void *arg, isc_result_t result);
static isc_result_t zone_signwithkey(dns_zone_t *zone, dns_secalg_t algorithm,
- isc_uint16_t keyid,
+ uint16_t keyid,
isc_boolean_t deleteit);
static isc_result_t delete_nsec(dns_db_t *db, dns_dbversion_t *ver,
dns_dbnode_t *node, dns_name_t *name,
#define DNS_ZONE_JITTER_ADD(a, b, c) \
do { \
isc_interval_t _i; \
- isc_uint32_t _j; \
+ uint32_t _j; \
_j = isc_random_jitter((b), (b)/4); \
isc_interval_set(&_i, _j, 0); \
if (isc_time_add((a), &_i, (c)) != ISC_R_SUCCESS) { \
struct ssevent {
isc_event_t event;
- isc_uint32_t serial;
+ uint32_t serial;
};
/*%
}
isc_result_t
-dns_zone_getserial2(dns_zone_t *zone, isc_uint32_t *serialp) {
+dns_zone_getserial2(dns_zone_t *zone, uint32_t *serialp) {
isc_result_t result;
unsigned int soacount;
return (result);
}
-isc_uint32_t
+uint32_t
dns_zone_getserial(dns_zone_t *zone) {
isc_result_t result;
- isc_uint32_t serial;
+ uint32_t serial;
result = dns_zone_getserial2(zone, &serial);
if (result != ISC_R_SUCCESS)
dns_fixedname_t fixed;
unsigned int resign;
isc_result_t result;
- isc_uint32_t nanosecs;
+ uint32_t nanosecs;
dns_db_t *db = NULL;
/* We only re-sign zones that can be dynamically updated */
isc_mem_t *mctx, dns_updatemethod_t method) {
dns_difftuple_t *deltuple = NULL;
dns_difftuple_t *addtuple = NULL;
- isc_uint32_t serial;
+ uint32_t serial;
isc_result_t result;
INSIST(method != dns_updatemethod_none);
* Write all transactions in 'diff' to the zone journal file.
*/
static isc_result_t
-zone_journal(dns_zone_t *zone, dns_diff_t *diff, isc_uint32_t *sourceserial,
+zone_journal(dns_zone_t *zone, dns_diff_t *diff, uint32_t *sourceserial,
const char *caller)
{
const char me[] = "zone_journal";
result = dns_rriterator_nextrrset(&rrit)) {
dns_rdataset_t *rdataset = NULL;
dns_name_t *rrname = NULL;
- isc_uint32_t ttl;
+ uint32_t ttl;
dns_rriterator_current(&rrit, &rrname, &ttl,
&rdataset, NULL);
*/
if (zone->raw->db != NULL) {
if (zone->db != NULL) {
- isc_uint32_t serial;
+ uint32_t serial;
unsigned int soacount;
result = zone_get_from_db(zone->raw, zone->raw->db,
unsigned int soacount = 0;
unsigned int nscount = 0;
unsigned int errors = 0;
- isc_uint32_t serial, oldserial, refresh, retry, expire, minimum;
+ uint32_t serial, oldserial, refresh, retry, expire, minimum;
isc_time_t now;
isc_boolean_t needdump = ISC_FALSE;
isc_boolean_t hasinclude = DNS_ZONE_FLAG(zone, DNS_ZONEFLG_HASINCLUDE);
*/
if (zone->journal != NULL && dns_zone_isdynamic(zone, ISC_TRUE) &&
! DNS_ZONE_OPTION(zone, DNS_ZONEOPT_IXFRFROMDIFFS)) {
- isc_uint32_t jserial;
+ uint32_t jserial;
dns_journal_t *journal = NULL;
result = dns_journal_open(zone->mctx, zone->journal,
RUNTIME_CHECK(soacount > 0U);
if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_IXFRFROMDIFFS) &&
!isc_serial_gt(serial, oldserial)) {
- isc_uint32_t serialmin, serialmax;
+ uint32_t serialmin, serialmax;
INSIST(zone->type == dns_zone_master);
INSIST(zone->raw == NULL);
(zone->type == dns_zone_redirect &&
zone->masters != NULL)) {
isc_time_t t;
- isc_uint32_t delay;
+ uint32_t delay;
result = isc_file_getmodtime(zone->journal, &t);
if (result != ISC_R_SUCCESS)
static isc_result_t
zone_load_soa_rr(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
unsigned int *soacount,
- isc_uint32_t *serial, isc_uint32_t *refresh,
- isc_uint32_t *retry, isc_uint32_t *expire,
- isc_uint32_t *minimum)
+ uint32_t *serial, uint32_t *refresh,
+ uint32_t *retry, uint32_t *expire,
+ uint32_t *minimum)
{
isc_result_t result;
unsigned int count;
*/
static isc_result_t
zone_get_from_db(dns_zone_t *zone, dns_db_t *db, unsigned int *nscount,
- unsigned int *soacount, isc_uint32_t *serial,
- isc_uint32_t *refresh, isc_uint32_t *retry,
- isc_uint32_t *expire, isc_uint32_t *minimum,
+ unsigned int *soacount, uint32_t *serial,
+ uint32_t *refresh, uint32_t *retry,
+ uint32_t *expire, uint32_t *minimum,
unsigned int *errors)
{
isc_result_t result;
static isc_boolean_t
same_addrs(isc_sockaddr_t const *oldlist, isc_sockaddr_t const *newlist,
- isc_uint32_t count)
+ uint32_t count)
{
unsigned int i;
static isc_boolean_t
same_keynames(dns_name_t * const *oldlist, dns_name_t * const *newlist,
- isc_uint32_t count)
+ uint32_t count)
{
unsigned int i;
isc_result_t
dns_zone_setalsonotify(dns_zone_t *zone, const isc_sockaddr_t *notify,
- isc_uint32_t count)
+ uint32_t count)
{
return (dns_zone_setalsonotifydscpkeys(zone, notify, NULL, NULL,
count));
isc_result_t
dns_zone_setalsonotifywithkeys(dns_zone_t *zone, const isc_sockaddr_t *notify,
- dns_name_t **keynames, isc_uint32_t count)
+ dns_name_t **keynames, uint32_t count)
{
return (dns_zone_setalsonotifydscpkeys(zone, notify, NULL, keynames,
count));
isc_result_t
dns_zone_setalsonotifydscpkeys(dns_zone_t *zone, const isc_sockaddr_t *notify,
const isc_dscp_t *dscps, dns_name_t **keynames,
- isc_uint32_t count)
+ uint32_t count)
{
isc_result_t result;
isc_sockaddr_t *newaddrs = NULL;
isc_result_t
dns_zone_setmasters(dns_zone_t *zone, const isc_sockaddr_t *masters,
- isc_uint32_t count)
+ uint32_t count)
{
isc_result_t result;
dns_zone_setmasterswithkeys(dns_zone_t *zone,
const isc_sockaddr_t *masters,
dns_name_t **keynames,
- isc_uint32_t count)
+ uint32_t count)
{
isc_result_t result = ISC_R_SUCCESS;
isc_sockaddr_t *newaddrs = NULL;
unsigned int i;
dns_rdata_rrsig_t rrsig;
isc_boolean_t found;
- isc_int64_t timewarn = 0, timemaybe = 0;
+ int64_t timewarn = 0, timemaybe = 0;
dns_rdataset_init(&rdataset);
if (!dst_key_inactive(keys[i]) &&
!dst_key_isprivate(keys[i]))
{
- isc_int64_t timeexpire =
+ int64_t timeexpire =
dns_time64_from32(rrsig.timeexpire);
if (timewarn != 0 &&
timewarn > timeexpire)
isc_boolean_t check_ksk, keyset_kskonly = ISC_FALSE;
isc_result_t result;
isc_stdtime_t now, inception, soaexpire, expire, stop;
- isc_uint32_t jitter, sigvalidityinterval;
+ uint32_t jitter, sigvalidityinterval;
unsigned int i;
unsigned int nkeys = 0;
unsigned int resign;
isc_stdtime_t inception, isc_stdtime_t expire,
unsigned int minimum, isc_boolean_t is_ksk,
isc_boolean_t keyset_kskonly, isc_boolean_t *delegation,
- dns_diff_t *diff, isc_int32_t *signatures, isc_mem_t *mctx)
+ dns_diff_t *diff, int32_t *signatures, isc_mem_t *mctx)
{
isc_result_t result;
dns_rdatasetiter_t *iterator = NULL;
dns_nsec3chain_t *nsec3chain = NULL, *nextnsec3chain;
dns_nsec3chainlist_t cleanup;
dst_key_t *zone_keys[DNS_MAXZONEKEYS];
- isc_int32_t signatures;
+ int32_t signatures;
isc_boolean_t check_ksk, keyset_kskonly;
isc_boolean_t delegation;
isc_boolean_t first;
isc_result_t result;
isc_stdtime_t now, inception, soaexpire, expire;
- isc_uint32_t jitter, sigvalidityinterval;
+ uint32_t jitter, sigvalidityinterval;
unsigned int i;
unsigned int nkeys = 0;
- isc_uint32_t nodes;
+ uint32_t nodes;
isc_boolean_t unsecure = ISC_FALSE;
isc_boolean_t seen_soa, seen_ns, seen_dname, seen_ds;
isc_boolean_t seen_nsec, seen_nsec3, seen_rr;
static isc_result_t
del_sig(dns_db_t *db, dns_dbversion_t *version, dns_name_t *name,
dns_dbnode_t *node, unsigned int nkeys, dns_secalg_t algorithm,
- isc_uint16_t keyid, isc_boolean_t *has_algp, dns_diff_t *diff)
+ uint16_t keyid, isc_boolean_t *has_algp, dns_diff_t *diff)
{
dns_rdata_rrsig_t rrsig;
dns_rdataset_t rdataset;
dns_signing_t *signing, *nextsigning;
dns_signinglist_t cleanup;
dst_key_t *zone_keys[DNS_MAXZONEKEYS];
- isc_int32_t signatures;
+ int32_t signatures;
isc_boolean_t check_ksk, keyset_kskonly, is_ksk;
isc_boolean_t with_ksk, with_zsk;
isc_boolean_t commit = ISC_FALSE;
isc_boolean_t first;
isc_result_t result;
isc_stdtime_t now, inception, soaexpire, expire;
- isc_uint32_t jitter, sigvalidityinterval;
+ uint32_t jitter, sigvalidityinterval;
unsigned int i, j;
unsigned int nkeys = 0;
- isc_uint32_t nodes;
+ uint32_t nodes;
ENTER;
static inline isc_stdtime_t
refresh_time(dns_keyfetch_t *kfetch, isc_boolean_t retry) {
isc_result_t result;
- isc_uint32_t t;
+ uint32_t t;
dns_rdataset_t *rdset;
dns_rdata_t sigrr = DNS_RDATA_INIT;
dns_rdata_sig_t sig;
t = sig.originalttl / 2;
if (isc_serial_gt(sig.timeexpire, now)) {
- isc_uint32_t exp = (sig.timeexpire - now) / 2;
+ uint32_t exp = (sig.timeexpire - now) / 2;
if (t > exp)
t = exp;
}
t = sig.originalttl / 10;
if (isc_serial_gt(sig.timeexpire, now)) {
- isc_uint32_t exp = (sig.timeexpire - now) / 10;
+ uint32_t exp = (sig.timeexpire - now) / 10;
if (t > exp)
t = exp;
}
dns_name_t *name = NULL, *kname = NULL;
dns_rdataset_t *kdset = NULL;
dns_keyfetch_t *kfetch;
- isc_uint32_t ttl;
+ uint32_t ttl;
dns_rriterator_current(&rrit, &name, &ttl, &kdset, NULL);
if (kdset == NULL || kdset->type != dns_rdatatype_keydata ||
void
dns_zone_markdirty(dns_zone_t *zone) {
- isc_uint32_t serial;
+ uint32_t serial;
isc_result_t result = ISC_R_SUCCESS;
dns_zone_t *secure = NULL;
void
dns_zone_refresh(dns_zone_t *zone) {
isc_interval_t i;
- isc_uint32_t oldflags;
+ uint32_t oldflags;
unsigned int j;
isc_result_t result;
dns_dbversion_t *version;
isc_boolean_t again = ISC_FALSE;
isc_boolean_t compact = ISC_FALSE;
- isc_uint32_t serial;
+ uint32_t serial;
isc_result_t tresult;
REQUIRE(DNS_ZONE_VALID(zone));
* use its serial if it is less than ours.
*/
if (tresult == ISC_R_SUCCESS && secure != NULL) {
- isc_uint32_t sserial;
+ uint32_t sserial;
isc_result_t mresult;
ZONEDB_LOCK(&secure->dblock, isc_rwlocktype_read);
static isc_result_t
dumptostream(dns_zone_t *zone, FILE *fd, const dns_master_style_t *style,
- dns_masterformat_t format, const isc_uint32_t rawversion)
+ dns_masterformat_t format, const uint32_t rawversion)
{
isc_result_t result;
dns_dbversion_t *version = NULL;
isc_result_t
dns_zone_dumptostream3(dns_zone_t *zone, FILE *fd, dns_masterformat_t format,
const dns_master_style_t *style,
- const isc_uint32_t rawversion)
+ const uint32_t rawversion)
{
return (dumptostream(zone, fd, style, format, rawversion));
}
}
void
-dns_zone_setminrefreshtime(dns_zone_t *zone, isc_uint32_t val) {
+dns_zone_setminrefreshtime(dns_zone_t *zone, uint32_t val) {
REQUIRE(DNS_ZONE_VALID(zone));
REQUIRE(val > 0);
}
void
-dns_zone_setmaxrefreshtime(dns_zone_t *zone, isc_uint32_t val) {
+dns_zone_setmaxrefreshtime(dns_zone_t *zone, uint32_t val) {
REQUIRE(DNS_ZONE_VALID(zone));
REQUIRE(val > 0);
}
void
-dns_zone_setminretrytime(dns_zone_t *zone, isc_uint32_t val) {
+dns_zone_setminretrytime(dns_zone_t *zone, uint32_t val) {
REQUIRE(DNS_ZONE_VALID(zone));
REQUIRE(val > 0);
}
void
-dns_zone_setmaxretrytime(dns_zone_t *zone, isc_uint32_t val) {
+dns_zone_setmaxretrytime(dns_zone_t *zone, uint32_t val) {
REQUIRE(DNS_ZONE_VALID(zone));
REQUIRE(val > 0);
zone->maxretry = val;
}
-isc_uint32_t
+uint32_t
dns_zone_getmaxrecords(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
}
void
-dns_zone_setmaxrecords(dns_zone_t *zone, isc_uint32_t val) {
+dns_zone_setmaxrecords(dns_zone_t *zone, uint32_t val) {
REQUIRE(DNS_ZONE_VALID(zone));
zone->maxrecords = val;
dns_name_t master;
dns_rdata_ns_t ns;
dns_rdata_soa_t soa;
- isc_uint32_t serial;
+ uint32_t serial;
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_t nsrdset;
dns_rdataset_t soardset;
dns_zone_t *zone = NULL;
char master[ISC_SOCKADDR_FORMATSIZE];
char source[ISC_SOCKADDR_FORMATSIZE];
- isc_uint32_t nscnt, cnamecnt, refresh, retry, expire;
+ uint32_t nscnt, cnamecnt, refresh, retry, expire;
isc_result_t result;
isc_time_t now;
isc_boolean_t exiting = ISC_FALSE;
*/
static void
get_edns_expire(dns_zone_t * zone, dns_message_t *message,
- isc_uint32_t *expirep)
+ uint32_t *expirep)
{
isc_result_t result;
- isc_uint32_t expire;
+ uint32_t expire;
dns_rdata_t rdata = DNS_RDATA_INIT;
isc_buffer_t optbuf;
- isc_uint16_t optcode;
- isc_uint16_t optlen;
+ uint16_t optcode;
+ uint16_t optlen;
REQUIRE(expirep != NULL);
REQUIRE(message != NULL);
dns_requestevent_t *revent = (dns_requestevent_t *)event;
dns_zone_t *zone;
dns_message_t *msg = NULL;
- isc_uint32_t soacnt, cnamecnt, soacount, nscount;
+ uint32_t soacnt, cnamecnt, soacount, nscount;
isc_time_t now;
char master[ISC_SOCKADDR_FORMATSIZE];
char source[ISC_SOCKADDR_FORMATSIZE];
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_soa_t soa;
isc_result_t result;
- isc_uint32_t serial, oldserial = 0;
+ uint32_t serial, oldserial = 0;
unsigned int j;
isc_boolean_t do_queue_xfrin = ISC_FALSE;
dns_message_destroy(&msg);
} else if (isc_serial_eq(soa.serial, oldserial)) {
isc_time_t expiretime;
- isc_uint32_t expire;
+ uint32_t expire;
/*
* Compute the new expire time based on this response.
}
static isc_result_t
-add_opt(dns_message_t *message, isc_uint16_t udpsize, isc_boolean_t reqnsid,
+add_opt(dns_message_t *message, uint16_t udpsize, isc_boolean_t reqnsid,
isc_boolean_t reqexpire)
{
isc_result_t result;
dns_zone_t *dummy = NULL;
isc_netaddr_t masterip;
dns_tsigkey_t *key = NULL;
- isc_uint32_t options;
+ uint32_t options;
isc_boolean_t cancel = ISC_TRUE;
int timeout;
isc_boolean_t have_xfrsource, have_xfrdscp, reqnsid, reqexpire;
- isc_uint16_t udpsize = SEND_BUFFER_SIZE;
+ uint16_t udpsize = SEND_BUFFER_SIZE;
isc_dscp_t dscp = -1;
REQUIRE(DNS_ZONE_VALID(zone));
int timeout;
isc_boolean_t have_xfrsource = ISC_FALSE, have_xfrdscp = ISC_FALSE;
isc_boolean_t reqnsid;
- isc_uint16_t udpsize = SEND_BUFFER_SIZE;
+ uint16_t udpsize = SEND_BUFFER_SIZE;
isc_dscp_t dscp = -1;
REQUIRE(DNS_ZONE_VALID(zone));
char fromtext[ISC_SOCKADDR_FORMATSIZE];
int match = 0;
isc_netaddr_t netaddr;
- isc_uint32_t serial = 0;
+ uint32_t serial = 0;
isc_boolean_t have_serial = ISC_FALSE;
dns_tsigkey_t *tsigkey;
dns_name_t *tsig;
if (result == ISC_R_SUCCESS)
result = dns_rdataset_first(rdataset);
if (result == ISC_R_SUCCESS) {
- isc_uint32_t oldserial;
+ uint32_t oldserial;
unsigned int soacount;
dns_rdataset_current(rdataset, &rdata);
}
void
-dns_zone_setjournalsize(dns_zone_t *zone, isc_int32_t size) {
+dns_zone_setjournalsize(dns_zone_t *zone, int32_t size) {
REQUIRE(DNS_ZONE_VALID(zone));
zone->journalsize = size;
}
-isc_int32_t
+int32_t
dns_zone_getjournalsize(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
}
void
-dns_zone_setmaxxfrin(dns_zone_t *zone, isc_uint32_t maxxfrin) {
+dns_zone_setmaxxfrin(dns_zone_t *zone, uint32_t maxxfrin) {
REQUIRE(DNS_ZONE_VALID(zone));
zone->maxxfrin = maxxfrin;
}
-isc_uint32_t
+uint32_t
dns_zone_getmaxxfrin(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
}
void
-dns_zone_setmaxxfrout(dns_zone_t *zone, isc_uint32_t maxxfrout) {
+dns_zone_setmaxxfrout(dns_zone_t *zone, uint32_t maxxfrout) {
REQUIRE(DNS_ZONE_VALID(zone));
zone->maxxfrout = maxxfrout;
}
-isc_uint32_t
+uint32_t
dns_zone_getmaxxfrout(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
}
void
-dns_zone_setidlein(dns_zone_t *zone, isc_uint32_t idlein) {
+dns_zone_setidlein(dns_zone_t *zone, uint32_t idlein) {
REQUIRE(DNS_ZONE_VALID(zone));
if (idlein == 0)
zone->idlein = idlein;
}
-isc_uint32_t
+uint32_t
dns_zone_getidlein(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
}
void
-dns_zone_setidleout(dns_zone_t *zone, isc_uint32_t idleout) {
+dns_zone_setidleout(dns_zone_t *zone, uint32_t idleout) {
REQUIRE(DNS_ZONE_VALID(zone));
zone->idleout = idleout;
}
-isc_uint32_t
+uint32_t
dns_zone_getidleout(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
struct secure_event {
isc_event_t e;
dns_db_t *db;
- isc_uint32_t serial;
+ uint32_t serial;
};
static void
static isc_result_t
sync_secure_journal(dns_zone_t *zone, dns_zone_t *raw, dns_journal_t *journal,
- isc_uint32_t start, isc_uint32_t end,
+ uint32_t start, uint32_t end,
dns_difftuple_t **soatuplep, dns_diff_t *diff)
{
isc_result_t result;
result = dns_journal_next_rr(journal))
{
dns_name_t *name = NULL;
- isc_uint32_t ttl;
+ uint32_t ttl;
dns_rdata_t *rdata = NULL;
dns_journal_current_rr(journal, &name, &ttl, &rdata);
isc_result_t result = ISC_R_SUCCESS;
dns_journal_t *rjournal = NULL;
dns_journal_t *sjournal = NULL;
- isc_uint32_t start, end;
+ uint32_t start, end;
dns_zone_t *zone;
dns_difftuple_t *tuple = NULL, *soatuple = NULL;
dns_update_log_t log = { update_log_cb, NULL };
- isc_uint32_t newserial = 0, desired = 0;
+ uint32_t newserial = 0, desired = 0;
isc_time_t timenow;
UNUSED(task);
dns_journal_set_sourceserial(rjournal, start);
}
if (sjournal != NULL) {
- isc_uint32_t serial;
+ uint32_t serial;
/*
* We read the secure journal first, if that
* exists use its value provided it is greater
zone->rss_newver));
if (soatuple != NULL) {
- isc_uint32_t oldserial;
+ uint32_t oldserial;
CHECK(dns_db_createsoatuple(zone->rss_db,
zone->rss_oldver,
}
static isc_result_t
-zone_send_secureserial(dns_zone_t *zone, isc_uint32_t serial) {
+zone_send_secureserial(dns_zone_t *zone, uint32_t serial) {
isc_event_t *e;
dns_zone_t *dummy = NULL;
static isc_result_t
checkandaddsoa(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
- dns_rdataset_t *rdataset, isc_uint32_t oldserial)
+ dns_rdataset_t *rdataset, uint32_t oldserial)
{
dns_rdata_soa_t soa;
dns_rdata_t rdata = DNS_RDATA_INIT;
DNS_ZONE_OPTION(zone, DNS_ZONEOPT_IXFRFROMDIFFS) &&
!DNS_ZONE_FLAG(zone, DNS_ZONEFLG_FORCEXFER))
{
- isc_uint32_t serial, oldserial;
+ uint32_t serial, oldserial;
dns_zone_log(zone, ISC_LOG_DEBUG(3), "generating diffs");
(zone->type == dns_zone_redirect &&
zone->masters != NULL))
&& !isc_serial_gt(serial, oldserial)) {
- isc_uint32_t serialmin, serialmax;
+ uint32_t serialmin, serialmax;
serialmin = (oldserial + 1) & 0xffffffffU;
serialmax = (oldserial + 0x7fffffffU) & 0xffffffffU;
dns_zone_log(zone, ISC_LOG_ERROR,
isc_boolean_t again = ISC_FALSE;
unsigned int soacount;
unsigned int nscount;
- isc_uint32_t serial, refresh, retry, expire, minimum;
+ uint32_t serial, refresh, retry, expire, minimum;
isc_result_t xfrresult = result;
isc_boolean_t free_needed;
dns_zone_t *secure = NULL;
}
void
-dns_zone_setsigvalidityinterval(dns_zone_t *zone, isc_uint32_t interval) {
+dns_zone_setsigvalidityinterval(dns_zone_t *zone, uint32_t interval) {
REQUIRE(DNS_ZONE_VALID(zone));
zone->sigvalidityinterval = interval;
}
-isc_uint32_t
+uint32_t
dns_zone_getsigvalidityinterval(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
}
void
-dns_zone_setsigresigninginterval(dns_zone_t *zone, isc_uint32_t interval) {
+dns_zone_setsigresigninginterval(dns_zone_t *zone, uint32_t interval) {
isc_time_t now;
REQUIRE(DNS_ZONE_VALID(zone));
UNLOCK_ZONE(zone);
}
-isc_uint32_t
+uint32_t
dns_zone_getsigresigninginterval(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
}
void
-dns_zonemgr_settransfersin(dns_zonemgr_t *zmgr, isc_uint32_t value) {
+dns_zonemgr_settransfersin(dns_zonemgr_t *zmgr, uint32_t value) {
REQUIRE(DNS_ZONEMGR_VALID(zmgr));
zmgr->transfersin = value;
}
-isc_uint32_t
+uint32_t
dns_zonemgr_getttransfersin(dns_zonemgr_t *zmgr) {
REQUIRE(DNS_ZONEMGR_VALID(zmgr));
}
void
-dns_zonemgr_settransfersperns(dns_zonemgr_t *zmgr, isc_uint32_t value) {
+dns_zonemgr_settransfersperns(dns_zonemgr_t *zmgr, uint32_t value) {
REQUIRE(DNS_ZONEMGR_VALID(zmgr));
zmgr->transfersperns = value;
}
-isc_uint32_t
+uint32_t
dns_zonemgr_getttransfersperns(dns_zonemgr_t *zmgr) {
REQUIRE(DNS_ZONEMGR_VALID(zmgr));
zmgr_start_xfrin_ifquota(dns_zonemgr_t *zmgr, dns_zone_t *zone) {
dns_peer_t *peer = NULL;
isc_netaddr_t masterip;
- isc_uint32_t nxfrsin, nxfrsperns;
+ uint32_t nxfrsin, nxfrsperns;
dns_zone_t *x;
- isc_uint32_t maxtransfersin, maxtransfersperns;
+ uint32_t maxtransfersin, maxtransfersperns;
isc_event_t *e;
/*
}
void
-dns_zonemgr_setiolimit(dns_zonemgr_t *zmgr, isc_uint32_t iolimit) {
+dns_zonemgr_setiolimit(dns_zonemgr_t *zmgr, uint32_t iolimit) {
REQUIRE(DNS_ZONEMGR_VALID(zmgr));
REQUIRE(iolimit > 0);
zmgr->iolimit = iolimit;
}
-isc_uint32_t
+uint32_t
dns_zonemgr_getiolimit(dns_zonemgr_t *zmgr) {
REQUIRE(DNS_ZONEMGR_VALID(zmgr));
static void
setrl(isc_ratelimiter_t *rl, unsigned int *rate, unsigned int value) {
isc_interval_t interval;
- isc_uint32_t s, ns;
- isc_uint32_t pertic;
+ uint32_t s, ns;
+ uint32_t pertic;
isc_result_t result;
if (value == 0)
unsigned int i;
isc_rwlocktype_t locktype;
isc_result_t result;
- isc_uint32_t seconds = isc_time_seconds(now);
- isc_uint32_t count = 0;
+ uint32_t seconds = isc_time_seconds(now);
+ uint32_t count = 0;
REQUIRE(DNS_ZONEMGR_VALID(zmgr));
dns_zonemgr_unreachableadd(dns_zonemgr_t *zmgr, isc_sockaddr_t *remote,
isc_sockaddr_t *local, isc_time_t *now)
{
- isc_uint32_t seconds = isc_time_seconds(now);
- isc_uint32_t last = seconds;
+ uint32_t seconds = isc_time_seconds(now);
+ uint32_t last = seconds;
unsigned int i, slot = UNREACH_CHACHE_SIZE, oldest = 0;
REQUIRE(DNS_ZONEMGR_VALID(zmgr));
return (ISC_R_NOTIMPLEMENTED);
}
-isc_uint64_t *
+uint64_t *
dns_zone_getstatscounters(dns_zone_t *zone) {
/*
* This function is obsoleted.
}
void
-dns_zone_setnotifydelay(dns_zone_t *zone, isc_uint32_t delay) {
+dns_zone_setnotifydelay(dns_zone_t *zone, uint32_t delay) {
REQUIRE(DNS_ZONE_VALID(zone));
LOCK_ZONE(zone);
UNLOCK_ZONE(zone);
}
-isc_uint32_t
+uint32_t
dns_zone_getnotifydelay(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
isc_result_t
dns_zone_signwithkey(dns_zone_t *zone, dns_secalg_t algorithm,
- isc_uint16_t keyid, isc_boolean_t deleteit)
+ uint16_t keyid, isc_boolean_t deleteit)
{
isc_result_t result;
REQUIRE(DNS_ZONE_VALID(zone));
}
void
-dns_zone_setnodes(dns_zone_t *zone, isc_uint32_t nodes) {
+dns_zone_setnodes(dns_zone_t *zone, uint32_t nodes) {
REQUIRE(DNS_ZONE_VALID(zone));
if (nodes == 0)
}
void
-dns_zone_setsignatures(dns_zone_t *zone, isc_uint32_t signatures) {
+dns_zone_setsignatures(dns_zone_t *zone, uint32_t signatures) {
REQUIRE(DNS_ZONE_VALID(zone));
/*
* We treat signatures as a signed value so explicitly
* limit its range here.
*/
- if (signatures > ISC_INT32_MAX)
- signatures = ISC_INT32_MAX;
+ if (signatures > INT32_MAX)
+ signatures = INT32_MAX;
else if (signatures == 0)
signatures = 1;
zone->signatures = signatures;
}
-isc_uint32_t
+uint32_t
dns_zone_getsignatures(dns_zone_t *zone) {
REQUIRE(DNS_ZONE_VALID(zone));
return (zone->signatures);
}
static isc_result_t
-zone_signwithkey(dns_zone_t *zone, dns_secalg_t algorithm, isc_uint16_t keyid,
+zone_signwithkey(dns_zone_t *zone, dns_secalg_t algorithm, uint16_t keyid,
isc_boolean_t deleteit)
{
dns_signing_t *signing;
isc_boolean_t flag;
isc_region_t r;
isc_result_t result = ISC_R_SUCCESS;
- isc_uint16_t keyid;
+ uint16_t keyid;
unsigned char buf[5];
dns_name_t *name = dns_db_origin(db);
for (tuple = ISC_LIST_HEAD(diff->tuples);
tuple != NULL;
tuple = ISC_LIST_NEXT(tuple, link)) {
- isc_uint8_t alg;
+ uint8_t alg;
if (tuple->rdata.type != dns_rdatatype_dnskey ||
tuple->op != DNS_DIFFOP_ADD)
continue;
}
isc_result_t
-dns_zone_setrefreshkeyinterval(dns_zone_t *zone, isc_uint32_t interval) {
+dns_zone_setrefreshkeyinterval(dns_zone_t *zone, uint32_t interval) {
REQUIRE(DNS_ZONE_VALID(zone));
if (interval == 0)
return (ISC_R_RANGE);
* structure passed as an argument.
*/
isc_result_t
-dns_zone_setnsec3param(dns_zone_t *zone, isc_uint8_t hash, isc_uint8_t flags,
- isc_uint16_t iter, isc_uint8_t saltlen,
+dns_zone_setnsec3param(dns_zone_t *zone, uint8_t hash, uint8_t flags,
+ uint16_t iter, uint8_t saltlen,
unsigned char *salt, isc_boolean_t replace)
{
isc_result_t result = ISC_R_SUCCESS;
static void
setserial(isc_task_t *task, isc_event_t *event) {
- isc_uint32_t oldserial, desired;
+ uint32_t oldserial, desired;
const char *me = "setserial";
isc_boolean_t commit = ISC_FALSE;
isc_result_t result;
}
isc_result_t
-dns_zone_setserial(dns_zone_t *zone, isc_uint32_t serial) {
+dns_zone_setserial(dns_zone_t *zone, uint32_t serial) {
isc_result_t result = ISC_R_SUCCESS;
dns_zone_t *dummy = NULL;
isc_event_t *e = NULL;
#include <config.h>
+#include <inttypes.h>
+
#include <isc/file.h>
#include <isc/magic.h>
#include <isc/mem.h>
void * loaddone_arg;
/* Locked by lock. */
isc_boolean_t flush;
- isc_uint32_t references;
+ uint32_t references;
unsigned int loads_pending;
dns_rbt_t *table;
};
#include <config.h>
+#include <inttypes.h>
#include <string.h>
#include <isc/base64.h>
dns_name_t *keyname_base, *keyname;
const cfg_listelt_t *element, *element2;
isc_result_t result;
- isc_uint32_t flags, proto, alg;
+ uint32_t flags, proto, alg;
const char *keystr, *keynamestr;
unsigned char keydata[4096];
isc_buffer_t keydatabuf_base, *keydatabuf;
return (ISC_R_RANGE);
if (alg > 0xff)
return (ISC_R_RANGE);
- keystruct.flags = (isc_uint16_t)flags;
- keystruct.protocol = (isc_uint8_t)proto;
- keystruct.algorithm = (isc_uint8_t)alg;
+ keystruct.flags = (uint16_t)flags;
+ keystruct.protocol = (uint8_t)proto;
+ keystruct.algorithm = (uint8_t)alg;
isc_buffer_init(&keydatabuf_base, keydata,
sizeof(keydata));
#include <config.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#ifdef IRS_HAVE_SIN6_SCOPE_ID
char *p, *ep;
char ntmp[NI_MAXHOST];
- isc_uint32_t scopeid;
+ uint32_t scopeid;
#endif
#ifdef IRS_HAVE_SIN6_SCOPE_ID
*/
if (p != NULL)
- scopeid = (isc_uint32_t)strtoul(p + 1,
+ scopeid = (uint32_t)strtoul(p + 1,
&ep, 10);
if (p != NULL && ep != NULL && ep[0] == '\0')
*p = '\0';
#include <ctype.h>
#include <errno.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
char *domainname;
char *search[RESCONFMAXSEARCH];
- isc_uint8_t searchnxt; /*%< index for next free slot */
+ uint8_t searchnxt; /*%< index for next free slot */
irs_resconf_searchlist_t searchlist;
/*% mask has a non-zero 'family' if set */
isc_netaddr_t mask;
} sortlist[RESCONFMAXSORTLIST];
- isc_uint8_t sortlistnxt;
+ uint8_t sortlistnxt;
/*%< non-zero if 'options debug' set */
- isc_uint8_t resdebug;
+ uint8_t resdebug;
/*%< set to n in 'options ndots:n' */
- isc_uint8_t ndots;
+ uint8_t ndots;
};
static isc_result_t
return (ISC_R_UNEXPECTEDTOKEN);
if (ndots < 0 || ndots > 0xff) /* Out of range. */
return (ISC_R_RANGE);
- conf->ndots = (isc_uint8_t)ndots;
+ conf->ndots = (uint8_t)ndots;
}
if (delim == EOF || delim == '\n')
#ifndef ISC_ATOMIC_H
#define ISC_ATOMIC_H 1
+#include <inttypes.h>
+
#include <isc/platform.h>
#include <isc/types.h>
* can be critical, so we add explicit memory block instructions at the
* beginning and the end of it (same for other functions).
*/
-static inline isc_int32_t
-isc_atomic_xadd(isc_int32_t *p, isc_int32_t val) {
+static inline int32_t
+isc_atomic_xadd(int32_t *p, int32_t val) {
return (asm("mb;"
"1:"
"ldl_l %t0, 0(%a0);" /* load old value */
* This routine atomically stores the value 'val' in 'p'.
*/
static inline void
-isc_atomic_store(isc_int32_t *p, isc_int32_t val) {
+isc_atomic_store(int32_t *p, int32_t val) {
(void)asm("mb;"
"1:"
"ldl_l %t0, 0(%a0);" /* load old value */
* original value is equal to 'cmpval'. The original value is returned in any
* case.
*/
-static inline isc_int32_t
-isc_atomic_cmpxchg(isc_int32_t *p, isc_int32_t cmpval, isc_int32_t val) {
+static inline int32_t
+isc_atomic_cmpxchg(int32_t *p, int32_t cmpval, int32_t val) {
return(asm("mb;"
"1:"
p, cmpval, val));
}
#elif defined (ISC_PLATFORM_USEGCCASM)
-static inline isc_int32_t
-isc_atomic_xadd(isc_int32_t *p, isc_int32_t val) {
- isc_int32_t temp, prev;
+static inline int32_t
+isc_atomic_xadd(int32_t *p, int32_t val) {
+ int32_t temp, prev;
__asm__ volatile(
"mb;"
}
static inline void
-isc_atomic_store(isc_int32_t *p, isc_int32_t val) {
- isc_int32_t temp;
+isc_atomic_store(int32_t *p, int32_t val) {
+ int32_t temp;
__asm__ volatile(
"mb;"
: "memory");
}
-static inline isc_int32_t
-isc_atomic_cmpxchg(isc_int32_t *p, isc_int32_t cmpval, isc_int32_t val) {
- isc_int32_t temp, prev;
+static inline int32_t
+isc_atomic_cmpxchg(int32_t *p, int32_t cmpval, int32_t val) {
+ int32_t temp, prev;
__asm__ volatile(
"mb;"
b->used = length;
}
-isc_uint8_t
+uint8_t
isc_buffer_getuint8(isc_buffer_t *b) {
unsigned char *cp;
- isc_uint8_t result;
+ uint8_t result;
/*
* Read an unsigned 8-bit integer from 'b' and return it.
cp = isc_buffer_current(b);
b->current += 1;
- result = ((isc_uint8_t)(cp[0]));
+ result = ((uint8_t)(cp[0]));
return (result);
}
void
-isc__buffer_putuint8(isc_buffer_t *b, isc_uint8_t val) {
+isc__buffer_putuint8(isc_buffer_t *b, uint8_t val) {
isc_result_t result;
REQUIRE(ISC_BUFFER_VALID(b));
if (ISC_UNLIKELY(b->autore)) {
ISC__BUFFER_PUTUINT8(b, val);
}
-isc_uint16_t
+uint16_t
isc_buffer_getuint16(isc_buffer_t *b) {
unsigned char *cp;
- isc_uint16_t result;
+ uint16_t result;
/*
* Read an unsigned 16-bit integer in network byte order from 'b',
}
void
-isc__buffer_putuint16(isc_buffer_t *b, isc_uint16_t val) {
+isc__buffer_putuint16(isc_buffer_t *b, uint16_t val) {
isc_result_t result;
REQUIRE(ISC_BUFFER_VALID(b));
if (ISC_UNLIKELY(b->autore)) {
}
void
-isc__buffer_putuint24(isc_buffer_t *b, isc_uint32_t val) {
+isc__buffer_putuint24(isc_buffer_t *b, uint32_t val) {
isc_result_t result;
REQUIRE(ISC_BUFFER_VALID(b));
if (ISC_UNLIKELY(b->autore)) {
ISC__BUFFER_PUTUINT24(b, val);
}
-isc_uint32_t
+uint32_t
isc_buffer_getuint32(isc_buffer_t *b) {
unsigned char *cp;
- isc_uint32_t result;
+ uint32_t result;
/*
* Read an unsigned 32-bit integer in network byte order from 'b',
}
void
-isc__buffer_putuint32(isc_buffer_t *b, isc_uint32_t val) {
+isc__buffer_putuint32(isc_buffer_t *b, uint32_t val) {
isc_result_t result;
REQUIRE(ISC_BUFFER_VALID(b));
if (ISC_UNLIKELY(b->autore)) {
ISC__BUFFER_PUTUINT32(b, val);
}
-isc_uint64_t
+uint64_t
isc_buffer_getuint48(isc_buffer_t *b) {
unsigned char *cp;
- isc_uint64_t result;
+ uint64_t result;
/*
* Read an unsigned 48-bit integer in network byte order from 'b',
cp = isc_buffer_current(b);
b->current += 6;
- result = ((isc_int64_t)(cp[0])) << 40;
- result |= ((isc_int64_t)(cp[1])) << 32;
- result |= ((isc_int64_t)(cp[2])) << 24;
- result |= ((isc_int64_t)(cp[3])) << 16;
- result |= ((isc_int64_t)(cp[4])) << 8;
- result |= ((isc_int64_t)(cp[5]));
+ result = ((int64_t)(cp[0])) << 40;
+ result |= ((int64_t)(cp[1])) << 32;
+ result |= ((int64_t)(cp[2])) << 24;
+ result |= ((int64_t)(cp[3])) << 16;
+ result |= ((int64_t)(cp[4])) << 8;
+ result |= ((int64_t)(cp[5]));
return (result);
}
void
-isc__buffer_putuint48(isc_buffer_t *b, isc_uint64_t val) {
+isc__buffer_putuint48(isc_buffer_t *b, uint64_t val) {
isc_result_t result;
- isc_uint16_t valhi;
- isc_uint32_t vallo;
+ uint16_t valhi;
+ uint32_t vallo;
REQUIRE(ISC_BUFFER_VALID(b));
if (ISC_UNLIKELY(b->autore)) {
}
REQUIRE(isc_buffer_availablelength(b) >= 6);
- valhi = (isc_uint16_t)(val >> 32);
- vallo = (isc_uint32_t)(val & 0xFFFFFFFF);
+ valhi = (uint16_t)(val >> 32);
+ vallo = (uint32_t)(val & 0xFFFFFFFF);
ISC__BUFFER_PUTUINT16(b, valhi);
ISC__BUFFER_PUTUINT32(b, vallo);
}
}
void
-isc_buffer_putdecint(isc_buffer_t *b, isc_int64_t v) {
+isc_buffer_putdecint(isc_buffer_t *b, int64_t v) {
unsigned int l=0;
unsigned char *cp;
char buf[21];
isc_result_t
isc_buffer_reserve(isc_buffer_t **dynbuffer, unsigned int size) {
- isc_uint64_t len;
+ uint64_t len;
REQUIRE(dynbuffer != NULL);
REQUIRE(ISC_BUFFER_VALID(*dynbuffer));
#include "config.h"
+#include <inttypes.h>
+
#include <isc/assertions.h>
#include <isc/crc64.h>
#include <isc/string.h>
/*%<
* ECMA-182 CRC64 polynomial.
*/
-static const isc_uint64_t crc64_table[256] = {
+static const uint64_t crc64_table[256] = {
0x0000000000000000ULL, 0x42F0E1EBA9EA3693ULL, 0x85E1C3D753D46D26ULL,
0xC711223CFA3E5BB5ULL, 0x493366450E42ECDFULL, 0x0BC387AEA7A8DA4CULL,
0xCCD2A5925D9681F9ULL, 0x8E224479F47CB76AULL, 0x9266CC8A1C85D9BEULL,
};
void
-isc_crc64_init(isc_uint64_t *crc) {
+isc_crc64_init(uint64_t *crc) {
REQUIRE(crc != NULL);
*crc = 0xffffffffffffffffULL;
}
void
-isc_crc64_update(isc_uint64_t *crc, const void *data, size_t len) {
+isc_crc64_update(uint64_t *crc, const void *data, size_t len) {
const unsigned char *p = data;
int i;
void
-isc_crc64_final(isc_uint64_t *crc) {
+isc_crc64_final(uint64_t *crc) {
REQUIRE(crc != NULL);
*crc ^= 0xffffffffffffffffULL;
/*% Entropy Pool */
typedef struct {
- isc_uint32_t cursor; /*%< current add point in the pool */
- isc_uint32_t entropy; /*%< current entropy estimate in bits */
- isc_uint32_t pseudo; /*%< bits extracted in pseudorandom */
- isc_uint32_t rotate; /*%< how many bits to rotate by */
- isc_uint32_t pool[RND_POOLWORDS]; /*%< random pool data */
+ uint32_t cursor; /*%< current add point in the pool */
+ uint32_t entropy; /*%< current entropy estimate in bits */
+ uint32_t pseudo; /*%< bits extracted in pseudorandom */
+ uint32_t rotate; /*%< how many bits to rotate by */
+ uint32_t pool[RND_POOLWORDS]; /*%< random pool data */
} isc_entropypool_t;
struct isc_entropy {
isc_mem_t *mctx;
isc_mutex_t lock;
unsigned int refcnt;
- isc_uint32_t initialized;
- isc_uint32_t initcount;
+ uint32_t initialized;
+ uint32_t initcount;
isc_entropypool_t pool;
unsigned int nsources;
isc_entropysource_t *nextsource;
/*% Sample Queue */
typedef struct {
- isc_uint32_t last_time; /*%< last time recorded */
- isc_uint32_t last_delta; /*%< last delta value */
- isc_uint32_t last_delta2; /*%< last delta2 value */
- isc_uint32_t nsamples; /*%< number of samples filled in */
- isc_uint32_t *samples; /*%< the samples */
- isc_uint32_t *extra; /*%< extra samples added in */
+ uint32_t last_time; /*%< last time recorded */
+ uint32_t last_delta; /*%< last delta value */
+ uint32_t last_delta2; /*%< last delta2 value */
+ uint32_t nsamples; /*%< number of samples filled in */
+ uint32_t *samples; /*%< the samples */
+ uint32_t *extra; /*%< extra samples added in */
} sample_queue_t;
typedef struct {
unsigned int magic;
unsigned int type;
isc_entropy_t *ent;
- isc_uint32_t total; /*%< entropy from this source */
+ uint32_t total; /*%< entropy from this source */
ISC_LINK(isc_entropysource_t) link;
char name[32];
isc_boolean_t bad;
* very large.
*/
static inline void
-add_entropy(isc_entropy_t *ent, isc_uint32_t entropy) {
+add_entropy(isc_entropy_t *ent, uint32_t entropy) {
/* clamp input. Yes, this must be done. */
entropy = ISC_MIN(entropy, RND_POOLBITS);
/* Add in the entropy we already have. */
* Decrement the amount of entropy the pool has.
*/
static inline void
-subtract_entropy(isc_entropy_t *ent, isc_uint32_t entropy) {
+subtract_entropy(isc_entropy_t *ent, uint32_t entropy) {
entropy = ISC_MIN(entropy, ent->pool.entropy);
ent->pool.entropy -= entropy;
}
* very large.
*/
static inline void
-add_pseudo(isc_entropy_t *ent, isc_uint32_t pseudo) {
+add_pseudo(isc_entropy_t *ent, uint32_t pseudo) {
/* clamp input. Yes, this must be done. */
pseudo = ISC_MIN(pseudo, RND_POOLBITS * 8);
/* Add in the pseudo we already have. */
* Decrement the amount of pseudo the pool has.
*/
static inline void
-subtract_pseudo(isc_entropy_t *ent, isc_uint32_t pseudo) {
+subtract_pseudo(isc_entropy_t *ent, uint32_t pseudo) {
pseudo = ISC_MIN(pseudo, ent->pool.pseudo);
ent->pool.pseudo -= pseudo;
}
* Add one word to the pool, rotating the input as needed.
*/
static inline void
-entropypool_add_word(isc_entropypool_t *rp, isc_uint32_t val) {
+entropypool_add_word(isc_entropypool_t *rp, uint32_t val) {
/*
* Steal some values out of the pool, and xor them into the
* word we were given.
*/
static void
entropypool_adddata(isc_entropy_t *ent, void *p, unsigned int len,
- isc_uint32_t entropy)
+ uint32_t entropy)
{
- isc_uint32_t val;
+ uint32_t val;
unsigned long addr;
- isc_uint8_t *buf;
+ uint8_t *buf;
/* Silly MSVC in 64 bit mode complains here... */
#ifdef _WIN64
}
for (; len > 3; len -= 4) {
- val = *((isc_uint32_t *)buf);
+ val = *((uint32_t *)buf);
entropypool_add_word(&ent->pool, val);
buf += 4;
}
static inline unsigned int
-estimate_entropy(sample_queue_t *sq, isc_uint32_t t) {
- isc_int32_t delta;
- isc_int32_t delta2;
- isc_int32_t delta3;
+estimate_entropy(sample_queue_t *sq, uint32_t t) {
+ int32_t delta;
+ int32_t delta2;
+ int32_t delta3;
/*!
* If the time counter has overflowed, calculate the real difference.
unsigned int i;
isc_sha1_t hash;
unsigned char digest[ISC_SHA1_DIGESTLENGTH];
- isc_uint32_t remain, deltae, count, total;
- isc_uint8_t *buf;
+ uint32_t remain, deltae, count, total;
+ uint8_t *buf;
isc_boolean_t goodonly, partial, blocking;
REQUIRE(VALID_ENTROPY(ent));
* queue was full when this function was called.
*/
static isc_result_t
-addsample(sample_queue_t *sq, isc_uint32_t sample, isc_uint32_t extra) {
+addsample(sample_queue_t *sq, uint32_t sample, uint32_t extra) {
if (sq->nsamples >= RND_EVENTQSIZE)
return (ISC_R_NOMORE);
}
isc_result_t
-isc_entropy_addsample(isc_entropysource_t *source, isc_uint32_t sample,
- isc_uint32_t extra)
+isc_entropy_addsample(isc_entropysource_t *source, uint32_t sample,
+ uint32_t extra)
{
isc_entropy_t *ent;
sample_queue_t *sq;
}
isc_result_t
-isc_entropy_addcallbacksample(isc_entropysource_t *source, isc_uint32_t sample,
- isc_uint32_t extra)
+isc_entropy_addcallbacksample(isc_entropysource_t *source, uint32_t sample,
+ uint32_t extra)
{
sample_queue_t *sq;
isc_result_t result;
void
isc_entropy_putdata(isc_entropy_t *ent, void *data, unsigned int length,
- isc_uint32_t entropy)
+ uint32_t entropy)
{
REQUIRE(VALID_ENTROPY(ent));
kbdget(isc_entropysource_t *source, void *arg, isc_boolean_t blocking) {
isc_result_t result;
isc_time_t t;
- isc_uint32_t sample;
- isc_uint32_t extra;
+ uint32_t sample;
+ uint32_t extra;
unsigned char c;
UNUSED(arg);
* Types of random seed and hash accumulator. Perhaps they can be system
* dependent.
*/
-typedef isc_uint32_t hash_accum_t;
-typedef isc_uint16_t hash_random_t;
+typedef uint32_t hash_accum_t;
+typedef uint16_t hash_random_t;
/*@}*/
/*% isc hash structure */
NULL, 0);
INSIST(result == ISC_R_SUCCESS);
} else {
- isc_uint32_t pr;
+ uint32_t pr;
size_t i, copylen;
unsigned char *p;
}
void
-isc__hash_setvec(const isc_uint16_t *vec) {
+isc__hash_setvec(const uint16_t *vec) {
int i;
hash_random_t *p;
}
}
-static isc_uint32_t fnv_offset_basis;
+static uint32_t fnv_offset_basis;
static isc_once_t fnv_once = ISC_ONCE_INIT;
static isc_boolean_t fnv_initialized = ISC_FALSE;
fnv_offset_basis = *((const unsigned int *) initializer);
}
-isc_uint32_t
+uint32_t
isc_hash_function(const void *data, size_t length,
isc_boolean_t case_sensitive,
- const isc_uint32_t *previous_hashp)
+ const uint32_t *previous_hashp)
{
- isc_uint32_t hval;
+ uint32_t hval;
const unsigned char *bp;
const unsigned char *be;
return (hval);
}
-isc_uint32_t
+uint32_t
isc_hash_function_reverse(const void *data, size_t length,
isc_boolean_t case_sensitive,
- const isc_uint32_t *previous_hashp)
+ const uint32_t *previous_hashp)
{
- isc_uint32_t hval;
+ uint32_t hval;
const unsigned char *bp;
const unsigned char *be;
#include <config.h>
+#include <inttypes.h>
#include <string.h>
#include <isc/hash.h>
};
isc_result_t
-isc_ht_init(isc_ht_t **htp, isc_mem_t *mctx, isc_uint8_t bits) {
+isc_ht_init(isc_ht_t **htp, isc_mem_t *mctx, uint8_t bits) {
isc_ht_t *ht = NULL;
size_t i;
isc_result_t
isc_ht_add(isc_ht_t *ht, const unsigned char *key,
- isc_uint32_t keysize, void *value)
+ uint32_t keysize, void *value)
{
isc_ht_node_t *node;
- isc_uint32_t hash;
+ uint32_t hash;
REQUIRE(ISC_HT_VALID(ht));
REQUIRE(key != NULL && keysize > 0);
isc_result_t
isc_ht_find(const isc_ht_t *ht, const unsigned char *key,
- isc_uint32_t keysize, void **valuep)
+ uint32_t keysize, void **valuep)
{
isc_ht_node_t *node;
- isc_uint32_t hash;
+ uint32_t hash;
REQUIRE(ISC_HT_VALID(ht));
REQUIRE(key != NULL && keysize > 0);
}
isc_result_t
-isc_ht_delete(isc_ht_t *ht, const unsigned char *key, isc_uint32_t keysize) {
+isc_ht_delete(isc_ht_t *ht, const unsigned char *key, uint32_t keysize) {
isc_ht_node_t *node, *prev;
- isc_uint32_t hash;
+ uint32_t hash;
REQUIRE(ISC_HT_VALID(ht));
REQUIRE(key != NULL && keysize > 0);
isc_ht_node_t *to_delete = NULL;
isc_ht_node_t *prev = NULL;
isc_ht_node_t *node = NULL;
- isc_uint32_t hash;
+ uint32_t hash;
isc_ht_t *ht;
REQUIRE(it != NULL);
REQUIRE(it->cur != NULL);
#include <config.h>
+#include <inttypes.h>
+#include <string.h>
+
#include <isc/buffer.h>
#include <isc/httpd.h>
#include <isc/mem.h>
#include <isc/time.h>
#include <isc/util.h>
-#include <string.h>
-
#ifdef HAVE_ZLIB
#include <zlib.h>
#endif
* Received data state.
*/
char recvbuf[HTTP_RECVLEN]; /*%< receive buffer */
- isc_uint32_t recvlen; /*%< length recv'd */
+ uint32_t recvlen; /*%< length recv'd */
char *headers; /*%< set in process_request() */
unsigned int method;
char *url;
#ifndef ISC_ATOMIC_H
#define ISC_ATOMIC_H 1
+#include <inttypes.h>
+
#include <isc/platform.h>
#include <isc/types.h>
* Open issue: can 'fetchadd' make the code faster for some particular values
* (e.g., 1 and -1)?
*/
-static inline isc_int32_t
+static inline int32_t
#ifdef __GNUC__
__attribute__ ((unused))
#endif
-isc_atomic_xadd(isc_int32_t *p, isc_int32_t val)
+isc_atomic_xadd(int32_t *p, int32_t val)
{
- isc_int32_t prev, swapped;
+ int32_t prev, swapped;
- for (prev = *(volatile isc_int32_t *)p; ; prev = swapped) {
+ for (prev = *(volatile int32_t *)p; ; prev = swapped) {
swapped = prev + val;
__asm__ volatile(
"mov ar.ccv=%2;;"
#ifdef __GNUC__
__attribute__ ((unused))
#endif
-isc_atomic_store(isc_int32_t *p, isc_int32_t val)
+isc_atomic_store(int32_t *p, int32_t val)
{
__asm__ volatile(
"st4.rel %0=%1"
* original value is equal to 'cmpval'. The original value is returned in any
* case.
*/
-static inline isc_int32_t
+static inline int32_t
#ifdef __GNUC__
__attribute__ ((unused))
#endif
-isc_atomic_cmpxchg(isc_int32_t *p, isc_int32_t cmpval, isc_int32_t val)
+isc_atomic_cmpxchg(int32_t *p, int32_t cmpval, int32_t val)
{
- isc_int32_t ret;
+ int32_t ret;
__asm__ volatile(
"mov ar.ccv=%2;;"
*** Imports
***/
+#include <inttypes.h>
+
#include <isc/assertions.h>
#include <isc/formatcheck.h>
#include <isc/lang.h>
* are those of the remaining region (as it was before the call).
*/
-isc_uint8_t
+uint8_t
isc_buffer_getuint8(isc_buffer_t *b);
/*!<
* \brief Read an unsigned 8-bit integer from 'b' and return it.
*/
void
-isc__buffer_putuint8(isc_buffer_t *b, isc_uint8_t val);
+isc__buffer_putuint8(isc_buffer_t *b, uint8_t val);
/*!<
* \brief Store an unsigned 8-bit integer from 'val' into 'b'.
*
*\li The used pointer in 'b' is advanced by 1.
*/
-isc_uint16_t
+uint16_t
isc_buffer_getuint16(isc_buffer_t *b);
/*!<
* \brief Read an unsigned 16-bit integer in network byte order from 'b', convert
*/
void
-isc__buffer_putuint16(isc_buffer_t *b, isc_uint16_t val);
+isc__buffer_putuint16(isc_buffer_t *b, uint16_t val);
/*!<
* \brief Store an unsigned 16-bit integer in host byte order from 'val'
* into 'b' in network byte order.
*\li The used pointer in 'b' is advanced by 2.
*/
-isc_uint32_t
+uint32_t
isc_buffer_getuint32(isc_buffer_t *b);
/*!<
* \brief Read an unsigned 32-bit integer in network byte order from 'b', convert
*/
void
-isc__buffer_putuint32(isc_buffer_t *b, isc_uint32_t val);
+isc__buffer_putuint32(isc_buffer_t *b, uint32_t val);
/*!<
* \brief Store an unsigned 32-bit integer in host byte order from 'val'
* into 'b' in network byte order.
*\li The used pointer in 'b' is advanced by 4.
*/
-isc_uint64_t
+uint64_t
isc_buffer_getuint48(isc_buffer_t *b);
/*!<
* \brief Read an unsigned 48-bit integer in network byte order from 'b',
*/
void
-isc__buffer_putuint48(isc_buffer_t *b, isc_uint64_t val);
+isc__buffer_putuint48(isc_buffer_t *b, uint64_t val);
/*!<
* \brief Store an unsigned 48-bit integer in host byte order from 'val'
* into 'b' in network byte order.
*/
void
-isc__buffer_putuint24(isc_buffer_t *b, isc_uint32_t val);
+isc__buffer_putuint24(isc_buffer_t *b, uint32_t val);
/*!<
* Store an unsigned 24-bit integer in host byte order from 'val'
* into 'b' in network byte order.
*/
void
-isc_buffer_putdecint(isc_buffer_t *b, isc_int64_t v);
+isc_buffer_putdecint(isc_buffer_t *b, int64_t v);
/*!<
* \brief Put decimal representation of 'v' in b
*
do { \
unsigned char *_cp; \
/* evaluate (_val) only once */ \
- isc_uint8_t _val2 = (_val); \
+ uint8_t _val2 = (_val); \
if (ISC_UNLIKELY((_b)->autore)) { \
isc_buffer_t *_tmp = _b; \
ISC_REQUIRE(isc_buffer_reserve(&_tmp, 1) \
do { \
unsigned char *_cp; \
/* evaluate (_val) only once */ \
- isc_uint16_t _val2 = (_val); \
+ uint16_t _val2 = (_val); \
if (ISC_UNLIKELY((_b)->autore)) { \
isc_buffer_t *_tmp = _b; \
ISC_REQUIRE(isc_buffer_reserve(&_tmp, 2) \
do { \
unsigned char *_cp; \
/* evaluate (_val) only once */ \
- isc_uint32_t _val2 = (_val); \
+ uint32_t _val2 = (_val); \
if (ISC_UNLIKELY((_b)->autore)) { \
isc_buffer_t *_tmp = _b; \
ISC_REQUIRE(isc_buffer_reserve(&_tmp, 3) \
do { \
unsigned char *_cp; \
/* evaluate (_val) only once */ \
- isc_uint32_t _val2 = (_val); \
+ uint32_t _val2 = (_val); \
if (ISC_UNLIKELY((_b)->autore)) { \
isc_buffer_t *_tmp = _b; \
ISC_REQUIRE(isc_buffer_reserve(&_tmp, 4) \
* \brief CRC64 in C
*/
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <isc/types.h>
ISC_LANG_BEGINDECLS
void
-isc_crc64_init(isc_uint64_t *crc);
+isc_crc64_init(uint64_t *crc);
/*%
* Initialize a new CRC.
*
*/
void
-isc_crc64_update(isc_uint64_t *crc, const void *data, size_t len);
+isc_crc64_update(uint64_t *crc, const void *data, size_t len);
/*%
* Add data to the CRC.
*
*/
void
-isc_crc64_final(isc_uint64_t *crc);
+isc_crc64_final(uint64_t *crc);
/*%
* Finalize the CRC.
*
/*@{*/
isc_result_t
-isc_entropy_addcallbacksample(isc_entropysource_t *source, isc_uint32_t sample,
- isc_uint32_t extra);
+isc_entropy_addcallbacksample(isc_entropysource_t *source, uint32_t sample,
+ uint32_t extra);
isc_result_t
-isc_entropy_addsample(isc_entropysource_t *source, isc_uint32_t sample,
- isc_uint32_t extra);
+isc_entropy_addsample(isc_entropysource_t *source, uint32_t sample,
+ uint32_t extra);
/*!<
* \brief Add a sample to the sample source.
*
void
isc_entropy_putdata(isc_entropy_t *ent, void *data, unsigned int length,
- isc_uint32_t entropy);
+ uint32_t entropy);
/*!<
* \brief Add "length" bytes in "data" to the entropy pool, incrementing the
* pool's entropy count by "entropy."
* solve this problem.
*/
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <isc/types.h>
/*%
* Adding any permission bits beyond 0x200 would mean typedef'ing
- * isc_fsaccess_t as isc_uint64_t, and redefining this value to
+ * isc_fsaccess_t as uint64_t, and redefining this value to
* reflect the new range of permission types, Probably to 21 for
* maximum flexibility. The number of bits has to accommodate all of
* the permission types, and three full sets of them have to fit
/*@}*/
void
-isc__hash_setvec(const isc_uint16_t *vec)
+isc__hash_setvec(const uint16_t *vec)
ISC_DEPRECATED;
/*!<
void
isc_hash_set_initializer(const void *initializer);
-isc_uint32_t
+uint32_t
isc_hash_function(const void *data, size_t length,
isc_boolean_t case_sensitive,
- const isc_uint32_t *previous_hashp);
-isc_uint32_t
+ const uint32_t *previous_hashp);
+uint32_t
isc_hash_function_reverse(const void *data, size_t length,
isc_boolean_t case_sensitive,
- const isc_uint32_t *previous_hashp);
+ const uint32_t *previous_hashp);
/*!<
* \brief Calculate a hash over data.
*
#ifndef ISC_HT_H
#define ISC_HT_H 1
+#include <inttypes.h>
#include <string.h>
+
#include <isc/types.h>
#include <isc/result.h>
*\li #ISC_R_SUCCESS -- all is well.
*/
isc_result_t
-isc_ht_init(isc_ht_t **htp, isc_mem_t *mctx, isc_uint8_t bits);
+isc_ht_init(isc_ht_t **htp, isc_mem_t *mctx, uint8_t bits);
/*%
* Destroy hashtable, freeing everything
*\li #ISC_R_SUCCESS -- all is well.
*/
isc_result_t
-isc_ht_add(isc_ht_t *ht, const unsigned char *key, isc_uint32_t keysize,
+isc_ht_add(isc_ht_t *ht, const unsigned char *key, uint32_t keysize,
void *value);
/*%
*/
isc_result_t
isc_ht_find(const isc_ht_t *ht, const unsigned char *key,
- isc_uint32_t keysize, void **valuep);
+ uint32_t keysize, void **valuep);
/*%
* Delete node from hashtable
*\li #ISC_R_SUCCESS -- all is well
*/
isc_result_t
-isc_ht_delete(isc_ht_t *ht, const unsigned char *key, isc_uint32_t keysize);
+isc_ht_delete(isc_ht_t *ht, const unsigned char *key, uint32_t keysize);
/*%
* Create an iterator for the hashtable; point '*itp' to it.
*** Imports
***/
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <isc/netaddr.h>
#include <isc/types.h>
isc_netaddr_t address; /*%< Local address. */
isc_netaddr_t netmask; /*%< Network mask. */
isc_netaddr_t dstaddress; /*%< Destination address (point-to-point only). */
- isc_uint32_t flags; /*%< Flags; see INTERFACE flags. */
+ uint32_t flags; /*%< Flags; see INTERFACE flags. */
};
/*@{*/
*** Imports.
***/
-#include <isc/int.h>
+#include <inttypes.h>
#include <isc/platform.h>
/***
struct in6_addr {
union {
- isc_uint8_t _S6_u8[16];
- isc_uint16_t _S6_u16[8];
- isc_uint32_t _S6_u32[4];
+ uint8_t _S6_u8[16];
+ uint16_t _S6_u16[8];
+ uint32_t _S6_u32[4];
} _S6_un;
};
#define s6_addr _S6_un._S6_u8
struct sockaddr_in6 {
#ifdef ISC_PLATFORM_HAVESALEN
- isc_uint8_t sin6_len;
- isc_uint8_t sin6_family;
+ uint8_t sin6_len;
+ uint8_t sin6_family;
#else
- isc_uint16_t sin6_family;
+ uint16_t sin6_family;
#endif
- isc_uint16_t sin6_port;
- isc_uint32_t sin6_flowinfo;
+ uint16_t sin6_port;
+ uint32_t sin6_flowinfo;
struct in6_addr sin6_addr;
- isc_uint32_t sin6_scope_id;
+ uint32_t sin6_scope_id;
};
#ifdef ISC_PLATFORM_HAVESALEN
/*! \file isc/lfsr.h */
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <isc/types.h>
* needs to be taken to not change state once the lfsr is in operation.
*/
struct isc_lfsr {
- isc_uint32_t state; /*%< previous state */
+ uint32_t state; /*%< previous state */
unsigned int bits; /*%< length */
- isc_uint32_t tap; /*%< bit taps */
+ uint32_t tap; /*%< bit taps */
unsigned int count; /*%< reseed count (in BITS!) */
isc_lfsrreseed_t reseed; /*%< reseed function */
void *arg; /*%< reseed function argument */
void
-isc_lfsr_init(isc_lfsr_t *lfsr, isc_uint32_t state, unsigned int bits,
- isc_uint32_t tap, unsigned int count,
+isc_lfsr_init(isc_lfsr_t *lfsr, uint32_t state, unsigned int bits,
+ uint32_t tap, unsigned int count,
isc_lfsrreseed_t reseed, void *arg);
/*%<
* Initialize an LFSR.
*\li lfsr be valid.
*/
-isc_uint32_t
+uint32_t
isc_lfsr_generate32(isc_lfsr_t *lfsr1, isc_lfsr_t *lfsr2);
/*%<
* Given two LFSRs, use the current state from each to skip entries in the
#else
typedef struct {
- isc_uint32_t buf[4];
- isc_uint32_t bytes[2];
- isc_uint32_t in[16];
+ uint32_t buf[4];
+ uint32_t bytes[2];
+ uint32_t in[16];
} isc_md5_t;
#endif
#ifndef ISC_MEMINFO_H
#define ISC_MEMINFO_H 1
+#include <inttypes.h>
+
#include <isc/types.h>
#include <isc/lang.h>
ISC_LANG_BEGINDECLS
-isc_uint64_t
+uint64_t
isc_meminfo_totalphys(void);
/*%<
* Return total available physical memory in bytes, or 0 if this cannot
/*! \file isc/netaddr.h */
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <isc/net.h>
#include <isc/types.h>
char un[sizeof(((struct sockaddr_un *)0)->sun_path)];
#endif
} type;
- isc_uint32_t zone;
+ uint32_t zone;
};
isc_boolean_t
isc_netaddr_frompath(isc_netaddr_t *netaddr, const char *path);
void
-isc_netaddr_setzone(isc_netaddr_t *netaddr, isc_uint32_t zone);
+isc_netaddr_setzone(isc_netaddr_t *netaddr, uint32_t zone);
-isc_uint32_t
+uint32_t
isc_netaddr_getzone(const isc_netaddr_t *netaddr);
void
/*! \file isc/netscope.h */
+#include <inttypes.h>
+
ISC_LANG_BEGINDECLS
/*%
* \li ISC_R_FAILURE: conversion fails
*/
isc_result_t
-isc_netscope_pton(int af, char *scopename, void *addr, isc_uint32_t *zoneid);
+isc_netscope_pton(int af, char *scopename, void *addr, uint32_t *zoneid);
ISC_LANG_ENDDECLS
#ifndef ISC_PARSEINT_H
#define ISC_PARSEINT_H 1
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <isc/types.h>
ISC_LANG_BEGINDECLS
isc_result_t
-isc_parse_uint32(isc_uint32_t *uip, const char *string, int base);
+isc_parse_uint32(uint32_t *uip, const char *string, int base);
isc_result_t
-isc_parse_uint16(isc_uint16_t *uip, const char *string, int base);
+isc_parse_uint16(uint16_t *uip, const char *string, int base);
isc_result_t
-isc_parse_uint8(isc_uint8_t *uip, const char *string, int base);
+isc_parse_uint8(uint8_t *uip, const char *string, int base);
/*%<
* Parse the null-terminated string 'string' containing a base 'base'
* integer, storing the result in '*uip'.
typedef struct isc_radix_node {
isc_mem_t *mctx;
- isc_uint32_t bit; /* bit length of the prefix */
+ uint32_t bit; /* bit length of the prefix */
isc_prefix_t *prefix; /* who we are in radix tree */
struct isc_radix_node *l, *r; /* left and right children */
struct isc_radix_node *parent; /* may be used */
unsigned int magic;
isc_mem_t *mctx;
isc_radix_node_t *head;
- isc_uint32_t maxbits; /* for IP, 32 bit addresses */
+ uint32_t maxbits; /* for IP, 32 bit addresses */
int num_active_node; /* for debugging purposes */
int num_added_node; /* total number of nodes */
} isc_radix_tree_t;
*/
void
-isc_random_seed(isc_uint32_t seed);
+isc_random_seed(uint32_t seed);
/*%<
* Set the initial seed of the random state.
*/
void
-isc_random_get(isc_uint32_t *val);
+isc_random_get(uint32_t *val);
/*%<
* Get a random value.
*
* val != NULL.
*/
-isc_uint32_t
-isc_random_jitter(isc_uint32_t max, isc_uint32_t jitter);
+uint32_t
+isc_random_jitter(uint32_t max, uint32_t jitter);
/*%<
* Get a random value between (max - jitter) and (max).
* This is useful for jittering timer values.
* \li rngp != NULL the RNG struct to decrement reference for
*/
-isc_uint16_t
+uint16_t
isc_rng_random(isc_rng_t *rngctx);
/*%<
* Returns a pseudo random 16-bit unsigned integer.
*/
-isc_uint16_t
-isc_rng_uniformrandom(isc_rng_t *rngctx, isc_uint16_t upper_bound);
+uint16_t
+isc_rng_uniformrandom(isc_rng_t *rngctx, uint16_t upper_bound);
/*%<
* Returns a uniformly distributed pseudo random 16-bit unsigned
* integer.
*** Imports.
***/
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <isc/types.h>
*/
void
-isc_ratelimiter_setpertic(isc_ratelimiter_t *rl, isc_uint32_t perint);
+isc_ratelimiter_setpertic(isc_ratelimiter_t *rl, uint32_t perint);
/*%<
* Set the number of events processed per interval timer tick.
* If 'perint' is zero it is treated as 1.
#ifndef ISC_REFCOUNT_H
#define ISC_REFCOUNT_H 1
+#include <inttypes.h>
+
#include <isc/assertions.h>
#include <isc/atomic.h>
#include <isc/error.h>
#if defined(ISC_REFCOUNT_HAVESTDATOMIC)
atomic_int_fast32_t refs;
#else
- isc_int32_t refs;
+ int32_t refs;
#endif
} isc_refcount_t;
#define isc_refcount_increment0(rp, tp) \
do { \
unsigned int *_tmp = (unsigned int *)(tp); \
- isc_int32_t prev; \
+ int32_t prev; \
prev = atomic_fetch_add_explicit \
(&(rp)->refs, 1, memory_order_relaxed); \
if (_tmp != NULL) \
#define isc_refcount_increment(rp, tp) \
do { \
unsigned int *_tmp = (unsigned int *)(tp); \
- isc_int32_t prev; \
+ int32_t prev; \
prev = atomic_fetch_add_explicit \
(&(rp)->refs, 1, memory_order_relaxed); \
ISC_REQUIRE(prev > 0); \
#define isc_refcount_decrement(rp, tp) \
do { \
unsigned int *_tmp = (unsigned int *)(tp); \
- isc_int32_t prev; \
+ int32_t prev; \
prev = atomic_fetch_sub_explicit \
(&(rp)->refs, 1, memory_order_relaxed); \
ISC_REQUIRE(prev > 0); \
#define isc_refcount_increment0(rp, tp) \
do { \
unsigned int *_tmp = (unsigned int *)(tp); \
- isc_int32_t prev; \
+ int32_t prev; \
prev = isc_atomic_xadd(&(rp)->refs, 1); \
if (_tmp != NULL) \
*_tmp = prev + 1; \
#define isc_refcount_increment(rp, tp) \
do { \
unsigned int *_tmp = (unsigned int *)(tp); \
- isc_int32_t prev; \
+ int32_t prev; \
prev = isc_atomic_xadd(&(rp)->refs, 1); \
ISC_REQUIRE(prev > 0); \
if (_tmp != NULL) \
#define isc_refcount_decrement(rp, tp) \
do { \
unsigned int *_tmp = (unsigned int *)(tp); \
- isc_int32_t prev; \
+ int32_t prev; \
prev = isc_atomic_xadd(&(rp)->refs, -1); \
ISC_REQUIRE(prev > 0); \
if (_tmp != NULL) \
#include <isc/lang.h>
#include <isc/types.h>
-#define ISC_RESOURCE_UNLIMITED ((isc_resourcevalue_t)ISC_UINT64_MAX)
+#define ISC_RESOURCE_UNLIMITED ((isc_resourcevalue_t)UINT64_MAX)
ISC_LANG_BEGINDECLS
* behaves the same.
*
*\li The current ISC libdns configuration file parser assigns a value
- * of ISC_UINT32_MAX for a size_spec of "unlimited" and ISC_UNIT32_MAX - 1
+ * of UINT32_MAX for a size_spec of "unlimited" and ISC_UNIT32_MAX - 1
* for "default", the latter of which is supposed to represent "the
* limit that was in force when the server started". Since these are
* valid values in the middle of the range of isc_resourcevalue_t,
#ifndef ISC_RWLOCK_H
#define ISC_RWLOCK_H 1
+#include <inttypes.h>
+
/*! \file isc/rwlock.h */
#include <isc/condition.h>
#include <isc/types.h>
#if defined(ISC_PLATFORM_HAVESTDATOMIC)
-#include <stdint.h>
#include <stdatomic.h>
#endif
/* Unlocked. */
unsigned int magic;
isc_mutex_t lock;
- isc_int32_t spins;
+ int32_t spins;
#if defined(ISC_RWLOCK_USEATOMIC)
/*
atomic_int_fast32_t write_completions;
atomic_int_fast32_t cnt_and_flag;
#else
- isc_int32_t write_requests;
- isc_int32_t write_completions;
- isc_int32_t cnt_and_flag;
+ int32_t write_requests;
+ int32_t write_completions;
+ int32_t cnt_and_flag;
#endif
/* Locked by lock. */
#ifndef ISC_SERIAL_H
#define ISC_SERIAL_H 1
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <isc/types.h>
ISC_LANG_BEGINDECLS
isc_boolean_t
-isc_serial_lt(isc_uint32_t a, isc_uint32_t b);
+isc_serial_lt(uint32_t a, uint32_t b);
/*%<
* Return true if 'a' < 'b' otherwise false.
*/
isc_boolean_t
-isc_serial_gt(isc_uint32_t a, isc_uint32_t b);
+isc_serial_gt(uint32_t a, uint32_t b);
/*%<
* Return true if 'a' > 'b' otherwise false.
*/
isc_boolean_t
-isc_serial_le(isc_uint32_t a, isc_uint32_t b);
+isc_serial_le(uint32_t a, uint32_t b);
/*%<
* Return true if 'a' <= 'b' otherwise false.
*/
isc_boolean_t
-isc_serial_ge(isc_uint32_t a, isc_uint32_t b);
+isc_serial_ge(uint32_t a, uint32_t b);
/*%<
* Return true if 'a' >= 'b' otherwise false.
*/
isc_boolean_t
-isc_serial_eq(isc_uint32_t a, isc_uint32_t b);
+isc_serial_eq(uint32_t a, uint32_t b);
/*%<
* Return true if 'a' == 'b' otherwise false.
*/
isc_boolean_t
-isc_serial_ne(isc_uint32_t a, isc_uint32_t b);
+isc_serial_ne(uint32_t a, uint32_t b);
/*%<
* Return true if 'a' != 'b' otherwise false.
*/
#else
typedef struct {
- isc_uint32_t state[5];
- isc_uint32_t count[2];
+ uint32_t state[5];
+ uint32_t count[2];
unsigned char buffer[ISC_SHA1_BLOCK_LENGTH];
} isc_sha1_t;
#endif
#ifndef ISC_SHA2_H
#define ISC_SHA2_H
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <isc/platform.h>
#include <isc/types.h>
* Keep buffer immediately after bitcount to preserve alignment.
*/
typedef struct {
- isc_uint32_t state[8];
- isc_uint64_t bitcount;
- isc_uint8_t buffer[ISC_SHA256_BLOCK_LENGTH];
+ uint32_t state[8];
+ uint64_t bitcount;
+ uint8_t buffer[ISC_SHA256_BLOCK_LENGTH];
} isc_sha256_t;
/*
* Keep buffer immediately after bitcount to preserve alignment.
*/
typedef struct {
- isc_uint64_t state[8];
- isc_uint64_t bitcount[2];
- isc_uint8_t buffer[ISC_SHA512_BLOCK_LENGTH];
+ uint64_t state[8];
+ uint64_t bitcount[2];
+ uint8_t buffer[ISC_SHA512_BLOCK_LENGTH];
} isc_sha512_t;
#endif
void isc_sha224_init (isc_sha224_t *);
void isc_sha224_invalidate (isc_sha224_t *);
-void isc_sha224_update (isc_sha224_t *, const isc_uint8_t *, size_t);
-void isc_sha224_final (isc_uint8_t[ISC_SHA224_DIGESTLENGTH], isc_sha224_t *);
+void isc_sha224_update (isc_sha224_t *, const uint8_t *, size_t);
+void isc_sha224_final (uint8_t[ISC_SHA224_DIGESTLENGTH], isc_sha224_t *);
char *isc_sha224_end (isc_sha224_t *, char[ISC_SHA224_DIGESTSTRINGLENGTH]);
-char *isc_sha224_data (const isc_uint8_t *, size_t, char[ISC_SHA224_DIGESTSTRINGLENGTH]);
+char *isc_sha224_data (const uint8_t *, size_t, char[ISC_SHA224_DIGESTSTRINGLENGTH]);
void isc_sha256_init (isc_sha256_t *);
void isc_sha256_invalidate (isc_sha256_t *);
-void isc_sha256_update (isc_sha256_t *, const isc_uint8_t *, size_t);
-void isc_sha256_final (isc_uint8_t[ISC_SHA256_DIGESTLENGTH], isc_sha256_t *);
+void isc_sha256_update (isc_sha256_t *, const uint8_t *, size_t);
+void isc_sha256_final (uint8_t[ISC_SHA256_DIGESTLENGTH], isc_sha256_t *);
char *isc_sha256_end (isc_sha256_t *, char[ISC_SHA256_DIGESTSTRINGLENGTH]);
-char *isc_sha256_data (const isc_uint8_t *, size_t, char[ISC_SHA256_DIGESTSTRINGLENGTH]);
+char *isc_sha256_data (const uint8_t *, size_t, char[ISC_SHA256_DIGESTSTRINGLENGTH]);
void isc_sha384_init (isc_sha384_t *);
void isc_sha384_invalidate (isc_sha384_t *);
-void isc_sha384_update (isc_sha384_t *, const isc_uint8_t *, size_t);
-void isc_sha384_final (isc_uint8_t[ISC_SHA384_DIGESTLENGTH], isc_sha384_t *);
+void isc_sha384_update (isc_sha384_t *, const uint8_t *, size_t);
+void isc_sha384_final (uint8_t[ISC_SHA384_DIGESTLENGTH], isc_sha384_t *);
char *isc_sha384_end (isc_sha384_t *, char[ISC_SHA384_DIGESTSTRINGLENGTH]);
-char *isc_sha384_data (const isc_uint8_t *, size_t, char[ISC_SHA384_DIGESTSTRINGLENGTH]);
+char *isc_sha384_data (const uint8_t *, size_t, char[ISC_SHA384_DIGESTSTRINGLENGTH]);
void isc_sha512_init (isc_sha512_t *);
void isc_sha512_invalidate (isc_sha512_t *);
-void isc_sha512_update (isc_sha512_t *, const isc_uint8_t *, size_t);
-void isc_sha512_final (isc_uint8_t[ISC_SHA512_DIGESTLENGTH], isc_sha512_t *);
+void isc_sha512_update (isc_sha512_t *, const uint8_t *, size_t);
+void isc_sha512_final (uint8_t[ISC_SHA512_DIGESTLENGTH], isc_sha512_t *);
char *isc_sha512_end (isc_sha512_t *, char[ISC_SHA512_DIGESTSTRINGLENGTH]);
-char *isc_sha512_data (const isc_uint8_t *, size_t, char[ISC_SHA512_DIGESTSTRINGLENGTH]);
+char *isc_sha512_data (const uint8_t *, size_t, char[ISC_SHA512_DIGESTSTRINGLENGTH]);
ISC_LANG_ENDDECLS
*** Imports
***/
+#include <inttypes.h>
+
#include <isc/event.h>
#include <isc/eventclass.h>
#include <isc/lang.h>
isc_sockaddr_t address; /*%< source address */
isc_time_t timestamp; /*%< timestamp of packet recv */
struct in6_pktinfo pktinfo; /*%< ipv6 pktinfo */
- isc_uint32_t attributes; /*%< see below */
+ uint32_t attributes; /*%< see below */
isc_eventdestructor_t destroy; /*%< original destructor */
unsigned int dscp; /*%< UDP dscp value */
};
*/
isc_result_t
-isc_socket_permunix(isc_sockaddr_t *sockaddr, isc_uint32_t perm,
- isc_uint32_t owner, isc_uint32_t group);
+isc_socket_permunix(isc_sockaddr_t *sockaddr, uint32_t perm,
+ uint32_t owner, uint32_t group);
/*%<
* Set ownership and file permissions on the UNIX domain socket.
*
*/
void
-isc__socketmgr_setreserved(isc_socketmgr_t *mgr, isc_uint32_t);
+isc__socketmgr_setreserved(isc_socketmgr_t *mgr, uint32_t);
/*%<
* Temporary. For use by named only.
*/
/*! \file isc/stats.h */
+#include <inttypes.h>
+
#include <isc/types.h>
ISC_LANG_BEGINDECLS
/*%<
* Dump callback type.
*/
-typedef void (*isc_stats_dumper_t)(isc_statscounter_t, isc_uint64_t, void *);
+typedef void (*isc_stats_dumper_t)(isc_statscounter_t, uint64_t, void *);
isc_result_t
isc_stats_create(isc_mem_t *mctx, isc_stats_t **statsp, int ncounters);
*/
void
-isc_stats_set(isc_stats_t *stats, isc_uint64_t val,
+isc_stats_set(isc_stats_t *stats, uint64_t val,
isc_statscounter_t counter);
/*%<
* Set the given counter to the specfied value.
*/
void
-isc_stats_set(isc_stats_t *stats, isc_uint64_t val,
+isc_stats_set(isc_stats_t *stats, uint64_t val,
isc_statscounter_t counter);
/*%<
* Set the given counter to the specfied value.
/*! \file isc/string.h */
+#include <inttypes.h>
+
#include <isc/formatcheck.h>
-#include <isc/int.h>
#include <isc/lang.h>
#include <isc/platform.h>
#include <isc/types.h>
ISC_LANG_BEGINDECLS
-isc_uint64_t
+uint64_t
isc_string_touint64(char *source, char **endp, int base);
/*%<
- * Convert the string pointed to by 'source' to isc_uint64_t.
+ * Convert the string pointed to by 'source' to uint64_t.
*
* On successful conversion 'endp' points to the first character
* after conversion is complete.
* \brief
* OS-specific types, from the OS-specific include directories.
*/
-#include <isc/int.h>
+#include <inttypes.h>
#include <isc/offset.h>
/*
typedef struct isc_constregion isc_constregion_t; /*%< Const region */
typedef struct isc_consttextregion isc_consttextregion_t; /*%< Const Text Region */
typedef struct isc_counter isc_counter_t; /*%< Counter */
-typedef isc_int16_t isc_dscp_t; /*%< Diffserv code point */
+typedef int16_t isc_dscp_t; /*%< Diffserv code point */
typedef struct isc_entropy isc_entropy_t; /*%< Entropy */
typedef struct isc_entropysource isc_entropysource_t; /*%< Entropy Source */
typedef struct isc_event isc_event_t; /*%< Event */
typedef ISC_LIST(isc_event_t) isc_eventlist_t; /*%< Event List */
typedef unsigned int isc_eventtype_t; /*%< Event Type */
-typedef isc_uint32_t isc_fsaccess_t; /*%< FS Access */
+typedef uint32_t isc_fsaccess_t; /*%< FS Access */
typedef struct isc_hash isc_hash_t; /*%< Hash */
typedef struct isc_httpd isc_httpd_t; /*%< HTTP client */
typedef void (isc_httpdfree_t)(isc_buffer_t *, void *); /*%< HTTP free function */
typedef struct isc_random isc_random_t; /*%< Random */
typedef struct isc_ratelimiter isc_ratelimiter_t; /*%< Rate Limiter */
typedef struct isc_region isc_region_t; /*%< Region */
-typedef isc_uint64_t isc_resourcevalue_t; /*%< Resource Value */
+typedef uint64_t isc_resourcevalue_t; /*%< Resource Value */
typedef unsigned int isc_result_t; /*%< Result */
typedef struct isc_rwlock isc_rwlock_t; /*%< Read Write Lock */
typedef struct isc_sockaddr isc_sockaddr_t; /*%< Socket Address */
*/
int
isc_net_aton(const char *cp, struct in_addr *addr) {
- isc_uint32_t val;
+ uint32_t val;
int base;
ptrdiff_t n;
unsigned char c;
- isc_uint32_t parts[4];
- isc_uint32_t *pp = parts;
+ uint32_t parts[4];
+ uint32_t *pp = parts;
int digit;
c = *cp;
#include <errno.h>
#include <stdio.h>
+#include <inttypes.h>
#include <string.h>
#include <isc/net.h>
#include <ctype.h>
#include <errno.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <isc/buffer.h>
isc_buffer_free(&source->pushback);
source->pushback = tbuf;
}
- isc_buffer_putuint8(source->pushback, (isc_uint8_t)c);
+ isc_buffer_putuint8(source->pushback, (uint8_t)c);
return (ISC_R_SUCCESS);
}
FILE *stream;
char *curr, *prev;
size_t remaining;
- isc_uint32_t as_ulong;
+ uint32_t as_ulong;
unsigned int saved_options;
isc_result_t result;
#include <config.h>
#include <stddef.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <isc/assertions.h>
#define VALID_LFSR(x) (x != NULL)
void
-isc_lfsr_init(isc_lfsr_t *lfsr, isc_uint32_t state, unsigned int bits,
- isc_uint32_t tap, unsigned int count,
+isc_lfsr_init(isc_lfsr_t *lfsr, uint32_t state, unsigned int bits,
+ uint32_t tap, unsigned int count,
isc_lfsrreseed_t reseed, void *arg)
{
REQUIRE(VALID_LFSR(lfsr));
/*!
* Return the next state of the lfsr.
*/
-static inline isc_uint32_t
+static inline uint32_t
lfsr_generate(isc_lfsr_t *lfsr)
{
}
}
-static inline isc_uint32_t
+static inline uint32_t
lfsr_skipgenerate(isc_lfsr_t *lfsr, unsigned int skip)
{
while (skip--)
* Skip states in lfsr1 and lfsr2 using the other's current state.
* Return the final state of lfsr1 ^ lfsr2.
*/
-isc_uint32_t
+uint32_t
isc_lfsr_generate32(isc_lfsr_t *lfsr1, isc_lfsr_t *lfsr2)
{
- isc_uint32_t state1, state2;
- isc_uint32_t skip1, skip2;
+ uint32_t state1, state2;
+ uint32_t skip1, skip2;
REQUIRE(VALID_LFSR(lfsr1));
REQUIRE(VALID_LFSR(lfsr2));
#include <config.h>
#include <errno.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <limits.h>
#include <time.h>
#else
static void
-byteSwap(isc_uint32_t *buf, unsigned words)
+byteSwap(uint32_t *buf, unsigned words)
{
unsigned char *p = (unsigned char *)buf;
do {
- *buf++ = (isc_uint32_t)((unsigned)p[3] << 8 | p[2]) << 16 |
+ *buf++ = (uint32_t)((unsigned)p[3] << 8 | p[2]) << 16 |
((unsigned)p[1] << 8 | p[0]);
p += 4;
} while (--words);
* the data and converts bytes into longwords for this routine.
*/
static void
-transform(isc_uint32_t buf[4], isc_uint32_t const in[16]) {
- register isc_uint32_t a, b, c, d;
+transform(uint32_t buf[4], uint32_t const in[16]) {
+ register uint32_t a, b, c, d;
a = buf[0];
b = buf[1];
*/
void
isc_md5_update(isc_md5_t *ctx, const unsigned char *buf, unsigned int len) {
- isc_uint32_t t;
+ uint32_t t;
/* Update byte count */
#include <config.h>
+#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
-#include <inttypes.h>
#include <limits.h>
#include <isc/bind9.h>
* Total size of lost memory due to a bug of external library.
* Locked by the global lock.
*/
-static isc_uint64_t totallost;
+static uint64_t totallost;
struct isc__mem {
isc_mem_t common;
}
typedef struct summarystat {
- isc_uint64_t total;
- isc_uint64_t inuse;
- isc_uint64_t blocksize;
- isc_uint64_t contextsize;
+ uint64_t total;
+ uint64_t inuse;
+ uint64_t blocksize;
+ uint64_t contextsize;
} summarystat_t;
#ifdef HAVE_LIBXML2
TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "total"));
TRY0(xmlTextWriterWriteFormatString(writer,
"%" PRIu64,
- (isc_uint64_t)ctx->total));
+ (uint64_t)ctx->total));
TRY0(xmlTextWriterEndElement(writer)); /* total */
summary->inuse += ctx->inuse;
TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "inuse"));
TRY0(xmlTextWriterWriteFormatString(writer,
"%" PRIu64,
- (isc_uint64_t)ctx->inuse));
+ (uint64_t)ctx->inuse));
TRY0(xmlTextWriterEndElement(writer)); /* inuse */
TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "maxinuse"));
TRY0(xmlTextWriterWriteFormatString(writer,
"%" PRIu64,
- (isc_uint64_t)ctx->maxinuse));
+ (uint64_t)ctx->maxinuse));
TRY0(xmlTextWriterEndElement(writer)); /* maxinuse */
TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "blocksize"));
NUM_BASIC_BLOCKS * ctx->mem_target;
TRY0(xmlTextWriterWriteFormatString(writer,
"%" PRIu64,
- (isc_uint64_t)
+ (uint64_t)
ctx->basic_table_count *
NUM_BASIC_BLOCKS *
ctx->mem_target));
TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "hiwater"));
TRY0(xmlTextWriterWriteFormatString(writer,
"%" PRIu64,
- (isc_uint64_t)ctx->hi_water));
+ (uint64_t)ctx->hi_water));
TRY0(xmlTextWriterEndElement(writer)); /* hiwater */
TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "lowater"));
TRY0(xmlTextWriterWriteFormatString(writer,
- "%" PRIu64,
- (isc_uint64_t)ctx->lo_water));
+ "%" PRIu64 "",
+ (uint64_t)ctx->lo_water));
TRY0(xmlTextWriterEndElement(writer)); /* lowater */
TRY0(xmlTextWriterEndElement(writer)); /* context */
isc_mem_renderxml(xmlTextWriterPtr writer) {
isc__mem_t *ctx;
summarystat_t summary;
- isc_uint64_t lost;
+ uint64_t lost;
int xmlrc;
memset(&summary, 0, sizeof(summary));
json_object_object_add(ctxobj, "maxinuse", obj);
if ((ctx->flags & ISC_MEMFLAG_INTERNAL) != 0) {
- isc_uint64_t blocksize;
+ uint64_t blocksize;
blocksize = ctx->basic_table_count * NUM_BASIC_BLOCKS *
ctx->mem_target;
obj = json_object_new_int64(blocksize);
isc_result_t result = ISC_R_SUCCESS;
isc__mem_t *ctx;
summarystat_t summary;
- isc_uint64_t lost;
+ uint64_t lost;
json_object *ctxarray, *obj;
memset(&summary, 0, sizeof(summary));
#ifndef ISC_ATOMIC_H
#define ISC_ATOMIC_H 1
+#include <inttypes.h>
+
#include <isc/platform.h>
#include <isc/types.h>
* This routine atomically increments the value stored in 'p' by 'val', and
* returns the previous value.
*/
-static inline isc_int32_t
-isc_atomic_xadd(isc_int32_t *p, int val) {
- isc_int32_t orig;
+static inline int32_t
+isc_atomic_xadd(int32_t *p, int val) {
+ int32_t orig;
__asm__ __volatile__ (
" .set push \n"
* This routine atomically stores the value 'val' in 'p'.
*/
static inline void
-isc_atomic_store(isc_int32_t *p, isc_int32_t val) {
+isc_atomic_store(int32_t *p, int32_t val) {
*p = val;
}
* original value is equal to 'cmpval'. The original value is returned in any
* case.
*/
-static inline isc_int32_t
-isc_atomic_cmpxchg(isc_int32_t *p, int cmpval, int val) {
- isc_int32_t orig;
- isc_int32_t tmp;
+static inline int32_t
+isc_atomic_cmpxchg(int32_t *p, int cmpval, int val) {
+ int32_t orig;
+ int32_t tmp;
__asm__ __volatile__ (
" .set push \n"
#include <config.h>
#include <stdio.h>
+#include <inttypes.h>
#include <isc/buffer.h>
#include <isc/msgs.h>
void
-isc_netaddr_setzone(isc_netaddr_t *netaddr, isc_uint32_t zone) {
+isc_netaddr_setzone(isc_netaddr_t *netaddr, uint32_t zone) {
/* we currently only support AF_INET6. */
REQUIRE(netaddr->family == AF_INET6);
netaddr->zone = zone;
}
-isc_uint32_t
+uint32_t
isc_netaddr_getzone(const isc_netaddr_t *netaddr) {
return (netaddr->zone);
}
}
#define ISC_IPADDR_ISNETZERO(i) \
- (((isc_uint32_t)(i) & ISC__IPADDR(0xff000000)) \
+ (((uint32_t)(i) & ISC__IPADDR(0xff000000)) \
== ISC__IPADDR(0x00000000))
isc_boolean_t
#include <isc/result.h>
isc_result_t
-isc_netscope_pton(int af, char *scopename, void *addr, isc_uint32_t *zoneid) {
+isc_netscope_pton(int af, char *scopename, void *addr, uint32_t *zoneid) {
char *ep;
#ifdef ISC_PLATFORM_HAVEIFNAMETOINDEX
unsigned int ifid;
struct in6_addr *in6;
#endif
- isc_uint32_t zone;
- isc_uint64_t llz;
+ uint32_t zone;
+ uint64_t llz;
/* at this moment, we only support AF_INET6 */
if (af != AF_INET6)
in6 = (struct in6_addr *)addr;
if (IN6_IS_ADDR_LINKLOCAL(in6) &&
(ifid = if_nametoindex((const char *)scopename)) != 0)
- zone = (isc_uint32_t)ifid;
+ zone = (uint32_t)ifid;
else {
#endif
llz = isc_string_touint64(scopename, &ep, 10);
return (ISC_R_FAILURE);
/* check overflow */
- zone = (isc_uint32_t)(llz & 0xffffffffUL);
+ zone = (uint32_t)(llz & 0xffffffffUL);
if (zone != llz)
return (ISC_R_FAILURE);
#ifdef ISC_PLATFORM_HAVEIFNAMETOINDEX
#include <ctype.h>
#include <errno.h>
#include <limits.h>
+#include <inttypes.h>
#include <isc/parseint.h>
#include <isc/result.h>
#include <isc/stdlib.h>
isc_result_t
-isc_parse_uint32(isc_uint32_t *uip, const char *string, int base) {
+isc_parse_uint32(uint32_t *uip, const char *string, int base) {
unsigned long n;
- isc_uint32_t r;
+ uint32_t r;
char *e;
if (! isalnum((unsigned char)(string[0])))
return (ISC_R_BADNUMBER);
* equality. This is a no-op on 32 bit machines and a good compiler
* will optimise it away.
*/
- r = (isc_uint32_t)n;
+ r = (uint32_t)n;
if ((n == ULONG_MAX && errno == ERANGE) || (n != (unsigned long)r))
return (ISC_R_RANGE);
*uip = r;
}
isc_result_t
-isc_parse_uint16(isc_uint16_t *uip, const char *string, int base) {
- isc_uint32_t val;
+isc_parse_uint16(uint16_t *uip, const char *string, int base) {
+ uint32_t val;
isc_result_t result;
result = isc_parse_uint32(&val, string, base);
if (result != ISC_R_SUCCESS)
return (result);
if (val > 0xFFFF)
return (ISC_R_RANGE);
- *uip = (isc_uint16_t) val;
+ *uip = (uint16_t) val;
return (ISC_R_SUCCESS);
}
isc_result_t
-isc_parse_uint8(isc_uint8_t *uip, const char *string, int base) {
- isc_uint32_t val;
+isc_parse_uint8(uint8_t *uip, const char *string, int base) {
+ uint32_t val;
isc_result_t result;
result = isc_parse_uint32(&val, string, base);
if (result != ISC_R_SUCCESS)
return (result);
if (val > 0xFF)
return (ISC_R_RANGE);
- *uip = (isc_uint8_t) val;
+ *uip = (uint8_t) val;
return (ISC_R_SUCCESS);
}
#include <config.h>
#include <stdio.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
static isc_once_t once = ISC_ONCE_INIT;
static isc_mem_t *pk11_mctx = NULL;
-static isc_int32_t allocsize = 0;
+static int32_t allocsize = 0;
static isc_boolean_t initialized = ISC_FALSE;
typedef struct pk11_session pk11_session_t;
void *
isc_pool_get(isc_pool_t *pool) {
- isc_uint32_t i;
+ uint32_t i;
isc_random_get(&i);
return (pool->pool[i % pool->count]);
}
#include <config.h>
+#include <inttypes.h>
+
#include <isc/mem.h>
#include <isc/portset.h>
#include <isc/string.h>
#include <isc/types.h>
#include <isc/util.h>
-#define ISC_PORTSET_BUFSIZE (65536 / (sizeof(isc_uint32_t) * 8))
+#define ISC_PORTSET_BUFSIZE (65536 / (sizeof(uint32_t) * 8))
/*%
* Internal representation of portset. It's an array of 32-bit integers, each
*/
struct isc_portset {
unsigned int nports; /*%< number of ports in the set */
- isc_uint32_t buf[ISC_PORTSET_BUFSIZE];
+ uint32_t buf[ISC_PORTSET_BUFSIZE];
};
static inline isc_boolean_t
portset_isset(isc_portset_t *portset, in_port_t port) {
- return (ISC_TF((portset->buf[port >> 5] & ((isc_uint32_t)1 << (port & 31))) != 0));
+ return (ISC_TF((portset->buf[port >> 5] & ((uint32_t)1 << (port & 31))) != 0));
}
static inline void
portset_add(isc_portset_t *portset, in_port_t port) {
if (!portset_isset(portset, port)) {
portset->nports++;
- portset->buf[port >> 5] |= ((isc_uint32_t)1 << (port & 31));
+ portset->buf[port >> 5] |= ((uint32_t)1 << (port & 31));
}
}
portset_remove(isc_portset_t *portset, in_port_t port) {
if (portset_isset(portset, port)) {
portset->nports--;
- portset->buf[port >> 5] &= ~((isc_uint32_t)1 << (port & 31));
+ portset->buf[port >> 5] &= ~((uint32_t)1 << (port & 31));
}
}
#ifndef ISC_ATOMIC_H
#define ISC_ATOMIC_H 1
+#include <inttypes.h>
+
#include <isc/platform.h>
#include <isc/types.h>
/*!\file
- * static inline isc_int32_t
- * isc_atomic_xadd(isc_int32_t *p, isc_int32_t val);
+ * static inline int32_t
+ * isc_atomic_xadd(int32_t *p, int32_t val);
*
* This routine atomically increments the value stored in 'p' by 'val', and
* returns the previous value.
*
* static inline void
- * isc_atomic_store(void *p, isc_int32_t val);
+ * isc_atomic_store(void *p, int32_t val);
*
* This routine atomically stores the value 'val' in 'p'.
*
- * static inline isc_int32_t
- * isc_atomic_cmpxchg(isc_int32_t *p, isc_int32_t cmpval, isc_int32_t val);
+ * static inline int32_t
+ * isc_atomic_cmpxchg(int32_t *p, int32_t cmpval, int32_t val);
*
* This routine atomically replaces the value in 'p' with 'val', if the
* original value is equal to 'cmpval'. The original value is returned in any
#define isc_atomic_store(p, v) _clear_lock(p, v)
#ifdef __GNUC__
-static inline isc_int32_t
+static inline int32_t
#else
-static isc_int32_t
+static int32_t
#endif
-isc_atomic_xadd(isc_int32_t *p, isc_int32_t val) {
+isc_atomic_xadd(int32_t *p, int32_t val) {
int ret;
#ifdef __GNUC__
}
#elif defined(ISC_PLATFORM_USEGCCASM) || defined(ISC_PLATFORM_USEMACASM)
-static inline isc_int32_t
-isc_atomic_xadd(isc_int32_t *p, isc_int32_t val) {
- isc_int32_t orig;
+static inline int32_t
+isc_atomic_xadd(int32_t *p, int32_t val) {
+ int32_t orig;
__asm__ volatile (
#ifdef ISC_PLATFORM_USEMACASM
}
static inline void
-isc_atomic_store(void *p, isc_int32_t val) {
+isc_atomic_store(void *p, int32_t val) {
__asm__ volatile (
#ifdef ISC_PLATFORM_USEMACASM
"1:"
);
}
-static inline isc_int32_t
-isc_atomic_cmpxchg(isc_int32_t *p, isc_int32_t cmpval, isc_int32_t val) {
- isc_int32_t orig;
+static inline int32_t
+isc_atomic_cmpxchg(int32_t *p, int32_t cmpval, int32_t val) {
+ int32_t orig;
__asm__ volatile (
#ifdef ISC_PLATFORM_USEMACASM
#include <config.h>
#include <ctype.h>
+#include <inttypes.h>
#include <stdio.h> /* for sprintf() */
#include <string.h> /* for strlen() */
#include <assert.h> /* for assert() */
#define ISC__PRINT_SOURCE /* Used to get the isc_print_* prototypes. */
#include <isc/assertions.h>
-#include <isc/int.h>
#include <isc/msgs.h>
#include <isc/print.h>
#include <isc/stdlib.h>
int plus;
int space;
int neg;
- isc_int64_t tmpi;
- isc_uint64_t tmpui;
+ int64_t tmpi;
+ uint64_t tmpui;
unsigned long width;
unsigned long precision;
unsigned int length;
case 'i':
case 'd':
if (q)
- tmpi = va_arg(ap, isc_int64_t);
+ tmpi = va_arg(ap, int64_t);
else if (l)
tmpi = va_arg(ap, long int);
else if (z)
goto printint;
case 'o':
if (q)
- tmpui = va_arg(ap, isc_uint64_t);
+ tmpui = va_arg(ap, uint64_t);
else if (l)
tmpui = va_arg(ap, long int);
else if (z)
goto printint;
case 'u':
if (q)
- tmpui = va_arg(ap, isc_uint64_t);
+ tmpui = va_arg(ap, uint64_t);
else if (l)
tmpui = va_arg(ap, unsigned long int);
else if (z)
goto printint;
case 'x':
if (q)
- tmpui = va_arg(ap, isc_uint64_t);
+ tmpui = va_arg(ap, uint64_t);
else if (l)
tmpui = va_arg(ap, unsigned long int);
else if (z)
goto printint;
case 'X':
if (q)
- tmpui = va_arg(ap, isc_uint64_t);
+ tmpui = va_arg(ap, uint64_t);
else if (l)
tmpui = va_arg(ap, unsigned long int);
else if (z)
#include <config.h>
+#include <inttypes.h>
+
#include <isc/mem.h>
#include <isc/types.h>
#include <isc/util.h>
isc_radix_node_t *node;
isc_radix_node_t *stack[RADIX_MAXBITS + 1];
u_char *addr;
- isc_uint32_t bitlen;
+ uint32_t bitlen;
int tfam = -1, cnt = 0;
REQUIRE(radix != NULL);
{
isc_radix_node_t *node, *new_node, *parent, *glue = NULL;
u_char *addr, *test_addr;
- isc_uint32_t bitlen, fam, check_bit, differ_bit;
- isc_uint32_t i, j, r;
+ uint32_t bitlen, fam, check_bit, differ_bit;
+ uint32_t i, j, r;
isc_result_t result;
REQUIRE(radix != NULL);
unsigned int magic;
isc_mem_t *mctx;
chacha_ctx cpctx;
- isc_uint8_t buffer[CHACHA_BUFFERSIZE];
+ uint8_t buffer[CHACHA_BUFFERSIZE];
size_t have;
unsigned int references;
int count;
}
void
-isc_random_seed(isc_uint32_t seed) {
+isc_random_seed(uint32_t seed) {
initialize();
#ifndef HAVE_ARC4RANDOM
UNUSED(seed);
arc4random_stir();
#elif defined(HAVE_ARC4RANDOM_ADDRANDOM)
- arc4random_addrandom((u_char *) &seed, sizeof(isc_uint32_t));
+ arc4random_addrandom((u_char *) &seed, sizeof(uint32_t));
#else
/*
* If arc4random() is available and no corresponding seeding
}
void
-isc_random_get(isc_uint32_t *val) {
+isc_random_get(uint32_t *val) {
REQUIRE(val != NULL);
initialize();
#endif
}
-isc_uint32_t
-isc_random_jitter(isc_uint32_t max, isc_uint32_t jitter) {
- isc_uint32_t rnd;
+uint32_t
+isc_random_jitter(uint32_t max, uint32_t jitter) {
+ uint32_t rnd;
REQUIRE(jitter < max || (jitter == 0 && max == 0));
}
static void
-chacha_reinit(isc_rng_t *rng, isc_uint8_t *buffer, size_t n) {
+chacha_reinit(isc_rng_t *rng, uint8_t *buffer, size_t n) {
REQUIRE(rng != NULL);
if (n < CHACHA_KEYSIZE + CHACHA_IVSIZE)
isc_rng_create(isc_mem_t *mctx, isc_entropy_t *entropy, isc_rng_t **rngp) {
union {
unsigned char rnd[128];
- isc_uint32_t rnd32[32];
+ uint32_t rnd32[32];
} rnd;
isc_result_t result;
isc_rng_t *rng;
rng->have = CHACHA_BUFFERSIZE - CHACHA_KEYSIZE - CHACHA_IVSIZE;
}
-static inline isc_uint16_t
+static inline uint16_t
chacha_getuint16(isc_rng_t *rng) {
- isc_uint16_t val;
+ uint16_t val;
REQUIRE(VALID_RNG(rng));
chacha_stir(isc_rng_t *rng) {
union {
unsigned char rnd[128];
- isc_uint32_t rnd32[32];
+ uint32_t rnd32[32];
} rnd;
isc_result_t result;
rng->count = 1600000;
}
-isc_uint16_t
+uint16_t
isc_rng_random(isc_rng_t *rng) {
- isc_uint16_t result;
+ uint16_t result;
REQUIRE(VALID_RNG(rng));
LOCK(&rng->lock);
- rng->count -= sizeof(isc_uint16_t);
+ rng->count -= sizeof(uint16_t);
if (rng->count <= 0)
chacha_stir(rng);
result = chacha_getuint16(rng);
return (result);
}
-isc_uint16_t
-isc_rng_uniformrandom(isc_rng_t *rng, isc_uint16_t upper_bound) {
- isc_uint16_t min, r;
+uint16_t
+isc_rng_uniformrandom(isc_rng_t *rng, uint16_t upper_bound) {
+ uint16_t min, r;
REQUIRE(VALID_RNG(rng));
if (upper_bound > 0x8000)
min = 1 + ~upper_bound; /* 0x8000 - upper_bound */
else
- min = (isc_uint16_t)(0x10000 % (isc_uint32_t)upper_bound);
+ min = (uint16_t)(0x10000 % (uint32_t)upper_bound);
/*
* This could theoretically loop forever but each retry has
#include <config.h>
+#include <inttypes.h>
+
#include <isc/mem.h>
#include <isc/ratelimiter.h>
#include <isc/task.h>
isc_task_t * task;
isc_timer_t * timer;
isc_interval_t interval;
- isc_uint32_t pertic;
+ uint32_t pertic;
isc_boolean_t pushpop;
isc_ratelimiter_state_t state;
isc_event_t shutdownevent;
}
void
-isc_ratelimiter_setpertic(isc_ratelimiter_t *rl, isc_uint32_t pertic) {
+isc_ratelimiter_setpertic(isc_ratelimiter_t *rl, uint32_t pertic) {
REQUIRE(rl != NULL);
isc_result_t result = ISC_R_SUCCESS;
isc_ratelimiter_t *rl = (isc_ratelimiter_t *)event->ev_arg;
isc_event_t *p;
- isc_uint32_t pertic;
+ uint32_t pertic;
UNUSED(task);
#include <config.h>
#include <stddef.h>
+#include <inttypes.h>
#include <isc/atomic.h>
#include <isc/magic.h>
static isc_result_t
isc__rwlock_lock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
- isc_int32_t cntflag;
+ int32_t cntflag;
REQUIRE(VALID_RWLOCK(rwl));
*/
rwl->write_granted = 0;
} else {
- isc_int32_t prev_writer;
+ int32_t prev_writer;
/* enter the waiting queue, and wait for our turn */
#if defined(ISC_RWLOCK_USESTDATOMIC)
(&rwl->cnt_and_flag, &cntflag2, WRITER_ACTIVE,
memory_order_relaxed, memory_order_relaxed);
#else
- isc_int32_t cntflag2;
+ int32_t cntflag2;
cntflag2 = isc_atomic_cmpxchg(&rwl->cnt_and_flag, 0,
WRITER_ACTIVE);
#endif
isc_result_t
isc_rwlock_lock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
- isc_int32_t cnt = 0;
- isc_int32_t max_cnt = rwl->spins * 2 + 10;
+ int32_t cnt = 0;
+ int32_t max_cnt = rwl->spins * 2 + 10;
isc_result_t result = ISC_R_SUCCESS;
if (max_cnt > RWLOCK_MAX_ADAPTIVE_COUNT)
isc_result_t
isc_rwlock_trylock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
- isc_int32_t cntflag;
+ int32_t cntflag;
REQUIRE(VALID_RWLOCK(rwl));
}
#else
{
- isc_int32_t prevcnt;
+ int32_t prevcnt;
/* Try to acquire write access. */
prevcnt = isc_atomic_cmpxchg(&rwl->cnt_and_flag,
void
isc_rwlock_downgrade(isc_rwlock_t *rwl) {
- isc_int32_t prev_readers;
+ int32_t prev_readers;
REQUIRE(VALID_RWLOCK(rwl));
isc_result_t
isc_rwlock_unlock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
- isc_int32_t prev_cnt;
+ int32_t prev_cnt;
REQUIRE(VALID_RWLOCK(rwl));
isc_result_t
isc_rwlock_lock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {
- isc_int32_t cnt = 0;
- isc_int32_t max_cnt = rwl->spins * 2 + 10;
+ int32_t cnt = 0;
+ int32_t max_cnt = rwl->spins * 2 + 10;
isc_result_t result = ISC_R_SUCCESS;
if (max_cnt > RWLOCK_MAX_ADAPTIVE_COUNT)
isc_boolean_t
isc_safe_memequal(const void *s1, const void *s2, size_t n) {
- isc_uint8_t acc = 0;
+ uint8_t acc = 0;
if (n != 0U) {
- const isc_uint8_t *p1 = s1, *p2 = s2;
+ const uint8_t *p1 = s1, *p2 = s2;
do {
acc |= *p1++ ^ *p2++;
#include <config.h>
+#include <inttypes.h>
+
#include <isc/serial.h>
isc_boolean_t
-isc_serial_lt(isc_uint32_t a, isc_uint32_t b) {
+isc_serial_lt(uint32_t a, uint32_t b) {
/*
* Undefined => ISC_FALSE
*/
if (a == (b ^ 0x80000000U))
return (ISC_FALSE);
- return (((isc_int32_t)(a - b) < 0) ? ISC_TRUE : ISC_FALSE);
+ return (((int32_t)(a - b) < 0) ? ISC_TRUE : ISC_FALSE);
}
isc_boolean_t
-isc_serial_gt(isc_uint32_t a, isc_uint32_t b) {
- return (((isc_int32_t)(a - b) > 0) ? ISC_TRUE : ISC_FALSE);
+isc_serial_gt(uint32_t a, uint32_t b) {
+ return (((int32_t)(a - b) > 0) ? ISC_TRUE : ISC_FALSE);
}
isc_boolean_t
-isc_serial_le(isc_uint32_t a, isc_uint32_t b) {
+isc_serial_le(uint32_t a, uint32_t b) {
return ((a == b) ? ISC_TRUE : isc_serial_lt(a, b));
}
isc_boolean_t
-isc_serial_ge(isc_uint32_t a, isc_uint32_t b) {
+isc_serial_ge(uint32_t a, uint32_t b) {
return ((a == b) ? ISC_TRUE : isc_serial_gt(a, b));
}
isc_boolean_t
-isc_serial_eq(isc_uint32_t a, isc_uint32_t b) {
+isc_serial_eq(uint32_t a, uint32_t b) {
return ((a == b) ? ISC_TRUE : ISC_FALSE);
}
isc_boolean_t
-isc_serial_ne(isc_uint32_t a, isc_uint32_t b) {
+isc_serial_ne(uint32_t a, uint32_t b) {
return ((a != b) ? ISC_TRUE : ISC_FALSE);
}
} CHAR64LONG16;
#ifdef __sparc_v9__
-static void do_R01(isc_uint32_t *a, isc_uint32_t *b, isc_uint32_t *c,
- isc_uint32_t *d, isc_uint32_t *e, CHAR64LONG16 *);
-static void do_R2(isc_uint32_t *a, isc_uint32_t *b, isc_uint32_t *c,
- isc_uint32_t *d, isc_uint32_t *e, CHAR64LONG16 *);
-static void do_R3(isc_uint32_t *a, isc_uint32_t *b, isc_uint32_t *c,
- isc_uint32_t *d, isc_uint32_t *e, CHAR64LONG16 *);
-static void do_R4(isc_uint32_t *a, isc_uint32_t *b, isc_uint32_t *c,
- isc_uint32_t *d, isc_uint32_t *e, CHAR64LONG16 *);
+static void do_R01(uint32_t *a, uint32_t *b, uint32_t *c,
+ uint32_t *d, uint32_t *e, CHAR64LONG16 *);
+static void do_R2(uint32_t *a, uint32_t *b, uint32_t *c,
+ uint32_t *d, uint32_t *e, CHAR64LONG16 *);
+static void do_R3(uint32_t *a, uint32_t *b, uint32_t *c,
+ uint32_t *d, uint32_t *e, CHAR64LONG16 *);
+static void do_R4(uint32_t *a, uint32_t *b, uint32_t *c,
+ uint32_t *d, uint32_t *e, CHAR64LONG16 *);
#define nR0(v,w,x,y,z,i) R0(*v,*w,*x,*y,*z,i)
#define nR1(v,w,x,y,z,i) R1(*v,*w,*x,*y,*z,i)
#define nR4(v,w,x,y,z,i) R4(*v,*w,*x,*y,*z,i)
static void
-do_R01(isc_uint32_t *a, isc_uint32_t *b, isc_uint32_t *c, isc_uint32_t *d,
- isc_uint32_t *e, CHAR64LONG16 *block)
+do_R01(uint32_t *a, uint32_t *b, uint32_t *c, uint32_t *d,
+ uint32_t *e, CHAR64LONG16 *block)
{
nR0(a,b,c,d,e, 0); nR0(e,a,b,c,d, 1); nR0(d,e,a,b,c, 2);
nR0(c,d,e,a,b, 3); nR0(b,c,d,e,a, 4); nR0(a,b,c,d,e, 5);
}
static void
-do_R2(isc_uint32_t *a, isc_uint32_t *b, isc_uint32_t *c, isc_uint32_t *d,
- isc_uint32_t *e, CHAR64LONG16 *block)
+do_R2(uint32_t *a, uint32_t *b, uint32_t *c, uint32_t *d,
+ uint32_t *e, CHAR64LONG16 *block)
{
nR2(a,b,c,d,e,20); nR2(e,a,b,c,d,21); nR2(d,e,a,b,c,22);
nR2(c,d,e,a,b,23); nR2(b,c,d,e,a,24); nR2(a,b,c,d,e,25);
}
static void
-do_R3(isc_uint32_t *a, isc_uint32_t *b, isc_uint32_t *c, isc_uint32_t *d,
- isc_uint32_t *e, CHAR64LONG16 *block)
+do_R3(uint32_t *a, uint32_t *b, uint32_t *c, uint32_t *d,
+ uint32_t *e, CHAR64LONG16 *block)
{
nR3(a,b,c,d,e,40); nR3(e,a,b,c,d,41); nR3(d,e,a,b,c,42);
nR3(c,d,e,a,b,43); nR3(b,c,d,e,a,44); nR3(a,b,c,d,e,45);
}
static void
-do_R4(isc_uint32_t *a, isc_uint32_t *b, isc_uint32_t *c, isc_uint32_t *d,
- isc_uint32_t *e, CHAR64LONG16 *block)
+do_R4(uint32_t *a, uint32_t *b, uint32_t *c, uint32_t *d,
+ uint32_t *e, CHAR64LONG16 *block)
{
nR4(a,b,c,d,e,60); nR4(e,a,b,c,d,61); nR4(d,e,a,b,c,62);
nR4(c,d,e,a,b,63); nR4(b,c,d,e,a,64); nR4(a,b,c,d,e,65);
* Hash a single 512-bit block. This is the core of the algorithm.
*/
static void
-transform(isc_uint32_t state[5], const unsigned char buffer[64]) {
- isc_uint32_t a, b, c, d, e;
+transform(uint32_t state[5], const unsigned char buffer[64]) {
+ uint32_t a, b, c, d, e;
CHAR64LONG16 *block;
CHAR64LONG16 workspace;
#include <config.h>
+#include <inttypes.h>
+
#include <isc/assertions.h>
#include <isc/platform.h>
#include <isc/safe.h>
}
void
-isc_sha224_update(isc_sha224_t *context, const isc_uint8_t* data, size_t len) {
+isc_sha224_update(isc_sha224_t *context, const uint8_t* data, size_t len) {
if (len == 0U) {
/* Calling with no data is valid - we do nothing */
return;
/* Sanity check: */
REQUIRE(context != (isc_sha224_t *)0);
REQUIRE(context->ctx != (EVP_MD_CTX *)0);
- REQUIRE(data != (isc_uint8_t*)0);
+ REQUIRE(data != (uint8_t*)0);
RUNTIME_CHECK(EVP_DigestUpdate(context->ctx,
(const void *) data, len) == 1);
}
void
-isc_sha224_final(isc_uint8_t digest[], isc_sha224_t *context) {
+isc_sha224_final(uint8_t digest[], isc_sha224_t *context) {
/* Sanity check: */
REQUIRE(context != (isc_sha224_t *)0);
REQUIRE(context->ctx != (EVP_MD_CTX *)0);
/* If no digest buffer is passed, we don't bother doing this: */
- if (digest != (isc_uint8_t*)0)
+ if (digest != (uint8_t*)0)
RUNTIME_CHECK(EVP_DigestFinal(context->ctx,
digest, NULL) == 1);
EVP_MD_CTX_free(context->ctx);
}
void
-isc_sha256_update(isc_sha256_t *context, const isc_uint8_t *data, size_t len) {
+isc_sha256_update(isc_sha256_t *context, const uint8_t *data, size_t len) {
if (len == 0U) {
/* Calling with no data is valid - we do nothing */
return;
/* Sanity check: */
REQUIRE(context != (isc_sha256_t *)0);
REQUIRE(context->ctx != (EVP_MD_CTX *)0);
- REQUIRE(data != (isc_uint8_t*)0);
+ REQUIRE(data != (uint8_t*)0);
RUNTIME_CHECK(EVP_DigestUpdate(context->ctx,
(const void *) data, len) == 1);
}
void
-isc_sha256_final(isc_uint8_t digest[], isc_sha256_t *context) {
+isc_sha256_final(uint8_t digest[], isc_sha256_t *context) {
/* Sanity check: */
REQUIRE(context != (isc_sha256_t *)0);
REQUIRE(context->ctx != (EVP_MD_CTX *)0);
/* If no digest buffer is passed, we don't bother doing this: */
- if (digest != (isc_uint8_t*)0)
+ if (digest != (uint8_t*)0)
RUNTIME_CHECK(EVP_DigestFinal(context->ctx,
digest, NULL) == 1);
EVP_MD_CTX_free(context->ctx);
context->ctx = NULL;
}
-void isc_sha512_update(isc_sha512_t *context, const isc_uint8_t *data, size_t len) {
+void isc_sha512_update(isc_sha512_t *context, const uint8_t *data, size_t len) {
if (len == 0U) {
/* Calling with no data is valid - we do nothing */
return;
/* Sanity check: */
REQUIRE(context != (isc_sha512_t *)0);
REQUIRE(context->ctx != (EVP_MD_CTX *)0);
- REQUIRE(data != (isc_uint8_t*)0);
+ REQUIRE(data != (uint8_t*)0);
RUNTIME_CHECK(EVP_DigestUpdate(context->ctx,
(const void *) data, len) == 1);
}
-void isc_sha512_final(isc_uint8_t digest[], isc_sha512_t *context) {
+void isc_sha512_final(uint8_t digest[], isc_sha512_t *context) {
/* Sanity check: */
REQUIRE(context != (isc_sha512_t *)0);
REQUIRE(context->ctx != (EVP_MD_CTX *)0);
/* If no digest buffer is passed, we don't bother doing this: */
- if (digest != (isc_uint8_t*)0)
+ if (digest != (uint8_t*)0)
RUNTIME_CHECK(EVP_DigestFinal(context->ctx,
digest, NULL) == 1);
EVP_MD_CTX_free(context->ctx);
}
void
-isc_sha384_update(isc_sha384_t *context, const isc_uint8_t* data, size_t len) {
+isc_sha384_update(isc_sha384_t *context, const uint8_t* data, size_t len) {
if (len == 0U) {
/* Calling with no data is valid - we do nothing */
return;
/* Sanity check: */
REQUIRE(context != (isc_sha512_t *)0);
REQUIRE(context->ctx != (EVP_MD_CTX *)0);
- REQUIRE(data != (isc_uint8_t*)0);
+ REQUIRE(data != (uint8_t*)0);
RUNTIME_CHECK(EVP_DigestUpdate(context->ctx,
(const void *) data, len) == 1);
}
void
-isc_sha384_final(isc_uint8_t digest[], isc_sha384_t *context) {
+isc_sha384_final(uint8_t digest[], isc_sha384_t *context) {
/* Sanity check: */
REQUIRE(context != (isc_sha384_t *)0);
REQUIRE(context->ctx != (EVP_MD_CTX *)0);
/* If no digest buffer is passed, we don't bother doing this: */
- if (digest != (isc_uint8_t*)0)
+ if (digest != (uint8_t*)0)
RUNTIME_CHECK(EVP_DigestFinal(context->ctx,
digest, NULL) == 1);
EVP_MD_CTX_free(context->ctx);
}
void
-isc_sha224_update(isc_sha224_t *context, const isc_uint8_t* data, size_t len) {
+isc_sha224_update(isc_sha224_t *context, const uint8_t* data, size_t len) {
CK_RV rv;
CK_BYTE_PTR pPart;
}
/* Sanity check: */
- REQUIRE(context != (isc_sha224_t *)0 && data != (isc_uint8_t*)0);
+ REQUIRE(context != (isc_sha224_t *)0 && data != (uint8_t*)0);
DE_CONST(data, pPart);
PK11_FATALCHECK(pkcs_C_DigestUpdate,
}
void
-isc_sha224_final(isc_uint8_t digest[], isc_sha224_t *context) {
+isc_sha224_final(uint8_t digest[], isc_sha224_t *context) {
CK_RV rv;
CK_ULONG len = ISC_SHA224_DIGESTLENGTH;
REQUIRE(context != (isc_sha224_t *)0);
/* If no digest buffer is passed, we don't bother doing this: */
- if (digest != (isc_uint8_t*)0) {
+ if (digest != (uint8_t*)0) {
PK11_FATALCHECK(pkcs_C_DigestFinal,
(context->session,
(CK_BYTE_PTR) digest,
}
void
-isc_sha256_update(isc_sha256_t *context, const isc_uint8_t* data, size_t len) {
+isc_sha256_update(isc_sha256_t *context, const uint8_t* data, size_t len) {
CK_RV rv;
CK_BYTE_PTR pPart;
}
/* Sanity check: */
- REQUIRE(context != (isc_sha256_t *)0 && data != (isc_uint8_t*)0);
+ REQUIRE(context != (isc_sha256_t *)0 && data != (uint8_t*)0);
DE_CONST(data, pPart);
PK11_FATALCHECK(pkcs_C_DigestUpdate,
}
void
-isc_sha256_final(isc_uint8_t digest[], isc_sha256_t *context) {
+isc_sha256_final(uint8_t digest[], isc_sha256_t *context) {
CK_RV rv;
CK_ULONG len = ISC_SHA256_DIGESTLENGTH;
REQUIRE(context != (isc_sha256_t *)0);
/* If no digest buffer is passed, we don't bother doing this: */
- if (digest != (isc_uint8_t*)0) {
+ if (digest != (uint8_t*)0) {
PK11_FATALCHECK(pkcs_C_DigestFinal,
(context->session,
(CK_BYTE_PTR) digest,
}
void
-isc_sha512_update(isc_sha512_t *context, const isc_uint8_t* data, size_t len) {
+isc_sha512_update(isc_sha512_t *context, const uint8_t* data, size_t len) {
CK_RV rv;
CK_BYTE_PTR pPart;
}
/* Sanity check: */
- REQUIRE(context != (isc_sha512_t *)0 && data != (isc_uint8_t*)0);
+ REQUIRE(context != (isc_sha512_t *)0 && data != (uint8_t*)0);
DE_CONST(data, pPart);
PK11_FATALCHECK(pkcs_C_DigestUpdate,
}
void
-isc_sha512_final(isc_uint8_t digest[], isc_sha512_t *context) {
+isc_sha512_final(uint8_t digest[], isc_sha512_t *context) {
CK_RV rv;
CK_ULONG len = ISC_SHA512_DIGESTLENGTH;
REQUIRE(context != (isc_sha512_t *)0);
/* If no digest buffer is passed, we don't bother doing this: */
- if (digest != (isc_uint8_t*)0) {
+ if (digest != (uint8_t*)0) {
PK11_FATALCHECK(pkcs_C_DigestFinal,
(context->session,
(CK_BYTE_PTR) digest,
}
void
-isc_sha384_update(isc_sha384_t *context, const isc_uint8_t* data, size_t len) {
+isc_sha384_update(isc_sha384_t *context, const uint8_t* data, size_t len) {
CK_RV rv;
CK_BYTE_PTR pPart;
}
/* Sanity check: */
- REQUIRE(context != (isc_sha384_t *)0 && data != (isc_uint8_t*)0);
+ REQUIRE(context != (isc_sha384_t *)0 && data != (uint8_t*)0);
DE_CONST(data, pPart);
PK11_FATALCHECK(pkcs_C_DigestUpdate,
}
void
-isc_sha384_final(isc_uint8_t digest[], isc_sha384_t *context) {
+isc_sha384_final(uint8_t digest[], isc_sha384_t *context) {
CK_RV rv;
CK_ULONG len = ISC_SHA384_DIGESTLENGTH;
REQUIRE(context != (isc_sha384_t *)0);
/* If no digest buffer is passed, we don't bother doing this: */
- if (digest != (isc_uint8_t*)0) {
+ if (digest != (uint8_t*)0) {
PK11_FATALCHECK(pkcs_C_DigestFinal,
(context->session,
(CK_BYTE_PTR) digest,
/*** ENDIAN REVERSAL MACROS *******************************************/
#if BYTE_ORDER == LITTLE_ENDIAN
#define REVERSE32(w,x) { \
- isc_uint32_t tmp = (w); \
+ uint32_t tmp = (w); \
tmp = (tmp >> 16) | (tmp << 16); \
(x) = ((tmp & 0xff00ff00UL) >> 8) | ((tmp & 0x00ff00ffUL) << 8); \
}
#ifdef WIN32
#define REVERSE64(w,x) { \
- isc_uint64_t tmp = (w); \
+ uint64_t tmp = (w); \
tmp = (tmp >> 32) | (tmp << 32); \
tmp = ((tmp & 0xff00ff00ff00ff00UL) >> 8) | \
((tmp & 0x00ff00ff00ff00ffUL) << 8); \
}
#else
#define REVERSE64(w,x) { \
- isc_uint64_t tmp = (w); \
+ uint64_t tmp = (w); \
tmp = (tmp >> 32) | (tmp << 32); \
tmp = ((tmp & 0xff00ff00ff00ff00ULL) >> 8) | \
((tmp & 0x00ff00ff00ff00ffULL) << 8); \
* 64-bit words):
*/
#define ADDINC128(w,n) { \
- (w)[0] += (isc_uint64_t)(n); \
+ (w)[0] += (uint64_t)(n); \
if ((w)[0] < (n)) { \
(w)[1]++; \
} \
* only.
*/
void isc_sha512_last(isc_sha512_t *);
-void isc_sha256_transform(isc_sha256_t *, const isc_uint32_t*);
-void isc_sha512_transform(isc_sha512_t *, const isc_uint64_t*);
+void isc_sha256_transform(isc_sha256_t *, const uint32_t*);
+void isc_sha512_transform(isc_sha512_t *, const uint64_t*);
/*** SHA-XYZ INITIAL HASH VALUES AND CONSTANTS ************************/
/* Hash constant words K for SHA-224 and SHA-256: */
-static const isc_uint32_t K256[64] = {
+static const uint32_t K256[64] = {
0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL,
0x3956c25bUL, 0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL,
0xd807aa98UL, 0x12835b01UL, 0x243185beUL, 0x550c7dc3UL,
};
/* Initial hash value H for SHA-224: */
-static const isc_uint32_t sha224_initial_hash_value[8] = {
+static const uint32_t sha224_initial_hash_value[8] = {
0xc1059ed8UL,
0x367cd507UL,
0x3070dd17UL,
};
/* Initial hash value H for SHA-256: */
-static const isc_uint32_t sha256_initial_hash_value[8] = {
+static const uint32_t sha256_initial_hash_value[8] = {
0x6a09e667UL,
0xbb67ae85UL,
0x3c6ef372UL,
#ifdef WIN32
/* Hash constant words K for SHA-384 and SHA-512: */
-static const isc_uint64_t K512[80] = {
+static const uint64_t K512[80] = {
0x428a2f98d728ae22UL, 0x7137449123ef65cdUL,
0xb5c0fbcfec4d3b2fUL, 0xe9b5dba58189dbbcUL,
0x3956c25bf348b538UL, 0x59f111f1b605d019UL,
};
/* Initial hash value H for SHA-384: */
-static const isc_uint64_t sha384_initial_hash_value[8] = {
+static const uint64_t sha384_initial_hash_value[8] = {
0xcbbb9d5dc1059ed8UL,
0x629a292a367cd507UL,
0x9159015a3070dd17UL,
};
/* Initial hash value H for SHA-512: */
-static const isc_uint64_t sha512_initial_hash_value[8] = {
+static const uint64_t sha512_initial_hash_value[8] = {
0x6a09e667f3bcc908U,
0xbb67ae8584caa73bUL,
0x3c6ef372fe94f82bUL,
};
#else
/* Hash constant words K for SHA-384 and SHA-512: */
-static const isc_uint64_t K512[80] = {
+static const uint64_t K512[80] = {
0x428a2f98d728ae22ULL, 0x7137449123ef65cdULL,
0xb5c0fbcfec4d3b2fULL, 0xe9b5dba58189dbbcULL,
0x3956c25bf348b538ULL, 0x59f111f1b605d019ULL,
};
/* Initial hash value H for SHA-384: */
-static const isc_uint64_t sha384_initial_hash_value[8] = {
+static const uint64_t sha384_initial_hash_value[8] = {
0xcbbb9d5dc1059ed8ULL,
0x629a292a367cd507ULL,
0x9159015a3070dd17ULL,
};
/* Initial hash value H for SHA-512: */
-static const isc_uint64_t sha512_initial_hash_value[8] = {
+static const uint64_t sha512_initial_hash_value[8] = {
0x6a09e667f3bcc908ULL,
0xbb67ae8584caa73bULL,
0x3c6ef372fe94f82bULL,
}
void
-isc_sha224_update(isc_sha224_t *context, const isc_uint8_t* data, size_t len) {
+isc_sha224_update(isc_sha224_t *context, const uint8_t* data, size_t len) {
isc_sha256_update((isc_sha256_t *)context, data, len);
}
void
-isc_sha224_final(isc_uint8_t digest[], isc_sha224_t *context) {
- isc_uint8_t sha256_digest[ISC_SHA256_DIGESTLENGTH];
+isc_sha224_final(uint8_t digest[], isc_sha224_t *context) {
+ uint8_t sha256_digest[ISC_SHA256_DIGESTLENGTH];
isc_sha256_final(sha256_digest, (isc_sha256_t *)context);
memmove(digest, sha256_digest, ISC_SHA224_DIGESTLENGTH);
isc_safe_memwipe(sha256_digest, sizeof(sha256_digest));
(h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
j++
-void isc_sha256_transform(isc_sha256_t *context, const isc_uint32_t* data) {
- isc_uint32_t a, b, c, d, e, f, g, h, s0, s1;
- isc_uint32_t T1, *W256;
+void isc_sha256_transform(isc_sha256_t *context, const uint32_t* data) {
+ uint32_t a, b, c, d, e, f, g, h, s0, s1;
+ uint32_t T1, *W256;
int j;
- W256 = (isc_uint32_t*)context->buffer;
+ W256 = (uint32_t*)context->buffer;
/* Initialize registers with the prev. intermediate value */
a = context->state[0];
#else /* ISC_SHA2_UNROLL_TRANSFORM */
void
-isc_sha256_transform(isc_sha256_t *context, const isc_uint32_t* data) {
- isc_uint32_t a, b, c, d, e, f, g, h, s0, s1;
- isc_uint32_t T1, T2, *W256;
+isc_sha256_transform(isc_sha256_t *context, const uint32_t* data) {
+ uint32_t a, b, c, d, e, f, g, h, s0, s1;
+ uint32_t T1, T2, *W256;
int j;
- W256 = (isc_uint32_t*)context->buffer;
+ W256 = (uint32_t*)context->buffer;
/* Initialize registers with the prev. intermediate value */
a = context->state[0];
#endif /* ISC_SHA2_UNROLL_TRANSFORM */
void
-isc_sha256_update(isc_sha256_t *context, const isc_uint8_t *data, size_t len) {
+isc_sha256_update(isc_sha256_t *context, const uint8_t *data, size_t len) {
unsigned int freespace, usedspace;
if (len == 0U) {
}
/* Sanity check: */
- REQUIRE(context != (isc_sha256_t *)0 && data != (isc_uint8_t*)0);
+ REQUIRE(context != (isc_sha256_t *)0 && data != (uint8_t*)0);
usedspace = (unsigned int)((context->bitcount >> 3) %
ISC_SHA256_BLOCK_LENGTH);
len -= freespace;
data += freespace;
isc_sha256_transform(context,
- (isc_uint32_t*)context->buffer);
+ (uint32_t*)context->buffer);
} else {
/* The buffer is not yet full */
memmove(&context->buffer[usedspace], data, len);
while (len >= ISC_SHA256_BLOCK_LENGTH) {
/* Process as many complete blocks as we can */
memmove(context->buffer, data, ISC_SHA256_BLOCK_LENGTH);
- isc_sha256_transform(context, (isc_uint32_t*)context->buffer);
+ isc_sha256_transform(context, (uint32_t*)context->buffer);
context->bitcount += ISC_SHA256_BLOCK_LENGTH << 3;
len -= ISC_SHA256_BLOCK_LENGTH;
data += ISC_SHA256_BLOCK_LENGTH;
}
void
-isc_sha256_final(isc_uint8_t digest[], isc_sha256_t *context) {
- isc_uint32_t *d = (isc_uint32_t*)digest;
+isc_sha256_final(uint8_t digest[], isc_sha256_t *context) {
+ uint32_t *d = (uint32_t*)digest;
unsigned int usedspace;
/* Sanity check: */
REQUIRE(context != (isc_sha256_t *)0);
/* If no digest buffer is passed, we don't bother doing this: */
- if (digest != (isc_uint8_t*)0) {
+ if (digest != (uint8_t*)0) {
usedspace = (unsigned int)((context->bitcount >> 3) %
ISC_SHA256_BLOCK_LENGTH);
#if BYTE_ORDER == LITTLE_ENDIAN
}
/* Do second-to-last transform: */
isc_sha256_transform(context,
- (isc_uint32_t*)context->buffer);
+ (uint32_t*)context->buffer);
/* And set-up for the last transform: */
memset(context->buffer, 0,
*context->buffer = 0x80;
}
/* Set the bit count: */
- *(isc_uint64_t*)&context->buffer[ISC_SHA256_SHORT_BLOCK_LENGTH] = context->bitcount;
+ *(uint64_t*)&context->buffer[ISC_SHA256_SHORT_BLOCK_LENGTH] = context->bitcount;
/* Final transform: */
- isc_sha256_transform(context, (isc_uint32_t*)context->buffer);
+ isc_sha256_transform(context, (uint32_t*)context->buffer);
#if BYTE_ORDER == LITTLE_ENDIAN
{
(h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \
j++
-void isc_sha512_transform(isc_sha512_t *context, const isc_uint64_t* data) {
- isc_uint64_t a, b, c, d, e, f, g, h, s0, s1;
- isc_uint64_t T1, *W512 = (isc_uint64_t*)context->buffer;
+void isc_sha512_transform(isc_sha512_t *context, const uint64_t* data) {
+ uint64_t a, b, c, d, e, f, g, h, s0, s1;
+ uint64_t T1, *W512 = (uint64_t*)context->buffer;
int j;
/* Initialize registers with the prev. intermediate value */
#else /* ISC_SHA2_UNROLL_TRANSFORM */
void
-isc_sha512_transform(isc_sha512_t *context, const isc_uint64_t* data) {
- isc_uint64_t a, b, c, d, e, f, g, h, s0, s1;
- isc_uint64_t T1, T2, *W512 = (isc_uint64_t*)context->buffer;
+isc_sha512_transform(isc_sha512_t *context, const uint64_t* data) {
+ uint64_t a, b, c, d, e, f, g, h, s0, s1;
+ uint64_t T1, T2, *W512 = (uint64_t*)context->buffer;
int j;
/* Initialize registers with the prev. intermediate value */
#endif /* ISC_SHA2_UNROLL_TRANSFORM */
-void isc_sha512_update(isc_sha512_t *context, const isc_uint8_t *data, size_t len) {
+void isc_sha512_update(isc_sha512_t *context, const uint8_t *data, size_t len) {
unsigned int freespace, usedspace;
if (len == 0U) {
}
/* Sanity check: */
- REQUIRE(context != (isc_sha512_t *)0 && data != (isc_uint8_t*)0);
+ REQUIRE(context != (isc_sha512_t *)0 && data != (uint8_t*)0);
usedspace = (unsigned int)((context->bitcount[0] >> 3) %
ISC_SHA512_BLOCK_LENGTH);
len -= freespace;
data += freespace;
isc_sha512_transform(context,
- (isc_uint64_t*)context->buffer);
+ (uint64_t*)context->buffer);
} else {
/* The buffer is not yet full */
memmove(&context->buffer[usedspace], data, len);
while (len >= ISC_SHA512_BLOCK_LENGTH) {
/* Process as many complete blocks as we can */
memmove(context->buffer, data, ISC_SHA512_BLOCK_LENGTH);
- isc_sha512_transform(context, (isc_uint64_t*)context->buffer);
+ isc_sha512_transform(context, (uint64_t*)context->buffer);
ADDINC128(context->bitcount, ISC_SHA512_BLOCK_LENGTH << 3);
len -= ISC_SHA512_BLOCK_LENGTH;
data += ISC_SHA512_BLOCK_LENGTH;
}
/* Do second-to-last transform: */
isc_sha512_transform(context,
- (isc_uint64_t*)context->buffer);
+ (uint64_t*)context->buffer);
/* And set-up for the last transform: */
memset(context->buffer, 0, ISC_SHA512_BLOCK_LENGTH - 2);
*context->buffer = 0x80;
}
/* Store the length of input data (in bits): */
- *(isc_uint64_t*)&context->buffer[ISC_SHA512_SHORT_BLOCK_LENGTH] = context->bitcount[1];
- *(isc_uint64_t*)&context->buffer[ISC_SHA512_SHORT_BLOCK_LENGTH+8] = context->bitcount[0];
+ *(uint64_t*)&context->buffer[ISC_SHA512_SHORT_BLOCK_LENGTH] = context->bitcount[1];
+ *(uint64_t*)&context->buffer[ISC_SHA512_SHORT_BLOCK_LENGTH+8] = context->bitcount[0];
/* Final transform: */
- isc_sha512_transform(context, (isc_uint64_t*)context->buffer);
+ isc_sha512_transform(context, (uint64_t*)context->buffer);
}
-void isc_sha512_final(isc_uint8_t digest[], isc_sha512_t *context) {
- isc_uint64_t *d = (isc_uint64_t*)digest;
+void isc_sha512_final(uint8_t digest[], isc_sha512_t *context) {
+ uint64_t *d = (uint64_t*)digest;
/* Sanity check: */
REQUIRE(context != (isc_sha512_t *)0);
/* If no digest buffer is passed, we don't bother doing this: */
- if (digest != (isc_uint8_t*)0) {
+ if (digest != (uint8_t*)0) {
isc_sha512_last(context);
/* Save the hash data for output: */
}
void
-isc_sha384_update(isc_sha384_t *context, const isc_uint8_t* data, size_t len) {
+isc_sha384_update(isc_sha384_t *context, const uint8_t* data, size_t len) {
isc_sha512_update((isc_sha512_t *)context, data, len);
}
void
-isc_sha384_final(isc_uint8_t digest[], isc_sha384_t *context) {
- isc_uint64_t *d = (isc_uint64_t*)digest;
+isc_sha384_final(uint8_t digest[], isc_sha384_t *context) {
+ uint64_t *d = (uint64_t*)digest;
/* Sanity check: */
REQUIRE(context != (isc_sha384_t *)0);
/* If no digest buffer is passed, we don't bother doing this: */
- if (digest != (isc_uint8_t*)0) {
+ if (digest != (uint8_t*)0) {
isc_sha512_last((isc_sha512_t *)context);
/* Save the hash data for output: */
char *
isc_sha224_end(isc_sha224_t *context, char buffer[]) {
- isc_uint8_t digest[ISC_SHA224_DIGESTLENGTH], *d = digest;
+ uint8_t digest[ISC_SHA224_DIGESTLENGTH], *d = digest;
unsigned int i;
/* Sanity check: */
}
char *
-isc_sha224_data(const isc_uint8_t *data, size_t len,
+isc_sha224_data(const uint8_t *data, size_t len,
char digest[ISC_SHA224_DIGESTSTRINGLENGTH])
{
isc_sha224_t context;
char *
isc_sha256_end(isc_sha256_t *context, char buffer[]) {
- isc_uint8_t digest[ISC_SHA256_DIGESTLENGTH], *d = digest;
+ uint8_t digest[ISC_SHA256_DIGESTLENGTH], *d = digest;
unsigned int i;
/* Sanity check: */
}
char *
-isc_sha256_data(const isc_uint8_t* data, size_t len,
+isc_sha256_data(const uint8_t* data, size_t len,
char digest[ISC_SHA256_DIGESTSTRINGLENGTH])
{
isc_sha256_t context;
char *
isc_sha512_end(isc_sha512_t *context, char buffer[]) {
- isc_uint8_t digest[ISC_SHA512_DIGESTLENGTH], *d = digest;
+ uint8_t digest[ISC_SHA512_DIGESTLENGTH], *d = digest;
unsigned int i;
/* Sanity check: */
}
char *
-isc_sha512_data(const isc_uint8_t *data, size_t len,
+isc_sha512_data(const uint8_t *data, size_t len,
char digest[ISC_SHA512_DIGESTSTRINGLENGTH])
{
isc_sha512_t context;
char *
isc_sha384_end(isc_sha384_t *context, char buffer[]) {
- isc_uint8_t digest[ISC_SHA384_DIGESTLENGTH], *d = digest;
+ uint8_t digest[ISC_SHA384_DIGESTLENGTH], *d = digest;
unsigned int i;
/* Sanity check: */
}
char *
-isc_sha384_data(const isc_uint8_t *data, size_t len,
+isc_sha384_data(const uint8_t *data, size_t len,
char digest[ISC_SHA384_DIGESTSTRINGLENGTH])
{
isc_sha384_t context;
#include <config.h>
+#include <inttypes.h>
+
#include <isc/app.h>
#include <isc/magic.h>
#include <isc/mutex.h>
}
isc_result_t
-isc_socket_permunix(isc_sockaddr_t *sockaddr, isc_uint32_t perm,
- isc_uint32_t owner, isc_uint32_t group)
+isc_socket_permunix(isc_sockaddr_t *sockaddr, uint32_t perm,
+ uint32_t owner, uint32_t group)
{
return (isc__socket_permunix(sockaddr, perm, owner, group));
}
#ifndef ISC_ATOMIC_H
#define ISC_ATOMIC_H 1
+#include <inttypes.h>
+
#include <isc/platform.h>
#include <isc/types.h>
* This routine atomically increments the value stored in 'p' by 'val', and
* returns the previous value.
*/
-static inline isc_int32_t
-isc_atomic_xadd(isc_int32_t *p, isc_int32_t val) {
- isc_int32_t prev, swapped;
+static inline int32_t
+isc_atomic_xadd(int32_t *p, int32_t val) {
+ int32_t prev, swapped;
- for (prev = *(volatile isc_int32_t *)p; ; prev = swapped) {
+ for (prev = *(volatile int32_t *)p; ; prev = swapped) {
swapped = prev + val;
__asm__ volatile(
"casa [%2] %3, %4, %0"
* This routine atomically stores the value 'val' in 'p'.
*/
static inline void
-isc_atomic_store(isc_int32_t *p, isc_int32_t val) {
- isc_int32_t prev, swapped;
+isc_atomic_store(int32_t *p, int32_t val) {
+ int32_t prev, swapped;
- for (prev = *(volatile isc_int32_t *)p; ; prev = swapped) {
+ for (prev = *(volatile int32_t *)p; ; prev = swapped) {
swapped = val;
__asm__ volatile(
"casa [%2] %3, %4, %0"
* original value is equal to 'cmpval'. The original value is returned in any
* case.
*/
-static inline isc_int32_t
-isc_atomic_cmpxchg(isc_int32_t *p, isc_int32_t cmpval, isc_int32_t val) {
- isc_int32_t temp = val;
+static inline int32_t
+isc_atomic_cmpxchg(int32_t *p, int32_t cmpval, int32_t val) {
+ int32_t temp = val;
__asm__ volatile(
"casa [%2] %3, %4, %0"
#include <config.h>
+#include <inttypes.h>
#include <string.h>
#include <isc/atomic.h>
atomic_int_fast32_t hi;
atomic_int_fast32_t lo;
#else
- isc_uint32_t hi;
- isc_uint32_t lo;
+ uint32_t hi;
+ uint32_t lo;
#endif
} isc_stat_t;
#else
#if defined(ISC_STATS_HAVESTDATOMICQ)
typedef atomic_int_fast64_t isc_stat_t;
#else
-typedef isc_uint64_t isc_stat_t;
+typedef uint64_t isc_stat_t;
#endif
#endif
* simplicity here, however, under the assumption that this function
* should be only rarely called.
*/
- isc_uint64_t *copiedcounters;
+ uint64_t *copiedcounters;
};
static isc_result_t
goto clean_mutex;
}
stats->copiedcounters = isc_mem_get(mctx,
- sizeof(isc_uint64_t) * ncounters);
+ sizeof(uint64_t) * ncounters);
if (stats->copiedcounters == NULL) {
result = ISC_R_NOMEMORY;
goto clean_counters;
static inline void
incrementcounter(isc_stats_t *stats, int counter) {
- isc_int32_t prev;
+ int32_t prev;
#if ISC_STATS_LOCKCOUNTERS
/*
prev = atomic_fetch_add_explicit(&stats->counters[counter].lo, 1,
memory_order_relaxed);
#else
- prev = isc_atomic_xadd((isc_int32_t *)&stats->counters[counter].lo, 1);
+ prev = isc_atomic_xadd((int32_t *)&stats->counters[counter].lo, 1);
#endif
/*
* If the lower 32-bit field overflows, increment the higher field.
* isc_stats_copy() is called where the whole process is protected
* by the write (exclusive) lock.
*/
- if (prev == (isc_int32_t)0xffffffff) {
+ if (prev == (int32_t)0xffffffff) {
#if defined(ISC_STATS_HAVESTDATOMIC)
atomic_fetch_add_explicit(&stats->counters[counter].hi, 1,
memory_order_relaxed);
#else
- isc_atomic_xadd((isc_int32_t *)&stats->counters[counter].hi, 1);
+ isc_atomic_xadd((int32_t *)&stats->counters[counter].hi, 1);
#endif
}
#elif ISC_STATS_HAVEATOMICQ
atomic_fetch_add_explicit(&stats->counters[counter], 1,
memory_order_relaxed);
#else
- isc_atomic_xaddq((isc_int64_t *)&stats->counters[counter], 1);
+ isc_atomic_xaddq((int64_t *)&stats->counters[counter], 1);
#endif
#else
UNUSED(prev);
static inline void
decrementcounter(isc_stats_t *stats, int counter) {
- isc_int32_t prev;
+ int32_t prev;
#if ISC_STATS_LOCKCOUNTERS
isc_rwlock_lock(&stats->counterlock, isc_rwlocktype_read);
prev = atomic_fetch_sub_explicit(&stats->counters[counter].lo, 1,
memory_order_relaxed);
#else
- prev = isc_atomic_xadd((isc_int32_t *)&stats->counters[counter].lo, -1);
+ prev = isc_atomic_xadd((int32_t *)&stats->counters[counter].lo, -1);
#endif
if (prev == 0) {
#if defined(ISC_STATS_HAVESTDATOMIC)
atomic_fetch_sub_explicit(&stats->counters[counter].hi, 1,
memory_order_relaxed);
#else
- isc_atomic_xadd((isc_int32_t *)&stats->counters[counter].hi,
+ isc_atomic_xadd((int32_t *)&stats->counters[counter].hi,
-1);
#endif
}
atomic_fetch_sub_explicit(&stats->counters[counter], 1,
memory_order_relaxed);
#else
- isc_atomic_xaddq((isc_int64_t *)&stats->counters[counter], -1);
+ isc_atomic_xaddq((int64_t *)&stats->counters[counter], -1);
#endif
#else
UNUSED(prev);
for (i = 0; i < stats->ncounters; i++) {
#if ISC_STATS_USEMULTIFIELDS
stats->copiedcounters[i] =
- (isc_uint64_t)(stats->counters[i].hi) << 32 |
+ (uint64_t)(stats->counters[i].hi) << 32 |
stats->counters[i].lo;
#elif ISC_STATS_HAVEATOMICQ
#if defined(ISC_STATS_HAVESTDATOMICQ)
#else
/* use xaddq(..., 0) as an atomic load */
stats->copiedcounters[i] =
- (isc_uint64_t)isc_atomic_xaddq((isc_int64_t *)&stats->counters[i], 0);
+ (uint64_t)isc_atomic_xaddq((int64_t *)&stats->counters[i], 0);
#endif
#else
stats->copiedcounters[i] = stats->counters[i];
}
void
-isc_stats_set(isc_stats_t *stats, isc_uint64_t val,
+isc_stats_set(isc_stats_t *stats, uint64_t val,
isc_statscounter_t counter)
{
REQUIRE(ISC_STATS_VALID(stats));
#endif
#if ISC_STATS_USEMULTIFIELDS
- stats->counters[counter].hi = (isc_uint32_t)((val >> 32) & 0xffffffff);
- stats->counters[counter].lo = (isc_uint32_t)(val & 0xffffffff);
+ stats->counters[counter].hi = (uint32_t)((val >> 32) & 0xffffffff);
+ stats->counters[counter].lo = (uint32_t)(val & 0xffffffff);
#elif ISC_STATS_HAVEATOMICQ
#if defined(ISC_STATS_HAVESTDATOMICQ)
atomic_store_explicit(&stats->counters[counter], val,
memory_order_relaxed);
#else
- isc_atomic_storeq((isc_int64_t *)&stats->counters[counter], val);
+ isc_atomic_storeq((int64_t *)&stats->counters[counter], val);
#endif
#else
stats->counters[counter] = val;
static const char digits[] = "0123456789abcdefghijklmnoprstuvwxyz";
-isc_uint64_t
+uint64_t
isc_string_touint64(char *source, char **end, int base) {
- isc_uint64_t tmp;
- isc_uint64_t overflow;
+ uint64_t tmp;
+ uint64_t overflow;
char *s = source;
const char *o;
char c;
void
isc_taskpool_gettask(isc_taskpool_t *pool, isc_task_t **targetp) {
- isc_uint32_t i;
+ uint32_t i;
isc_random_get(&i);
isc_task_attach(pool->tasks[i % pool->ntasks], targetp);
}
#include <config.h>
-#include <stdlib.h>
#include <inttypes.h>
+#include <stdlib.h>
#include <atf-c.h>
#define TASKS 32
#define ITERATIONS 1000
#define COUNTS_PER_ITERATION 1000
-#define INCREMENT_64 (isc_int64_t)0x0000000010000000
+#define INCREMENT_64 (int64_t)0x0000000010000000
#define EXPECTED_COUNT_32 (TASKS * ITERATIONS * COUNTS_PER_ITERATION)
#define EXPECTED_COUNT_64 (TASKS * ITERATIONS * COUNTS_PER_ITERATION * INCREMENT_64)
typedef struct {
- isc_uint32_t iteration;
+ uint32_t iteration;
} counter_t;
counter_t counters[TASKS];
#if defined(ISC_PLATFORM_HAVEXADD)
-static isc_int32_t counter_32;
+static int32_t counter_32;
static void
do_xadd(isc_task_t *task, isc_event_t *ev) {
#endif
#if defined(ISC_PLATFORM_HAVEXADDQ)
-static isc_int64_t counter_64;
+static int64_t counter_64;
static void
do_xaddq(isc_task_t *task, isc_event_t *ev) {
#endif
#if defined(ISC_PLATFORM_HAVEATOMICSTORE)
-static isc_int32_t store_32;
+static int32_t store_32;
static void
do_store(isc_task_t *task, isc_event_t *ev) {
counter_t *state = (counter_t *)ev->ev_arg;
int i;
- isc_uint32_t r;
- isc_uint32_t val;
+ uint32_t r;
+ uint32_t val;
r = random() % 256;
val = (r << 24) | (r << 16) | (r << 8) | r;
isc_result_t result;
isc_task_t *tasks[TASKS];
isc_event_t *event = NULL;
- isc_uint32_t val;
- isc_uint32_t r;
+ uint32_t val;
+ uint32_t r;
int i;
UNUSED(tc);
val = (r << 24) | (r << 16) | (r << 8) | r;
printf("32-bit store 0x%x, expected 0x%x\n",
- (isc_uint32_t) store_32, val);
+ (uint32_t) store_32, val);
- ATF_CHECK_EQ((isc_uint32_t) store_32, val);
+ ATF_CHECK_EQ((uint32_t) store_32, val);
store_32 = 0;
}
#endif
#if defined(ISC_PLATFORM_HAVEATOMICSTOREQ)
-static isc_int64_t store_64;
+static int64_t store_64;
static void
do_storeq(isc_task_t *task, isc_event_t *ev) {
counter_t *state = (counter_t *)ev->ev_arg;
int i;
- isc_uint8_t r;
- isc_uint64_t val;
+ uint8_t r;
+ uint64_t val;
r = random() % 256;
- val = (((isc_uint64_t) r << 24) |
- ((isc_uint64_t) r << 16) |
- ((isc_uint64_t) r << 8) |
- (isc_uint64_t) r);
- val |= ((isc_uint64_t) val << 32);
+ val = (((uint64_t) r << 24) |
+ ((uint64_t) r << 16) |
+ ((uint64_t) r << 8) |
+ (uint64_t) r);
+ val |= ((uint64_t) val << 32);
for (i = 0 ; i < COUNTS_PER_ITERATION ; i++) {
isc_atomic_storeq(&store_64, val);
isc_result_t result;
isc_task_t *tasks[TASKS];
isc_event_t *event = NULL;
- isc_uint64_t val;
- isc_uint32_t r;
+ uint64_t val;
+ uint32_t r;
int i;
UNUSED(tc);
isc_test_end();
r = store_64 & 0xff;
- val = (((isc_uint64_t) r << 24) |
- ((isc_uint64_t) r << 16) |
- ((isc_uint64_t) r << 8) |
- (isc_uint64_t) r);
- val |= ((isc_uint64_t) val << 32);
+ val = (((uint64_t) r << 24) |
+ ((uint64_t) r << 16) |
+ ((uint64_t) r << 8) |
+ (uint64_t) r);
+ val |= ((uint64_t) val << 32);
printf("64-bit store 0x%" PRIx64 ", "
"expected 0x%" PRIx64 "\n",
- (isc_uint64_t) store_64, val);
+ (uint64_t) store_64, val);
- ATF_CHECK_EQ((isc_uint64_t) store_64, val);
+ ATF_CHECK_EQ((uint64_t) store_64, val);
store_64 = 0;
}
#endif
#include <atf-c.h>
+#include <inttypes.h>
#include <stdio.h>
#include <string.h>
-#include <inttypes.h>
#include <isc/hash.h>
isc_sha1_init(&sha1);
for(i = 0; i < testcase->repeats; i++) {
isc_sha1_update(&sha1,
- (const isc_uint8_t *) testcase->input,
+ (const uint8_t *) testcase->input,
testcase->input_len);
}
isc_sha1_final(&sha1, digest);
isc_sha224_init(&sha224);
for(i = 0; i < testcase->repeats; i++) {
isc_sha224_update(&sha224,
- (const isc_uint8_t *) testcase->input,
+ (const uint8_t *) testcase->input,
testcase->input_len);
}
isc_sha224_final(digest, &sha224);
isc_sha256_init(&sha256);
for(i = 0; i < testcase->repeats; i++) {
isc_sha256_update(&sha256,
- (const isc_uint8_t *) testcase->input,
+ (const uint8_t *) testcase->input,
testcase->input_len);
}
isc_sha256_final(digest, &sha256);
isc_sha384_init(&sha384);
for(i = 0; i < testcase->repeats; i++) {
isc_sha384_update(&sha384,
- (const isc_uint8_t *) testcase->input,
+ (const uint8_t *) testcase->input,
testcase->input_len);
}
isc_sha384_final(digest, &sha384);
isc_sha512_init(&sha512);
for(i = 0; i < testcase->repeats; i++) {
isc_sha512_update(&sha512,
- (const isc_uint8_t *) testcase->input,
+ (const uint8_t *) testcase->input,
testcase->input_len);
}
isc_sha512_final(digest, &sha512);
isc_md5_init(&md5);
for(i = 0; i < testcase->repeats; i++) {
isc_md5_update(&md5,
- (const isc_uint8_t *) testcase->input,
+ (const uint8_t *) testcase->input,
testcase->input_len);
}
isc_md5_final(&md5, digest);
memmove(buffer, test_key->key, test_key->len);
isc_hmacsha1_init(&hmacsha1, buffer, test_key->len);
isc_hmacsha1_update(&hmacsha1,
- (const isc_uint8_t *) testcase->input,
+ (const uint8_t *) testcase->input,
testcase->input_len);
isc_hmacsha1_sign(&hmacsha1, digest, ISC_SHA1_DIGESTLENGTH);
tohexstr(digest, ISC_SHA1_DIGESTLENGTH, str, sizeof(str));
memmove(buffer, test_key->key, test_key->len);
isc_hmacsha224_init(&hmacsha224, buffer, test_key->len);
isc_hmacsha224_update(&hmacsha224,
- (const isc_uint8_t *) testcase->input,
+ (const uint8_t *) testcase->input,
testcase->input_len);
isc_hmacsha224_sign(&hmacsha224, digest, ISC_SHA224_DIGESTLENGTH);
tohexstr(digest, ISC_SHA224_DIGESTLENGTH, str, sizeof(str));
memmove(buffer, test_key->key, test_key->len);
isc_hmacsha256_init(&hmacsha256, buffer, test_key->len);
isc_hmacsha256_update(&hmacsha256,
- (const isc_uint8_t *) testcase->input,
+ (const uint8_t *) testcase->input,
testcase->input_len);
isc_hmacsha256_sign(&hmacsha256, digest, ISC_SHA256_DIGESTLENGTH);
tohexstr(digest, ISC_SHA256_DIGESTLENGTH, str, sizeof(str));
memmove(buffer, test_key->key, test_key->len);
isc_hmacsha384_init(&hmacsha384, buffer, test_key->len);
isc_hmacsha384_update(&hmacsha384,
- (const isc_uint8_t *) testcase->input,
+ (const uint8_t *) testcase->input,
testcase->input_len);
isc_hmacsha384_sign(&hmacsha384, digest, ISC_SHA384_DIGESTLENGTH);
tohexstr(digest, ISC_SHA384_DIGESTLENGTH, str, sizeof(str));
memmove(buffer, test_key->key, test_key->len);
isc_hmacsha512_init(&hmacsha512, buffer, test_key->len);
isc_hmacsha512_update(&hmacsha512,
- (const isc_uint8_t *) testcase->input,
+ (const uint8_t *) testcase->input,
testcase->input_len);
isc_hmacsha512_sign(&hmacsha512, digest, ISC_SHA512_DIGESTLENGTH);
tohexstr(digest, ISC_SHA512_DIGESTLENGTH, str, sizeof(str));
memmove(buffer, test_key->key, test_key->len);
isc_hmacmd5_init(&hmacmd5, buffer, test_key->len);
isc_hmacmd5_update(&hmacmd5,
- (const isc_uint8_t *) testcase->input,
+ (const uint8_t *) testcase->input,
testcase->input_len);
isc_hmacmd5_sign(&hmacmd5, digest);
tohexstr(digest, ISC_MD5_DIGESTLENGTH, str, sizeof(str));
atf_tc_set_md_var(tc, "descr", "64-bit cyclic redundancy check");
}
ATF_TC_BODY(isc_crc64, tc) {
- isc_uint64_t crc;
+ uint64_t crc;
int i;
UNUSED(tc);
isc_crc64_init(&crc);
for(i = 0; i < testcase->repeats; i++) {
isc_crc64_update(&crc,
- (const isc_uint8_t *) testcase->input,
+ (const uint8_t *) testcase->input,
testcase->input_len);
}
isc_crc64_final(&crc);
#include <atf-c.h>
+#include <inttypes.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <isc/string.h>
#include <isc/util.h>
-#include <inttypes.h>
-
static void *
default_memalloc(void *arg, size_t size) {
UNUSED(arg);
uintptr_t i;
void *v;
uintptr_t count = 10000;
- isc_uint32_t walked;
+ uint32_t walked;
unsigned char key[16];
unsigned char *tkey;
size_t tksize;
#include <config.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <time.h>
* Sleep for 'usec' microseconds.
*/
void
-isc_test_nap(isc_uint32_t usec) {
+isc_test_nap(uint32_t usec) {
#ifdef HAVE_NANOSLEEP
struct timespec ts;
#include <config.h>
+#include <inttypes.h>
+
#include <isc/buffer.h>
#include <isc/entropy.h>
#include <isc/hash.h>
isc_test_end(void);
void
-isc_test_nap(isc_uint32_t usec);
+isc_test_nap(uint32_t usec);
#include <atf-c.h>
+#include <inttypes.h>
#include <unistd.h>
#include <time.h>
}
ATF_TC_BODY(parse_overflow, tc) {
isc_result_t result;
- isc_uint32_t output;
+ uint32_t output;
UNUSED(tc);
result = isc_test_begin(NULL, ISC_TRUE, 0);
}
ATF_TC_BODY(snprintf, tc) {
char buf[10000];
- isc_uint64_t ll = 8589934592ULL;
- isc_uint64_t nn = 20000000000000ULL;
- isc_uint64_t zz = 10000000000000000000ULL;
+ uint64_t ll = 8589934592ULL;
+ uint64_t nn = 20000000000000ULL;
+ uint64_t zz = 10000000000000000000ULL;
float pi = 3.141;
int n;
size_t size;
#include <atf-c.h>
#include <stdlib.h>
-#include <stdint.h>
#include "isctest.h"
#define REPS 25000
typedef double (pvalue_func_t)(isc_mem_t *mctx,
- isc_uint16_t *values, size_t length);
+ uint16_t *values, size_t length);
/* igamc(), igam(), etc. were adapted (and cleaned up) from the Cephes
* math library:
return (ans * ax / a);
}
-static isc_int8_t scounts_table[65536];
-static isc_uint8_t bitcounts_table[65536];
+static int8_t scounts_table[65536];
+static uint8_t bitcounts_table[65536];
-static isc_int8_t
-scount_calculate(isc_uint16_t n) {
+static int8_t
+scount_calculate(uint16_t n) {
int i;
- isc_int8_t sc;
+ int8_t sc;
sc = 0;
for (i = 0; i < 16; i++) {
- isc_uint16_t lsb;
+ uint16_t lsb;
lsb = n & 1;
if (lsb != 0)
return (sc);
}
-static isc_uint8_t
-bitcount_calculate(isc_uint16_t n) {
+static uint8_t
+bitcount_calculate(uint16_t n) {
int i;
- isc_uint8_t bc;
+ uint8_t bc;
bc = 0;
for (i = 0; i < 16; i++) {
- isc_uint16_t lsb;
+ uint16_t lsb;
lsb = n & 1;
if (lsb != 0)
static void
tables_init(void) {
- isc_uint32_t i;
+ uint32_t i;
for (i = 0; i < 65536; i++) {
scounts_table[i] = scount_calculate(i);
*
* This function destroys (modifies) the data passed in bits.
*/
-static isc_uint32_t
-matrix_binaryrank(isc_uint32_t *bits, size_t rows, size_t cols) {
+static uint32_t
+matrix_binaryrank(uint32_t *bits, size_t rows, size_t cols) {
size_t i, j, k;
unsigned int rt = 0;
- isc_uint32_t rank = 0;
- isc_uint32_t tmp;
+ uint32_t rank = 0;
+ uint32_t tmp;
for (k = 0; k < rows; k++) {
i = k;
isc_mem_t *mctx = NULL;
isc_result_t result;
isc_rng_t *rng;
- isc_uint32_t m;
- isc_uint32_t j;
- isc_uint32_t histogram[11] = { 0 };
- isc_uint32_t passed;
+ uint32_t m;
+ uint32_t j;
+ uint32_t histogram[11] = { 0 };
+ uint32_t passed;
double proportion;
double p_hat;
double lower_confidence, higher_confidence;
passed = 0;
for (j = 0; j < m; j++) {
- isc_uint32_t i;
- isc_uint16_t values[REPS];
+ uint32_t i;
+ uint16_t values[REPS];
double p_value;
for (i = 0; i < REPS; i++)
* RNG test suite.
*/
static double
-monobit(isc_mem_t *mctx, isc_uint16_t *values, size_t length) {
+monobit(isc_mem_t *mctx, uint16_t *values, size_t length) {
size_t i;
- isc_int32_t scount;
- isc_uint32_t numbits;
+ int32_t scount;
+ uint32_t numbits;
double s_obs;
double p_value;
* This is the runs test taken from the NIST SP 800-22 RNG test suite.
*/
static double
-runs(isc_mem_t *mctx, isc_uint16_t *values, size_t length) {
+runs(isc_mem_t *mctx, uint16_t *values, size_t length) {
size_t i;
- isc_uint32_t bcount;
- isc_uint32_t numbits;
+ uint32_t bcount;
+ uint32_t numbits;
double pi;
double tau;
- isc_uint32_t j;
- isc_uint32_t b;
- isc_uint8_t bit_this;
- isc_uint8_t bit_prev;
- isc_uint32_t v_obs;
+ uint32_t j;
+ uint32_t b;
+ uint8_t bit_this;
+ uint8_t bit_prev;
+ uint32_t v_obs;
double numer;
double denom;
double p_value;
* test suite.
*/
static double
-blockfrequency(isc_mem_t *mctx, isc_uint16_t *values, size_t length) {
- isc_uint32_t i;
- isc_uint32_t numbits;
- isc_uint32_t mbits;
- isc_uint32_t mwords;
- isc_uint32_t numblocks;
+blockfrequency(isc_mem_t *mctx, uint16_t *values, size_t length) {
+ uint32_t i;
+ uint32_t numbits;
+ uint32_t mbits;
+ uint32_t mwords;
+ uint32_t numblocks;
double *pi;
double chi_square;
double p_value;
ATF_REQUIRE(pi != NULL);
for (i = 0; i < numblocks; i++) {
- isc_uint32_t j;
+ uint32_t j;
pi[i] = 0.0;
for (j = 0; j < mwords; j++) {
- isc_uint32_t idx;
+ uint32_t idx;
idx = i * mwords + j;
pi[i] += bitcounts_table[values[idx]];
* test suite.
*/
static double
-binarymatrixrank(isc_mem_t *mctx, isc_uint16_t *values, size_t length) {
- isc_uint32_t i;
+binarymatrixrank(isc_mem_t *mctx, uint16_t *values, size_t length) {
+ uint32_t i;
size_t matrix_m;
size_t matrix_q;
- isc_uint32_t num_matrices;
+ uint32_t num_matrices;
size_t numbits;
- isc_uint32_t fm_0;
- isc_uint32_t fm_1;
- isc_uint32_t fm_rest;
+ uint32_t fm_0;
+ uint32_t fm_1;
+ uint32_t fm_rest;
double term1;
double term2;
double term3;
fm_rest = 0;
for (i = 0; i < num_matrices; i++) {
/*
- * Each isc_uint32_t supplies 32 bits, so a 32x32 bit matrix
- * takes up isc_uint32_t array of size 32.
+ * Each uint32_t supplies 32 bits, so a 32x32 bit matrix
+ * takes up uint32_t array of size 32.
*/
- isc_uint32_t bits[32];
+ uint32_t bits[32];
int j;
- isc_uint32_t rank;
+ uint32_t rank;
for (j = 0; j < 32; j++) {
size_t idx;
- isc_uint32_t r1;
- isc_uint32_t r2;
+ uint32_t r1;
+ uint32_t r2;
idx = i * ((matrix_m * matrix_q) / 16);
idx += j * 2;
#include <sys/types.h>
#include <stddef.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
if (result != ISC_R_SUCCESS)
tvp = NULL;
else {
- isc_uint64_t us;
+ uint64_t us;
TIME_NOW(&now);
us = isc_time_microdiff(&when, &now);
#include "../entropy.c"
static unsigned int
-get_from_filesource(isc_entropysource_t *source, isc_uint32_t desired) {
+get_from_filesource(isc_entropysource_t *source, uint32_t desired) {
isc_entropy_t *ent = source->ent;
unsigned char buf[128];
int fd = source->sources.file.handle;
}
static unsigned int
-get_from_usocketsource(isc_entropysource_t *source, isc_uint32_t desired) {
+get_from_usocketsource(isc_entropysource_t *source, uint32_t desired) {
isc_entropy_t *ent = source->ent;
unsigned char buf[128];
int fd = source->sources.usocket.handle;
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <time.h> /* Required for utimes on some platforms. */
#include <unistd.h> /* Required for mkstemp on NetBSD. */
* we can at least cast to signed so the IRIX compiler shuts up.
*/
times[0].tv_usec = times[1].tv_usec =
- (isc_int32_t)(isc_time_nanoseconds(when) / 1000);
+ (int32_t)(isc_time_nanoseconds(when) / 1000);
if (utimes(file, times) < 0)
return (isc__errno2result(errno));
x = cp--;
while (cp >= templet && *cp == 'X') {
- isc_uint32_t which;
+ uint32_t which;
isc_random_get(&which);
*cp = alphnum[which % (sizeof(alphnum) - 1)];
x = cp--;
while (cp >= templet && *cp == 'X') {
- isc_uint32_t which;
+ uint32_t which;
isc_random_get(&which);
*cp = alphnum[which % (sizeof(alphnum) - 1)];
* and 19.16.
*/
+#include <config.h>
+
+#include <inttypes.h>
+
#include <sys/param.h>
#include <sys/sysctl.h>
VERSION=@BIND9_VERSION@
-HEADERS = dir.h int.h keyboard.h net.h netdb.h offset.h stat.h \
+HEADERS = dir.h keyboard.h net.h netdb.h offset.h stat.h \
stdtime.h strerror.h syslog.h time.h
SUBDIRS =
+++ /dev/null
-/*
- * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * See the COPYRIGHT file distributed with this work for additional
- * information regarding copyright ownership.
- */
-
-/* $Id: int.h,v 1.16 2007/06/19 23:47:19 tbox Exp $ */
-
-#ifndef ISC_INT_H
-#define ISC_INT_H 1
-
-/*! \file */
-
-typedef signed char isc_int8_t;
-typedef unsigned char isc_uint8_t;
-typedef short isc_int16_t;
-typedef unsigned short isc_uint16_t;
-typedef int isc_int32_t;
-typedef unsigned int isc_uint32_t;
-typedef long long isc_int64_t;
-typedef unsigned long long isc_uint64_t;
-
-#define ISC_INT8_MIN -128
-#define ISC_INT8_MAX 127
-#define ISC_UINT8_MAX 255
-
-#define ISC_INT16_MIN -32768
-#define ISC_INT16_MAX 32767
-#define ISC_UINT16_MAX 65535
-
-/*%
- * Note that "int" is 32 bits on all currently supported Unix-like operating
- * systems, but "long" can be either 32 bits or 64 bits, thus the 32 bit
- * constants are not qualified with "L".
- */
-#define ISC_INT32_MIN -2147483648
-#define ISC_INT32_MAX 2147483647
-#define ISC_UINT32_MAX 4294967295U
-
-#define ISC_INT64_MIN -9223372036854775808LL
-#define ISC_INT64_MAX 9223372036854775807LL
-#define ISC_UINT64_MAX 18446744073709551615ULL
-
-#endif /* ISC_INT_H */
***/
#include <isc/platform.h>
+#include <inttypes.h>
+
#include <sys/types.h>
#include <sys/socket.h> /* Contractual promise. */
#ifndef ISC_PLATFORM_HAVESOCKADDRSTORAGE
#define _SS_MAXSIZE 128
-#define _SS_ALIGNSIZE (sizeof (isc_uint64_t))
+#define _SS_ALIGNSIZE (sizeof (uint64_t))
#ifdef ISC_PLATFORM_HAVESALEN
-#define _SS_PAD1SIZE (_SS_ALIGNSIZE - (2 * sizeof(isc_uint8_t)))
+#define _SS_PAD1SIZE (_SS_ALIGNSIZE - (2 * sizeof(uint8_t)))
#define _SS_PAD2SIZE (_SS_MAXSIZE - (_SS_ALIGNSIZE + _SS_PAD1SIZE \
- + 2 * sizeof(isc_uint8_t)))
+ + 2 * sizeof(uint8_t)))
#else
-#define _SS_PAD1SIZE (_SS_ALIGNSIZE - sizeof(isc_uint16_t))
+#define _SS_PAD1SIZE (_SS_ALIGNSIZE - sizeof(uint16_t))
#define _SS_PAD2SIZE (_SS_MAXSIZE - (_SS_ALIGNSIZE + _SS_PAD1SIZE \
- + sizeof(isc_uint16_t)))
+ + sizeof(uint16_t)))
#endif
struct sockaddr_storage {
#ifdef ISC_PLATFORM_HAVESALEN
- isc_uint8_t ss_len;
- isc_uint8_t ss_family;
+ uint8_t ss_len;
+ uint8_t ss_family;
#else
- isc_uint16_t ss_family;
+ uint16_t ss_family;
#endif
char __ss_pad1[_SS_PAD1SIZE];
- isc_uint64_t __ss_align; /* field to force desired structure */
+ uint64_t __ss_align; /* field to force desired structure */
char __ss_pad2[_SS_PAD2SIZE];
};
#endif
/*%
* Ensure type in_port_t is defined.
*/
-typedef isc_uint16_t in_port_t;
+typedef uint16_t in_port_t;
#endif
#ifndef MSG_TRUNC
#endif
/*% IP address. */
-#define ISC__IPADDR(x) ((isc_uint32_t)htonl((isc_uint32_t)(x)))
+#define ISC__IPADDR(x) ((uint32_t)htonl((uint32_t)(x)))
/*% Is IP address multicast? */
#define ISC_IPADDR_ISMULTICAST(i) \
- (((isc_uint32_t)(i) & ISC__IPADDR(0xf0000000)) \
+ (((uint32_t)(i) & ISC__IPADDR(0xf0000000)) \
== ISC__IPADDR(0xe0000000))
#define ISC_IPADDR_ISEXPERIMENTAL(i) \
- (((isc_uint32_t)(i) & ISC__IPADDR(0xf0000000)) \
+ (((uint32_t)(i) & ISC__IPADDR(0xf0000000)) \
== ISC__IPADDR(0xf0000000))
/***
/*! \file */
#include <isc/lang.h>
-#include <isc/int.h>
+#include <inttypes.h>
/*%
* It's public information that 'isc_stdtime_t' is an unsigned integral type.
* Applications that want maximum portability should not assume anything
* about its size.
*/
-typedef isc_uint32_t isc_stdtime_t;
+typedef uint32_t isc_stdtime_t;
/* but this flag helps... */
#define STDTIME_ON_32BITS 1
* type should only be used as an opaque integer (e.g.,) to compare two
* time values.
*/
-typedef isc_uint32_t isc_stdtime32_t;
+typedef uint32_t isc_stdtime32_t;
ISC_LANG_BEGINDECLS
/* */
/*! \file */
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <isc/types.h>
* The interval is larger than the time since the epoch.
*/
-isc_uint64_t
+uint64_t
isc_time_microdiff(const isc_time_t *t1, const isc_time_t *t2);
/*%<
* Find the difference in microseconds between time t1 and time t2.
*\li The difference of t1 - t2, or 0 if t1 <= t2.
*/
-isc_uint32_t
+uint32_t
isc_time_seconds(const isc_time_t *t);
/*%<
* Return the number of seconds since the epoch stored in a time structure.
*\li Out of range
*/
-isc_uint32_t
+uint32_t
isc_time_nanoseconds(const isc_time_t *t);
/*%<
* Return the number of nanoseconds stored in a time structure.
#endif
#include <stdio.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
* we only consider unicast link-local addresses.
*/
if (IN6_IS_ADDR_LINKLOCAL(&sa6->sin6_addr)) {
- isc_uint16_t zone16;
+ uint16_t zone16;
memmove(&zone16, &sa6->sin6_addr.s6_addr[2],
sizeof(zone16));
if (zone16 != 0) {
/* the zone ID is embedded */
isc_netaddr_setzone(dst,
- (isc_uint32_t)zone16);
+ (uint32_t)zone16);
dst->type.in6.s6_addr[2] = 0;
dst->type.in6.s6_addr[3] = 0;
#ifdef ISC_PLATFORM_HAVEIFNAMETOINDEX
zone = if_nametoindex(ifname);
if (zone != 0) {
isc_netaddr_setzone(dst,
- (isc_uint32_t)zone);
+ (uint32_t)zone);
}
#endif
}
isc_netaddr_fromin6(&iter->current.address, &addr6);
if (isc_netaddr_islinklocal(&iter->current.address)) {
isc_netaddr_setzone(&iter->current.address,
- (isc_uint32_t)ifindex);
+ (uint32_t)ifindex);
}
for (i = 0; i < 16; i++) {
if (prefix > 8) {
#include <config.h>
#include <isc/meminfo.h>
+#include <inttypes.h>
#include <unistd.h>
#ifdef HAVE_SYS_SYSCTL_H
#include <sys/sysctl.h>
#endif
-isc_uint64_t
+uint64_t
isc_meminfo_totalphys(void) {
#if defined(CTL_HW) && (defined(HW_PHYSMEM64) || defined(HW_MEMSIZE))
int mib[2];
#elif defined(HW_PHYSMEM64)
mib[1] = HW_PHYSMEM64;
#endif
- isc_uint64_t size = 0;
+ uint64_t size = 0;
size_t len = sizeof(size);
if (sysctl(mib, 2, &size, &len, NULL, 0) == 0)
return (size);
#include <config.h>
+#include <inttypes.h>
+
#include <sys/types.h>
#include <sys/time.h> /* Required on some systems for <sys/resource.h>. */
#include <sys/resource.h>
#include <config.h>
+#include <inttypes.h>
+#include <stdbool.h>
+
#include <sys/param.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
-#include <inttypes.h>
#include <isc/buffer.h>
#include <isc/bufferlist.h>
void
isc__socket_cleanunix(isc_sockaddr_t *sockaddr, isc_boolean_t active);
isc_result_t
-isc__socket_permunix(isc_sockaddr_t *sockaddr, isc_uint32_t perm,
- isc_uint32_t owner, isc_uint32_t group);
+isc__socket_permunix(isc_sockaddr_t *sockaddr, uint32_t perm,
+ uint32_t owner, uint32_t group);
isc_result_t
isc__socket_bind(isc_socket_t *sock, isc_sockaddr_t *sockaddr,
unsigned int options);
#endif /* USE_WATCHER_THREAD */
void
-isc__socketmgr_setreserved(isc_socketmgr_t *manager0, isc_uint32_t reserved) {
+isc__socketmgr_setreserved(isc_socketmgr_t *manager0, uint32_t reserved) {
isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
REQUIRE(VALID_MANAGER(manager));
}
isc_result_t
-isc__socket_permunix(isc_sockaddr_t *sockaddr, isc_uint32_t perm,
- isc_uint32_t owner, isc_uint32_t group)
+isc__socket_permunix(isc_sockaddr_t *sockaddr, uint32_t perm,
+ uint32_t owner, uint32_t group)
{
#ifdef ISC_PLATFORM_HAVESYSUNH
isc_result_t result = ISC_R_SUCCESS;
#include <errno.h>
#include <limits.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <syslog.h>
#include <time.h>
return (ISC_R_SUCCESS);
}
-isc_uint64_t
+uint64_t
isc_time_microdiff(const isc_time_t *t1, const isc_time_t *t2) {
- isc_uint64_t i1, i2, i3;
+ uint64_t i1, i2, i3;
REQUIRE(t1 != NULL && t2 != NULL);
INSIST(t1->nanoseconds < NS_PER_S && t2->nanoseconds < NS_PER_S);
- i1 = (isc_uint64_t)t1->seconds * NS_PER_S + t1->nanoseconds;
- i2 = (isc_uint64_t)t2->seconds * NS_PER_S + t2->nanoseconds;
+ i1 = (uint64_t)t1->seconds * NS_PER_S + t1->nanoseconds;
+ i2 = (uint64_t)t2->seconds * NS_PER_S + t2->nanoseconds;
if (i1 <= i2)
return (0);
return (i3);
}
-isc_uint32_t
+uint32_t
isc_time_seconds(const isc_time_t *t) {
REQUIRE(t != NULL);
INSIST(t->nanoseconds < NS_PER_S);
- return ((isc_uint32_t)t->seconds);
+ return ((uint32_t)t->seconds);
}
isc_result_t
*/
seconds = (time_t)t->seconds;
- INSIST(sizeof(unsigned int) == sizeof(isc_uint32_t));
- INSIST(sizeof(time_t) >= sizeof(isc_uint32_t));
+ INSIST(sizeof(unsigned int) == sizeof(uint32_t));
+ INSIST(sizeof(time_t) >= sizeof(uint32_t));
if (t->seconds > (~0U>>1) && seconds <= (time_t)(~0U>>1))
return (ISC_R_RANGE);
return (ISC_R_SUCCESS);
}
-isc_uint32_t
+uint32_t
isc_time_nanoseconds(const isc_time_t *t) {
REQUIRE(t != NULL);
ENSURE(t->nanoseconds < NS_PER_S);
- return ((isc_uint32_t)t->nanoseconds);
+ return ((uint32_t)t->nanoseconds);
}
void
#include <config.h>
+#include <inttypes.h>
+
#include <isc/condition.h>
#include <isc/assertions.h>
#include <isc/util.h>
isc_condition_waituntil(isc_condition_t *cond, isc_mutex_t *mutex,
isc_time_t *t) {
DWORD milliseconds;
- isc_uint64_t microseconds;
+ uint64_t microseconds;
isc_time_t now;
if (isc_time_now(&now) != ISC_R_SUCCESS) {
#include "../entropy.c"
static unsigned int
-get_from_filesource(isc_entropysource_t *source, isc_uint32_t desired) {
+get_from_filesource(isc_entropysource_t *source, uint32_t desired) {
isc_entropy_t *ent = source->ent;
unsigned char buf[128];
HCRYPTPROV hcryptprov = source->sources.file.handle;
(unsigned int)ndesired,
(unsigned int)ndesired * 8);
added += (unsigned int)ndesired * 8;
- desired -= (isc_uint32_t)ndesired;
+ desired -= (uint32_t)ndesired;
}
out:
trv++;
/* extra X's get set to 0's */
while (*--trv == 'X') {
- isc_uint32_t which;
+ uint32_t which;
isc_random_get(&which);
*trv = alphnum[which % (sizeof(alphnum) - 1)];
VERSION=@BIND9_VERSION@
-HEADERS = dir.h int.h keyboard.h mutex.h net.h netdb.h once.h \
+HEADERS = dir.h keyboard.h mutex.h net.h netdb.h once.h \
stat.h stdtime.h thread.h time.h
SUBDIRS =
#ifndef ISC_ATOMIC_H
#define ISC_ATOMIC_H 1
-#include <config.h>
+#include <inttypes.h>
+
#include <isc/platform.h>
#include <isc/types.h>
* returns the previous value.
*/
#ifdef ISC_PLATFORM_HAVEXADD
-static __inline isc_int32_t
-isc_atomic_xadd(isc_int32_t *p, isc_int32_t val) {
- return (isc_int32_t) _InterlockedExchangeAdd((long *)p, (long)val);
+static __inline int32_t
+isc_atomic_xadd(int32_t *p, int32_t val) {
+ return (int32_t) _InterlockedExchangeAdd((long *)p, (long)val);
}
#endif
#ifdef ISC_PLATFORM_HAVEXADDQ
-static __inline isc_int64_t
-isc_atomic_xaddq(isc_int64_t *p, isc_int64_t val) {
- return (isc_int64_t) _InterlockedExchangeAdd64((__int64 *)p,
+static __inline int64_t
+isc_atomic_xaddq(int64_t *p, int64_t val) {
+ return (int64_t) _InterlockedExchangeAdd64((__int64 *)p,
(__int64) val);
}
#endif
*/
#ifdef ISC_PLATFORM_HAVEATOMICSTORE
static __inline void
-isc_atomic_store(isc_int32_t *p, isc_int32_t val) {
+isc_atomic_store(int32_t *p, int32_t val) {
(void) _InterlockedExchange((long *)p, (long)val);
}
#endif
*/
#ifdef ISC_PLATFORM_HAVEATOMICSTOREQ
static __inline void
-isc_atomic_storeq(isc_int64_t *p, isc_int64_t val) {
+isc_atomic_storeq(int64_t *p, int64_t val) {
(void) _InterlockedExchange64((__int64 *)p, (__int64)val);
}
#endif
* case.
*/
#ifdef ISC_PLATFORM_HAVECMPXCHG
-static __inline isc_int32_t
-isc_atomic_cmpxchg(isc_int32_t *p, isc_int32_t cmpval, isc_int32_t val) {
+static __inline int32_t
+isc_atomic_cmpxchg(int32_t *p, int32_t cmpval, int32_t val) {
/* beware: swap arguments */
- return (isc_int32_t) _InterlockedCompareExchange((long *)p,
+ return (int32_t) _InterlockedCompareExchange((long *)p,
(long)val,
(long)cmpval);
}
+++ /dev/null
-/*
- * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * See the COPYRIGHT file distributed with this work for additional
- * information regarding copyright ownership.
- */
-
-/* $Id: int.h,v 1.13 2007/06/19 23:47:20 tbox Exp $ */
-
-#ifndef ISC_INT_H
-#define ISC_INT_H 1
-
-#define _INTEGRAL_MAX_BITS 64
-#include <limits.h>
-
-typedef __int8 isc_int8_t;
-typedef unsigned __int8 isc_uint8_t;
-typedef __int16 isc_int16_t;
-typedef unsigned __int16 isc_uint16_t;
-typedef __int32 isc_int32_t;
-typedef unsigned __int32 isc_uint32_t;
-typedef __int64 isc_int64_t;
-typedef unsigned __int64 isc_uint64_t;
-
-#define ISC_INT8_MIN -128
-#define ISC_INT8_MAX 127
-#define ISC_UINT8_MAX 255
-
-#define ISC_INT16_MIN -32768
-#define ISC_INT16_MAX 32767
-#define ISC_UINT16_MAX 65535
-
-/*
- * Note that "int" is 32 bits on all currently supported Unix-like operating
- * systems, but "long" can be either 32 bits or 64 bits, thus the 32 bit
- * constants are not qualified with "L".
- */
-#define ISC_INT32_MIN _I32_MIN
-#define ISC_INT32_MAX _I32_MAX
-#define ISC_UINT32_MAX _UI32_MAX
-
-#define ISC_INT64_MIN _I64_MIN
-#define ISC_INT64_MAX _I64_MAX
-#define ISC_UINT64_MAX _UI64_MAX
-
-#endif /* ISC_INT_H */
/***
*** Imports.
***/
+#include <inttypes.h>
+
#include <isc/platform.h>
/*
* Ensure type in_port_t is defined.
*/
#ifdef ISC_PLATFORM_NEEDPORTT
-typedef isc_uint16_t in_port_t;
+typedef uint16_t in_port_t;
#endif
/*
#define ISC_PLATFORM_RECVOVERFLOW
#endif
-#define ISC__IPADDR(x) ((isc_uint32_t)htonl((isc_uint32_t)(x)))
+#define ISC__IPADDR(x) ((uint32_t)htonl((uint32_t)(x)))
#define ISC_IPADDR_ISMULTICAST(i) \
- (((isc_uint32_t)(i) & ISC__IPADDR(0xf0000000)) \
+ (((uint32_t)(i) & ISC__IPADDR(0xf0000000)) \
== ISC__IPADDR(0xe0000000))
#define ISC_IPADDR_ISEXPERIMENTAL(i) \
- (((isc_uint32_t)(i) & ISC__IPADDR(0xf0000000)) \
+ (((uint32_t)(i) & ISC__IPADDR(0xf0000000)) \
== ISC__IPADDR(0xf0000000))
/*
#define ISC_STDTIME_H 1
#include <isc/lang.h>
-#include <isc/int.h>
+#include <inttypes.h>
/*
* It's public information that 'isc_stdtime_t' is an unsigned integral type.
* Applications that want maximum portability should not assume anything
* about its size.
*/
-typedef isc_uint32_t isc_stdtime_t;
+typedef uint32_t isc_stdtime_t;
/* but this flag helps... */
#define STDTIME_ON_32BITS 1
* type should only be used as an opaque integer (e.g.,) to compare two
* time values.
*/
-typedef isc_uint32_t isc_stdtime32_t;
+typedef uint32_t isc_stdtime32_t;
ISC_LANG_BEGINDECLS
#ifndef ISC_TIME_H
#define ISC_TIME_H 1
+#include <inttypes.h>
#include <windows.h>
#include <isc/lang.h>
* The contents are exposed only to allow callers to avoid dynamic allocation.
*/
struct isc_interval {
- isc_int64_t interval;
+ int64_t interval;
};
LIBISC_EXTERNAL_DATA extern const isc_interval_t * const isc_interval_zero;
* The interval is larger than the time since the epoch.
*/
-isc_uint64_t
+uint64_t
isc_time_microdiff(const isc_time_t *t1, const isc_time_t *t2);
/*
* Find the difference in milliseconds between time t1 and time t2.
*\li 'buf' and 't' are not NULL.
*/
-isc_uint32_t
+uint32_t
isc_time_nanoseconds(const isc_time_t *t);
/*
* Return the number of nanoseconds stored in a time structure.
*
*/
-isc_uint32_t
+uint32_t
isc_time_seconds(const isc_time_t *t);
/*%<
* Return the number of seconds since the epoch stored in a time structure.
<ClInclude Include="include\isc\dir.h">
<Filter>Win32 Header Files</Filter>
</ClInclude>
- <ClInclude Include="include\isc\int.h">
- <Filter>Win32 Header Files</Filter>
- </ClInclude>
<ClInclude Include="include\isc\ipv6.h">
<Filter>Win32 Header Files</Filter>
</ClInclude>
<ClInclude Include="include\isc\bind_registry.h" />
<ClInclude Include="include\isc\condition.h" />
<ClInclude Include="include\isc\dir.h" />
- <ClInclude Include="include\isc\int.h" />
<ClInclude Include="include\isc\ipv6.h" />
<ClInclude Include="include\isc\keyboard.h" />
<ClInclude Include="include\isc\mutex.h" />
#include <config.h>
+#include <inttypes.h>
#include <windows.h>
#include <isc/meminfo.h>
-isc_uint64_t
+uint64_t
isc_meminfo_totalphys(void) {
MEMORYSTATUSEX statex;
statex.dwLength = sizeof(statex);
GlobalMemoryStatusEx(&statex);
- return ((isc_uint64_t)statex.ullTotalPhys);
+ return ((uint64_t)statex.ullTotalPhys);
}
#include <errno.h>
#include <stddef.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
}
isc_result_t
-isc__socket_permunix(isc_sockaddr_t *addr, isc_uint32_t perm,
- isc_uint32_t owner, isc_uint32_t group)
+isc__socket_permunix(isc_sockaddr_t *addr, uint32_t perm,
+ uint32_t owner, uint32_t group)
{
UNUSED(addr);
UNUSED(perm);
}
void
-isc__socketmgr_setreserved(isc_socketmgr_t *manager, isc_uint32_t reserved) {
+isc__socketmgr_setreserved(isc_socketmgr_t *manager, uint32_t reserved) {
UNUSED(manager);
UNUSED(reserved);
}
#include <errno.h>
#include <limits.h>
#include <stddef.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
return (ISC_R_SUCCESS);
}
-isc_uint64_t
+uint64_t
isc_time_microdiff(const isc_time_t *t1, const isc_time_t *t2) {
ULARGE_INTEGER i1, i2;
LONGLONG i3;
return (i3);
}
-isc_uint32_t
+uint32_t
isc_time_seconds(const isc_time_t *t) {
SYSTEMTIME epoch1970 = { 1970, 1, 4, 1, 0, 0, 0, 0 };
FILETIME temp;
i3 = (i1.QuadPart - i2.QuadPart) / 10000000;
- return ((isc_uint32_t)i3);
+ return ((uint32_t)i3);
}
isc_result_t
seconds = (time_t)isc_time_seconds(t);
- INSIST(sizeof(unsigned int) == sizeof(isc_uint32_t));
- INSIST(sizeof(time_t) >= sizeof(isc_uint32_t));
+ INSIST(sizeof(unsigned int) == sizeof(uint32_t));
+ INSIST(sizeof(time_t) >= sizeof(uint32_t));
if (isc_time_seconds(t) > (~0U>>1) && seconds <= (time_t)(~0U>>1))
return (ISC_R_RANGE);
}
-isc_uint32_t
+uint32_t
isc_time_nanoseconds(const isc_time_t *t) {
ULARGE_INTEGER i;
i.LowPart = t->absolute.dwLowDateTime;
i.HighPart = t->absolute.dwHighDateTime;
- return ((isc_uint32_t)(i.QuadPart % 10000000) * 100);
+ return ((uint32_t)(i.QuadPart % 10000000) * 100);
}
void
#ifndef ISC_ATOMIC_H
#define ISC_ATOMIC_H 1
+#include <inttypes.h>
+
#include <isc/platform.h>
#include <isc/types.h>
* This routine atomically increments the value stored in 'p' by 'val', and
* returns the previous value.
*/
-static __inline__ isc_int32_t
-isc_atomic_xadd(isc_int32_t *p, isc_int32_t val) {
- isc_int32_t prev = val;
+static __inline__ int32_t
+isc_atomic_xadd(int32_t *p, int32_t val) {
+ int32_t prev = val;
__asm__ volatile(
#ifdef ISC_PLATFORM_USETHREADS
}
#ifdef ISC_PLATFORM_HAVEXADDQ
-static __inline__ isc_int64_t
-isc_atomic_xaddq(isc_int64_t *p, isc_int64_t val) {
- isc_int64_t prev = val;
+static __inline__ int64_t
+isc_atomic_xaddq(int64_t *p, int64_t val) {
+ int64_t prev = val;
__asm__ volatile(
#ifdef ISC_PLATFORM_USETHREADS
* This routine atomically stores the value 'val' in 'p' (32-bit version).
*/
static __inline__ void
-isc_atomic_store(isc_int32_t *p, isc_int32_t val) {
+isc_atomic_store(int32_t *p, int32_t val) {
__asm__ volatile(
#ifdef ISC_PLATFORM_USETHREADS
/*
* This routine atomically stores the value 'val' in 'p' (64-bit version).
*/
static __inline__ void
-isc_atomic_storeq(isc_int64_t *p, isc_int64_t val) {
+isc_atomic_storeq(int64_t *p, int64_t val) {
__asm__ volatile(
#ifdef ISC_PLATFORM_USETHREADS
/*
* original value is equal to 'cmpval'. The original value is returned in any
* case.
*/
-static __inline__ isc_int32_t
-isc_atomic_cmpxchg(isc_int32_t *p, isc_int32_t cmpval, isc_int32_t val) {
+static __inline__ int32_t
+isc_atomic_cmpxchg(int32_t *p, int32_t cmpval, int32_t val) {
__asm__ volatile(
#ifdef ISC_PLATFORM_USETHREADS
"lock;"
* positions of the stack frame, which would not actually point to the
* intended address in the embedded mnemonic.
*/
-static isc_int32_t
-isc_atomic_xadd(isc_int32_t *p, isc_int32_t val) {
+static int32_t
+isc_atomic_xadd(int32_t *p, int32_t val) {
(void)(p);
(void)(val);
}
static void
-isc_atomic_store(isc_int32_t *p, isc_int32_t val) {
+isc_atomic_store(int32_t *p, int32_t val) {
(void)(p);
(void)(val);
);
}
-static isc_int32_t
-isc_atomic_cmpxchg(isc_int32_t *p, isc_int32_t cmpval, isc_int32_t val) {
+static int32_t
+isc_atomic_cmpxchg(int32_t *p, int32_t cmpval, int32_t val) {
(void)(p);
(void)(cmpval);
(void)(val);
#ifndef ISC_ATOMIC_H
#define ISC_ATOMIC_H 1
+#include <inttypes.h>
+
#include <isc/platform.h>
#include <isc/types.h>
* intended address or value in the embedded mnemonic.
*/
-static isc_int32_t
-isc_atomic_xadd(isc_int32_t *p, isc_int32_t val) {
+static int32_t
+isc_atomic_xadd(int32_t *p, int32_t val) {
(void)(p);
(void)(val);
}
#ifdef ISC_PLATFORM_HAVEXADDQ
-static isc_int64_t
-isc_atomic_xaddq(isc_int64_t *p, isc_int64_t val) {
+static int64_t
+isc_atomic_xaddq(int64_t *p, int64_t val) {
(void)(p);
(void)(val);
#endif
static void
-isc_atomic_store(isc_int32_t *p, isc_int32_t val) {
+isc_atomic_store(int32_t *p, int32_t val) {
(void)(p);
(void)(val);
#ifdef ISC_PLATFORM_HAVEATOMICSTOREQ
static void
-isc_atomic_storeq(isc_int64_t *p, isc_int64_t val) {
+isc_atomic_storeq(int64_t *p, int64_t val) {
(void)(p);
(void)(val);
}
#endif
-static isc_int32_t
-isc_atomic_cmpxchg(isc_int32_t *p, isc_int32_t cmpval, isc_int32_t val) {
+static int32_t
+isc_atomic_cmpxchg(int32_t *p, int32_t cmpval, int32_t val) {
(void)(p);
(void)(cmpval);
(void)(val);
#include <config.h>
#include <stdio.h>
+#include <inttypes.h>
#include <string.h>
#include <errno.h>
result = isc_buffer_reserve(buffer, 1 + len);
if (result != ISC_R_SUCCESS)
return (ISC_R_NOSPACE);
- isc_buffer_putuint8(*buffer, (isc_uint8_t)len);
+ isc_buffer_putuint8(*buffer, (uint8_t)len);
isc_buffer_putmem(*buffer, (const unsigned char *) ks, len);
/*
* Emit the value.
static isc_result_t
sign(unsigned char *data, unsigned int length, unsigned char *hmac,
- isc_uint32_t algorithm, isccc_region_t *secret)
+ uint32_t algorithm, isccc_region_t *secret)
{
union {
#ifndef PK11_MD5_DISABLE
isc_result_t
isccc_cc_towire(isccc_sexpr_t *alist, isc_buffer_t **buffer,
- isc_uint32_t algorithm, isccc_region_t *secret)
+ uint32_t algorithm, isccc_region_t *secret)
{
unsigned int hmac_base, signed_base;
isc_result_t result;
static isc_result_t
verify(isccc_sexpr_t *alist, unsigned char *data, unsigned int length,
- isc_uint32_t algorithm, isccc_region_t *secret)
+ uint32_t algorithm, isccc_region_t *secret)
{
union {
#ifndef PK11_MD5_DISABLE
{
isccc_region_t *region;
unsigned char *value;
- isc_uint32_t valalg;
+ uint32_t valalg;
region = isccc_sexpr_tobinary(hmac);
static isc_result_t
table_fromwire(isccc_region_t *source, isccc_region_t *secret,
- isc_uint32_t algorithm, isccc_sexpr_t **alistp);
+ uint32_t algorithm, isccc_sexpr_t **alistp);
static isc_result_t
list_fromwire(isccc_region_t *source, isccc_sexpr_t **listp);
static isc_result_t
value_fromwire(isccc_region_t *source, isccc_sexpr_t **valuep) {
unsigned int msgtype;
- isc_uint32_t len;
+ uint32_t len;
isccc_sexpr_t *value;
isccc_region_t active;
isc_result_t result;
static isc_result_t
table_fromwire(isccc_region_t *source, isccc_region_t *secret,
- isc_uint32_t algorithm, isccc_sexpr_t **alistp)
+ uint32_t algorithm, isccc_sexpr_t **alistp)
{
char key[256];
- isc_uint32_t len;
+ uint32_t len;
isc_result_t result;
isccc_sexpr_t *alist, *value;
isc_boolean_t first_tag;
isc_result_t
isccc_cc_fromwire(isccc_region_t *source, isccc_sexpr_t **alistp,
- isc_uint32_t algorithm, isccc_region_t *secret)
+ uint32_t algorithm, isccc_region_t *secret)
{
unsigned int size;
- isc_uint32_t version;
+ uint32_t version;
size = REGION_SIZE(*source);
if (size < 4)
}
static isc_result_t
-createmessage(isc_uint32_t version, const char *from, const char *to,
- isc_uint32_t serial, isccc_time_t now,
+createmessage(uint32_t version, const char *from, const char *to,
+ uint32_t serial, isccc_time_t now,
isccc_time_t expires, isccc_sexpr_t **alistp,
isc_boolean_t want_expires)
{
}
isc_result_t
-isccc_cc_createmessage(isc_uint32_t version, const char *from, const char *to,
- isc_uint32_t serial, isccc_time_t now,
+isccc_cc_createmessage(uint32_t version, const char *from, const char *to,
+ uint32_t serial, isccc_time_t now,
isccc_time_t expires, isccc_sexpr_t **alistp)
{
return (createmessage(version, from, to, serial, now, expires,
isccc_sexpr_t **ackp)
{
char *_frm, *_to;
- isc_uint32_t serial;
+ uint32_t serial;
isccc_sexpr_t *ack, *_ctrl;
isc_result_t result;
isccc_time_t t;
isccc_time_t expires, isccc_sexpr_t **alistp)
{
char *_frm, *_to, *type = NULL;
- isc_uint32_t serial;
+ uint32_t serial;
isccc_sexpr_t *alist, *_ctrl, *_data;
isc_result_t result;
}
isccc_sexpr_t *
-isccc_cc_defineuint32(isccc_sexpr_t *alist, const char *key, isc_uint32_t i) {
+isccc_cc_defineuint32(isccc_sexpr_t *alist, const char *key, uint32_t i) {
char b[100];
size_t len;
isccc_region_t r;
isc_result_t
isccc_cc_lookupuint32(isccc_sexpr_t *alist, const char *key,
- isc_uint32_t *uintp)
+ uint32_t *uintp)
{
isccc_sexpr_t *kv, *v;
v = ISCCC_SEXPR_CDR(kv);
if (isccc_sexpr_binaryp(v)) {
if (uintp != NULL)
- *uintp = (isc_uint32_t)
+ *uintp = (uint32_t)
strtoul(isccc_sexpr_tostring(v),
NULL, 10);
return (ISC_R_SUCCESS);
#include <config.h>
+#include <inttypes.h>
+
#include <isc/mem.h>
#include <isc/result.h>
#include <isc/task.h>
NULL, NULL);
region.base = (unsigned char *)&ccmsg->size;
- region.length = 4; /* isc_uint32_t */
+ region.length = 4; /* uint32_t */
result = isc_socket_recv(ccmsg->sock, ®ion, 0,
ccmsg->task, recv_length, ccmsg);
/*! \file isccc/cc.h */
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <isc/buffer.h>
#include <isccc/types.h>
/*% Send to Wire */
isc_result_t
isccc_cc_towire(isccc_sexpr_t *alist, isc_buffer_t **buffer,
- isc_uint32_t algorithm, isccc_region_t *secret);
+ uint32_t algorithm, isccc_region_t *secret);
/*% Get From Wire */
isc_result_t
isccc_cc_fromwire(isccc_region_t *source, isccc_sexpr_t **alistp,
- isc_uint32_t algorithm, isccc_region_t *secret);
+ uint32_t algorithm, isccc_region_t *secret);
/*% Create Message */
isc_result_t
-isccc_cc_createmessage(isc_uint32_t version, const char *from, const char *to,
- isc_uint32_t serial, isccc_time_t now,
+isccc_cc_createmessage(uint32_t version, const char *from, const char *to,
+ uint32_t serial, isccc_time_t now,
isccc_time_t expires, isccc_sexpr_t **alistp);
/*% Create Acknowledgment */
/*% Define uint 32 */
isccc_sexpr_t *
-isccc_cc_defineuint32(isccc_sexpr_t *alist, const char *key, isc_uint32_t i);
+isccc_cc_defineuint32(isccc_sexpr_t *alist, const char *key, uint32_t i);
/*% Lookup String */
isc_result_t
/*% Lookup uint 32 */
isc_result_t
isccc_cc_lookupuint32(isccc_sexpr_t *alist, const char *key,
- isc_uint32_t *uintp);
+ uint32_t *uintp);
/*% Create Symbol Table */
isc_result_t
/*! \file isccc/ccmsg.h */
+#include <inttypes.h>
+
#include <isc/buffer.h>
#include <isc/lang.h>
#include <isc/socket.h>
typedef struct isccc_ccmsg {
/* private (don't touch!) */
unsigned int magic;
- isc_uint32_t size;
+ uint32_t size;
isc_buffer_t buffer;
unsigned int maxsize;
isc_mem_t *mctx;
/*! \file isccc/types.h */
+#include <inttypes.h>
+
#include <isc/boolean.h>
-#include <isc/int.h>
#include <isc/result.h>
/*% isccc_time_t typedef */
-typedef isc_uint32_t isccc_time_t;
+typedef uint32_t isccc_time_t;
/*% isccc_sexpr_t typedef */
typedef struct isccc_sexpr isccc_sexpr_t;
#ifndef ISCCC_UTIL_H
#define ISCCC_UTIL_H 1
+#include <inttypes.h>
+
#include <isc/util.h>
/*! \file isccc/util.h
#define GET64(v, w) \
do { \
- v = (isc_uint64_t)w[0] << 56; \
- v |= (isc_uint64_t)w[1] << 48; \
- v |= (isc_uint64_t)w[2] << 40; \
- v |= (isc_uint64_t)w[3] << 32; \
- v |= (isc_uint64_t)w[4] << 24; \
- v |= (isc_uint64_t)w[5] << 16; \
- v |= (isc_uint64_t)w[6] << 8; \
- v |= (isc_uint64_t)w[7]; \
+ v = (uint64_t)w[0] << 56; \
+ v |= (uint64_t)w[1] << 48; \
+ v |= (uint64_t)w[2] << 40; \
+ v |= (uint64_t)w[3] << 32; \
+ v |= (uint64_t)w[4] << 24; \
+ v |= (uint64_t)w[5] << 16; \
+ v |= (uint64_t)w[6] << 8; \
+ v |= (uint64_t)w[7]; \
w += 8; \
} while (0)
#include <config.h>
+#include <inttypes.h>
+
#include <isc/mem.h>
#include <isc/print.h>
#include <isc/string.h> /* Required for HP/UX (and others?) */
static isc_result_t
count_acl_elements(const cfg_obj_t *caml, const cfg_obj_t *cctx,
isc_log_t *lctx, cfg_aclconfctx_t *ctx, isc_mem_t *mctx,
- isc_uint32_t *count, isc_boolean_t *has_negative)
+ uint32_t *count, isc_boolean_t *has_negative)
{
const cfg_listelt_t *elt;
isc_result_t result;
- isc_uint32_t n = 0;
+ uint32_t n = 0;
REQUIRE(count != NULL);
n++;
} else if (cfg_obj_islist(ce)) {
isc_boolean_t negative;
- isc_uint32_t sub;
+ uint32_t sub;
result = count_acl_elements(ce, cctx, lctx, ctx, mctx,
&sub, &negative);
if (result != ISC_R_SUCCESS)
cfg_acl_fromconfig2(const cfg_obj_t *caml, const cfg_obj_t *cctx,
isc_log_t *lctx, cfg_aclconfctx_t *ctx,
isc_mem_t *mctx, unsigned int nest_level,
- isc_uint16_t family, dns_acl_t **target)
+ uint16_t family, dns_acl_t **target)
{
isc_result_t result;
dns_acl_t *dacl = NULL, *inneracl = NULL;
* elements table. (Note that if nest_level is nonzero,
* *everything* goes in the elements table.)
*/
- isc_uint32_t nelem;
+ uint32_t nelem;
if (nest_level == 0) {
result = count_acl_elements(caml, cctx, lctx, ctx,
#ifndef ISCCFG_ACLCONF_H
#define ISCCFG_ACLCONF_H 1
+#include <inttypes.h>
+
#include <isc/lang.h>
#include <isccfg/cfg.h>
cfg_acl_fromconfig2(const cfg_obj_t *caml, const cfg_obj_t *cctx,
isc_log_t *lctx, cfg_aclconfctx_t *ctx,
isc_mem_t *mctx, unsigned int nest_level,
- isc_uint16_t family, dns_acl_t **target);
+ uint16_t family, dns_acl_t **target);
/*
* Construct a new dns_acl_t from configuration data in 'caml' and
* 'cctx'. Memory is allocated through 'mctx'.
*** Imports
***/
+#include <inttypes.h>
+
#include <isc/formatcheck.h>
#include <isc/lang.h>
#include <isc/refcount.h>
* Return true iff 'obj' is of integer type.
*/
-isc_uint32_t
+uint32_t
cfg_obj_asuint32(const cfg_obj_t *obj);
/*%<
* Returns the value of a configuration object of 32-bit integer type.
* Return true iff 'obj' is of integer type.
*/
-isc_uint64_t
+uint64_t
cfg_obj_asuint64(const cfg_obj_t *obj);
/*%<
* Returns the value of a configuration object of 64-bit integer type.
* \li A 64-bit unsigned integer.
*/
-isc_uint32_t
+uint32_t
cfg_obj_asfixedpoint(const cfg_obj_t *obj);
/*%<
* Returns the value of a configuration object of fixed point number.
* \li A 32-bit unsigned integer.
*/
-isc_uint32_t
+uint32_t
cfg_obj_aspercentage(const cfg_obj_t *obj);
/*%<
* Returns the value of a configuration object of percentage
/*! \file isccfg/grammar.h */
+#include <inttypes.h>
+
#include <isc/lex.h>
#include <isc/netaddr.h>
#include <isc/sockaddr.h>
struct cfg_obj {
const cfg_type_t *type;
union {
- isc_uint32_t uint32;
- isc_uint64_t uint64;
+ uint32_t uint32;
+ uint64_t uint64;
isc_textregion_t string; /*%< null terminated, too */
isc_boolean_t boolean;
cfg_map_t map;
#include <config.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
parse_unitstring(char *str, isc_resourcevalue_t *valuep) {
char *endp;
unsigned int len;
- isc_uint64_t value;
- isc_uint64_t unit;
+ uint64_t value;
+ uint64_t unit;
value = isc_string_touint64(str, &endp, 10);
if (*endp == 0) {
default:
return (ISC_R_FAILURE);
}
- if (value > ISC_UINT64_MAX / unit)
+ if (value > UINT64_MAX / unit)
return (ISC_R_FAILURE);
*valuep = value * unit;
return (ISC_R_SUCCESS);
parse_sizeval(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
isc_result_t result;
cfg_obj_t *obj = NULL;
- isc_uint64_t val;
+ uint64_t val;
UNUSED(type);
char *endp;
isc_result_t result;
cfg_obj_t *obj = NULL;
- isc_uint64_t val;
- isc_uint64_t percent;
+ uint64_t val;
+ uint64_t percent;
UNUSED(type);
if (*endp == '%' && *(endp+1) == 0) {
CHECK(cfg_create_obj(pctx, &cfg_type_percentage, &obj));
- obj->value.uint32 = (isc_uint32_t)percent;
+ obj->value.uint32 = (uint32_t)percent;
*ret = obj;
return (ISC_R_SUCCESS);
} else {
parse_ttlval(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
isc_result_t result;
cfg_obj_t *obj = NULL;
- isc_uint32_t ttl;
+ uint32_t ttl;
UNUSED(type);
#include <config.h>
-#include <stdlib.h>
#include <inttypes.h>
+#include <stdlib.h>
#include <isc/buffer.h>
#include <isc/dir.h>
char *endp;
isc_result_t result;
cfg_obj_t *obj = NULL;
- isc_uint64_t percent;
+ uint64_t percent;
REQUIRE(pctx != NULL);
REQUIRE(ret != NULL && *ret == NULL);
}
CHECK(cfg_create_obj(pctx, &cfg_type_percentage, &obj));
- obj->value.uint32 = (isc_uint32_t)percent;
+ obj->value.uint32 = (uint32_t)percent;
*ret = obj;
cleanup:
cfg_print_chars(pctx, buf, strlen(buf));
}
-isc_uint32_t
+uint32_t
cfg_obj_aspercentage(const cfg_obj_t *obj) {
REQUIRE(obj != NULL && obj->type->rep == &cfg_rep_percentage);
return (obj->value.uint32);
cfg_print_chars(pctx, buf, strlen(buf));
}
-isc_uint32_t
+uint32_t
cfg_obj_asfixedpoint(const cfg_obj_t *obj) {
REQUIRE(obj != NULL && obj->type->rep == &cfg_rep_fixedpoint);
return (obj->value.uint32);
return (ISC_TF(obj->type->rep == &cfg_rep_uint32));
}
-isc_uint32_t
+uint32_t
cfg_obj_asuint32(const cfg_obj_t *obj) {
REQUIRE(obj != NULL && obj->type->rep == &cfg_rep_uint32);
return (obj->value.uint32);
return (ISC_TF(obj->type->rep == &cfg_rep_uint64));
}
-isc_uint64_t
+uint64_t
cfg_obj_asuint64(const cfg_obj_t *obj) {
REQUIRE(obj != NULL && obj->type->rep == &cfg_rep_uint64);
return (obj->value.uint64);
if ((flags & CFG_ADDR_V6OK) != 0 && strlen(s) <= 127U) {
char buf[128]; /* see lib/bind9/getaddresses.c */
char *d; /* zone delimiter */
- isc_uint32_t zone = 0; /* scope zone ID */
+ uint32_t zone = 0; /* scope zone ID */
strlcpy(buf, s, sizeof(buf));
d = strchr(buf, '%');
#include <ctype.h>
#include <stdio.h>
+#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
dns_name_t *name)
{
isc_result_t result;
- isc_uint32_t ttl;
+ uint32_t ttl;
char *word;
dns_rdataclass_t rdataclass;
dns_rdatatype_t rdatatype;
./lib/isc/unix/include/Makefile.in MAKE 1998,1999,2000,2001,2004,2007,2012,2014,2016,2018
./lib/isc/unix/include/isc/Makefile.in MAKE 1998,1999,2000,2001,2004,2007,2012,2013,2014,2015,2016,2018
./lib/isc/unix/include/isc/dir.h C 1999,2000,2001,2004,2005,2007,2016,2018
-./lib/isc/unix/include/isc/int.h C 1999,2000,2001,2004,2005,2007,2016,2018
./lib/isc/unix/include/isc/keyboard.h C 2000,2001,2004,2005,2007,2016,2018
./lib/isc/unix/include/isc/net.h C 1999,2000,2001,2002,2003,2004,2005,2007,2008,2012,2013,2014,2016,2017,2018
./lib/isc/unix/include/isc/netdb.h C 1999,2000,2001,2004,2005,2007,2016,2018
./lib/isc/win32/include/isc/bindevt.h C 2001,2004,2007,2016,2018
./lib/isc/win32/include/isc/condition.h C 1998,1999,2000,2001,2004,2007,2016,2018
./lib/isc/win32/include/isc/dir.h C 1999,2000,2001,2004,2007,2016,2018
-./lib/isc/win32/include/isc/int.h C 1999,2000,2001,2004,2007,2016,2018
./lib/isc/win32/include/isc/ipv6.h C 1999,2000,2001,2002,2004,2005,2007,2011,2012,2016,2018
./lib/isc/win32/include/isc/keyboard.h C 2000,2001,2004,2007,2016,2018
./lib/isc/win32/include/isc/mutex.h C 1998,1999,2000,2001,2004,2007,2008,2009,2016,2018
projects / thirdparty / bind9.git / commitdiff
