Compare commits

..
Author SHA1 Message Date
Vicky Risk c65d26855e Initial release checklist 2018-08-30 11:09:00 -04:00
Evan Hunt 59156c60eb Merge branch 'fix-configure-loop' into 'master'
configure could loop if --with-pic was specified

See merge request isc-projects/bind9!731
2018-08-29 19:28:33 -04:00
Evan Hunt d3e2f848ec configure could loop if --with-pic was specified 2018-08-29 19:19:50 -04:00
Ondřej Surý 6a9031b0a6 Merge branch '509-fix-strerr_r-on-Windows' into 'master'
Resolve "current master not building on ubuntu 16.04 using --with-libtool --enable-developer" also on Windows

See merge request isc-projects/bind9!730
2018-08-29 16:53:41 -04:00
Ondřej Surý e582d085de Fix InterlockedCompareExchange64Acquire -> InterlockedCompareExchangeAcquire64 and variants 2018-08-29 22:23:46 +02:00
Ondřej Surý 7f508ec229 Link arpaname and mdig with ws2_32.lib 2018-08-29 22:16:37 +02:00
Ondřej Surý d67b07c115 gai_strerror on Windows is just 'char *' 2018-08-29 22:05:09 +02:00
Ondřej Surý 7cba3cc474 Bump the minimum required Windows version to Windows Vista and Windows Server 2008 2018-08-29 22:03:09 +02:00
Ondřej Surý c74ee5bb17 Remove *_loadnew from libdns.def.in 2018-08-29 21:36:27 +02:00
Ondřej Surý d967e107f6 Remove isc_net_pton and isc_net_ntop from Windows libisc.def.in 2018-08-29 21:21:52 +02:00
Ondřej Surý aa3e33575d Fixup Windows build after strerr changes 2018-08-29 21:21:52 +02:00
Ondřej Surý 7d44cc2422 Merge branch '495-pic-dlopen' into 'master'
Resolve "building with libtool requires either pic or dlopen to be enabled"

Closes #495

See merge request isc-projects/bind9!704
2018-08-29 11:02:25 -04:00
Ondřej Surý d60e553a64 -Xcompiler -shared is generally needed when using libtool on Linux, not only when -ld is present 2018-08-29 16:37:26 +02:00
Ondřej Surý d03b9ec544 Make dnsrps play well with dlopen 2018-08-29 16:37:26 +02:00
Ondřej Surý 77f71d7d4a Rewrite dlopen detection using modern autoconf language constructs 2018-08-29 16:37:26 +02:00
Evan HuntandOndřej Surý 5928d31efc make --without-pic imply --disable-shared and --without-dlopen 2018-08-29 16:37:26 +02:00
Ondřej Surý ae80e61684 Merge branch '509-use-xsi-strerror_r' into 'master'
Resolve "current master not building on ubuntu 16.04 using --with-libtool --enable-developer"

Closes #509

See merge request isc-projects/bind9!727
2018-08-29 07:43:51 -04:00
Evan HuntandOndřej Surý 1656152d76 Ensure that POSIX strerror_r variant is use even when _GNU_SOURCE is enabled by default 2018-08-29 13:31:28 +02:00
Ondřej Surý cacd21c075 Enable system extensions macros using AC_USE_SYSTEM_EXTENSIONS
and remove handcrafted code that enabled __EXTENSIONS__ and _GNU_SOURCE
2018-08-29 13:31:27 +02:00
Evan Hunt b938f50ded Merge branch 'silence-warning' into 'master'
silence "missing print.h" warning

See merge request isc-projects/bind9!723
2018-08-28 19:21:33 -04:00
Evan Hunt 3c18b7d3fd silence "missing print.h" warning 2018-08-28 15:59:20 -07:00
Ondřej Surý e2a2f08ed5 Merge branch 'fix-missing-ipv6.h' into 'master'
Remove broken @ISC_IPV6_H@ placeholder from Makefile.in

See merge request isc-projects/bind9!720
2018-08-28 15:33:05 -04:00
Ondřej Surý dc410ce58f Remove broken @ISC_IPV6_H@ placeholder from Makefile.in 2018-08-28 21:15:32 +02:00
Witold Krecicki 416e09d715 Merge branch 'set-sndbuf' into 'master'
Set sndbuf

See merge request isc-projects/bind9!74
2018-08-28 14:33:57 -04:00
Witold Kręcicki 103b60e0bc Pre-merge nits 2018-08-28 20:25:36 +02:00
Mukund SivaramanandWitold Kręcicki d077f5c180 Add CHANGES entry 2018-08-28 20:20:25 +02:00
Evan HuntandWitold Kręcicki cddb699690 style nits 2018-08-28 20:19:47 +02:00
Mukund SivaramanandWitold Kręcicki 700614a0eb Set SO_SNDBUF 2018-08-28 20:19:47 +02:00
Witold Krecicki cc8a647887 Merge branch '276-rndc-reconfig-fixes' into 'master'
Resolve "rndc reconfig now performs stat() for all zones"

Closes #276

See merge request isc-projects/bind9!518
2018-08-28 11:16:47 -04:00
Witold Kręcicki c4c3b98a27 CHANGES note 2018-08-28 17:05:28 +02:00
Witold Kręcicki 79ce86090a rndc reconfig should not touch already loaded zones, some refactoring of dns_{zone,view,zt}_{async,}load 2018-08-28 17:04:45 +02:00
Ondřej Surý c268c47c76 Merge branch '178-remove-isc_keyboard' into 'master'
Remove isc_keyboard family of functions

See merge request isc-projects/bind9!718
2018-08-28 08:47:40 -04:00
Ondřej Surý dedb104382 Add CHANGES note for GL #178.
5023.   [cleanup]       Remove isc_keyboard family of functions. [GL #178]
2018-08-28 14:37:30 +02:00
Ondřej Surý fecbc7923a Remove isc_keyboard family of functions as they were not used anywhere 2018-08-28 14:37:30 +02:00
Ondřej Surý 6034664e36 Merge branch '10-use-atomic_builtins' into 'master'
Resolve "Use and require atomic primitives support"

Closes #10

See merge request isc-projects/bind9!657
2018-08-28 07:53:41 -04:00
Ondřej Surý ddaa853ed6 Add CHANGES note for GL #10.
5023.	[func]		Replace custom assembly for atomic operations with
			atomic support from the compiler. The code will now use
			C11 stdatomic, or __atomic, or __sync builtins with GCC
			or Clang compilers, and Interlocked functions with MSVC.
			[GL #10]
2018-08-28 13:15:59 +02:00
Ondřej Surý 91aa405778 Update the isc_refcount documentation in doxygen format 2018-08-28 13:15:59 +02:00
Ondřej Surý 0f24c55d38 Refactor *_destroy and *_detach functions to unified order of actions.
This properly orders clearing the freed pointer and calling isc_refcount_destroy
as early as possible to have ability to put proper memory barrier when cleaning
up reference counting.
2018-08-28 13:15:59 +02:00
Ondřej Surý 9d5df99a9d Directly use return value of atomic_compare_exchange_strong_explicit insteaf of comparing expected value 2018-08-28 12:15:39 +02:00
Ondřej Surý b5709e5531 Explicitly load atomic values in lib/isc/rwlock.c 2018-08-28 12:15:39 +02:00
Ondřej Surý d1d15c03e2 Switch everything back to relaxed memory ordering 2018-08-28 12:15:39 +02:00
Ondřej Surý 69b9b9ec77 Remove no-op NODE_STRONG(UN)?LOCK and rename NODE_WEAK(UN)?LOCK to just NODE_(UN)?LOCK 2018-08-28 12:15:39 +02:00
Ondřej Surý bef8ac5bae Rewrite isc_refcount API to fetch_and_<op>, instead of former <op>_and_<fetch> 2018-08-28 12:15:39 +02:00
Ondřej Surý 7fbbf09d21 Remove checks for atomic rwlock from rbtdb.cz and zone.c 2018-08-28 12:15:39 +02:00
Ondřej Surý 2b74478c8f Remove check for atomic isc_refcount in dns/rbt.h and always use isc_refcount 2018-08-28 12:15:39 +02:00
Ondřej Surý 93e8ba1b50 Rewrite reference counting in isc_mem to use isc_refcount API 2018-08-28 12:15:39 +02:00
Ondřej Surý 0a7535ac81 isc_refcount_init() now doesn't return isc_result_t and asserts on failed initialization 2018-08-28 12:15:39 +02:00
Ondřej Surý e9e55cbd03 Remove isc_atomic usage from rwlock.c and stats.c 2018-08-28 12:15:39 +02:00
Ondřej Surý e119de4169 Replace arch specific atomic.h with global atomic.h header using either stdatomic, __atomic or __sync primitives 2018-08-28 12:15:39 +02:00
Ondřej Surý facc390b54 Update configure.in to check for both stdatomic.h and __atomic builtins 2018-08-28 12:15:39 +02:00
Ondřej Surý 7ab9c9dbee Merge branch 'remove-dnsperf-and-queryperf-from-contrib' into 'master'
Remove dnsperf, queryperf and perftcpdns from contrib

See merge request isc-projects/bind9!717
2018-08-28 06:05:52 -04:00
Ondřej Surý ecb27adf86 Remove dnsperf, queryperf and perftcpdns from util/copyrights 2018-08-28 11:49:28 +02:00
Ondřej Surý f4c8e42f3e Update contrib/README with new locations for dnsperf, queryperf, and perftcpdns 2018-08-28 11:44:58 +02:00
Ondřej Surý 7de898777f Remove perftcpdns from BIND 9 repository 2018-08-28 11:42:31 +02:00
Ondřej Surý 1e404fdb0e Remove queryperf from BIND 9 repository 2018-08-28 11:42:14 +02:00
Ondřej Surý 99f17b80b8 Remove dnsperf and dnsperf-patches from BIND 9 repository 2018-08-28 11:41:58 +02:00
Ondřej Surý b6e64eb23b Merge branch '192-make-ipv6-mandatory' into 'master'
Remove all kind of legacy compatibility layers (including IPv6, networking and functions defined by C99 or POSIX.1)

Closes #192

See merge request isc-projects/bind9!668
2018-08-28 04:51:38 -04:00
Ondřej Surý 2c19877197 Add CHANGES entry for GL #192
5016.   [cleanup]       Remove wrappers that try to fix broken or incomplete
                        implementations of IPv6, pthreads and other core
                        functionality required and used by BIND. [GL #192]
2018-08-28 10:36:41 +02:00
Ondřej Surý 19a374e45d Cleanup util/copyrights 2018-08-28 10:36:41 +02:00
Ondřej Surý a8b868e820 Add release notes entry. 2018-08-28 10:31:49 +02:00
Ondřej Surý f1d658764c Remove dead check for long long support 2018-08-28 10:31:49 +02:00
Ondřej Surý 52e1c45156 Assume PTHREAD_ONCE_INIT is not broken (remove support for ancient Solaris) 2018-08-28 10:31:48 +02:00
Ondřej Surý a11a271b28 Assume non-broken recvmsg 2018-08-28 10:31:48 +02:00
Ondřej Surý 1672935717 Use strerror_r from POSIX.1-2001 (strerror_s on Windows) instead of custom isc__strerror() 2018-08-28 10:31:48 +02:00
Ondřej Surý efd613e874 memmove, strtoul, and strcasestr functions are part of ISO C90, remove the compatibility shim 2018-08-28 10:31:48 +02:00
Ondřej Surý 1e1804bb96 getifaddrs() is available on all supported Unix platforms (Linux, BSDs, macOS and Solaris) 2018-08-28 10:31:48 +02:00
Ondřej Surý 62fb0759e9 Assume always working getaddrinfo/getnameinfo implemenation 2018-08-28 10:31:48 +02:00
Ondřej Surý 29c853f500 Remove check for isc_port_t; Windows never have it, Unix always have it 2018-08-28 10:31:48 +02:00
Ondřej Surý 40f7680efa Ignore sockaddr_{sin,sin6,sun}.{sin,sin6,sun}_len even on systems that define it 2018-08-28 10:31:48 +02:00
Ondřej Surý e6dc08b06c Always assume BSD4.4 msghdr version 2018-08-28 10:31:48 +02:00
Ondřej Surý 388d6db5a1 Remove support for legacy systems without inet_{ntop,pton} w/ IPv6 support 2018-08-28 10:31:48 +02:00
Ondřej Surý 3ab9c99567 Remove support for legacy systems without in6_pktinfo 2018-08-28 10:31:48 +02:00
Ondřej Surý 8c526df306 Remove support for legacy systems without sin6_scope_id 2018-08-28 10:31:48 +02:00
Ondřej Surý 4150a86046 Remove support for legacy platforms without in6addr_loopback 2018-08-28 10:31:48 +02:00
Ondřej Surý 5083a42072 Remove support for legacy systems without in6addr_any 2018-08-28 10:31:48 +02:00
Ondřej Surý b962f47d3e Remove support for pre-RFC2133 IPv6 implementation (in_addr6) 2018-08-28 10:31:48 +02:00
Ondřej Surý 243a347d60 Remove support for legacy KAME IPv6 stack 2018-08-28 10:31:47 +02:00
Ondřej Surý 7b21bbb7c1 Require IPv6 support from the OS 2018-08-28 10:31:47 +02:00
Ondřej Surý 00ca487fec We always want IPv6 2018-08-28 10:31:47 +02:00
Ondřej Surý c19713aa51 Remove support for legacy SGI IRIX 2018-08-28 10:31:47 +02:00
Ondřej Surý 9f4528c623 Remove legacy support for Compaq TruCluster 2018-08-28 10:31:47 +02:00
Ondřej Surý 02e349c051 Remove legacy support for HP-UX 2018-08-28 10:31:47 +02:00
Ondřej Surý b02de1ec30 Remove legacy support for SunOS 2018-08-28 10:31:47 +02:00
Ondřej Surý 18e3c8d232 Remove legacy support for Tru64 2018-08-28 10:31:47 +02:00
Ondřej Surý f0f71420c8 Remove legacy support for AIX 2018-08-28 10:31:47 +02:00
Ondřej Surý 9a8da1e25a Remove legacy BSD/OS support (ipv6,various hacks) 2018-08-28 10:31:47 +02:00
Ondřej Surý e53a72a649 Remove legacy UnixWare support (sigwait, ipv6) 2018-08-28 10:31:47 +02:00
Ondřej Surý 518772e4e0 Merge branch 'gitlab-ci-dont-run-make-clean' into 'master'
Disable make clean at the end of configure step in GitLab CI

See merge request isc-projects/bind9!714
2018-08-28 01:18:18 -04:00
Ondřej Surý a1d783bbe2 Disable make clean at the end of configure step in GitLab CI 2018-08-28 07:09:18 +02:00
Ondřej Surý ca0ce1cb42 Merge branch '496-fix-freebsd-issue' into 'master'
threads.h was missing on C11/thread_local builds

Closes #496

See merge request isc-projects/bind9!712
2018-08-27 14:34:47 -04:00
Witold Kręcicki 525fd76685 Include threads.h for thread_local 2018-08-27 16:41:43 +02:00
Stephen Morris 760182271e Merge branch '498-clang-scan-build-detected-errors' into 'master'
Resolve "clang scan-build detected errors"

Closes #498

See merge request isc-projects/bind9!703
2018-08-27 10:25:22 -04:00
Ondřej SurýandStephen Morris de41f0beea Cleanup couple of set-but-unused errors from Coverity 2018-08-27 10:12:19 -04:00
Ondřej SurýandStephen Morris 55361748d7 Initialize all tvresults to ISC_R_UNSET 2018-08-27 10:12:19 -04:00
Witold Krecicki edf5c01fcb Merge branch '499-fix-rsabigexponent-with-pkc11' into 'master'
Resolve "rsabigexponent test is broken w/pkcs11"

Closes #499

See merge request isc-projects/bind9!711
2018-08-27 05:33:29 -04:00
Ondřej Surý 8b3878dc7d Run rsabigexponent test only when OpenSSL is used as cryptography provider 2018-08-27 11:24:32 +02:00
Mark Andrews dc4086d4f2 Merge branch 'update-documentation-for-ms-and-krb5-rules' into 'master'
update {krb5,ms}-{self,subdomain} descriptions

See merge request isc-projects/bind9!708
2018-08-27 02:58:36 -04:00
Mark Andrews a3c5c2c29c add CHANGES note 2018-08-27 16:46:07 +10:00
Mark Andrews 0370d13667 update {krb5,ms}-{self,subdomain} descriptions 2018-08-27 16:39:51 +10:00
Mark Andrews 25bb33c866 Merge branch '487-reset-dig-exit-code-after-a-tcp-connection-is-established' into 'master'
Reset dig exit code after a TCP connection is established

Closes #487

See merge request isc-projects/bind9!698
2018-08-27 00:07:21 -04:00
Michał KępieńandMark Andrews 59057bee5b Add CHANGES entry
5020.	[bug]		dig returned a non-zero exit code when it received a
			reply over TCP after a retry. [GL #487]
2018-08-27 13:58:43 +10:00
Michał KępieńandMark Andrews deb3b85cb2 Reset dig exit code after a TCP connection is established
The "exitcode" variable is set to 9 if a TCP connection fails, but is
not reset to 0 if a subsequent TCP connection succeeds.  This causes dig
to return a non-zero exit code if it succeeds in getting a TCP response
after a retry.  Fix by resetting "exitcode" to 0 if connect_done()
receives an event with the "result" field set to ISC_R_SUCCESS.
2018-08-27 13:58:08 +10:00
Michał Kępień d3bd90f3a7 Merge branch 'set-use-alt-transfer-source-no-in-the-mirror-system-test' into 'master'
Set "use-alt-transfer-source no;" in the "mirror" system test

See merge request isc-projects/bind9!705
2018-08-25 16:20:28 -04:00
Michał Kępień a23162ab28 Set "use-alt-transfer-source no;" in the "mirror" system test
Force ns3 to use a constant source address (10.53.0.3) when sending
transfer requests for the "initially-unavailable" zone to prevent
failures of transfers not triggered by bin/tests/system/mirror/tests.sh
from causing fallback to using a source address for which transfers of
that zone are refused throughout the entire "mirror" system test since
that might yield false positives.
2018-08-25 21:48:17 +02:00
Ondřej Surý 8f37439ccf Merge branch '496-tls-in-rng' into 'master'
Resolve "RNG should not be locking"

Closes #340 and #496

See merge request isc-projects/bind9!697
2018-08-25 08:08:13 -04:00
Ondřej Surý 7ab228cf71 Use __declspec( thread ) for thread local storage when compiling with Visual Studio 2015 and higher 2018-08-25 13:59:26 +02:00
Witold Kręcicki 18ebcf2b30 Add runtime check on top of pthread_mutex_{lock,unlock} in rng 2018-08-25 13:26:25 +02:00
Witold Kręcicki 8c5aeb6c4c Use TLS variables to store RNG state, make RNG lockless 2018-08-25 13:26:25 +02:00
Ondřej Surý e79b42fec0 Merge branch 'fix-line-continuation-in-fuzz-Makefile.in' into 'master'
Fix line continuation in fuzz/Makefile.in

See merge request isc-projects/bind9!699
2018-08-24 11:01:10 -04:00
Michał Kępień 875b29c3e3 Fix line continuation in fuzz/Makefile.in
Add a missing semicolon to prevent "make test" run from the top-level
directory from failing even when all system and unit tests succeed due
to "(cd fuzz && ${MAKE} check)" returning a non-zero exit code.
2018-08-24 14:00:32 +02:00
Michał Kępień ba350f40ff Merge branch '470-log-a-message-when-ixfr-from-differences-is-set-for-an-inline-signed-zone' into 'master'
Log a message when "ixfr-from-differences" is set for an inline-signed zone

Closes #470

See merge request isc-projects/bind9!648
2018-08-24 04:35:29 -04:00
Michał Kępień 4fb5d072c2 Add CHANGES entry
5019.	[cleanup]	A message is now logged when ixfr-from-differences is
			set at zone level for an inline-signed zone. [GL #470]
2018-08-24 10:18:59 +02:00
Michał Kępień 087157d14f Log a message when "ixfr-from-differences" is set for an inline-signed zone
For inline-signed zones, the value of "ixfr-from-differences" is
hardcoded to:

  - "yes" for the raw version of the zone,
  - "no" for the signed version of the zone.

In other words, any user-provided "ixfr-from-differences" setting is
effectively ignored for an inline-signed zone.  Ensure the user is aware
of that by adding a note to the ARM and logging a message when an
"ixfr-from-differences" option is found at the zone level.
2018-08-24 10:18:59 +02:00
Michał Kępień 2359f06aa6 Merge branch '491-prevent-a-race-in-the-inline-system-test' into 'master'
Prevent a race in the "inline" system test

Closes #491

See merge request isc-projects/bind9!682
2018-08-24 03:55:13 -04:00
Michał Kępień e36c869e85 Prevent a race in the "inline" system test
A short time window exists between logging the addition of an NSEC3PARAM
record to a zone and committing it to the current version of the zone
database.  If a query arrives during such a time window, an unsigned
response will be returned.  One of the checks in the "inline" system
test requires NSEC3 records to be present in an answer - that check
would fail in the case described above.  Use rndc instead of log
watching for checking whether zone signing and NSEC3 chain modifications
are complete in order to prevent intermittent "inline" system test
failures.
2018-08-24 09:37:37 +02:00
Mark Andrews 1c82dde85c Merge branch 'fix-non-portable' into 'master'
use sizeof(CK_SLOT_ID)

See merge request isc-projects/bind9!588
2018-08-23 21:29:52 -04:00
Mark Andrews 42b16771db add CHANGES note 2018-08-24 11:02:27 +10:00
Mark Andrews 2c1d8b2e99 use sizeof(CK_SLOT_ID) 2018-08-24 11:00:39 +10:00
Mark Andrews 751c660b9d Merge branch 'value-not-updated-atomically' into 'master'
unlink before unlock

See merge request isc-projects/bind9!589
2018-08-23 20:49:38 -04:00
Mark Andrews 05531d3a86 add CHANGES note 2018-08-24 10:41:11 +10:00
Mark Andrews 4742f4ecba unlink before unlock 2018-08-24 10:36:53 +10:00
Mark Andrews e59617441e Merge branch '445-filter-aaaa-and-dns64-can-both-attempt-to-recurse-for-a-records-at-the-same-time' into 'master'
Resolve "filter-aaaa and dns64 can both attempt to recurse for A records at the same time"

Closes #445

See merge request isc-projects/bind9!561
2018-08-23 19:44:18 -04:00
Mark Andrews c1bc3baf7f add CHANGES note 2018-08-24 09:29:35 +10:00
Mark Andrews 1056376d10 when filter-aaaa and dns64 are both configured a assertion failure could occur 2018-08-24 09:26:54 +10:00
Evan Hunt 0213626992 Merge branch '436-fix-dnstap-test' into 'master'
Resolve "dnstap tests are failing in Jenkins"

Closes #436

See merge request isc-projects/bind9!683
2018-08-23 14:11:45 -04:00
Evan Hunt 0d6f504ba3 specify "dnssec-validation yes" instead of default "auto" 2018-08-23 13:52:57 -04:00
Ondřej Surý af1df8738f Merge branch 'bump-to-9.13.3-dev' into 'master'
Bump the version in the master to 9.13.3-dev

See merge request isc-projects/bind9!679
2018-08-23 06:11:51 -04:00
Ondřej SurýandOndřej Surý ca9aaf926f Bump the version in the master to 9.13.3-dev 2018-08-23 06:02:24 -04:00
Ondřej Surý 591a6c94ee Merge branch 'run-update_copyrights' into 'master'
Run update copyrights in precheck stage

See merge request isc-projects/bind9!680
2018-08-23 05:52:56 -04:00
Ondřej Surý 4016369212 Check update_copyright results in precheck stage 2018-08-23 11:39:01 +02:00
Ondřej Surý 31b5360943 Whitespace fixes 2018-08-23 11:39:01 +02:00
Ondřej Surý 65de91f512 Cleanup cruft in util/copyrights 2018-08-23 11:39:01 +02:00
Ondřej Surý db3d69263d Make update_copyrights return error code when error is encountered during processing the files 2018-08-23 11:38:21 +02:00
Ondřej Surý d877d4a561 Merge branch 'bshastry/bind9-oss-fuzz' into 'master'
Add a skeleton directory for the oss-fuzz testing

See merge request isc-projects/bind9!530
2018-08-23 04:27:11 -04:00
Bhargava ShastryandOndřej Surý 1c57b73e34 oss-fuzz: Improve interaction with fuzzing tools and add new tests in fuzz/ directory 2018-08-23 10:07:28 +02:00
Evan Hunt d30b90dba6 Merge branch '484-fix-non-libtool-build' into 'master'
Resolve "Build Fails with --enable-developer when building without libtool"

Closes #484

See merge request isc-projects/bind9!676
2018-08-22 17:00:52 -04:00
Evan Hunt e67f81bbf1 set PTHREAD_CFLAGS when building backtrace_test_nosymtbl 2018-08-22 13:52:03 -07:00
Michał Kępień cb28c27b30 Merge branch '435-fix-reloading-inline-signed-zones' into 'master'
Fix reloading inline-signed zones

Closes #435

See merge request isc-projects/bind9!664
2018-08-22 06:00:56 -04:00
Michał Kępień f9931f1d22 Add CHANGES entry
5015.	[bug]		Reloading all zones caused zone maintenance to cease
			for inline-signed zones. [GL #435]
2018-08-22 11:28:54 +02:00
Michał Kępień 5431583971 Fix reloading inline-signed zones
While "rndc reload" causes dns_zone_asyncload() to be called for the
signed version of an inline-signed zone, the subsequent zone_load() call
causes the raw version to be reloaded from storage.  This means that
DNS_ZONEFLG_LOADPENDING gets set for the signed version of the zone by
dns_zone_asyncload() before the reload is attempted, but zone_postload()
is only called for the raw version and thus DNS_ZONEFLG_LOADPENDING is
cleared for the raw version, but not for the signed version.  This in
turn prevents zone maintenance from happening for the signed version of
the zone.

Until commit 29b7efdd9f, this problem
remained dormant because DNS_ZONEFLG_LOADPENDING was previously
immediately, unconditionally cleared after zone loading was started
(whereas it should only be cleared when zone loading is finished or an
error occurs).  This behavior caused other issues [1] and thus had to be
changed.

Fix reloading inline-signed zones by clearing DNS_ZONEFLG_LOADPENDING
for the signed version of the zone once the raw version reload
completes.  Take care not to clear it prematurely during initial zone
load.  Also make sure that DNS_ZONEFLG_LOADPENDING gets cleared when
zone_postload() encounters an error or returns early, to prevent other
scenarios from resulting in the same problem.  Add comments aiming to
help explain code flow.

[1] see RT #47076
2018-08-22 11:28:54 +02:00
Michał Kępień d2785afebe Merge branch '482-fix-secure-journal-loading-for-inline-signed-zones' into 'master'
Set DNS_JOURNALOPT_RESIGN when loading the secure journal for an inline-signed zone

Closes #482

See merge request isc-projects/bind9!663
2018-08-22 05:21:20 -04:00
Michał Kępień b3b1a9081b Add CHANGES entry
5014.	[bug]		Signatures loaded from the journal for the signed
			version of an inline-signed zone were not scheduled for
			refresh. [GL #482]
2018-08-22 10:48:07 +02:00
Michał Kępień 8db550c42f Set DNS_JOURNALOPT_RESIGN when loading the secure journal for an inline-signed zone
When an inline-signed zone is loaded, the master file for its signed
version is loaded and then a rollforward of the journal for the signed
version of the zone is performed.  If DNS_JOURNALOPT_RESIGN is not set
during the latter phase, signatures loaded from the journal for the
signed version of the zone will not be scheduled for refresh.  Fix the
conditional expression determining which flags should be used for the
dns_journal_rollforward() call so that DNS_JOURNALOPT_RESIGN is set when
zone_postload() is called for the signed version of an inline-signed
zone.

Extend bin/tests/system/stop.pl so that it can use "rndc halt" instead
of "rndc stop" as the former allows master file flushing upon shutdown
to be suppressed.
2018-08-22 10:48:07 +02:00
Michał Kępień 71793853df Merge branch '390-do-not-treat-a-referral-with-a-non-empty-answer-section-as-an-error' into 'master'
Do not treat a referral with a non-empty ANSWER section as an error

Closes #390

See merge request isc-projects/bind9!628
2018-08-22 04:42:58 -04:00
Michał Kępień 2923ab4945 Add CHANGES entry
5013.	[bug]		A referral response with a non-empty ANSWER section was
			inadvertently being treated as an error. [GL #390]
2018-08-22 10:14:39 +02:00
Michał Kępień 24b9ec555a Do not treat a referral with a non-empty ANSWER section as an error
As part of resquery_response() refactoring [1], a goto statement was
replaced [2] with a call to a new function - originally called
rctx_delegation(), now folded into rctx_answer_none() - extracted from
existing code.  However, one call site of that refactored function does
not reset the "result" variable, causing a referral with a non-empty
ANSWER section to be inadvertently treated as an error, which prevents
resolution of names reliant on servers sending such responses.  Fix by
resetting the "result" variable to ISC_R_SUCCESS when a response
containing a non-empty ANSWER section can be treated as a delegation.

[1] see RT #45362

[2] see commit e1380a16741a3b4a57e54d7a9ce09dd12691522f
2018-08-22 10:14:37 +02:00
Mark Andrews 3596bad5ce Merge branch 'fix-lock-order-reversal' into 'master'
fix lock order reversal

See merge request isc-projects/bind9!590
2018-08-20 23:17:33 -04:00
Mark Andrews 083007e930 add CHANGES note 2018-08-21 12:18:27 +10:00
Mark Andrews 2bb4392bb3 fix lock order reversal 2018-08-20 22:15:18 -04:00
Ondřej Surý bf98eb41bf Merge branch 'configure.in-cmocka-CFLAGS-fix' into 'master'
Fix missing $ in CMOCKA_CFLAGS when --with-cmocka=<path> was used

See merge request isc-projects/bind9!665
2018-08-17 09:37:31 -04:00
Ondřej Surý ab9f12c7f4 Fix missing $ in CMOCKA_CFLAGS when --with-cmocka=<path> was used 2018-08-17 15:28:42 +02:00
Witold Krecicki 28cf1a7a9c Merge branch '478-remove-support-for-unthreaded-bind' into 'master'
Remove support for unthreaded BIND

Closes #478

See merge request isc-projects/bind9!655
2018-08-16 15:09:43 -04:00
Witold Kręcicki 44cec639c4 CHANGES/notes/docs 2018-08-16 19:46:10 +02:00
Ondřej SurýandWitold Kręcicki c692da2182 Improve autoconf pthread detection 2018-08-16 17:18:52 +02:00
Witold Kręcicki 5cdb38c2c7 Remove unthreaded support 2018-08-16 17:18:52 +02:00
Ondřej Surý 8e164f784d Merge branch 'gitlab-ci-make-install-job' into 'master'
Add make install job to GitLab CI

See merge request isc-projects/bind9!661
2018-08-16 09:38:06 -04:00
Ondřej SurýandOndřej Surý 9c950e5961 Add install test job 2018-08-16 09:13:41 -04:00
Ondřej SurýandOndřej Surý 28748db0b2 paste config.log to output if configure ends up with failure 2018-08-16 09:13:41 -04:00
Ondřej Surý 1ff71c7cee Merge branch 'config.h-fixes' into 'master'
Replace "config.h" with <config.h>

See merge request isc-projects/bind9!660
2018-08-16 06:54:57 -04:00
Ondřej Surý e2c938d882 Replace "config.h" with <config.h> 2018-08-16 12:45:59 +02:00
Evan Hunt 0bdefcb599 Merge branch '237-validate-except' into 'master'
Resolve "dnssec-validation exception domains"

Closes #237

See merge request isc-projects/bind9!224
2018-08-14 16:38:00 -04:00
Evan Hunt 4eb0897c90 CHANGES, release notes, README 2018-08-14 13:28:02 -07:00
Evan Hunt 7ecd699e81 add a system test 2018-08-14 13:28:02 -07:00
Evan Hunt eaac2057c7 option to disable validation under specified names
- added new 'validate-except' option, which configures an NTA with
  expiry of 0xffffffff.  NTAs with that value in the expiry field do not
  expire, are are not written out when saving the NTA table and are not
  dumped by rndc secroots
2018-08-14 13:28:02 -07:00
Evan Hunt 509d71e1aa Merge branch '465-missing-check-in-acl_test-c-unit-test' into 'master'
Resolve "Missing check in acl_test.c unit test"

Closes #465

See merge request isc-projects/bind9!639
2018-08-14 12:13:04 -04:00
Mark AndrewsandEvan Hunt 0ce82e9d5f add missing ATF_REQUIRE 2018-08-14 09:04:16 -07:00
Ondřej Surý 53690ef21f Merge branch '476-fix-openssl-error-logging' into 'master'
Fix OpenSSL error logging

Closes #476

See merge request isc-projects/bind9!644
2018-08-14 07:05:20 -04:00
Michał Kępień cab7c34fbd Add CHANGES entry
5009.	[bug]		Upon an OpenSSL failure, the first error in the OpenSSL
			error queue was not logged. [GL #476]
2018-08-14 12:49:19 +02:00
Michał Kępień fe20f8fe25 Do not remove errors from the OpenSSL error queue in toresult()
dst__openssl_toresult3() first calls toresult() and subsequently uses
ERR_get_error_line_data() in a loop.  Given this, it is a mistake to use
ERR_get_error() in toresult() because it causes the retrieved error to
be removed from the OpenSSL error queue, thus preventing it from being
retrieved by the subsequent ERR_get_error_line_data() calls.  Fix by
using ERR_peek_error() instead of ERR_get_error() in toresult().
2018-08-14 12:49:19 +02:00
Michał Kępień 527614c750 Merge branch '471-fix-rbt_insert_and_remove-unit-test' into 'master'
Prevent rare rbt_insert_and_remove unit test failures

Closes #471

See merge request isc-projects/bind9!614
2018-08-14 05:11:17 -04:00
Michał Kępień 13fe763798 Prevent rare rbt_insert_and_remove unit test failures
When two or more absolute, two-label names are added to a completely
empty RBT, an extra, empty node for the root name will be created due to
node splitting.  check_tree() expects that, but the extra node will not
be created when just one name is added to a completely empty RBT.  This
problem could be handled inside check_tree(), but that would introduce
unnecessary complexity into it since adding a single name will result in
a different node count for a completely empty RBT (node count will be 1)
and an RBT containing only an empty node for the root name, created due
to prior node splitting (node count will be 2).  Thus, first explicitly
create a node for the root name to prevent rare check_tree() failures
caused by a single name being added in the first iteration of the
insert/remove loop.
2018-08-14 10:43:51 +02:00
Michał Kępień 495e10ba5a Merge branch '285-make-the-inline-system-test-more-lightweight' into 'master'
Make the "inline" system test more lightweight

Closes #285

See merge request isc-projects/bind9!611
2018-08-14 04:38:57 -04:00
Michał Kępień 24dd865b97 Make the "inline" system test more lightweight
Each zone used in the "inline" system test contains a few dozen records.
Over a dozen of these zones are used in the test.  Most records present
in these zones are not subsequently used in the test itself, but all of
them need to be signed by the named instances launched by the test,
which puts quite a bit of strain on lower-end machines, leading to
intermittent failures of the "inline" system test.  Remove all redundant
records from the zones used in the "inline" system test in order to
stabilize it.
2018-08-14 10:16:08 +02:00
Evan Hunt e0d309572f Merge branch '474-mempool-is-broken-if-object-size-is-below-the-alignment-size' into 'master'
Resolve "mempool is broken if object size is below the alignment size"

Closes #474

See merge request isc-projects/bind9!635
2018-08-14 04:09:17 -04:00
Mark AndrewsandEvan Hunt 5dd1beec8e mempool didn't work for sizes less than sizeof(void*) 2018-08-14 03:47:14 -04:00
Michał Kępień dc5b8ec97a Merge branch '468-queue-rndc-signing-nsec3param-requests-if-needed' into 'master'
Queue "rndc signing -nsec3param ..." requests if needed

Closes #468

See merge request isc-projects/bind9!610
2018-08-14 03:44:53 -04:00
Michał Kępień eed6778be4 Add CHANGES entry
5008.	[bug]		"rndc signing -nsec3param ..." requests were silently
			ignored for zones which were not yet loaded or
			transferred. [GL #468]
2018-08-14 09:22:43 +02:00
Michał Kępień cb40c5229a Queue "rndc signing -nsec3param ..." requests if needed
If "rndc signing -nsec3param ..." is ran for a zone which has not yet
been loaded or transferred (i.e. its "db" field is NULL), it will be
silently ignored by named despite rndc logging an "nsec3param request
queued" message, which is misleading.  Prevent this by keeping a
per-zone queue of NSEC3PARAM change requests which arrive before a zone
is loaded or transferred and processing that queue once the raw version
of an inline-signed zone becomes available.
2018-08-14 09:22:43 +02:00
Ondřej Surý f34e7ee612 Merge branch '462-full-recv-queue-on-netbsd' into 'master'
Resolve "Full Recv-Queue"

Closes #462

See merge request isc-projects/bind9!629
2018-08-13 13:19:48 -04:00
Ondřej Surý ebf3083e08 Make ENOBUFS a soft error 2018-08-13 18:51:10 +02:00
Ondřej Surý 9689313331 Merge branch '9-use-C99-integer-types-fix-install' into 'master'
Don't try to install removed int.h and boolean.h headers

See merge request isc-projects/bind9!627
2018-08-13 09:38:55 -04:00
Mathieu ArnoldandOndřej Surý 4c06eb20cc Don't try to install removed int.h and boolean.h headers 2018-08-13 15:30:36 +02:00
Ondřej Surý a2188e61e7 Merge branch 'support-softhsm-2.4.0' into 'master'
Fix build failures on Debian sid

See merge request isc-projects/bind9!626
2018-08-13 07:22:25 -04:00
Ondřej Surý c746037622 Disable libidn2 on Debian stretch images 2018-08-13 12:43:38 +02:00
Ondřej Surý 28b0de3e86 Use clang on Debian stretch to workaround Debian Bug #903709 2018-08-13 12:43:38 +02:00
Ondřej Surý 6bc771828c SoftHSM 2.4.0 only supports softhsm2.conf now, rewrite GitLab CI commands to properly support that 2018-08-13 12:43:38 +02:00
Ondřej Surý 2cd0a493ae Merge branch '469-typo-in-validate-glue-branch' into 'master'
Resolve "Typo in validate-glue branch"

See merge request isc-projects/bind9!613
2018-08-11 04:16:34 -04:00
Ondřej SurýandOndřej Surý bdc9860262 Fix !!validate typo to -> !validate 2018-08-11 04:07:46 -04:00
Evan Hunt d6f4592f6b Merge branch 'fix-ns-log-mismatch' into 'master'
mismatch between defined log modules and ns_modules[] in lib/ns/log.c

See merge request isc-projects/bind9!612
2018-08-10 15:14:10 -04:00
Evan Hunt b865fb77de mismatch between defined log modules and ns_modules[] in lib/ns/log.c 2018-08-10 15:04:39 -04:00
Ondřej Surý c3e4363303 Merge branch '434-after-isc_safe-merge-the-windows-build-fails-due-missing-openssl_libs-in-project-files' into 'master'
Resolve "After isc_safe merge, the Windows build fails due missing OPENSSL_LIBS in project files"

Closes #434

See merge request isc-projects/bind9!617
2018-08-10 10:58:04 -04:00
Ondřej Surý c5040e5c9e Add @OPENSSL_LIB@ to Windows project files as needed 2018-08-10 16:45:00 +02:00
Ondřej Surý 86c377ccbb Merge branch '457-restore-logging-of-used-openssl-versions-upon-startup' into 'master'
Restore logging of used OpenSSL versions upon startup

Closes #457

See merge request isc-projects/bind9!615
2018-08-10 09:16:05 -04:00
Michał Kępień b14e127569 Restore logging of used OpenSSL versions upon startup
Remove an #ifdef which commit c3b8130fe8
should have removed.
2018-08-10 13:58:41 +02:00
Evan Hunt 337f9dd0ec Merge branch 'security-complete-dname-fix' into 'master'
Merge CVE-2018-5740 fix

See merge request isc-projects/bind9!607
2018-08-08 18:33:21 -04:00
Evan Hunt b4b4277f5a CHANGES, release note 2018-08-08 14:33:19 -07:00
Evan Hunt 3f907b8bee caclulate nlabels and set *chainingp correctly 2018-08-08 14:33:19 -07:00
Evan Hunt 9d7ad52506 test case 2018-08-08 14:33:19 -07:00
Evan Hunt cac3978af2 explicit DNAME query could trigger a crash if deny-answer-aliases was set 2018-08-08 14:33:19 -07:00
Ondřej Surý fa03f94102 Merge branch '9-use-C99-integer-types' into 'master'
Redefine ISC's int and boolean types to use <stdint.h> and <stdbool.h> types

See merge request isc-projects/bind9!162
2018-08-08 05:05:26 -04:00
Ondřej Surý 75c2356f42 Add CHANGES entry
5007.   [cleanup]       Replace custom ISC boolean and integer data types
                        with C99 stdint.h and stdbool.h types. [GL #9]
2018-08-08 09:37:30 +02:00
Ondřej Surý 7351c505a0 Remove duplicate config.h 2018-08-08 09:37:30 +02:00
Ondřej Surý 994e656977 Replace custom isc_boolean_t with C standard bool type 2018-08-08 09:37:30 +02:00
Ondřej Surý cb6a185c69 Replace custom isc_u?intNN_t types with C99 u?intNN_t types 2018-08-08 09:37:28 +02:00
Ondřej Surý 055278c936 Get rid of extra UINT64_MAX definition in lib/isc/win32/time.c 2018-08-08 09:36:44 +02:00
Ondřej Surý 64fe6bbaf2 Replace ISC_PRINT_QUADFORMAT with inttypes.h format constants 2018-08-08 09:36:44 +02:00
Ondřej Surý 9e493798c6 Check for C99 compatible compiler 2018-08-08 09:36:44 +02:00
Ondřej Surý e5ee96fc1b Merge branch 'silence-openbsd-warning' into 'master'
Silence a compiler warning on openbsd and fix windows build

See merge request isc-projects/bind9!603
2018-08-08 03:34:44 -04:00
Evan HuntandOndřej Surý b55338e447 Silence a compiler warning on openbsd and fix windows build 2018-08-08 02:49:28 -04:00
Michał Kępień 20c52bf9b8 Merge branch '431-refactor-code-preparing-a-delegation-response' into 'master'
Refactor code preparing a delegation response

Closes #431

See merge request isc-projects/bind9!549
2018-08-08 02:26:40 -04:00
Michał Kępień 1d9c37876b Add CHANGES entry
5006.	[cleanup]	Code preparing a delegation response was extracted from
			query_delegation() and query_zone_delegation() into a
			separate function in order to decrease code
			duplication. [GL #431]
2018-08-08 08:08:40 +02:00
Michał Kępień 8e3fc5725f Extract code preparing a delegation response to a separate function
Changes introduced by the previous two commits make the parts of
query_delegation() and query_zone_delegation() which prepare a
delegation response functionally equivalent.  Extract this code into a
separate function, query_prepare_delegation_response(), and then call
the latter from both query_delegation() and query_zone_delegation() in
order to reduce code duplication.  Add a comment describing the purpose
of the extracted code.  Fix coding style issues.
2018-08-08 08:08:40 +02:00
Michał Kępień 7db4dedf6b Remove unused NS_QUERYATTR_CACHEGLUEOK query attribute
The NS_QUERYATTR_CACHEGLUEOK query attribute has no influence on query
processing.  Remove it.
2018-08-08 08:08:40 +02:00
Michał Kępień b6c77202cb Restore zone database and zone node if cache search results are to be ignored
When query processing hits a delegation from a locally configured zone,
an attempt may be made to look for a better answer in the cache.  In
such a case, the zone-sourced delegation data is set aside and the
lookup is retried using the cache database.  When that lookup is
completed, a decision is made whether the answer found in the cache is
better than the answer found in the zone.

Currently, if the zone-sourced answer turns out to be better than the
one found in the cache:

  - qctx->zdb is not restored into qctx->db,
  - qctx->node, holding the zone database node found, is not even saved.

Thus, in such a case both qctx->db and qctx->node will point at cache
data.  This is not an issue for BIND versions which do not support
mirror zones because in these versions non-recursive queries always
cause the zone-sourced delegation to be returned and thus the
non-recursive part of query_delegation() is never reached if the
delegation is coming from a zone.  With mirror zones, however,
non-recursive queries may cause cache lookups even after a zone
delegation is found.  Leaving qctx->db assigned to the cache database
when query_delegation() determines that the zone-sourced delegation is
the best answer to the client's query prevents DS records from being
added to delegations coming from mirror zones.  Fix this issue by
keeping the zone database and zone node in qctx while the cache is
searched for an answer and then restoring them into qctx->db and
qctx->node, respectively, if the zone-sourced delegation turns out to be
the best answer.  Since this change means that qctx->zdb cannot be used
as the glue database any more as it will be reset to NULL by RESTORE(),
ensure that qctx->db is not a cache database before attaching it to
qctx->client->query.gluedb.

Furthermore, current code contains a conditional statement which
prevents a mirror zone from being used as a source of glue records.
Said statement was added to prevent assertion failures caused by
attempting to use a zone database's glue cache for finding glue for an
NS RRset coming from a cache database.  However, that check is overly
strict since it completely prevents glue from being added to delegations
coming from mirror zones.  With the changes described above in place,
the scenario this check was preventing can no longer happen, so remove
the aforementioned check.

If qctx->zdb is not NULL, qctx->zfname will also not be NULL;
qctx->zsigrdataset may be NULL in such a case, but query_putrdataset()
handles pointers to NULL pointers gracefully.  Remove redundant
conditional expressions to make the cleanup code in query_freedata()
match the corresponding sequences of SAVE() / RESTORE() macros more
closely.
2018-08-08 08:07:46 +02:00
Ondřej Surý ec25056b48 Merge branch '440-root-zone-performance-regression-uint32' into 'master'
Resolve "Root zone performance regression since 9.12.2rc2 and 9.13.1"

Closes #440

See merge request isc-projects/bind9!602
2018-08-07 04:02:02 -04:00
Ondřej Surý e3131b8d52 Make sure the storage for isc_random32() result is 32-bit long 2018-08-07 09:52:47 +02:00
Ondřej Surý 21a547c100 Merge branch '440-root-zone-performance-regression' into 'master'
Resolve "Root zone performance regression since 9.12.2rc2 and 9.13.1"

Closes #440

See merge request isc-projects/bind9!593
2018-08-06 05:38:44 -04:00
Ondřej Surý 9e11b54bbc Update ARM on the default ordering 2018-08-06 11:24:14 +02:00
Ondřej Surý e80c26b22e Define and use new DNS_RDATASET_COUNT_UNDEFINED equals ISC_UINT32_MAX to make the code more readable 2018-08-06 11:24:14 +02:00
Ondřej Surý afddc2781e Modify the rrsetorder test to cope with the rrset order randomization (only four orders are now possible) 2018-08-06 11:24:14 +02:00
Ondřej Surý 41a68425ea Refactor code around random/cyclic/fixed to reduce code duplication 2018-08-06 11:24:14 +02:00
Mark AndrewsandOndřej Surý f7986c8d1a Only get one random number per response when order == random 2018-08-05 07:23:07 +02:00
941 changed files with 22319 additions and 56893 deletions
+28 -18
View File
@@ -4,6 +4,7 @@ variables:
DOCKER_DRIVER: overlay2 DOCKER_DRIVER: overlay2
CI_REGISTRY_IMAGE: registry.gitlab.isc.org/isc-projects/images/bind9 CI_REGISTRY_IMAGE: registry.gitlab.isc.org/isc-projects/images/bind9
CCACHE_DIR: "/ccache" CCACHE_DIR: "/ccache"
SOFTHSM2_CONF: "/var/tmp/softhsm2/softhsm2.conf"
stages: stages:
- precheck - precheck
@@ -114,20 +115,25 @@ stages:
- test -w "${CCACHE_DIR}" && export PATH="/usr/lib/ccache:${PATH}" - test -w "${CCACHE_DIR}" && export PATH="/usr/lib/ccache:${PATH}"
# - ./autogen.sh # - ./autogen.sh
script: script:
- ./configure --enable-developer --with-libtool --disable-static --with-atf=/usr $EXTRA_CONFIGURE - ./configure --enable-developer --with-libtool --disable-static --with-atf=/usr --prefix=$HOME/.local --without-make-clean $EXTRA_CONFIGURE || cat config.log
- make -j${PARALLEL_JOBS_BUILD:-1} -k all V=1 - make -j${PARALLEL_JOBS_BUILD:-1} -k all V=1
artifacts: artifacts:
expire_in: '1 hour' expire_in: '1 hour'
untracked: true untracked: true
.install_test: &install_test_job
stage: test
before_script:
- mkdir $HOME/.local
script:
- make install
.system_test: &system_test_job .system_test: &system_test_job
stage: test stage: test
before_script: before_script:
- rm -rf .ccache - rm -rf .ccache
- bash -x bin/tests/system/ifconfig.sh up - bash -x bin/tests/system/ifconfig.sh up
- export SOFTHSM_CONF="/tmp/softhsm.conf" - bash -x util/prepare-softhsm2.sh
- echo "0:/tmp/softhsm.db" > $SOFTHSM_CONF
- if command -v softhsm2-util >/dev/null; then softhsm2-util --init-token --free --pin 0000 --so-pin 0000 --label "softhsm"; fi
script: script:
- ( cd bin/tests && make -j${TEST_PARALLEL_JOBS:-1} -k test V=1 ) - ( cd bin/tests && make -j${TEST_PARALLEL_JOBS:-1} -k test V=1 )
- test -s bin/tests/system/systests.output - test -s bin/tests/system/systests.output
@@ -140,9 +146,7 @@ stages:
stage: test stage: test
before_script: before_script:
- export KYUA_RESULT="$CI_PROJECT_DIR/kyua.results" - export KYUA_RESULT="$CI_PROJECT_DIR/kyua.results"
- export SOFTHSM_CONF="/tmp/softhsm.conf" - bash -x util/prepare-softhsm2.sh
- echo "0:/tmp/softhsm.db" > $SOFTHSM_CONF
- if command -v softhsm2-util >/dev/null; then softhsm2-util --init-token --free --pin 0000 --so-pin 0000 --label "softhsm"; fi
script: script:
- make unit - make unit
after_script: after_script:
@@ -165,6 +169,8 @@ precheck:debian:sid:amd64:
- perl -w util/merge_copyrights - perl -w util/merge_copyrights
- diff -urNap util/copyrights util/newcopyrights - diff -urNap util/copyrights util/newcopyrights
- rm util/newcopyrights - rm util/newcopyrights
- perl -w util/update_copyrights < util/copyrights
- if test "$(git status --porcelain | grep -Ev '\?\?' | wc -l)" -gt "0"; then git status --short; exit 1; fi
- xmllint --noout --nonet `git ls-files '*.xml' '*.docbook'` - xmllint --noout --nonet `git ls-files '*.xml' '*.docbook'`
- xmllint --noout --nonet --html `git ls-files '*.html'` - xmllint --noout --nonet --html `git ls-files '*.html'`
artifacts: artifacts:
@@ -214,12 +220,11 @@ build:centos:centos7:amd64:
<<: *centos_centos7_amd64_image <<: *centos_centos7_amd64_image
<<: *build_job <<: *build_job
build:clang:debian:sid:amd64: build:clang:debian:stretch:amd64:
variables: variables:
CC: clang-6.0 CC: clang
CFLAGS: "-Wall -Wextra -Wenum-conversion -O2 -g" CFLAGS: "-Wall -Wextra -Wenum-conversion -O2 -g"
EXTRA_CONFIGURE: "--with-libidn2" <<: *debian_stretch_amd64_image
<<: *debian_sid_amd64_image
<<: *build_job <<: *build_job
build:debian:jessie:amd64: build:debian:jessie:amd64:
@@ -244,12 +249,11 @@ build:debian:sid:amd64:
<<: *debian_sid_amd64_image <<: *debian_sid_amd64_image
<<: *build_job <<: *build_job
build:clang:debian:sid:i386: build:clang:debian:stretch:i386:
variables: variables:
CC: clang-6.0 CC: clang
CFLAGS: "-Wall -Wextra -Wenum-conversion -O2 -g" CFLAGS: "-Wall -Wextra -Wenum-conversion -O2 -g"
EXTRA_CONFIGURE: "--with-libidn2" <<: *debian_stretch_i386_image
<<: *debian_sid_i386_image
<<: *build_job <<: *build_job
build:debian:sid:i386: build:debian:sid:i386:
@@ -290,11 +294,11 @@ unittest:debian:sid:amd64:
dependencies: dependencies:
- build:debian:sid:amd64 - build:debian:sid:amd64
unittest:clang:debian:sid:amd64: unittest:clang:debian:stretch:amd64:
<<: *debian_sid_amd64_image <<: *debian_stretch_amd64_image
<<: *unit_test_job <<: *unit_test_job
dependencies: dependencies:
- build:clang:debian:sid:amd64 - build:clang:debian:stretch:amd64
unittest:debian:sid:i386: unittest:debian:sid:i386:
<<: *debian_sid_i386_image <<: *debian_sid_i386_image
@@ -338,6 +342,12 @@ systemtest:debian:sid:i386:
dependencies: dependencies:
- build:debian:sid:i386 - build:debian:sid:i386
install:debian:sid:amd64:
<<: *debian_sid_amd64_image
<<: *install_test_job
dependencies:
- build:debian:sid:amd64
pkcs11:build:debian:sid:amd64: pkcs11:build:debian:sid:amd64:
variables: variables:
CC: gcc CC: gcc
@@ -0,0 +1,29 @@
##Release Checklist
- [ ] Check for the presence of a milestone for the release
- If there is a milestone, are all the issues for the milestone resolved? (other than this checklist)
- [ ] Prepare the sources for tarball generation
- [ ] Change software version and library versions in configure.in
- [ ] Update CHANGES
- [ ] Ensure the release notes are correct for this release
- [ ] Ensure the metainformation is correct for this release
- [ ] Make sure the tests are passing
- [ ] Create a tag (name vX_Y_Z[-alphatag], content BIND X.Y.Z[-alphatag], signed with a developer's GPG key): git tag -u <DEVELOPER_KEYID> -a -s -m "BIND X.Y.Z" vX.Y.Z
- [ ] Push the changes and tag
- [ ] Create the tarball
- [ ] Create the Windows zips
- [ ] Ask QA to sanity check the tarball and zips
- [ ] Request the signature on the tarballs
- [ ] Make tarballs and signatures available to download
- [ ] Edit the release https://gitlab.isc.org/isc-projects/bind9/tags and the NEWS snippet + links to the tarballs
- [ ] Update DEB and RPM packages
##Communication
- [ ] Inform support to upload to the web site (nice to give them a heads-up in advance)
Write release e-mail to bind9-announce, bind-users in case of a major release
- [ ] Inform marketing to announce the release
Post short note to Twitter
Update http://en.wikipedia.org/wiki/BIND (mktg)
Blog post if a major release
+74 -1
View File
@@ -1,3 +1,74 @@
5027. [func] Set SO_SNDBUF size on sockets. [GL #74]
5026. [bug] rndc reconfig should not touch already loaded zones.
[GL #276]
5025. [cleanup] Remove isc_keyboard family of functions. [GL #178]
5024. [func] Replace custom assembly for atomic operations with
atomic support from the compiler. The code will now use
C11 stdatomic, or __atomic, or __sync builtins with GCC
or Clang compilers, and Interlocked functions with MSVC.
[GL #10]
5023. [cleanup] Remove wrappers that try to fix broken or incomplete
implementations of IPv6, pthreads and other core
functionality required and used by BIND. [GL #192]
5022. [doc] Update ms-self, ms-subdomain, krb5-self, and
krb5-subdomain documentation. [GL !708]
5021. [bug] dig returned a non-zero exit code when it received a
reply over TCP after a retry. [GL #487]
5020. [func] RNG uses thread-local storage instead of locks, if
supported by platform. [GL #496]
5019. [cleanup] A message is now logged when ixfr-from-differences is
set at zone level for an inline-signed zone. [GL #470]
5018. [bug] Fix incorrect sizeof arguments in lib/isc/pk11.c.
[GL !588]
5017. [bug] lib/isc/pk11.c failed to unlink the session before
releasing the lock which is unsafe. [GL !589]
5016. [bug] Named could assert with overlapping filter-aaaa and
dns64 acls. [GL #445]
5015. [bug] Reloading all zones caused zone maintenance to cease
for inline-signed zones. [GL #435]
5014. [bug] Signatures loaded from the journal for the signed
version of an inline-signed zone were not scheduled for
refresh. [GL #482]
5013. [bug] A referral response with a non-empty ANSWER section was
inadvertently being treated as an error. [GL #390]
5012. [bug] Fix lock order reversal in pk11_initialize. [GL !590]
5011. [func] Remove support for unthreaded named. [GL #478]
5010. [func] New "validate-except" option specifies a list of
domains beneath which DNSSEC validation should not
be performed. [GL #237]
5009. [bug] Upon an OpenSSL failure, the first error in the OpenSSL
error queue was not logged. [GL #476]
5008. [bug] "rndc signing -nsec3param ..." requests were silently
ignored for zones which were not yet loaded or
transferred. [GL #468]
5007. [cleanup] Replace custom ISC boolean and integer data types
with C99 stdint.h and stdbool.h types. [GL #9]
5006. [cleanup] Code preparing a delegation response was extracted from
query_delegation() and query_zone_delegation() into a
separate function in order to decrease code
duplication. [GL #431]
5005. [bug] dnssec-verify, and dnssec-signzone at the verification 5005. [bug] dnssec-verify, and dnssec-signzone at the verification
step, failed on some validly signed zones. [GL #442] step, failed on some validly signed zones. [GL #442]
@@ -22,7 +93,9 @@
4998. [test] Make resolver and cacheclean tests more civilized. 4998. [test] Make resolver and cacheclean tests more civilized.
4997. [placeholder] 4997. [security] named could crash during recursive processing
of DNAME records when "deny-answer-aliases" was
in use. (CVE-2018-5740) [GL #387]
4996. [bug] dig: Handle malformed +ednsopt option. [GL #403] 4996. [bug] dig: Handle malformed +ednsopt option. [GL #403]
+2 -1
View File
@@ -14,7 +14,7 @@ top_builddir = @top_builddir@
VERSION=@BIND9_VERSION@ VERSION=@BIND9_VERSION@
SUBDIRS = make unit lib bin doc SUBDIRS = make unit lib fuzz bin doc
TARGETS = TARGETS =
PREREQS = bind.keys.h PREREQS = bind.keys.h
@@ -90,6 +90,7 @@ force-test: test-force
test-force: test-force:
status=0; \ status=0; \
(cd fuzz && ${MAKE} check) || status=1; \
(cd bin/tests && ${MAKE} ${MAKEDEFS} test) || status=1; \ (cd bin/tests && ${MAKE} ${MAKEDEFS} test) || status=1; \
(test -f ${top_builddir}/unit/unittest.sh && \ (test -f ${top_builddir}/unit/unittest.sh && \
$(SHELL) ${top_builddir}/unit/unittest.sh) || status=1; \ $(SHELL) ${top_builddir}/unit/unittest.sh) || status=1; \
+3
View File
@@ -114,6 +114,9 @@ of changes from BIND 9.12 and earlier releases. New features include:
subject to DNSSEC validation and are not treated as authoritative data subject to DNSSEC validation and are not treated as authoritative data
when answering. This makes it easier to configure a local copy of the when answering. This makes it easier to configure a local copy of the
root zone as described in RFC 7706. root zone as described in RFC 7706.
* QNAME minimization is now supported
* The "validate-except" option allows configuration of domains below
which DNSSEC validation should not be performed.
In addition, cryptographic support has been modernized. BIND now uses the In addition, cryptographic support has been modernized. BIND now uses the
best available pseudo-random number generator for the platform on which best available pseudo-random number generator for the platform on which
+4 -5
View File
@@ -131,6 +131,9 @@ include:
DNSSEC validation and are not treated as authoritative data when DNSSEC validation and are not treated as authoritative data when
answering. This makes it easier to configure a local copy of the root answering. This makes it easier to configure a local copy of the root
zone as described in RFC 7706. zone as described in RFC 7706.
* QNAME minimization is now supported
* The "validate-except" option allows configuration of domains below which
DNSSEC validation should not be performed.
In addition, cryptographic support has been modernized. BIND now uses the In addition, cryptographic support has been modernized. BIND now uses the
best available pseudo-random number generator for the platform on which best available pseudo-random number generator for the platform on which
@@ -144,7 +147,7 @@ Minimally, BIND requires a UNIX or Linux system with an ANSI C compiler,
basic POSIX support, and a 64-bit integer type. Successful builds have been basic POSIX support, and a 64-bit integer type. Successful builds have been
observed on many versions of Linux and UNIX, including RedHat, Fedora, observed on many versions of Linux and UNIX, including RedHat, Fedora,
Debian, Ubuntu, SuSE, Slackware, FreeBSD, NetBSD, OpenBSD, Mac OS X, Debian, Ubuntu, SuSE, Slackware, FreeBSD, NetBSD, OpenBSD, Mac OS X,
Solaris, HP-UX, AIX, SCO OpenServer, and OpenWRT. Solaris, HP-UX, and OpenWRT.
BIND requires a cryptography provider library such as OpenSSL or a BIND requires a cryptography provider library such as OpenSSL or a
hardware service module supporting PKCS#11. On Linux, BIND requires hardware service module supporting PKCS#11. On Linux, BIND requires
@@ -268,10 +271,6 @@ specifying `--enable-fixed-rrset` or `--disable-fixed-rrset` on the
configure command line. By default, fixed rrset-order is disabled to configure command line. By default, fixed rrset-order is disabled to
reduce memory footprint. reduce memory footprint.
If your operating system has integrated support for IPv6, it will be used
automatically. If you have installed KAME IPv6 separately, use
`--with-kame[=PATH]` to specify its location.
`make install` will install `named` and the various BIND 9 libraries. By `make install` will install `named` and the various BIND 9 libraries. By
default, installation is into /usr/local, but this can be changed with the default, installation is into /usr/local, but this can be changed with the
`--prefix` option when running `configure`. `--prefix` option when running `configure`.
-50
View File
@@ -17,9 +17,6 @@
***/ ***/
@TOP@ @TOP@
/** define on DEC OSF to enable 4.4BSD style sa_len support */
#undef _SOCKADDR_LEN
/** define if your system needs pthread_init() before using pthreads */ /** define if your system needs pthread_init() before using pthreads */
#undef NEED_PTHREAD_INIT #undef NEED_PTHREAD_INIT
@@ -29,9 +26,6 @@
/** define if sigwait() is the UnixWare flavor */ /** define if sigwait() is the UnixWare flavor */
#undef HAVE_UNIXWARE_SIGWAIT #undef HAVE_UNIXWARE_SIGWAIT
/** define on Solaris to get sigwait() to work using pthreads semantics */
#undef _POSIX_PTHREAD_SEMANTICS
/** define if LinuxThreads is in use */ /** define if LinuxThreads is in use */
#undef HAVE_LINUXTHREADS #undef HAVE_LINUXTHREADS
@@ -53,62 +47,18 @@
/** define if tzset() is available */ /** define if tzset() is available */
#undef HAVE_TZSET #undef HAVE_TZSET
/** define if struct addrinfo exists */
#undef HAVE_ADDRINFO
/** define if getaddrinfo() exists */
#undef HAVE_GETADDRINFO
/** define if gai_strerror() exists */
#undef HAVE_GAISTRERROR
/** /**
* define if pthread_setconcurrency() should be called to tell the * define if pthread_setconcurrency() should be called to tell the
* OS how many threads we might want to run. * OS how many threads we might want to run.
*/ */
#undef CALL_PTHREAD_SETCONCURRENCY #undef CALL_PTHREAD_SETCONCURRENCY
/** define if IPv6 is not disabled */
#undef WANT_IPV6
/** define if flockfile() is available */ /** define if flockfile() is available */
#undef HAVE_FLOCKFILE #undef HAVE_FLOCKFILE
/** define if getc_unlocked() is available */ /** define if getc_unlocked() is available */
#undef HAVE_GETCUNLOCKED #undef HAVE_GETCUNLOCKED
/** Shut up warnings about sputaux in stdio.h on BSD/OS pre-4.1 */
#undef SHUTUP_SPUTAUX
#ifdef SHUTUP_SPUTAUX
struct __sFILE;
extern __inline int __sputaux(int _c, struct __sFILE *_p);
#endif
/** Shut up warnings about missing sigwait prototype on BSD/OS 4.0* */
#undef SHUTUP_SIGWAIT
#ifdef SHUTUP_SIGWAIT
int sigwait(const unsigned int *set, int *sig);
#endif
/** Shut up warnings from gcc -Wcast-qual on BSD/OS 4.1. */
#undef SHUTUP_STDARG_CAST
#if defined(SHUTUP_STDARG_CAST) && defined(__GNUC__)
#include <stdarg.h> /** Grr. Must be included *every time*. */
/**
* The silly continuation line is to keep configure from
* commenting out the #undef.
*/
#undef \
va_start
#define va_start(ap, last) \
do { \
union { const void *konst; long *var; } _u; \
_u.konst = &(last); \
ap = (va_list)(_u.var + __va_words(__typeof(last))); \
} while (0)
#endif /** SHUTUP_STDARG_CAST && __GNUC__ */
/** define if the system has a random number generating device */ /** define if the system has a random number generating device */
#undef PATH_RANDOMDEV #undef PATH_RANDOMDEV
Vendored
+11 -10
View File
@@ -1,6 +1,6 @@
# generated automatically by aclocal 1.15.1 -*- Autoconf -*- # generated automatically by aclocal 1.16.1 -*- Autoconf -*-
# Copyright (C) 1996-2017 Free Software Foundation, Inc. # Copyright (C) 1996-2018 Free Software Foundation, Inc.
# This file is free software; the Free Software Foundation # This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it, # gives unlimited permission to copy and/or distribute it,
@@ -12,9 +12,9 @@
# PARTICULAR PURPOSE. # PARTICULAR PURPOSE.
m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])]) m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])])
dnl pkg.m4 - Macros to locate and utilise pkg-config. -*- Autoconf -*- # pkg.m4 - Macros to locate and utilise pkg-config. -*- Autoconf -*-
dnl serial 11 (pkg-config-0.29.1) # serial 12 (pkg-config-0.29.2)
dnl
dnl Copyright © 2004 Scott James Remnant <scott@netsplit.com>. dnl Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
dnl Copyright © 2012-2015 Dan Nicholson <dbn.lists@gmail.com> dnl Copyright © 2012-2015 Dan Nicholson <dbn.lists@gmail.com>
dnl dnl
@@ -55,7 +55,7 @@ dnl
dnl See the "Since" comment for each macro you use to see what version dnl See the "Since" comment for each macro you use to see what version
dnl of the macros you require. dnl of the macros you require.
m4_defun([PKG_PREREQ], m4_defun([PKG_PREREQ],
[m4_define([PKG_MACROS_VERSION], [0.29.1]) [m4_define([PKG_MACROS_VERSION], [0.29.2])
m4_if(m4_version_compare(PKG_MACROS_VERSION, [$1]), -1, m4_if(m4_version_compare(PKG_MACROS_VERSION, [$1]), -1,
[m4_fatal([pkg.m4 version $1 or higher is required but ]PKG_MACROS_VERSION[ found])]) [m4_fatal([pkg.m4 version $1 or higher is required but ]PKG_MACROS_VERSION[ found])])
])dnl PKG_PREREQ ])dnl PKG_PREREQ
@@ -156,7 +156,7 @@ AC_ARG_VAR([$1][_CFLAGS], [C compiler flags for $1, overriding pkg-config])dnl
AC_ARG_VAR([$1][_LIBS], [linker flags for $1, overriding pkg-config])dnl AC_ARG_VAR([$1][_LIBS], [linker flags for $1, overriding pkg-config])dnl
pkg_failed=no pkg_failed=no
AC_MSG_CHECKING([for $1]) AC_MSG_CHECKING([for $2])
_PKG_CONFIG([$1][_CFLAGS], [cflags], [$2]) _PKG_CONFIG([$1][_CFLAGS], [cflags], [$2])
_PKG_CONFIG([$1][_LIBS], [libs], [$2]) _PKG_CONFIG([$1][_LIBS], [libs], [$2])
@@ -166,11 +166,11 @@ and $1[]_LIBS to avoid the need to call pkg-config.
See the pkg-config man page for more details.]) See the pkg-config man page for more details.])
if test $pkg_failed = yes; then if test $pkg_failed = yes; then
AC_MSG_RESULT([no]) AC_MSG_RESULT([no])
_PKG_SHORT_ERRORS_SUPPORTED _PKG_SHORT_ERRORS_SUPPORTED
if test $_pkg_short_errors_supported = yes; then if test $_pkg_short_errors_supported = yes; then
$1[]_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "$2" 2>&1` $1[]_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "$2" 2>&1`
else else
$1[]_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "$2" 2>&1` $1[]_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "$2" 2>&1`
fi fi
# Put the nasty error message in config.log where it belongs # Put the nasty error message in config.log where it belongs
@@ -187,7 +187,7 @@ installed software in a non-standard prefix.
_PKG_TEXT])[]dnl _PKG_TEXT])[]dnl
]) ])
elif test $pkg_failed = untried; then elif test $pkg_failed = untried; then
AC_MSG_RESULT([no]) AC_MSG_RESULT([no])
m4_default([$4], [AC_MSG_FAILURE( m4_default([$4], [AC_MSG_FAILURE(
[The pkg-config script could not be found or is too old. Make sure it [The pkg-config script could not be found or is too old. Make sure it
is in your PATH or set the PKG_CONFIG environment variable to the full is in your PATH or set the PKG_CONFIG environment variable to the full
@@ -289,6 +289,7 @@ AS_VAR_IF([$1], [""], [$5], [$4])dnl
])dnl PKG_CHECK_VAR ])dnl PKG_CHECK_VAR
m4_include([m4/ax_check_openssl.m4]) m4_include([m4/ax_check_openssl.m4])
m4_include([m4/ax_pthread.m4])
m4_include([m4/libtool.m4]) m4_include([m4/libtool.m4])
m4_include([m4/ltoptions.m4]) m4_include([m4/ltoptions.m4])
m4_include([m4/ltsugar.m4]) m4_include([m4/ltsugar.m4])
+45 -64
View File
@@ -14,7 +14,9 @@
#include <config.h> #include <config.h>
#include <stdbool.h>
#include <stdio.h> #include <stdio.h>
#include <inttypes.h>
#ifdef _WIN32 #ifdef _WIN32
#include <Winsock2.h> #include <Winsock2.h>
@@ -60,14 +62,6 @@
#define CHECK_LOCAL 1 #define CHECK_LOCAL 1
#endif #endif
#ifdef HAVE_ADDRINFO
#ifdef HAVE_GETADDRINFO
#ifdef HAVE_GAISTRERROR
#define USE_GETADDRINFO
#endif
#endif
#endif
#define CHECK(r) \ #define CHECK(r) \
do { \ do { \
result = (r); \ result = (r); \
@@ -88,15 +82,15 @@ static const char *dbtype[] = { "rbt" };
int debug = 0; int debug = 0;
const char *journal = NULL; const char *journal = NULL;
isc_boolean_t nomerge = ISC_TRUE; bool nomerge = true;
#if CHECK_LOCAL #if CHECK_LOCAL
isc_boolean_t docheckmx = ISC_TRUE; bool docheckmx = true;
isc_boolean_t dochecksrv = ISC_TRUE; bool dochecksrv = true;
isc_boolean_t docheckns = ISC_TRUE; bool docheckns = true;
#else #else
isc_boolean_t docheckmx = ISC_FALSE; bool docheckmx = false;
isc_boolean_t dochecksrv = ISC_FALSE; bool dochecksrv = false;
isc_boolean_t docheckns = ISC_FALSE; bool docheckns = false;
#endif #endif
dns_zoneopt_t zone_options = DNS_ZONEOPT_CHECKNS | dns_zoneopt_t zone_options = DNS_ZONEOPT_CHECKNS |
DNS_ZONEOPT_CHECKMX | DNS_ZONEOPT_CHECKMX |
@@ -142,7 +136,7 @@ add(char *key, int value) {
if (symtab == NULL) { if (symtab == NULL) {
result = isc_symtab_create(sym_mctx, 100, freekey, sym_mctx, result = isc_symtab_create(sym_mctx, 100, freekey, sym_mctx,
ISC_FALSE, &symtab); false, &symtab);
if (result != ISC_R_SUCCESS) if (result != ISC_R_SUCCESS)
return; return;
} }
@@ -158,32 +152,31 @@ add(char *key, int value) {
isc_mem_free(sym_mctx, key); isc_mem_free(sym_mctx, key);
} }
static isc_boolean_t static bool
logged(char *key, int value) { logged(char *key, int value) {
isc_result_t result; isc_result_t result;
if (symtab == NULL) if (symtab == NULL)
return (ISC_FALSE); return (false);
result = isc_symtab_lookup(symtab, key, value, NULL); result = isc_symtab_lookup(symtab, key, value, NULL);
if (result == ISC_R_SUCCESS) if (result == ISC_R_SUCCESS)
return (ISC_TRUE); return (true);
return (ISC_FALSE); return (false);
} }
static isc_boolean_t static bool
checkns(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner, checkns(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner,
dns_rdataset_t *a, dns_rdataset_t *aaaa) dns_rdataset_t *a, dns_rdataset_t *aaaa)
{ {
#ifdef USE_GETADDRINFO
dns_rdataset_t *rdataset; dns_rdataset_t *rdataset;
dns_rdata_t rdata = DNS_RDATA_INIT; dns_rdata_t rdata = DNS_RDATA_INIT;
struct addrinfo hints, *ai, *cur; struct addrinfo hints, *ai, *cur;
char namebuf[DNS_NAME_FORMATSIZE + 1]; char namebuf[DNS_NAME_FORMATSIZE + 1];
char ownerbuf[DNS_NAME_FORMATSIZE]; char ownerbuf[DNS_NAME_FORMATSIZE];
char addrbuf[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:123.123.123.123")]; char addrbuf[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:123.123.123.123")];
isc_boolean_t answer = ISC_TRUE; bool answer = true;
isc_boolean_t match; bool match;
const char *type; const char *type;
void *ptr = NULL; void *ptr = NULL;
int result; int result;
@@ -232,7 +225,7 @@ checkns(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner,
ownerbuf, namebuf, ownerbuf, namebuf,
cur->ai_canonname); cur->ai_canonname);
/* XXX950 make fatal for 9.5.0 */ /* XXX950 make fatal for 9.5.0 */
/* answer = ISC_FALSE; */ /* answer = false; */
add(namebuf, ERR_IS_CNAME); add(namebuf, ERR_IS_CNAME);
} }
break; break;
@@ -248,7 +241,7 @@ checkns(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner,
add(namebuf, ERR_NO_ADDRESSES); add(namebuf, ERR_NO_ADDRESSES);
} }
/* XXX950 make fatal for 9.5.0 */ /* XXX950 make fatal for 9.5.0 */
return (ISC_TRUE); return (true);
default: default:
if (!logged(namebuf, ERR_LOOKUP_FAILURE)) { if (!logged(namebuf, ERR_LOOKUP_FAILURE)) {
@@ -257,7 +250,7 @@ checkns(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner,
namebuf, gai_strerror(result)); namebuf, gai_strerror(result));
add(namebuf, ERR_LOOKUP_FAILURE); add(namebuf, ERR_LOOKUP_FAILURE);
} }
return (ISC_TRUE); return (true);
} }
/* /*
@@ -268,13 +261,13 @@ checkns(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner,
result = dns_rdataset_first(a); result = dns_rdataset_first(a);
while (result == ISC_R_SUCCESS) { while (result == ISC_R_SUCCESS) {
dns_rdataset_current(a, &rdata); dns_rdataset_current(a, &rdata);
match = ISC_FALSE; match = false;
for (cur = ai; cur != NULL; cur = cur->ai_next) { for (cur = ai; cur != NULL; cur = cur->ai_next) {
if (cur->ai_family != AF_INET) if (cur->ai_family != AF_INET)
continue; continue;
ptr = &((struct sockaddr_in *)(cur->ai_addr))->sin_addr; ptr = &((struct sockaddr_in *)(cur->ai_addr))->sin_addr;
if (memcmp(ptr, rdata.data, rdata.length) == 0) { if (memcmp(ptr, rdata.data, rdata.length) == 0) {
match = ISC_TRUE; match = true;
break; break;
} }
} }
@@ -286,7 +279,7 @@ checkns(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner,
addrbuf, sizeof(addrbuf))); addrbuf, sizeof(addrbuf)));
add(namebuf, ERR_EXTRA_A); add(namebuf, ERR_EXTRA_A);
/* XXX950 make fatal for 9.5.0 */ /* XXX950 make fatal for 9.5.0 */
/* answer = ISC_FALSE; */ /* answer = false; */
} }
dns_rdata_reset(&rdata); dns_rdata_reset(&rdata);
result = dns_rdataset_next(a); result = dns_rdataset_next(a);
@@ -298,13 +291,13 @@ checkns(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner,
result = dns_rdataset_first(aaaa); result = dns_rdataset_first(aaaa);
while (result == ISC_R_SUCCESS) { while (result == ISC_R_SUCCESS) {
dns_rdataset_current(aaaa, &rdata); dns_rdataset_current(aaaa, &rdata);
match = ISC_FALSE; match = false;
for (cur = ai; cur != NULL; cur = cur->ai_next) { for (cur = ai; cur != NULL; cur = cur->ai_next) {
if (cur->ai_family != AF_INET6) if (cur->ai_family != AF_INET6)
continue; continue;
ptr = &((struct sockaddr_in6 *)(cur->ai_addr))->sin6_addr; ptr = &((struct sockaddr_in6 *)(cur->ai_addr))->sin6_addr;
if (memcmp(ptr, rdata.data, rdata.length) == 0) { if (memcmp(ptr, rdata.data, rdata.length) == 0) {
match = ISC_TRUE; match = true;
break; break;
} }
} }
@@ -316,7 +309,7 @@ checkns(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner,
addrbuf, sizeof(addrbuf))); addrbuf, sizeof(addrbuf)));
add(namebuf, ERR_EXTRA_AAAA); add(namebuf, ERR_EXTRA_AAAA);
/* XXX950 make fatal for 9.5.0. */ /* XXX950 make fatal for 9.5.0. */
/* answer = ISC_FALSE; */ /* answer = false; */
} }
dns_rdata_reset(&rdata); dns_rdata_reset(&rdata);
result = dns_rdataset_next(aaaa); result = dns_rdataset_next(aaaa);
@@ -327,7 +320,7 @@ checkns(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner,
* Check that all addresses appear in the glue. * Check that all addresses appear in the glue.
*/ */
if (!logged(namebuf, ERR_MISSING_GLUE)) { if (!logged(namebuf, ERR_MISSING_GLUE)) {
isc_boolean_t missing_glue = ISC_FALSE; bool missing_glue = false;
for (cur = ai; cur != NULL; cur = cur->ai_next) { for (cur = ai; cur != NULL; cur = cur->ai_next) {
switch (cur->ai_family) { switch (cur->ai_family) {
case AF_INET: case AF_INET:
@@ -343,7 +336,7 @@ checkns(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner,
default: default:
continue; continue;
} }
match = ISC_FALSE; match = false;
if (dns_rdataset_isassociated(rdataset)) if (dns_rdataset_isassociated(rdataset))
result = dns_rdataset_first(rdataset); result = dns_rdataset_first(rdataset);
else else
@@ -351,7 +344,7 @@ checkns(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner,
while (result == ISC_R_SUCCESS && !match) { while (result == ISC_R_SUCCESS && !match) {
dns_rdataset_current(rdataset, &rdata); dns_rdataset_current(rdataset, &rdata);
if (memcmp(ptr, rdata.data, rdata.length) == 0) if (memcmp(ptr, rdata.data, rdata.length) == 0)
match = ISC_TRUE; match = true;
dns_rdata_reset(&rdata); dns_rdata_reset(&rdata);
result = dns_rdataset_next(rdataset); result = dns_rdataset_next(rdataset);
} }
@@ -362,8 +355,8 @@ checkns(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner,
inet_ntop(cur->ai_family, ptr, inet_ntop(cur->ai_family, ptr,
addrbuf, sizeof(addrbuf))); addrbuf, sizeof(addrbuf)));
/* XXX950 make fatal for 9.5.0. */ /* XXX950 make fatal for 9.5.0. */
/* answer = ISC_FALSE; */ /* answer = false; */
missing_glue = ISC_TRUE; missing_glue = true;
} }
} }
if (missing_glue) if (missing_glue)
@@ -371,20 +364,16 @@ checkns(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner,
} }
freeaddrinfo(ai); freeaddrinfo(ai);
return (answer); return (answer);
#else
return (ISC_TRUE);
#endif
} }
static isc_boolean_t static bool
checkmx(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner) { checkmx(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner) {
#ifdef USE_GETADDRINFO
struct addrinfo hints, *ai, *cur; struct addrinfo hints, *ai, *cur;
char namebuf[DNS_NAME_FORMATSIZE + 1]; char namebuf[DNS_NAME_FORMATSIZE + 1];
char ownerbuf[DNS_NAME_FORMATSIZE]; char ownerbuf[DNS_NAME_FORMATSIZE];
int result; int result;
int level = ISC_LOG_ERROR; int level = ISC_LOG_ERROR;
isc_boolean_t answer = ISC_TRUE; bool answer = true;
memset(&hints, 0, sizeof(hints)); memset(&hints, 0, sizeof(hints));
hints.ai_flags = AI_CANONNAME; hints.ai_flags = AI_CANONNAME;
@@ -428,7 +417,7 @@ checkmx(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner) {
add(namebuf, ERR_IS_MXCNAME); add(namebuf, ERR_IS_MXCNAME);
} }
if (level == ISC_LOG_ERROR) if (level == ISC_LOG_ERROR)
answer = ISC_FALSE; answer = false;
} }
} }
freeaddrinfo(ai); freeaddrinfo(ai);
@@ -446,7 +435,7 @@ checkmx(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner) {
add(namebuf, ERR_NO_ADDRESSES); add(namebuf, ERR_NO_ADDRESSES);
} }
/* XXX950 make fatal for 9.5.0. */ /* XXX950 make fatal for 9.5.0. */
return (ISC_TRUE); return (true);
default: default:
if (!logged(namebuf, ERR_LOOKUP_FAILURE)) { if (!logged(namebuf, ERR_LOOKUP_FAILURE)) {
@@ -455,22 +444,18 @@ checkmx(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner) {
namebuf, gai_strerror(result)); namebuf, gai_strerror(result));
add(namebuf, ERR_LOOKUP_FAILURE); add(namebuf, ERR_LOOKUP_FAILURE);
} }
return (ISC_TRUE); return (true);
} }
#else
return (ISC_TRUE);
#endif
} }
static isc_boolean_t static bool
checksrv(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner) { checksrv(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner) {
#ifdef USE_GETADDRINFO
struct addrinfo hints, *ai, *cur; struct addrinfo hints, *ai, *cur;
char namebuf[DNS_NAME_FORMATSIZE + 1]; char namebuf[DNS_NAME_FORMATSIZE + 1];
char ownerbuf[DNS_NAME_FORMATSIZE]; char ownerbuf[DNS_NAME_FORMATSIZE];
int result; int result;
int level = ISC_LOG_ERROR; int level = ISC_LOG_ERROR;
isc_boolean_t answer = ISC_TRUE; bool answer = true;
memset(&hints, 0, sizeof(hints)); memset(&hints, 0, sizeof(hints));
hints.ai_flags = AI_CANONNAME; hints.ai_flags = AI_CANONNAME;
@@ -513,7 +498,7 @@ checksrv(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner) {
add(namebuf, ERR_IS_SRVCNAME); add(namebuf, ERR_IS_SRVCNAME);
} }
if (level == ISC_LOG_ERROR) if (level == ISC_LOG_ERROR)
answer = ISC_FALSE; answer = false;
} }
} }
freeaddrinfo(ai); freeaddrinfo(ai);
@@ -531,7 +516,7 @@ checksrv(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner) {
add(namebuf, ERR_NO_ADDRESSES); add(namebuf, ERR_NO_ADDRESSES);
} }
/* XXX950 make fatal for 9.5.0. */ /* XXX950 make fatal for 9.5.0. */
return (ISC_TRUE); return (true);
default: default:
if (!logged(namebuf, ERR_LOOKUP_FAILURE)) { if (!logged(namebuf, ERR_LOOKUP_FAILURE)) {
@@ -540,11 +525,8 @@ checksrv(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner) {
namebuf, gai_strerror(result)); namebuf, gai_strerror(result));
add(namebuf, ERR_LOOKUP_FAILURE); add(namebuf, ERR_LOOKUP_FAILURE);
} }
return (ISC_TRUE); return (true);
} }
#else
return (ISC_TRUE);
#endif
} }
isc_result_t isc_result_t
@@ -650,7 +632,7 @@ check_ttls(dns_zone_t *zone, dns_ttl_t maxttl) {
if (dbiter != NULL) if (dbiter != NULL)
dns_dbiterator_destroy(&dbiter); dns_dbiterator_destroy(&dbiter);
if (version != NULL) if (version != NULL)
dns_db_closeversion(db, &version, ISC_FALSE); dns_db_closeversion(db, &version, false);
if (db != NULL) if (db != NULL)
dns_db_detach(&db); dns_db_detach(&db);
@@ -697,7 +679,7 @@ load_zone(isc_mem_t *mctx, const char *zonename, const char *filename,
CHECK(dns_rdataclass_fromtext(&rdclass, &region)); CHECK(dns_rdataclass_fromtext(&rdclass, &region));
dns_zone_setclass(zone, rdclass); dns_zone_setclass(zone, rdclass);
dns_zone_setoption(zone, zone_options, ISC_TRUE); dns_zone_setoption(zone, zone_options, true);
dns_zone_setoption(zone, DNS_ZONEOPT_NOMERGE, nomerge); dns_zone_setoption(zone, DNS_ZONEOPT_NOMERGE, nomerge);
dns_zone_setmaxttl(zone, maxttl); dns_zone_setmaxttl(zone, maxttl);
@@ -709,7 +691,7 @@ load_zone(isc_mem_t *mctx, const char *zonename, const char *filename,
if (dochecksrv) if (dochecksrv)
dns_zone_setchecksrv(zone, checksrv); dns_zone_setchecksrv(zone, checksrv);
CHECK(dns_zone_load(zone)); CHECK(dns_zone_load(zone, false));
/* /*
* When loading map files we can't catch oversize TTLs during * When loading map files we can't catch oversize TTLs during
@@ -734,7 +716,7 @@ load_zone(isc_mem_t *mctx, const char *zonename, const char *filename,
isc_result_t isc_result_t
dump_zone(const char *zonename, dns_zone_t *zone, const char *filename, dump_zone(const char *zonename, dns_zone_t *zone, const char *filename,
dns_masterformat_t fileformat, const dns_master_style_t *style, dns_masterformat_t fileformat, const dns_master_style_t *style,
const isc_uint32_t rawversion) const uint32_t rawversion)
{ {
isc_result_t result; isc_result_t result;
FILE *output = stdout; FILE *output = stdout;
@@ -789,4 +771,3 @@ DestroySockets(void) {
WSACleanup(); WSACleanup();
} }
#endif #endif
+8 -5
View File
@@ -15,6 +15,9 @@
/*! \file */ /*! \file */
#include <inttypes.h>
#include <stdbool.h>
#include <isc/lang.h> #include <isc/lang.h>
#include <isc/stdio.h> #include <isc/stdio.h>
#include <isc/types.h> #include <isc/types.h>
@@ -36,7 +39,7 @@ load_zone(isc_mem_t *mctx, const char *zonename, const char *filename,
isc_result_t isc_result_t
dump_zone(const char *zonename, dns_zone_t *zone, const char *filename, dump_zone(const char *zonename, dns_zone_t *zone, const char *filename,
dns_masterformat_t fileformat, const dns_master_style_t *style, dns_masterformat_t fileformat, const dns_master_style_t *style,
const isc_uint32_t rawversion); const uint32_t rawversion);
#ifdef _WIN32 #ifdef _WIN32
void InitSockets(void); void InitSockets(void);
@@ -45,10 +48,10 @@ void DestroySockets(void);
extern int debug; extern int debug;
extern const char *journal; extern const char *journal;
extern isc_boolean_t nomerge; extern bool nomerge;
extern isc_boolean_t docheckmx; extern bool docheckmx;
extern isc_boolean_t docheckns; extern bool docheckns;
extern isc_boolean_t dochecksrv; extern bool dochecksrv;
extern dns_zoneopt_t zone_options; extern dns_zoneopt_t zone_options;
ISC_LANG_ENDDECLS ISC_LANG_ENDDECLS
+23 -22
View File
@@ -15,6 +15,7 @@
#include <config.h> #include <config.h>
#include <errno.h> #include <errno.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
@@ -91,18 +92,18 @@ directory_callback(const char *clausename, const cfg_obj_t *obj, void *arg) {
return (ISC_R_SUCCESS); return (ISC_R_SUCCESS);
} }
static isc_boolean_t static bool
get_maps(const cfg_obj_t **maps, const char *name, const cfg_obj_t **obj) { get_maps(const cfg_obj_t **maps, const char *name, const cfg_obj_t **obj) {
int i; int i;
for (i = 0;; i++) { for (i = 0;; i++) {
if (maps[i] == NULL) if (maps[i] == NULL)
return (ISC_FALSE); return (false);
if (cfg_map_get(maps[i], name, obj) == ISC_R_SUCCESS) if (cfg_map_get(maps[i], name, obj) == ISC_R_SUCCESS)
return (ISC_TRUE); return (true);
} }
} }
static isc_boolean_t static bool
get_checknames(const cfg_obj_t **maps, const cfg_obj_t **obj) { get_checknames(const cfg_obj_t **maps, const cfg_obj_t **obj) {
const cfg_listelt_t *element; const cfg_listelt_t *element;
const cfg_obj_t *checknames; const cfg_obj_t *checknames;
@@ -113,14 +114,14 @@ get_checknames(const cfg_obj_t **maps, const cfg_obj_t **obj) {
for (i = 0;; i++) { for (i = 0;; i++) {
if (maps[i] == NULL) if (maps[i] == NULL)
return (ISC_FALSE); return (false);
checknames = NULL; checknames = NULL;
result = cfg_map_get(maps[i], "check-names", &checknames); result = cfg_map_get(maps[i], "check-names", &checknames);
if (result != ISC_R_SUCCESS) if (result != ISC_R_SUCCESS)
continue; continue;
if (checknames != NULL && !cfg_obj_islist(checknames)) { if (checknames != NULL && !cfg_obj_islist(checknames)) {
*obj = checknames; *obj = checknames;
return (ISC_TRUE); return (true);
} }
for (element = cfg_list_first(checknames); for (element = cfg_list_first(checknames);
element != NULL; element != NULL;
@@ -135,7 +136,7 @@ get_checknames(const cfg_obj_t **maps, const cfg_obj_t **obj) {
continue; continue;
} }
*obj = cfg_tuple_get(value, "mode"); *obj = cfg_tuple_get(value, "mode");
return (ISC_TRUE); return (true);
} }
} }
} }
@@ -168,7 +169,7 @@ configure_hint(const char *zfile, const char *zclass, isc_mem_t *mctx) {
static isc_result_t static isc_result_t
configure_zone(const char *vclass, const char *view, configure_zone(const char *vclass, const char *view,
const cfg_obj_t *zconfig, const cfg_obj_t *vconfig, const cfg_obj_t *zconfig, const cfg_obj_t *vconfig,
const cfg_obj_t *config, isc_mem_t *mctx, isc_boolean_t list) const cfg_obj_t *config, isc_mem_t *mctx, bool list)
{ {
int i = 0; int i = 0;
isc_result_t result; isc_result_t result;
@@ -420,7 +421,7 @@ configure_zone(const char *vclass, const char *view,
/*% configure a view */ /*% configure a view */
static isc_result_t static isc_result_t
configure_view(const char *vclass, const char *view, const cfg_obj_t *config, configure_view(const char *vclass, const char *view, const cfg_obj_t *config,
const cfg_obj_t *vconfig, isc_mem_t *mctx, isc_boolean_t list) const cfg_obj_t *vconfig, isc_mem_t *mctx, bool list)
{ {
const cfg_listelt_t *element; const cfg_listelt_t *element;
const cfg_obj_t *voptions; const cfg_obj_t *voptions;
@@ -469,7 +470,7 @@ config_getclass(const cfg_obj_t *classobj, dns_rdataclass_t defclass,
/*% load zones from the configuration */ /*% load zones from the configuration */
static isc_result_t static isc_result_t
load_zones_fromconfig(const cfg_obj_t *config, isc_mem_t *mctx, load_zones_fromconfig(const cfg_obj_t *config, isc_mem_t *mctx,
isc_boolean_t list_zones) bool list_zones)
{ {
const cfg_listelt_t *element; const cfg_listelt_t *element;
const cfg_obj_t *views; const cfg_obj_t *views;
@@ -537,12 +538,12 @@ main(int argc, char **argv) {
isc_mem_t *mctx = NULL; isc_mem_t *mctx = NULL;
isc_result_t result; isc_result_t result;
int exit_status = 0; int exit_status = 0;
isc_boolean_t load_zones = ISC_FALSE; bool load_zones = false;
isc_boolean_t list_zones = ISC_FALSE; bool list_zones = false;
isc_boolean_t print = ISC_FALSE; bool print = false;
unsigned int flags = 0; unsigned int flags = 0;
isc_commandline_errprint = ISC_FALSE; isc_commandline_errprint = false;
/* /*
* Process memory debugging argument first. * Process memory debugging argument first.
@@ -566,7 +567,7 @@ main(int argc, char **argv) {
break; break;
} }
} }
isc_commandline_reset = ISC_TRUE; isc_commandline_reset = true;
RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS); RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS);
@@ -577,11 +578,11 @@ main(int argc, char **argv) {
break; break;
case 'j': case 'j':
nomerge = ISC_FALSE; nomerge = false;
break; break;
case 'l': case 'l':
list_zones = ISC_TRUE; list_zones = true;
break; break;
case 'm': case 'm':
@@ -597,7 +598,7 @@ main(int argc, char **argv) {
break; break;
case 'p': case 'p':
print = ISC_TRUE; print = true;
break; break;
case 'v': case 'v':
@@ -609,10 +610,10 @@ main(int argc, char **argv) {
break; break;
case 'z': case 'z':
load_zones = ISC_TRUE; load_zones = true;
docheckmx = ISC_FALSE; docheckmx = false;
docheckns = ISC_FALSE; docheckns = false;
dochecksrv = ISC_FALSE; dochecksrv = false;
break; break;
case '?': case '?':
+25 -23
View File
@@ -14,7 +14,9 @@
#include <config.h> #include <config.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <inttypes.h>
#include <isc/app.h> #include <isc/app.h>
#include <isc/commandline.h> #include <isc/commandline.h>
@@ -106,10 +108,10 @@ main(int argc, char **argv) {
dns_masterformat_t inputformat = dns_masterformat_text; dns_masterformat_t inputformat = dns_masterformat_text;
dns_masterformat_t outputformat = dns_masterformat_text; dns_masterformat_t outputformat = dns_masterformat_text;
dns_masterrawheader_t header; dns_masterrawheader_t header;
isc_uint32_t rawversion = 1, serialnum = 0; uint32_t rawversion = 1, serialnum = 0;
dns_ttl_t maxttl = 0; dns_ttl_t maxttl = 0;
isc_boolean_t snset = ISC_FALSE; bool snset = false;
isc_boolean_t logdump = ISC_FALSE; bool logdump = false;
FILE *errout = stdout; FILE *errout = stdout;
char *endp; char *endp;
@@ -159,7 +161,7 @@ main(int argc, char **argv) {
#define ARGCMP(X) (strcmp(isc_commandline_argument, X) == 0) #define ARGCMP(X) (strcmp(isc_commandline_argument, X) == 0)
isc_commandline_errprint = ISC_FALSE; isc_commandline_errprint = false;
while ((c = isc_commandline_parse(argc, argv, while ((c = isc_commandline_parse(argc, argv,
"c:df:hi:jJ:k:L:l:m:n:qr:s:t:o:vw:DF:M:S:T:W:")) "c:df:hi:jJ:k:L:l:m:n:qr:s:t:o:vw:DF:M:S:T:W:"))
@@ -177,33 +179,33 @@ main(int argc, char **argv) {
if (ARGCMP("full")) { if (ARGCMP("full")) {
zone_options |= DNS_ZONEOPT_CHECKINTEGRITY | zone_options |= DNS_ZONEOPT_CHECKINTEGRITY |
DNS_ZONEOPT_CHECKSIBLING; DNS_ZONEOPT_CHECKSIBLING;
docheckmx = ISC_TRUE; docheckmx = true;
docheckns = ISC_TRUE; docheckns = true;
dochecksrv = ISC_TRUE; dochecksrv = true;
} else if (ARGCMP("full-sibling")) { } else if (ARGCMP("full-sibling")) {
zone_options |= DNS_ZONEOPT_CHECKINTEGRITY; zone_options |= DNS_ZONEOPT_CHECKINTEGRITY;
zone_options &= ~DNS_ZONEOPT_CHECKSIBLING; zone_options &= ~DNS_ZONEOPT_CHECKSIBLING;
docheckmx = ISC_TRUE; docheckmx = true;
docheckns = ISC_TRUE; docheckns = true;
dochecksrv = ISC_TRUE; dochecksrv = true;
} else if (ARGCMP("local")) { } else if (ARGCMP("local")) {
zone_options |= DNS_ZONEOPT_CHECKINTEGRITY; zone_options |= DNS_ZONEOPT_CHECKINTEGRITY;
zone_options |= DNS_ZONEOPT_CHECKSIBLING; zone_options |= DNS_ZONEOPT_CHECKSIBLING;
docheckmx = ISC_FALSE; docheckmx = false;
docheckns = ISC_FALSE; docheckns = false;
dochecksrv = ISC_FALSE; dochecksrv = false;
} else if (ARGCMP("local-sibling")) { } else if (ARGCMP("local-sibling")) {
zone_options |= DNS_ZONEOPT_CHECKINTEGRITY; zone_options |= DNS_ZONEOPT_CHECKINTEGRITY;
zone_options &= ~DNS_ZONEOPT_CHECKSIBLING; zone_options &= ~DNS_ZONEOPT_CHECKSIBLING;
docheckmx = ISC_FALSE; docheckmx = false;
docheckns = ISC_FALSE; docheckns = false;
dochecksrv = ISC_FALSE; dochecksrv = false;
} else if (ARGCMP("none")) { } else if (ARGCMP("none")) {
zone_options &= ~DNS_ZONEOPT_CHECKINTEGRITY; zone_options &= ~DNS_ZONEOPT_CHECKINTEGRITY;
zone_options &= ~DNS_ZONEOPT_CHECKSIBLING; zone_options &= ~DNS_ZONEOPT_CHECKSIBLING;
docheckmx = ISC_FALSE; docheckmx = false;
docheckns = ISC_FALSE; docheckns = false;
dochecksrv = ISC_FALSE; dochecksrv = false;
} else { } else {
fprintf(stderr, "invalid argument to -i: %s\n", fprintf(stderr, "invalid argument to -i: %s\n",
isc_commandline_argument); isc_commandline_argument);
@@ -220,12 +222,12 @@ main(int argc, char **argv) {
break; break;
case 'j': case 'j':
nomerge = ISC_FALSE; nomerge = false;
break; break;
case 'J': case 'J':
journal = isc_commandline_argument; journal = isc_commandline_argument;
nomerge = ISC_FALSE; nomerge = false;
break; break;
case 'k': case 'k':
@@ -246,7 +248,7 @@ main(int argc, char **argv) {
break; break;
case 'L': case 'L':
snset = ISC_TRUE; snset = true;
endp = NULL; endp = NULL;
serialnum = strtol(isc_commandline_argument, &endp, 0); serialnum = strtol(isc_commandline_argument, &endp, 0);
if (*endp != '\0') { if (*endp != '\0') {
@@ -505,7 +507,7 @@ main(int argc, char **argv) {
strcmp(output_filename, "/dev/fd/1") == 0 || strcmp(output_filename, "/dev/fd/1") == 0 ||
strcmp(output_filename, "/dev/stdout") == 0)) { strcmp(output_filename, "/dev/stdout") == 0)) {
errout = stderr; errout = stderr;
logdump = ISC_FALSE; logdump = false;
} }
if (isc_commandline_index + 2 != argc) if (isc_commandline_index + 2 != argc)
+2 -2
View File
@@ -70,7 +70,7 @@
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\isccc\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);..\..\..\lib\ns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\isccc\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);..\..\..\lib\ns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>checktool.lib;libisc.lib;libdns.lib;libisccfg.lib;libisccc.lib;libbind9.lib;libns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@checktool.lib;libisc.lib;libdns.lib;libisccfg.lib;libisccc.lib;libbind9.lib;libns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'"> <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'">
@@ -99,7 +99,7 @@
<OptimizeReferences>true</OptimizeReferences> <OptimizeReferences>true</OptimizeReferences>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\isccc\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);..\..\..\lib\ns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\isccc\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);..\..\..\lib\ns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>checktool.lib;libisc.lib;libdns.lib;libisccfg.lib;libisccc.lib;libbind9.lib;libns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@checktool.lib;libisc.lib;libdns.lib;libisccfg.lib;libisccc.lib;libbind9.lib;libns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration> <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
+2 -2
View File
@@ -70,7 +70,7 @@
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);..\..\..\lib\ns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);..\..\..\lib\ns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>checktool.lib;libisc.lib;libdns.lib;libisccfg.lib;libbind9.lib;libns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@checktool.lib;libisc.lib;libdns.lib;libisccfg.lib;libbind9.lib;libns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
<PostBuildEvent> <PostBuildEvent>
<Command>cd ..\..\..\Build\$(Configuration) <Command>cd ..\..\..\Build\$(Configuration)
@@ -105,7 +105,7 @@ copy /Y named-checkzone.ilk named-compilezone.ilk
<OptimizeReferences>true</OptimizeReferences> <OptimizeReferences>true</OptimizeReferences>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);..\..\..\lib\ns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);..\..\..\lib\ns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>checktool.lib;libisc.lib;libdns.lib;libisccfg.lib;libbind9.lib;libns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@checktool.lib;libisc.lib;libdns.lib;libisccfg.lib;libbind9.lib;libns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration> <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
</Link> </Link>
<PostBuildEvent> <PostBuildEvent>
+9 -9
View File
@@ -19,15 +19,15 @@
#include <config.h> #include <config.h>
#include <stdlib.h>
#include <stdarg.h> #include <stdarg.h>
#include <stdbool.h>
#include <stdlib.h>
#include <isc/assertions.h> #include <isc/assertions.h>
#include <isc/base64.h> #include <isc/base64.h>
#include <isc/buffer.h> #include <isc/buffer.h>
#include <isc/commandline.h> #include <isc/commandline.h>
#include <isc/file.h> #include <isc/file.h>
#include <isc/keyboard.h>
#include <isc/mem.h> #include <isc/mem.h>
#include <isc/net.h> #include <isc/net.h>
#include <isc/print.h> #include <isc/print.h>
@@ -56,7 +56,7 @@
static char program[256]; static char program[256];
const char *progname; const char *progname;
static enum { progmode_keygen, progmode_confgen} progmode; static enum { progmode_keygen, progmode_confgen} progmode;
isc_boolean_t verbose = ISC_FALSE; /* needed by util.c but not used here */ bool verbose = false; /* needed by util.c but not used here */
ISC_PLATFORM_NORETURN_PRE static void ISC_PLATFORM_NORETURN_PRE static void
usage(int status) ISC_PLATFORM_NORETURN_POST; usage(int status) ISC_PLATFORM_NORETURN_POST;
@@ -87,8 +87,8 @@ Usage:\n\
int int
main(int argc, char **argv) { main(int argc, char **argv) {
isc_result_t result = ISC_R_SUCCESS; isc_result_t result = ISC_R_SUCCESS;
isc_boolean_t show_final_mem = ISC_FALSE; bool show_final_mem = false;
isc_boolean_t quiet = ISC_FALSE; bool quiet = false;
isc_buffer_t key_txtbuffer; isc_buffer_t key_txtbuffer;
char key_txtsecret[256]; char key_txtsecret[256];
isc_mem_t *mctx = NULL; isc_mem_t *mctx = NULL;
@@ -124,13 +124,13 @@ main(int argc, char **argv) {
if (PROGCMP("tsig-keygen")) { if (PROGCMP("tsig-keygen")) {
progmode = progmode_keygen; progmode = progmode_keygen;
quiet = ISC_TRUE; quiet = true;
} else if (PROGCMP("ddns-confgen")) } else if (PROGCMP("ddns-confgen"))
progmode = progmode_confgen; progmode = progmode_confgen;
else else
INSIST(0); INSIST(0);
isc_commandline_errprint = ISC_FALSE; isc_commandline_errprint = false;
while ((ch = isc_commandline_parse(argc, argv, while ((ch = isc_commandline_parse(argc, argv,
"a:hk:Mmr:qs:y:z:")) != -1) { "a:hk:Mmr:qs:y:z:")) != -1) {
@@ -155,11 +155,11 @@ main(int argc, char **argv) {
isc_mem_debugging = ISC_MEM_DEBUGTRACE; isc_mem_debugging = ISC_MEM_DEBUGTRACE;
break; break;
case 'm': case 'm':
show_final_mem = ISC_TRUE; show_final_mem = true;
break; break;
case 'q': case 'q':
if (progmode == progmode_confgen) if (progmode == progmode_confgen)
quiet = ISC_TRUE; quiet = true;
else else
usage(1); usage(1);
break; break;
-2
View File
@@ -20,7 +20,6 @@
#include <isc/base64.h> #include <isc/base64.h>
#include <isc/buffer.h> #include <isc/buffer.h>
#include <isc/file.h> #include <isc/file.h>
#include <isc/keyboard.h>
#include <isc/mem.h> #include <isc/mem.h>
#include <isc/print.h> #include <isc/print.h>
#include <isc/result.h> #include <isc/result.h>
@@ -192,4 +191,3 @@ write_key_file(const char *keyfile, const char *user,
fatal("fclose(%s) failed\n", keyfile); fatal("fclose(%s) failed\n", keyfile);
fprintf(stderr, "wrote key file \"%s\"\n", keyfile); fprintf(stderr, "wrote key file \"%s\"\n", keyfile);
} }
+9 -9
View File
@@ -22,15 +22,15 @@
#include <config.h> #include <config.h>
#include <stdlib.h>
#include <stdarg.h> #include <stdarg.h>
#include <stdbool.h>
#include <stdlib.h>
#include <isc/assertions.h> #include <isc/assertions.h>
#include <isc/base64.h> #include <isc/base64.h>
#include <isc/buffer.h> #include <isc/buffer.h>
#include <isc/commandline.h> #include <isc/commandline.h>
#include <isc/file.h> #include <isc/file.h>
#include <isc/keyboard.h>
#include <isc/mem.h> #include <isc/mem.h>
#include <isc/net.h> #include <isc/net.h>
#include <isc/print.h> #include <isc/print.h>
@@ -57,7 +57,7 @@
static char program[256]; static char program[256];
const char *progname; const char *progname;
isc_boolean_t verbose = ISC_FALSE; bool verbose = false;
const char *keyfile, *keydef; const char *keyfile, *keydef;
@@ -87,7 +87,7 @@ Usage:\n\
int int
main(int argc, char **argv) { main(int argc, char **argv) {
isc_boolean_t show_final_mem = ISC_FALSE; bool show_final_mem = false;
isc_buffer_t key_txtbuffer; isc_buffer_t key_txtbuffer;
char key_txtsecret[256]; char key_txtsecret[256];
isc_mem_t *mctx = NULL; isc_mem_t *mctx = NULL;
@@ -104,7 +104,7 @@ main(int argc, char **argv) {
struct in6_addr addr6_dummy; struct in6_addr addr6_dummy;
char *chrootdir = NULL; char *chrootdir = NULL;
char *user = NULL; char *user = NULL;
isc_boolean_t keyonly = ISC_FALSE; bool keyonly = false;
int len; int len;
keydef = keyfile = RNDC_KEYFILE; keydef = keyfile = RNDC_KEYFILE;
@@ -119,14 +119,14 @@ main(int argc, char **argv) {
serveraddr = DEFAULT_SERVER; serveraddr = DEFAULT_SERVER;
port = DEFAULT_PORT; port = DEFAULT_PORT;
isc_commandline_errprint = ISC_FALSE; isc_commandline_errprint = false;
while ((ch = isc_commandline_parse(argc, argv, while ((ch = isc_commandline_parse(argc, argv,
"aA:b:c:hk:Mmp:r:s:t:u:Vy")) != -1) "aA:b:c:hk:Mmp:r:s:t:u:Vy")) != -1)
{ {
switch (ch) { switch (ch) {
case 'a': case 'a':
keyonly = ISC_TRUE; keyonly = true;
break; break;
case 'A': case 'A':
algname = isc_commandline_argument; algname = isc_commandline_argument;
@@ -153,7 +153,7 @@ main(int argc, char **argv) {
break; break;
case 'm': case 'm':
show_final_mem = ISC_TRUE; show_final_mem = true;
break; break;
case 'p': case 'p':
port = strtol(isc_commandline_argument, &p, 10); port = strtol(isc_commandline_argument, &p, 10);
@@ -177,7 +177,7 @@ main(int argc, char **argv) {
user = isc_commandline_argument; user = isc_commandline_argument;
break; break;
case 'V': case 'V':
verbose = ISC_TRUE; verbose = true;
break; break;
case '?': case '?':
if (isc_commandline_option != '?') { if (isc_commandline_option != '?') {
+2 -2
View File
@@ -15,15 +15,15 @@
#include <config.h> #include <config.h>
#include <stdarg.h> #include <stdarg.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <isc/boolean.h>
#include <isc/print.h> #include <isc/print.h>
#include "util.h" #include "util.h"
extern isc_boolean_t verbose; extern bool verbose;
extern const char *progname; extern const char *progname;
void void
+2 -2
View File
@@ -70,7 +70,7 @@
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\isccc\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\isccc\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>confgentool.lib;libisc.lib;libdns.lib;libisccfg.lib;libisccc.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@confgentool.lib;libisc.lib;libdns.lib;libisccfg.lib;libisccc.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
<PostBuildEvent> <PostBuildEvent>
<Command>cd ..\..\..\Build\$(Configuration) <Command>cd ..\..\..\Build\$(Configuration)
@@ -106,7 +106,7 @@ copy /Y ddns-confgen.ilk tsig-keygen.ilk
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration> <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\isccc\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\isccc\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>confgentool.lib;libisc.lib;libdns.lib;libisccfg.lib;libisccc.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@confgentool.lib;libisc.lib;libdns.lib;libisccfg.lib;libisccc.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
<PostBuildEvent> <PostBuildEvent>
<Command>cd ..\..\..\Build\$(Configuration) <Command>cd ..\..\..\Build\$(Configuration)
+2 -2
View File
@@ -70,7 +70,7 @@
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\isccc\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\isccc\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>confgentool.lib;libisc.lib;libdns.lib;libisccfg.lib;libisccc.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@confgentool.lib;libisc.lib;libdns.lib;libisccfg.lib;libisccc.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'"> <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'">
@@ -100,7 +100,7 @@
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration> <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\isccc\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\isccc\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>confgentool.lib;libisc.lib;libdns.lib;libisccfg.lib;libisccc.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@confgentool.lib;libisc.lib;libdns.lib;libisccfg.lib;libisccc.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemGroup> <ItemGroup>
+76 -74
View File
@@ -24,7 +24,9 @@
#include <netdb.h> #include <netdb.h>
#endif #endif
#include <stdbool.h>
#include <stdio.h> #include <stdio.h>
#include <inttypes.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <unistd.h> #include <unistd.h>
@@ -94,40 +96,40 @@ static const char *port = "53";
static isc_sockaddr_t *srcaddr4 = NULL, *srcaddr6 = NULL; static isc_sockaddr_t *srcaddr4 = NULL, *srcaddr6 = NULL;
static isc_sockaddr_t a4, a6; static isc_sockaddr_t a4, a6;
static char *curqname = NULL, *qname = NULL; static char *curqname = NULL, *qname = NULL;
static isc_boolean_t classset = ISC_FALSE; static bool classset = false;
static dns_rdatatype_t qtype = dns_rdatatype_none; static dns_rdatatype_t qtype = dns_rdatatype_none;
static isc_boolean_t typeset = ISC_FALSE; static bool typeset = false;
static unsigned int styleflags = 0; static unsigned int styleflags = 0;
static isc_uint32_t splitwidth = 0xffffffff; static uint32_t splitwidth = 0xffffffff;
static isc_boolean_t static bool
showcomments = ISC_TRUE, showcomments = true,
showdnssec = ISC_TRUE, showdnssec = true,
showtrust = ISC_TRUE, showtrust = true,
rrcomments = ISC_TRUE, rrcomments = true,
noclass = ISC_FALSE, noclass = false,
nocrypto = ISC_FALSE, nocrypto = false,
nottl = ISC_FALSE, nottl = false,
multiline = ISC_FALSE, multiline = false,
short_form = ISC_FALSE, short_form = false,
print_unknown_format = ISC_FALSE; print_unknown_format = false;
static isc_boolean_t static bool
resolve_trace = ISC_FALSE, resolve_trace = false,
validator_trace = ISC_FALSE, validator_trace = false,
message_trace = ISC_FALSE; message_trace = false;
static isc_boolean_t static bool
use_ipv4 = ISC_TRUE, use_ipv4 = true,
use_ipv6 = ISC_TRUE; use_ipv6 = true;
static isc_boolean_t static bool
cdflag = ISC_FALSE, cdflag = false,
no_sigs = ISC_FALSE, no_sigs = false,
root_validation = ISC_TRUE, root_validation = true,
dlv_validation = ISC_TRUE; dlv_validation = true;
static isc_boolean_t use_tcp = ISC_FALSE; static bool use_tcp = false;
static char *anchorfile = NULL; static char *anchorfile = NULL;
static char *trust_anchor = NULL; static char *trust_anchor = NULL;
@@ -144,10 +146,10 @@ static char anchortext[] = MANAGED_KEYS;
* Static function prototypes * Static function prototypes
*/ */
static isc_result_t static isc_result_t
get_reverse(char *reverse, size_t len, char *value, isc_boolean_t strict); get_reverse(char *reverse, size_t len, char *value, bool strict);
static isc_result_t 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); const char *desc);
static void static void
@@ -408,7 +410,7 @@ printdata(dns_rdataset_t *rdataset, dns_name_t *owner,
{ {
isc_result_t result = ISC_R_SUCCESS; isc_result_t result = ISC_R_SUCCESS;
static dns_trust_t trust; static dns_trust_t trust;
static isc_boolean_t first = ISC_TRUE; static bool first = true;
isc_buffer_t target; isc_buffer_t target;
isc_region_t r; isc_region_t r;
char *t = NULL; char *t = NULL;
@@ -430,7 +432,7 @@ printdata(dns_rdataset_t *rdataset, dns_name_t *owner,
putchar('\n'); putchar('\n');
print_status(rdataset); print_status(rdataset);
trust = rdataset->trust; trust = rdataset->trust;
first = ISC_FALSE; first = false;
} }
do { do {
@@ -566,7 +568,7 @@ convert_name(dns_fixedname_t *fn, dns_name_t **name, const char *text) {
static isc_result_t static isc_result_t
key_fromconfig(const cfg_obj_t *key, dns_client_t *client) { key_fromconfig(const cfg_obj_t *key, dns_client_t *client) {
dns_rdata_dnskey_t keystruct; dns_rdata_dnskey_t keystruct;
isc_uint32_t flags, proto, alg; uint32_t flags, proto, alg;
const char *keystr, *keynamestr; const char *keystr, *keynamestr;
unsigned char keydata[4096]; unsigned char keydata[4096];
isc_buffer_t keydatabuf; isc_buffer_t keydatabuf;
@@ -576,7 +578,7 @@ key_fromconfig(const cfg_obj_t *key, dns_client_t *client) {
dns_fixedname_t fkeyname; dns_fixedname_t fkeyname;
dns_name_t *keyname; dns_name_t *keyname;
isc_result_t result; isc_result_t result;
isc_boolean_t match_root = ISC_FALSE, match_dlv = ISC_FALSE; bool match_root = false, match_dlv = false;
keynamestr = cfg_obj_asstring(cfg_tuple_get(key, "name")); keynamestr = cfg_obj_asstring(cfg_tuple_get(key, "name"));
CHECK(convert_name(&fkeyname, &keyname, keynamestr)); CHECK(convert_name(&fkeyname, &keyname, keynamestr));
@@ -621,9 +623,9 @@ key_fromconfig(const cfg_obj_t *key, dns_client_t *client) {
if (alg > 0xff) if (alg > 0xff)
CHECK(ISC_R_RANGE); CHECK(ISC_R_RANGE);
keystruct.flags = (isc_uint16_t)flags; keystruct.flags = (uint16_t)flags;
keystruct.protocol = (isc_uint8_t)proto; keystruct.protocol = (uint8_t)proto;
keystruct.algorithm = (isc_uint8_t)alg; keystruct.algorithm = (uint8_t)alg;
isc_buffer_init(&keydatabuf, keydata, sizeof(keydata)); isc_buffer_init(&keydatabuf, keydata, sizeof(keydata));
isc_buffer_init(&rrdatabuf, rrdata, sizeof(rrdata)); isc_buffer_init(&rrdatabuf, rrdata, sizeof(rrdata));
@@ -778,7 +780,7 @@ addserver(dns_client_t *client) {
struct in6_addr in6; struct in6_addr in6;
isc_sockaddr_t *sa; isc_sockaddr_t *sa;
isc_sockaddrlist_t servers; isc_sockaddrlist_t servers;
isc_uint32_t destport; uint32_t destport;
isc_result_t result; isc_result_t result;
dns_name_t *name = NULL; dns_name_t *name = NULL;
@@ -869,7 +871,7 @@ findserver(dns_client_t *client) {
irs_resconf_t *resconf = NULL; irs_resconf_t *resconf = NULL;
isc_sockaddrlist_t *nameservers; isc_sockaddrlist_t *nameservers;
isc_sockaddr_t *sa, *next; isc_sockaddr_t *sa, *next;
isc_uint32_t destport; uint32_t destport;
result = parse_uint(&destport, port, 0xffff, "port"); result = parse_uint(&destport, port, 0xffff, "port");
if (result != ISC_R_SUCCESS) if (result != ISC_R_SUCCESS)
@@ -944,9 +946,9 @@ cleanup:
} }
static isc_result_t 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) { const char *desc) {
isc_uint32_t n; uint32_t n;
isc_result_t result = isc_parse_uint32(&n, value, 10); isc_result_t result = isc_parse_uint32(&n, value, 10);
if (result == ISC_R_SUCCESS && n > max) if (result == ISC_R_SUCCESS && n > max)
result = ISC_R_RANGE; result = ISC_R_RANGE;
@@ -963,7 +965,7 @@ static void
plus_option(char *option) { plus_option(char *option) {
isc_result_t result; isc_result_t result;
char *cmd, *value, *last = NULL; char *cmd, *value, *last = NULL;
isc_boolean_t state = ISC_TRUE; bool state = true;
INSIST(option != NULL); INSIST(option != NULL);
@@ -974,7 +976,7 @@ plus_option(char *option) {
} }
if (strncasecmp(cmd, "no", 2)==0) { if (strncasecmp(cmd, "no", 2)==0) {
cmd += 2; cmd += 2;
state = ISC_FALSE; state = false;
} }
value = strtok_r(NULL, "\0", &last); value = strtok_r(NULL, "\0", &last);
@@ -1001,7 +1003,7 @@ plus_option(char *option) {
break; break;
case 'l': /* class */ case 'l': /* class */
FULLCHECK("class"); FULLCHECK("class");
noclass = ISC_TF(!state); noclass = !state;
break; break;
case 'o': /* comments */ case 'o': /* comments */
FULLCHECK("comments"); FULLCHECK("comments");
@@ -1009,7 +1011,7 @@ plus_option(char *option) {
break; break;
case 'r': /* crypto */ case 'r': /* crypto */
FULLCHECK("crypto"); FULLCHECK("crypto");
nocrypto = ISC_TF(!state); nocrypto = !state;
break; break;
default: default:
goto invalid_option; goto invalid_option;
@@ -1082,10 +1084,10 @@ plus_option(char *option) {
FULLCHECK("short"); FULLCHECK("short");
short_form = state; short_form = state;
if (short_form) { if (short_form) {
multiline = ISC_FALSE; multiline = false;
showcomments = ISC_FALSE; showcomments = false;
showtrust = ISC_FALSE; showtrust = false;
showdnssec = ISC_FALSE; showdnssec = false;
} }
break; break;
case 'p': /* split */ case 'p': /* split */
@@ -1137,7 +1139,7 @@ plus_option(char *option) {
break; break;
case 't': /* ttl */ case 't': /* ttl */
FULLCHECK("ttl"); FULLCHECK("ttl");
nottl = ISC_TF(!state); nottl = !state;
break; break;
default: default:
goto invalid_option; goto invalid_option;
@@ -1165,11 +1167,11 @@ plus_option(char *option) {
* options: "46a:b:c:d:himp:q:t:vx:"; * options: "46a:b:c:d:himp:q:t:vx:";
*/ */
static const char *single_dash_opts = "46himv"; static const char *single_dash_opts = "46himv";
static isc_boolean_t static bool
dash_option(char *option, char *next, isc_boolean_t *open_type_class) { dash_option(char *option, char *next, bool *open_type_class) {
char opt, *value; char opt, *value;
isc_result_t result; isc_result_t result;
isc_boolean_t value_from_next; bool value_from_next;
isc_textregion_t tr; isc_textregion_t tr;
dns_rdatatype_t rdtype; dns_rdatatype_t rdtype;
dns_rdataclass_t rdclass; dns_rdataclass_t rdclass;
@@ -1177,7 +1179,7 @@ dash_option(char *option, char *next, isc_boolean_t *open_type_class) {
struct in_addr in4; struct in_addr in4;
struct in6_addr in6; struct in6_addr in6;
in_port_t srcport; in_port_t srcport;
isc_uint32_t num; uint32_t num;
char *hash; char *hash;
while (strpbrk(option, single_dash_opts) == &option[0]) { while (strpbrk(option, single_dash_opts) == &option[0]) {
@@ -1193,7 +1195,7 @@ dash_option(char *option, char *next, isc_boolean_t *open_type_class) {
fatal("IPv4 networking not available"); fatal("IPv4 networking not available");
if (use_ipv6) { if (use_ipv6) {
isc_net_disableipv6(); isc_net_disableipv6();
use_ipv6 = ISC_FALSE; use_ipv6 = false;
} }
break; break;
case '6': case '6':
@@ -1201,7 +1203,7 @@ dash_option(char *option, char *next, isc_boolean_t *open_type_class) {
fatal("IPv6 networking not available"); fatal("IPv6 networking not available");
if (use_ipv4) { if (use_ipv4) {
isc_net_disableipv4(); isc_net_disableipv4();
use_ipv4 = ISC_FALSE; use_ipv4 = false;
} }
break; break;
case 'h': case 'h':
@@ -1209,9 +1211,9 @@ dash_option(char *option, char *next, isc_boolean_t *open_type_class) {
exit(0); exit(0);
/* NOTREACHED */ /* NOTREACHED */
case 'i': case 'i':
no_sigs = ISC_TRUE; no_sigs = true;
dlv_validation = ISC_FALSE; dlv_validation = false;
root_validation = ISC_FALSE; root_validation = false;
break; break;
case 'm': case 'm':
/* handled in preparse_args() */ /* handled in preparse_args() */
@@ -1226,14 +1228,14 @@ dash_option(char *option, char *next, isc_boolean_t *open_type_class) {
if (strlen(option) > 1U) if (strlen(option) > 1U)
option = &option[1]; option = &option[1];
else else
return (ISC_FALSE); return (false);
} }
opt = option[0]; opt = option[0];
if (strlen(option) > 1U) { if (strlen(option) > 1U) {
value_from_next = ISC_FALSE; value_from_next = false;
value = &option[1]; value = &option[1];
} else { } else {
value_from_next = ISC_TRUE; value_from_next = true;
value = next; value = next;
} }
if (value == NULL) if (value == NULL)
@@ -1279,13 +1281,13 @@ dash_option(char *option, char *next, isc_boolean_t *open_type_class) {
if (classset) if (classset)
warn("extra query class"); warn("extra query class");
*open_type_class = ISC_FALSE; *open_type_class = false;
tr.base = value; tr.base = value;
tr.length = strlen(value); tr.length = strlen(value);
result = dns_rdataclass_fromtext(&rdclass, result = dns_rdataclass_fromtext(&rdclass,
(isc_textregion_t *)&tr); (isc_textregion_t *)&tr);
if (result == ISC_R_SUCCESS) if (result == ISC_R_SUCCESS)
classset = ISC_TRUE; classset = true;
else if (rdclass != dns_rdataclass_in) else if (rdclass != dns_rdataclass_in)
warn("ignoring non-IN query class"); warn("ignoring non-IN query class");
else else
@@ -1310,7 +1312,7 @@ dash_option(char *option, char *next, isc_boolean_t *open_type_class) {
fatal("out of memory"); fatal("out of memory");
return (value_from_next); return (value_from_next);
case 't': case 't':
*open_type_class = ISC_FALSE; *open_type_class = false;
tr.base = value; tr.base = value;
tr.length = strlen(value); tr.length = strlen(value);
result = dns_rdatatype_fromtext(&rdtype, result = dns_rdatatype_fromtext(&rdtype,
@@ -1322,13 +1324,13 @@ dash_option(char *option, char *next, isc_boolean_t *open_type_class) {
rdtype == dns_rdatatype_axfr) rdtype == dns_rdatatype_axfr)
fatal("Transfer not supported"); fatal("Transfer not supported");
qtype = rdtype; qtype = rdtype;
typeset = ISC_TRUE; typeset = true;
} else } else
warn("ignoring invalid type"); warn("ignoring invalid type");
return (value_from_next); return (value_from_next);
case 'x': case 'x':
result = get_reverse(textname, sizeof(textname), value, result = get_reverse(textname, sizeof(textname), value,
ISC_FALSE); false);
if (result == ISC_R_SUCCESS) { if (result == ISC_R_SUCCESS) {
if (curqname != NULL) { if (curqname != NULL) {
isc_mem_free(mctx, curqname); isc_mem_free(mctx, curqname);
@@ -1340,7 +1342,7 @@ dash_option(char *option, char *next, isc_boolean_t *open_type_class) {
if (typeset) if (typeset)
warn("extra query type"); warn("extra query type");
qtype = dns_rdatatype_ptr; qtype = dns_rdatatype_ptr;
typeset = ISC_TRUE; typeset = true;
} else { } else {
fprintf(stderr, "Invalid IP address %s\n", value); fprintf(stderr, "Invalid IP address %s\n", value);
exit(1); exit(1);
@@ -1352,7 +1354,7 @@ dash_option(char *option, char *next, isc_boolean_t *open_type_class) {
usage(); usage();
} }
/* NOTREACHED */ /* NOTREACHED */
return (ISC_FALSE); return (false);
} }
/* /*
@@ -1361,7 +1363,7 @@ dash_option(char *option, char *next, isc_boolean_t *open_type_class) {
*/ */
static void static void
preparse_args(int argc, char **argv) { preparse_args(int argc, char **argv) {
isc_boolean_t ipv4only = ISC_FALSE, ipv6only = ISC_FALSE; bool ipv4only = false, ipv6only = false;
char *option; char *option;
for (argc--, argv++; argc > 0; argc--, argv++) { for (argc--, argv++; argc > 0; argc--, argv++) {
@@ -1378,13 +1380,13 @@ preparse_args(int argc, char **argv) {
if (ipv6only) { if (ipv6only) {
fatal("only one of -4 and -6 allowed"); fatal("only one of -4 and -6 allowed");
} }
ipv4only = ISC_TRUE; ipv4only = true;
break; break;
case '6': case '6':
if (ipv4only) { if (ipv4only) {
fatal("only one of -4 and -6 allowed"); fatal("only one of -4 and -6 allowed");
} }
ipv6only = ISC_TRUE; ipv6only = true;
break; break;
} }
option = &option[1]; option = &option[1];
@@ -1404,7 +1406,7 @@ parse_args(int argc, char **argv) {
isc_textregion_t tr; isc_textregion_t tr;
dns_rdatatype_t rdtype; dns_rdatatype_t rdtype;
dns_rdataclass_t rdclass; dns_rdataclass_t rdclass;
isc_boolean_t open_type_class = ISC_TRUE; bool open_type_class = true;
for (; argc > 0; argc--, argv++) { for (; argc > 0; argc--, argv++) {
if (argv[0][0] == '@') { if (argv[0][0] == '@') {
@@ -1443,7 +1445,7 @@ parse_args(int argc, char **argv) {
rdtype == dns_rdatatype_axfr) rdtype == dns_rdatatype_axfr)
fatal("Transfer not supported"); fatal("Transfer not supported");
qtype = rdtype; qtype = rdtype;
typeset = ISC_TRUE; typeset = true;
continue; continue;
} }
result = dns_rdataclass_fromtext(&rdclass, result = dns_rdataclass_fromtext(&rdclass,
@@ -1512,7 +1514,7 @@ reverse_octets(const char *in, char **p, char *end) {
} }
static isc_result_t static isc_result_t
get_reverse(char *reverse, size_t len, char *value, isc_boolean_t strict) { get_reverse(char *reverse, size_t len, char *value, bool strict) {
int r; int r;
isc_result_t result; isc_result_t result;
isc_netaddr_t addr; isc_netaddr_t addr;
+2 -2
View File
@@ -68,7 +68,7 @@
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<AdditionalLibraryDirectories>..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\irs\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\irs\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>libisc.lib;libdns.lib;libisccfg.lib;libirs.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@libisc.lib;libdns.lib;libisccfg.lib;libirs.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'"> <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'">
@@ -98,7 +98,7 @@
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration> <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
<AdditionalLibraryDirectories>..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\irs\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\irs\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>libisc.lib;libdns.lib;libisccfg.lib;libirs.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@libisc.lib;libdns.lib;libisccfg.lib;libirs.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemGroup> <ItemGroup>
+145 -141
View File
@@ -12,6 +12,9 @@
/*! \file */ /*! \file */
#include <config.h> #include <config.h>
#include <inttypes.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <time.h> #include <time.h>
#include <ctype.h> #include <ctype.h>
@@ -61,10 +64,10 @@ static int addresscount = 0;
static char domainopt[DNS_NAME_MAXTEXT]; static char domainopt[DNS_NAME_MAXTEXT];
static char hexcookie[81]; static char hexcookie[81];
static isc_boolean_t short_form = ISC_FALSE, printcmd = ISC_TRUE, static bool short_form = false, printcmd = true,
ip6_int = ISC_FALSE, plusquest = ISC_FALSE, pluscomm = ISC_FALSE, ip6_int = false, plusquest = false, pluscomm = false,
ipv4only = ISC_FALSE, ipv6only = ISC_FALSE; ipv4only = false, ipv6only = false;
static isc_uint32_t splitwidth = 0xffffffff; static uint32_t splitwidth = 0xffffffff;
/*% opcode text */ /*% opcode text */
static const char * const opcodetext[] = { static const char * const opcodetext[] = {
@@ -240,7 +243,7 @@ help(void) {
*/ */
static void static void
received(unsigned int bytes, isc_sockaddr_t *from, dig_query_t *query) { received(unsigned int bytes, isc_sockaddr_t *from, dig_query_t *query) {
isc_uint64_t diff; uint64_t diff;
time_t tnow; time_t tnow;
struct tm tmnow; struct tm tmnow;
#ifdef WIN32 #ifdef WIN32
@@ -281,7 +284,7 @@ received(unsigned int bytes, isc_sockaddr_t *from, dig_query_t *query) {
#endif #endif
if (query->lookup->doing_xfr) { if (query->lookup->doing_xfr) {
printf(";; XFR size: %u records (messages %u, " printf(";; XFR size: %u records (messages %u, "
"bytes %" ISC_PRINT_QUADFORMAT "u)\n", "bytes %" PRIu64 ")\n",
query->rr_count, query->msg_count, query->rr_count, query->msg_count,
query->byte_count); query->byte_count);
} else { } else {
@@ -299,18 +302,18 @@ received(unsigned int bytes, isc_sockaddr_t *from, dig_query_t *query) {
} else if (query->lookup->identify && !short_form) { } else if (query->lookup->identify && !short_form) {
diff = isc_time_microdiff(&query->time_recv, &query->time_sent); diff = isc_time_microdiff(&query->time_recv, &query->time_sent);
if (query->lookup->use_usec) if (query->lookup->use_usec)
printf(";; Received %" ISC_PRINT_QUADFORMAT "u bytes " printf(";; Received %" PRIu64 " bytes "
"from %s(%s) in %ld us\n\n", "from %s(%s) in %ld us\n\n",
query->lookup->doing_xfr query->lookup->doing_xfr
? query->byte_count ? query->byte_count
: (isc_uint64_t)bytes, : (uint64_t)bytes,
fromtext, query->userarg, (long) diff); fromtext, query->userarg, (long) diff);
else else
printf(";; Received %" ISC_PRINT_QUADFORMAT "u bytes " printf(";; Received %" PRIu64 " bytes "
"from %s(%s) in %ld ms\n\n", "from %s(%s) in %ld ms\n\n",
query->lookup->doing_xfr query->lookup->doing_xfr
? query->byte_count ? query->byte_count
: (isc_uint64_t)bytes, : (uint64_t)bytes,
fromtext, query->userarg, (long) diff / 1000); fromtext, query->userarg, (long) diff / 1000);
} }
} }
@@ -332,7 +335,7 @@ trying(char *frm, dig_lookup_t *lookup) {
static isc_result_t static isc_result_t
say_message(dns_rdata_t *rdata, dig_query_t *query, isc_buffer_t *buf) { say_message(dns_rdata_t *rdata, dig_query_t *query, isc_buffer_t *buf) {
isc_result_t result; isc_result_t result;
isc_uint64_t diff; uint64_t diff;
char store[sizeof(" in 18446744073709551616 us.")]; char store[sizeof(" in 18446744073709551616 us.")];
unsigned int styleflags = 0; unsigned int styleflags = 0;
@@ -360,10 +363,11 @@ say_message(dns_rdata_t *rdata, dig_query_t *query, isc_buffer_t *buf) {
diff = isc_time_microdiff(&query->time_recv, &query->time_sent); diff = isc_time_microdiff(&query->time_recv, &query->time_sent);
ADD_STRING(buf, " from server "); ADD_STRING(buf, " from server ");
ADD_STRING(buf, query->servname); ADD_STRING(buf, query->servname);
if (query->lookup->use_usec) if (query->lookup->use_usec) {
snprintf(store, sizeof(store), " in %" ISC_PLATFORM_QUADFORMAT "u us.", diff); snprintf(store, sizeof(store), " in %" PRIu64 " us.", diff);
else } else {
snprintf(store, sizeof(store), " in %" ISC_PLATFORM_QUADFORMAT "u ms.", diff / 1000); snprintf(store, sizeof(store), " in %" PRIu64 " ms.", diff / 1000);
}
ADD_STRING(buf, store); ADD_STRING(buf, store);
} }
ADD_STRING(buf, "\n"); ADD_STRING(buf, "\n");
@@ -421,7 +425,7 @@ short_answer(dns_message_t *msg, dns_messagetextflag_t flags,
return (ISC_R_SUCCESS); return (ISC_R_SUCCESS);
} }
static isc_boolean_t static bool
isdotlocal(dns_message_t *msg) { isdotlocal(dns_message_t *msg) {
isc_result_t result; isc_result_t result;
static unsigned char local_ndata[] = { "\005local\0" }; static unsigned char local_ndata[] = { "\005local\0" };
@@ -436,16 +440,16 @@ isdotlocal(dns_message_t *msg) {
dns_name_t *name = NULL; dns_name_t *name = NULL;
dns_message_currentname(msg, DNS_SECTION_QUESTION, &name); dns_message_currentname(msg, DNS_SECTION_QUESTION, &name);
if (dns_name_issubdomain(name, &local)) if (dns_name_issubdomain(name, &local))
return (ISC_TRUE); return (true);
} }
return (ISC_FALSE); return (false);
} }
/* /*
* Callback from dighost.c to print the reply from a server * Callback from dighost.c to print the reply from a server
*/ */
static isc_result_t static isc_result_t
printmessage(dig_query_t *query, dns_message_t *msg, isc_boolean_t headers) { printmessage(dig_query_t *query, dns_message_t *msg, bool headers) {
isc_result_t result; isc_result_t result;
dns_messagetextflag_t flags; dns_messagetextflag_t flags;
isc_buffer_t *buf = NULL; isc_buffer_t *buf = NULL;
@@ -689,7 +693,7 @@ cleanup:
static void static void
printgreeting(int argc, char **argv, dig_lookup_t *lookup) { printgreeting(int argc, char **argv, dig_lookup_t *lookup) {
int i; int i;
static isc_boolean_t first = ISC_TRUE; static bool first = true;
char append[MXNAME]; char append[MXNAME];
if (printcmd) { if (printcmd) {
@@ -716,7 +720,7 @@ printgreeting(int argc, char **argv, dig_lookup_t *lookup) {
";; global options:%s%s\n", ";; global options:%s%s\n",
short_form ? " +short" : "", short_form ? " +short" : "",
printcmd ? " +cmd" : ""); printcmd ? " +cmd" : "");
first = ISC_FALSE; first = false;
strlcat(lookup->cmdline, append, strlcat(lookup->cmdline, append,
sizeof(lookup->cmdline)); sizeof(lookup->cmdline));
} }
@@ -731,13 +735,13 @@ printgreeting(int argc, char **argv, dig_lookup_t *lookup) {
*/ */
static void static void
plus_option(char *option, isc_boolean_t is_batchfile, plus_option(char *option, bool is_batchfile,
dig_lookup_t *lookup) dig_lookup_t *lookup)
{ {
isc_result_t result; isc_result_t result;
char *cmd, *value, *last = NULL, *code, *extra; char *cmd, *value, *last = NULL, *code, *extra;
isc_uint32_t num; uint32_t num;
isc_boolean_t state = ISC_TRUE; bool state = true;
size_t n; size_t n;
INSIST(option != NULL); INSIST(option != NULL);
@@ -748,7 +752,7 @@ plus_option(char *option, isc_boolean_t is_batchfile,
} }
if (strncasecmp(cmd, "no", 2)==0) { if (strncasecmp(cmd, "no", 2)==0) {
cmd += 2; cmd += 2;
state = ISC_FALSE; state = false;
} }
/* parse the rest of the string */ /* parse the rest of the string */
value = strtok_r(NULL, "", &last); value = strtok_r(NULL, "", &last);
@@ -855,7 +859,7 @@ plus_option(char *option, isc_boolean_t is_batchfile,
case 'l': /* class */ case 'l': /* class */
/* keep +cl for backwards compatibility */ /* keep +cl for backwards compatibility */
FULLCHECK2("cl", "class"); FULLCHECK2("cl", "class");
lookup->noclass = ISC_TF(!state); lookup->noclass = !state;
break; break;
case 'm': /* cmd */ case 'm': /* cmd */
FULLCHECK("cmd"); FULLCHECK("cmd");
@@ -891,7 +895,7 @@ plus_option(char *option, isc_boolean_t is_batchfile,
break; break;
case 'r': case 'r':
FULLCHECK("crypto"); FULLCHECK("crypto");
lookup->nocrypto = ISC_TF(!state); lookup->nocrypto = !state;
break; break;
default: default:
goto invalid_option; goto invalid_option;
@@ -1004,7 +1008,7 @@ plus_option(char *option, isc_boolean_t is_batchfile,
code = NULL; code = NULL;
if (value != NULL) { if (value != NULL) {
code = strtok_r(value, code = strtok_r(value,
":", ":",
&last); &last);
} }
if (code == NULL) { if (code == NULL) {
@@ -1162,17 +1166,17 @@ plus_option(char *option, isc_boolean_t is_batchfile,
FULLCHECK("nssearch"); FULLCHECK("nssearch");
lookup->ns_search_only = state; lookup->ns_search_only = state;
if (state) { if (state) {
lookup->trace_root = ISC_TRUE; lookup->trace_root = true;
lookup->recurse = ISC_TRUE; lookup->recurse = true;
lookup->identify = ISC_TRUE; lookup->identify = true;
lookup->stats = ISC_FALSE; lookup->stats = false;
lookup->comments = ISC_FALSE; lookup->comments = false;
lookup->section_additional = ISC_FALSE; lookup->section_additional = false;
lookup->section_authority = ISC_FALSE; lookup->section_authority = false;
lookup->section_question = ISC_FALSE; lookup->section_question = false;
lookup->rdtype = dns_rdatatype_ns; lookup->rdtype = dns_rdatatype_ns;
lookup->rdtypeset = ISC_TRUE; lookup->rdtypeset = true;
short_form = ISC_TRUE; short_form = true;
lookup->rrcomments = 0; lookup->rrcomments = 0;
} }
break; break;
@@ -1230,7 +1234,7 @@ plus_option(char *option, isc_boolean_t is_batchfile,
warn("Couldn't parse padding"); warn("Couldn't parse padding");
goto exit_or_usage; goto exit_or_usage;
} }
lookup->padding = (isc_uint16_t)num; lookup->padding = (uint16_t)num;
break; break;
case 'q': case 'q':
switch (cmd[1]) { switch (cmd[1]) {
@@ -1306,13 +1310,13 @@ plus_option(char *option, isc_boolean_t is_batchfile,
FULLCHECK("short"); FULLCHECK("short");
short_form = state; short_form = state;
if (state) { if (state) {
printcmd = ISC_FALSE; printcmd = false;
lookup->section_additional = ISC_FALSE; lookup->section_additional = false;
lookup->section_answer = ISC_TRUE; lookup->section_answer = true;
lookup->section_authority = ISC_FALSE; lookup->section_authority = false;
lookup->section_question = ISC_FALSE; lookup->section_question = false;
lookup->comments = ISC_FALSE; lookup->comments = false;
lookup->stats = ISC_FALSE; lookup->stats = false;
lookup->rrcomments = -1; lookup->rrcomments = -1;
} }
break; break;
@@ -1406,7 +1410,7 @@ plus_option(char *option, isc_boolean_t is_batchfile,
FULLCHECK("tcp"); FULLCHECK("tcp");
if (!is_batchfile) { if (!is_batchfile) {
lookup->tcp_mode = state; lookup->tcp_mode = state;
lookup->tcp_mode_set = ISC_TRUE; lookup->tcp_mode_set = true;
} }
break; break;
default: default:
@@ -1439,17 +1443,17 @@ plus_option(char *option, isc_boolean_t is_batchfile,
lookup->trace = state; lookup->trace = state;
lookup->trace_root = state; lookup->trace_root = state;
if (state) { if (state) {
lookup->recurse = ISC_FALSE; lookup->recurse = false;
lookup->identify = ISC_TRUE; lookup->identify = true;
lookup->comments = ISC_FALSE; lookup->comments = false;
lookup->rrcomments = 0; lookup->rrcomments = 0;
lookup->stats = ISC_FALSE; lookup->stats = false;
lookup->section_additional = ISC_FALSE; lookup->section_additional = false;
lookup->section_authority = ISC_TRUE; lookup->section_authority = true;
lookup->section_question = ISC_FALSE; lookup->section_question = false;
lookup->dnssec = ISC_TRUE; lookup->dnssec = true;
lookup->sendcookie = ISC_TRUE; lookup->sendcookie = true;
usesearch = ISC_FALSE; usesearch = false;
} }
break; break;
case 'i': /* tries */ case 'i': /* tries */
@@ -1483,12 +1487,12 @@ plus_option(char *option, isc_boolean_t is_batchfile,
case 0: case 0:
case 'i': /* ttlid */ case 'i': /* ttlid */
FULLCHECK2("ttl", "ttlid"); FULLCHECK2("ttl", "ttlid");
lookup->nottl = ISC_TF(!state); lookup->nottl = !state;
break; break;
case 'u': /* ttlunits */ case 'u': /* ttlunits */
FULLCHECK("ttlunits"); FULLCHECK("ttlunits");
lookup->nottl = ISC_FALSE; lookup->nottl = false;
lookup->ttlunits = ISC_TF(state); lookup->ttlunits = state;
break; break;
default: default:
goto invalid_option; goto invalid_option;
@@ -1510,7 +1514,7 @@ plus_option(char *option, isc_boolean_t is_batchfile,
FULLCHECK("vc"); FULLCHECK("vc");
if (!is_batchfile) { if (!is_batchfile) {
lookup->tcp_mode = state; lookup->tcp_mode = state;
lookup->tcp_mode_set = ISC_TRUE; lookup->tcp_mode_set = true;
} }
break; break;
case 'z': /* zflag */ case 'z': /* zflag */
@@ -1536,19 +1540,19 @@ plus_option(char *option, isc_boolean_t is_batchfile,
} }
/*% /*%
* #ISC_TRUE returned if value was used * #true returned if value was used
*/ */
static const char *single_dash_opts = "46dhimnuv"; static const char *single_dash_opts = "46dhimnuv";
static const char *dash_opts = "46bcdfhikmnptvyx"; static const char *dash_opts = "46bcdfhikmnptvyx";
static isc_boolean_t static bool
dash_option(char *option, char *next, dig_lookup_t **lookup, dash_option(char *option, char *next, dig_lookup_t **lookup,
isc_boolean_t *open_type_class, isc_boolean_t *need_clone, bool *open_type_class, bool *need_clone,
isc_boolean_t config_only, int argc, char **argv, bool config_only, int argc, char **argv,
isc_boolean_t *firstarg) bool *firstarg)
{ {
char opt, *value, *ptr, *ptr2, *ptr3, *last; char opt, *value, *ptr, *ptr2, *ptr3, *last;
isc_result_t result; isc_result_t result;
isc_boolean_t value_from_next; bool value_from_next;
isc_textregion_t tr; isc_textregion_t tr;
dns_rdatatype_t rdtype; dns_rdatatype_t rdtype;
dns_rdataclass_t rdclass; dns_rdataclass_t rdclass;
@@ -1557,7 +1561,7 @@ dash_option(char *option, char *next, dig_lookup_t **lookup,
struct in6_addr in6; struct in6_addr in6;
in_port_t srcport; in_port_t srcport;
char *hash, *cmd; char *hash, *cmd;
isc_uint32_t num; uint32_t num;
while (strpbrk(option, single_dash_opts) == &option[0]) { while (strpbrk(option, single_dash_opts) == &option[0]) {
/* /*
@@ -1570,21 +1574,21 @@ dash_option(char *option, char *next, dig_lookup_t **lookup,
case '4': case '4':
if (have_ipv4) { if (have_ipv4) {
isc_net_disableipv6(); isc_net_disableipv6();
have_ipv6 = ISC_FALSE; have_ipv6 = false;
} else { } else {
fatal("can't find IPv4 networking"); fatal("can't find IPv4 networking");
/* NOTREACHED */ /* NOTREACHED */
return (ISC_FALSE); return (false);
} }
break; break;
case '6': case '6':
if (have_ipv6) { if (have_ipv6) {
isc_net_disableipv4(); isc_net_disableipv4();
have_ipv4 = ISC_FALSE; have_ipv4 = false;
} else { } else {
fatal("can't find IPv6 networking"); fatal("can't find IPv6 networking");
/* NOTREACHED */ /* NOTREACHED */
return (ISC_FALSE); return (false);
} }
break; break;
case 'd': case 'd':
@@ -1592,17 +1596,17 @@ dash_option(char *option, char *next, dig_lookup_t **lookup,
if (ptr != &option[1]) { if (ptr != &option[1]) {
cmd = option; cmd = option;
FULLCHECK("debug"); FULLCHECK("debug");
debugging = ISC_TRUE; debugging = true;
return (ISC_FALSE); return (false);
} else } else
debugging = ISC_TRUE; debugging = true;
break; break;
case 'h': case 'h':
help(); help();
exit(0); exit(0);
break; break;
case 'i': case 'i':
ip6_int = ISC_TRUE; ip6_int = true;
break; break;
case 'm': /* memdebug */ case 'm': /* memdebug */
/* memdebug is handled in preparse_args() */ /* memdebug is handled in preparse_args() */
@@ -1611,7 +1615,7 @@ dash_option(char *option, char *next, dig_lookup_t **lookup,
/* deprecated */ /* deprecated */
break; break;
case 'u': case 'u':
(*lookup)->use_usec = ISC_TRUE; (*lookup)->use_usec = true;
break; break;
case 'v': case 'v':
version(); version();
@@ -1621,14 +1625,14 @@ dash_option(char *option, char *next, dig_lookup_t **lookup,
if (strlen(option) > 1U) if (strlen(option) > 1U)
option = &option[1]; option = &option[1];
else else
return (ISC_FALSE); return (false);
} }
opt = option[0]; opt = option[0];
if (strlen(option) > 1U) { if (strlen(option) > 1U) {
value_from_next = ISC_FALSE; value_from_next = false;
value = &option[1]; value = &option[1];
} else { } else {
value_from_next = ISC_TRUE; value_from_next = true;
value = next; value = next;
} }
if (value == NULL) if (value == NULL)
@@ -1658,20 +1662,20 @@ dash_option(char *option, char *next, dig_lookup_t **lookup,
} }
if (hash != NULL) if (hash != NULL)
*hash = '#'; *hash = '#';
specified_source = ISC_TRUE; specified_source = true;
return (value_from_next); return (value_from_next);
case 'c': case 'c':
if ((*lookup)->rdclassset) { if ((*lookup)->rdclassset) {
fprintf(stderr, ";; Warning, extra class option\n"); fprintf(stderr, ";; Warning, extra class option\n");
} }
*open_type_class = ISC_FALSE; *open_type_class = false;
tr.base = value; tr.base = value;
tr.length = (unsigned int) strlen(value); tr.length = (unsigned int) strlen(value);
result = dns_rdataclass_fromtext(&rdclass, result = dns_rdataclass_fromtext(&rdclass,
(isc_textregion_t *)&tr); (isc_textregion_t *)&tr);
if (result == ISC_R_SUCCESS) { if (result == ISC_R_SUCCESS) {
(*lookup)->rdclass = rdclass; (*lookup)->rdclass = rdclass;
(*lookup)->rdclassset = ISC_TRUE; (*lookup)->rdclassset = true;
} else } else
fprintf(stderr, ";; Warning, ignoring " fprintf(stderr, ";; Warning, ignoring "
"invalid class %s\n", "invalid class %s\n",
@@ -1693,23 +1697,23 @@ dash_option(char *option, char *next, dig_lookup_t **lookup,
if (!config_only) { if (!config_only) {
if (*need_clone) if (*need_clone)
(*lookup) = clone_lookup(default_lookup, (*lookup) = clone_lookup(default_lookup,
ISC_TRUE); true);
*need_clone = ISC_TRUE; *need_clone = true;
strlcpy((*lookup)->textname, value, strlcpy((*lookup)->textname, value,
sizeof((*lookup)->textname)); sizeof((*lookup)->textname));
(*lookup)->trace_root = ISC_TF((*lookup)->trace || (*lookup)->trace_root = ((*lookup)->trace ||
(*lookup)->ns_search_only); (*lookup)->ns_search_only);
(*lookup)->new_search = ISC_TRUE; (*lookup)->new_search = true;
if (*firstarg) { if (*firstarg) {
printgreeting(argc, argv, *lookup); printgreeting(argc, argv, *lookup);
*firstarg = ISC_FALSE; *firstarg = false;
} }
ISC_LIST_APPEND(lookup_list, (*lookup), link); ISC_LIST_APPEND(lookup_list, (*lookup), link);
debug("looking up %s", (*lookup)->textname); debug("looking up %s", (*lookup)->textname);
} }
return (value_from_next); return (value_from_next);
case 't': case 't':
*open_type_class = ISC_FALSE; *open_type_class = false;
if (strncasecmp(value, "ixfr=", 5) == 0) { if (strncasecmp(value, "ixfr=", 5) == 0) {
rdtype = dns_rdatatype_ixfr; rdtype = dns_rdatatype_ixfr;
result = ISC_R_SUCCESS; result = ISC_R_SUCCESS;
@@ -1729,9 +1733,9 @@ dash_option(char *option, char *next, dig_lookup_t **lookup,
"extra type option\n"); "extra type option\n");
} }
if (rdtype == dns_rdatatype_ixfr) { if (rdtype == dns_rdatatype_ixfr) {
isc_uint32_t serial; uint32_t serial;
(*lookup)->rdtype = dns_rdatatype_ixfr; (*lookup)->rdtype = dns_rdatatype_ixfr;
(*lookup)->rdtypeset = ISC_TRUE; (*lookup)->rdtypeset = true;
result = parse_uint(&serial, &value[5], result = parse_uint(&serial, &value[5],
MAXSERIAL, "serial number"); MAXSERIAL, "serial number");
if (result != ISC_R_SUCCESS) if (result != ISC_R_SUCCESS)
@@ -1740,19 +1744,19 @@ dash_option(char *option, char *next, dig_lookup_t **lookup,
(*lookup)->section_question = plusquest; (*lookup)->section_question = plusquest;
(*lookup)->comments = pluscomm; (*lookup)->comments = pluscomm;
if (!(*lookup)->tcp_mode_set) if (!(*lookup)->tcp_mode_set)
(*lookup)->tcp_mode = ISC_TRUE; (*lookup)->tcp_mode = true;
} else { } else {
(*lookup)->rdtype = rdtype; (*lookup)->rdtype = rdtype;
if (!config_only) if (!config_only)
(*lookup)->rdtypeset = ISC_TRUE; (*lookup)->rdtypeset = true;
if (rdtype == dns_rdatatype_axfr) { if (rdtype == dns_rdatatype_axfr) {
(*lookup)->section_question = plusquest; (*lookup)->section_question = plusquest;
(*lookup)->comments = pluscomm; (*lookup)->comments = pluscomm;
} else if (rdtype == dns_rdatatype_any) { } else if (rdtype == dns_rdatatype_any) {
if (!(*lookup)->tcp_mode_set) if (!(*lookup)->tcp_mode_set)
(*lookup)->tcp_mode = ISC_TRUE; (*lookup)->tcp_mode = true;
} }
(*lookup)->ixfr_serial = ISC_FALSE; (*lookup)->ixfr_serial = false;
} }
} else } else
fprintf(stderr, ";; Warning, ignoring " fprintf(stderr, ";; Warning, ignoring "
@@ -1780,24 +1784,24 @@ dash_option(char *option, char *next, dig_lookup_t **lookup,
return (value_from_next); return (value_from_next);
case 'x': case 'x':
if (*need_clone) if (*need_clone)
*lookup = clone_lookup(default_lookup, ISC_TRUE); *lookup = clone_lookup(default_lookup, true);
*need_clone = ISC_TRUE; *need_clone = true;
if (get_reverse(textname, sizeof(textname), value, if (get_reverse(textname, sizeof(textname), value,
ip6_int, ISC_FALSE) == ISC_R_SUCCESS) { ip6_int, false) == ISC_R_SUCCESS) {
strlcpy((*lookup)->textname, textname, strlcpy((*lookup)->textname, textname,
sizeof((*lookup)->textname)); sizeof((*lookup)->textname));
debug("looking up %s", (*lookup)->textname); debug("looking up %s", (*lookup)->textname);
(*lookup)->trace_root = ISC_TF((*lookup)->trace || (*lookup)->trace_root = ((*lookup)->trace ||
(*lookup)->ns_search_only); (*lookup)->ns_search_only);
(*lookup)->ip6_int = ip6_int; (*lookup)->ip6_int = ip6_int;
if (!(*lookup)->rdtypeset) if (!(*lookup)->rdtypeset)
(*lookup)->rdtype = dns_rdatatype_ptr; (*lookup)->rdtype = dns_rdatatype_ptr;
if (!(*lookup)->rdclassset) if (!(*lookup)->rdclassset)
(*lookup)->rdclass = dns_rdataclass_in; (*lookup)->rdclass = dns_rdataclass_in;
(*lookup)->new_search = ISC_TRUE; (*lookup)->new_search = true;
if (*firstarg) { if (*firstarg) {
printgreeting(argc, argv, *lookup); printgreeting(argc, argv, *lookup);
*firstarg = ISC_FALSE; *firstarg = false;
} }
ISC_LIST_APPEND(lookup_list, *lookup, link); ISC_LIST_APPEND(lookup_list, *lookup, link);
} else { } else {
@@ -1811,7 +1815,7 @@ dash_option(char *option, char *next, dig_lookup_t **lookup,
usage(); usage();
} }
/* NOTREACHED */ /* NOTREACHED */
return (ISC_FALSE); return (false);
} }
/*% /*%
@@ -1838,19 +1842,19 @@ preparse_args(int argc, char **argv) {
while (strpbrk(option, single_dash_opts) == &option[0]) { while (strpbrk(option, single_dash_opts) == &option[0]) {
switch (option[0]) { switch (option[0]) {
case 'm': case 'm':
memdebugging = ISC_TRUE; memdebugging = true;
isc_mem_debugging = ISC_MEM_DEBUGTRACE | isc_mem_debugging = ISC_MEM_DEBUGTRACE |
ISC_MEM_DEBUGRECORD; ISC_MEM_DEBUGRECORD;
break; break;
case '4': case '4':
if (ipv6only) if (ipv6only)
fatal("only one of -4 and -6 allowed"); fatal("only one of -4 and -6 allowed");
ipv4only = ISC_TRUE; ipv4only = true;
break; break;
case '6': case '6':
if (ipv4only) if (ipv4only)
fatal("only one of -4 and -6 allowed"); fatal("only one of -4 and -6 allowed");
ipv6only = ISC_TRUE; ipv6only = true;
break; break;
} }
option = &option[1]; option = &option[1];
@@ -1875,16 +1879,16 @@ split_batchline(char *batchline, char **bargv, int len, const char *msg) {
} }
static void static void
parse_args(isc_boolean_t is_batchfile, isc_boolean_t config_only, parse_args(bool is_batchfile, bool config_only,
int argc, char **argv) int argc, char **argv)
{ {
isc_result_t result; isc_result_t result;
isc_textregion_t tr; isc_textregion_t tr;
isc_boolean_t firstarg = ISC_TRUE; bool firstarg = true;
dig_lookup_t *lookup = NULL; dig_lookup_t *lookup = NULL;
dns_rdatatype_t rdtype; dns_rdatatype_t rdtype;
dns_rdataclass_t rdclass; dns_rdataclass_t rdclass;
isc_boolean_t open_type_class = ISC_TRUE; bool open_type_class = true;
char batchline[MXNAME]; char batchline[MXNAME];
int bargc; int bargc;
char *bargv[64]; char *bargv[64];
@@ -1894,7 +1898,7 @@ parse_args(isc_boolean_t is_batchfile, isc_boolean_t config_only,
char *homedir; char *homedir;
char rcfile[PATH_MAX]; char rcfile[PATH_MAX];
#endif #endif
isc_boolean_t need_clone = ISC_TRUE; bool need_clone = true;
/* /*
* The semantics for parsing the args is a bit complex; if * The semantics for parsing the args is a bit complex; if
@@ -1911,9 +1915,9 @@ parse_args(isc_boolean_t is_batchfile, isc_boolean_t config_only,
if (!is_batchfile) { if (!is_batchfile) {
debug("making new lookup"); debug("making new lookup");
default_lookup = make_empty_lookup(); default_lookup = make_empty_lookup();
default_lookup->adflag = ISC_TRUE; default_lookup->adflag = true;
default_lookup->edns = 0; default_lookup->edns = 0;
default_lookup->sendcookie = ISC_TRUE; default_lookup->sendcookie = true;
#ifndef NOPOSIX #ifndef NOPOSIX
/* /*
@@ -1938,7 +1942,7 @@ parse_args(isc_boolean_t is_batchfile, isc_boolean_t config_only,
".digrc argv"); ".digrc argv");
bargv[0] = argv[0]; bargv[0] = argv[0];
argv0 = argv[0]; argv0 = argv[0];
parse_args(ISC_TRUE, ISC_TRUE, parse_args(true, true,
bargc, (char **)bargv); bargc, (char **)bargv);
} }
fclose(batchfp); fclose(batchfp);
@@ -1948,8 +1952,8 @@ parse_args(isc_boolean_t is_batchfile, isc_boolean_t config_only,
if (is_batchfile && !config_only) { if (is_batchfile && !config_only) {
/* Processing '-f batchfile'. */ /* Processing '-f batchfile'. */
lookup = clone_lookup(default_lookup, ISC_TRUE); lookup = clone_lookup(default_lookup, true);
need_clone = ISC_FALSE; need_clone = false;
} else { } else {
lookup = default_lookup; lookup = default_lookup;
} }
@@ -2032,10 +2036,10 @@ parse_args(isc_boolean_t is_batchfile, isc_boolean_t config_only,
"extra type option\n"); "extra type option\n");
} }
if (rdtype == dns_rdatatype_ixfr) { if (rdtype == dns_rdatatype_ixfr) {
isc_uint32_t serial; uint32_t serial;
lookup->rdtype = lookup->rdtype =
dns_rdatatype_ixfr; dns_rdatatype_ixfr;
lookup->rdtypeset = ISC_TRUE; lookup->rdtypeset = true;
result = parse_uint(&serial, result = parse_uint(&serial,
&rv[0][5], &rv[0][5],
MAXSERIAL, MAXSERIAL,
@@ -2048,10 +2052,10 @@ parse_args(isc_boolean_t is_batchfile, isc_boolean_t config_only,
plusquest; plusquest;
lookup->comments = pluscomm; lookup->comments = pluscomm;
if (!lookup->tcp_mode_set) if (!lookup->tcp_mode_set)
lookup->tcp_mode = ISC_TRUE; lookup->tcp_mode = true;
} else { } else {
lookup->rdtype = rdtype; lookup->rdtype = rdtype;
lookup->rdtypeset = ISC_TRUE; lookup->rdtypeset = true;
if (rdtype == if (rdtype ==
dns_rdatatype_axfr) { dns_rdatatype_axfr) {
lookup->section_question = lookup->section_question =
@@ -2061,8 +2065,8 @@ parse_args(isc_boolean_t is_batchfile, isc_boolean_t config_only,
if (rdtype == if (rdtype ==
dns_rdatatype_any && dns_rdatatype_any &&
!lookup->tcp_mode_set) !lookup->tcp_mode_set)
lookup->tcp_mode = ISC_TRUE; lookup->tcp_mode = true;
lookup->ixfr_serial = ISC_FALSE; lookup->ixfr_serial = false;
} }
continue; continue;
} }
@@ -2074,7 +2078,7 @@ parse_args(isc_boolean_t is_batchfile, isc_boolean_t config_only,
"extra class option\n"); "extra class option\n");
} }
lookup->rdclass = rdclass; lookup->rdclass = rdclass;
lookup->rdclassset = ISC_TRUE; lookup->rdclassset = true;
continue; continue;
} }
} }
@@ -2082,16 +2086,16 @@ parse_args(isc_boolean_t is_batchfile, isc_boolean_t config_only,
if (!config_only) { if (!config_only) {
if (need_clone) if (need_clone)
lookup = clone_lookup(default_lookup, lookup = clone_lookup(default_lookup,
ISC_TRUE); true);
need_clone = ISC_TRUE; need_clone = true;
strlcpy(lookup->textname, rv[0], strlcpy(lookup->textname, rv[0],
sizeof(lookup->textname)); sizeof(lookup->textname));
lookup->trace_root = ISC_TF(lookup->trace || lookup->trace_root = (lookup->trace ||
lookup->ns_search_only); lookup->ns_search_only);
lookup->new_search = ISC_TRUE; lookup->new_search = true;
if (firstarg) { if (firstarg) {
printgreeting(argc, argv, lookup); printgreeting(argc, argv, lookup);
firstarg = ISC_FALSE; firstarg = false;
} }
ISC_LIST_APPEND(lookup_list, lookup, link); ISC_LIST_APPEND(lookup_list, lookup, link);
debug("looking up %s", lookup->textname); debug("looking up %s", lookup->textname);
@@ -2127,7 +2131,7 @@ parse_args(isc_boolean_t is_batchfile, isc_boolean_t config_only,
"batch argv"); "batch argv");
bargv[0] = argv[0]; bargv[0] = argv[0];
argv0 = argv[0]; argv0 = argv[0];
parse_args(ISC_TRUE, ISC_FALSE, bargc, (char **)bargv); parse_args(true, false, bargc, (char **)bargv);
return; return;
} }
return; return;
@@ -2137,17 +2141,17 @@ parse_args(isc_boolean_t is_batchfile, isc_boolean_t config_only,
*/ */
if ((lookup_list.head == NULL) && !config_only) { if ((lookup_list.head == NULL) && !config_only) {
if (need_clone) if (need_clone)
lookup = clone_lookup(default_lookup, ISC_TRUE); lookup = clone_lookup(default_lookup, true);
need_clone = ISC_TRUE; need_clone = true;
lookup->trace_root = ISC_TF(lookup->trace || lookup->trace_root = (lookup->trace ||
lookup->ns_search_only); lookup->ns_search_only);
lookup->new_search = ISC_TRUE; lookup->new_search = true;
strlcpy(lookup->textname, ".", sizeof(lookup->textname)); strlcpy(lookup->textname, ".", sizeof(lookup->textname));
lookup->rdtype = dns_rdatatype_ns; lookup->rdtype = dns_rdatatype_ns;
lookup->rdtypeset = ISC_TRUE; lookup->rdtypeset = true;
if (firstarg) { if (firstarg) {
printgreeting(argc, argv, lookup); printgreeting(argc, argv, lookup);
firstarg = ISC_FALSE; firstarg = false;
} }
ISC_LIST_APPEND(lookup_list, lookup, link); ISC_LIST_APPEND(lookup_list, lookup, link);
} }
@@ -2184,7 +2188,7 @@ query_finished(void) {
debug("batch line %s", batchline); debug("batch line %s", batchline);
bargc = split_batchline(batchline, bargv, 14, "batch argv"); bargc = split_batchline(batchline, bargv, 14, "batch argv");
bargv[0] = argv0; bargv[0] = argv0;
parse_args(ISC_TRUE, ISC_FALSE, bargc, (char **)bargv); parse_args(true, false, bargc, (char **)bargv);
start_lookup(); start_lookup();
} else { } else {
batchname = NULL; batchname = NULL;
@@ -2221,7 +2225,7 @@ void dig_setup(int argc, char **argv)
setup_system(ipv4only, ipv6only); setup_system(ipv4only, ipv6only);
} }
void dig_query_setup(isc_boolean_t is_batchfile, isc_boolean_t config_only, void dig_query_setup(bool is_batchfile, bool config_only,
int argc, char **argv) int argc, char **argv)
{ {
debug("dig_query_setup"); debug("dig_query_setup");
@@ -2233,7 +2237,7 @@ void dig_query_setup(isc_boolean_t is_batchfile, isc_boolean_t config_only,
setup_text_key(); setup_text_key();
if (domainopt[0] != '\0') { if (domainopt[0] != '\0') {
set_search_domain(domainopt); set_search_domain(domainopt);
usesearch = ISC_TRUE; usesearch = true;
} }
} }
@@ -2270,7 +2274,7 @@ int
main(int argc, char **argv) { main(int argc, char **argv) {
dig_setup(argc, argv); dig_setup(argc, argv);
dig_query_setup(ISC_FALSE, ISC_FALSE, argc, argv); dig_query_setup(false, false, argc, argv);
dig_startup(); dig_startup();
dig_shutdown(); dig_shutdown();
+250 -246
View File
File diff suppressed because it is too large Load Diff
+87 -85
View File
@@ -12,6 +12,9 @@
/*! \file */ /*! \file */
#include <config.h> #include <config.h>
#include <inttypes.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <limits.h> #include <limits.h>
@@ -26,7 +29,6 @@
#include <isc/string.h> #include <isc/string.h>
#include <isc/util.h> #include <isc/util.h>
#include <isc/task.h> #include <isc/task.h>
#include <isc/stdlib.h>
#include <dns/byaddr.h> #include <dns/byaddr.h>
#include <dns/fixedname.h> #include <dns/fixedname.h>
@@ -40,14 +42,14 @@
#include <dig/dig.h> #include <dig/dig.h>
static isc_boolean_t short_form = ISC_TRUE, listed_server = ISC_FALSE; static bool short_form = true, listed_server = false;
static isc_boolean_t default_lookups = ISC_TRUE; static bool default_lookups = true;
static int seen_error = -1; static int seen_error = -1;
static isc_boolean_t list_addresses = ISC_TRUE; static bool list_addresses = true;
static isc_boolean_t list_almost_all = ISC_FALSE; static bool list_almost_all = false;
static dns_rdatatype_t list_type = dns_rdatatype_a; static dns_rdatatype_t list_type = dns_rdatatype_a;
static isc_boolean_t printed_server = ISC_FALSE; static bool printed_server = false;
static isc_boolean_t ipv4only = ISC_FALSE, ipv6only = ISC_FALSE; static bool ipv4only = false, ipv6only = false;
static const char *opcodetext[] = { static const char *opcodetext[] = {
"QUERY", "QUERY",
@@ -224,7 +226,7 @@ say_message(dns_name_t *name, const char *msg, dns_rdata_t *rdata,
static isc_result_t static isc_result_t
printsection(dns_message_t *msg, dns_section_t sectionid, printsection(dns_message_t *msg, dns_section_t sectionid,
const char *section_name, isc_boolean_t headers, const char *section_name, bool headers,
dig_query_t *query) dig_query_t *query)
{ {
dns_name_t *name, *print_name; dns_name_t *name, *print_name;
@@ -235,13 +237,13 @@ printsection(dns_message_t *msg, dns_section_t sectionid,
isc_region_t r; isc_region_t r;
dns_name_t empty_name; dns_name_t empty_name;
char tbuf[4096]; char tbuf[4096];
isc_boolean_t first; bool first;
isc_boolean_t no_rdata; bool no_rdata;
if (sectionid == DNS_SECTION_QUESTION) if (sectionid == DNS_SECTION_QUESTION)
no_rdata = ISC_TRUE; no_rdata = true;
else else
no_rdata = ISC_FALSE; no_rdata = false;
if (headers) if (headers)
printf(";; %s SECTION:\n", section_name); printf(";; %s SECTION:\n", section_name);
@@ -259,7 +261,7 @@ printsection(dns_message_t *msg, dns_section_t sectionid,
dns_message_currentname(msg, sectionid, &name); dns_message_currentname(msg, sectionid, &name);
isc_buffer_init(&target, tbuf, sizeof(tbuf)); isc_buffer_init(&target, tbuf, sizeof(tbuf));
first = ISC_TRUE; first = true;
print_name = name; print_name = name;
for (rdataset = ISC_LIST_HEAD(name->list); for (rdataset = ISC_LIST_HEAD(name->list);
@@ -283,7 +285,7 @@ printsection(dns_message_t *msg, dns_section_t sectionid,
if (!short_form) { if (!short_form) {
result = dns_rdataset_totext(rdataset, result = dns_rdataset_totext(rdataset,
print_name, print_name,
ISC_FALSE, false,
no_rdata, no_rdata,
&target); &target);
if (result != ISC_R_SUCCESS) if (result != ISC_R_SUCCESS)
@@ -291,7 +293,7 @@ printsection(dns_message_t *msg, dns_section_t sectionid,
#ifdef USEINITALWS #ifdef USEINITALWS
if (first) { if (first) {
print_name = &empty_name; print_name = &empty_name;
first = ISC_FALSE; first = false;
} }
#else #else
UNUSED(first); /* Shut up compiler. */ UNUSED(first); /* Shut up compiler. */
@@ -350,7 +352,7 @@ printsection(dns_message_t *msg, dns_section_t sectionid,
static isc_result_t static isc_result_t
printrdata(dns_message_t *msg, dns_rdataset_t *rdataset, printrdata(dns_message_t *msg, dns_rdataset_t *rdataset,
const dns_name_t *owner, const char *set_name, const dns_name_t *owner, const char *set_name,
isc_boolean_t headers) bool headers)
{ {
isc_buffer_t target; isc_buffer_t target;
isc_result_t result; isc_result_t result;
@@ -363,7 +365,7 @@ printrdata(dns_message_t *msg, dns_rdataset_t *rdataset,
isc_buffer_init(&target, tbuf, sizeof(tbuf)); isc_buffer_init(&target, tbuf, sizeof(tbuf));
result = dns_rdataset_totext(rdataset, owner, ISC_FALSE, ISC_FALSE, result = dns_rdataset_totext(rdataset, owner, false, false,
&target); &target);
if (result != ISC_R_SUCCESS) if (result != ISC_R_SUCCESS)
return (result); return (result);
@@ -400,8 +402,8 @@ chase_cnamechain(dns_message_t *msg, dns_name_t *qname) {
} }
static isc_result_t static isc_result_t
printmessage(dig_query_t *query, dns_message_t *msg, isc_boolean_t headers) { printmessage(dig_query_t *query, dns_message_t *msg, bool headers) {
isc_boolean_t did_flag = ISC_FALSE; bool did_flag = false;
dns_rdataset_t *opt, *tsig = NULL; dns_rdataset_t *opt, *tsig = NULL;
const dns_name_t *tsigname; const dns_name_t *tsigname;
isc_result_t result = ISC_R_SUCCESS; isc_result_t result = ISC_R_SUCCESS;
@@ -424,7 +426,7 @@ printmessage(dig_query_t *query, dns_message_t *msg, isc_boolean_t headers) {
sizeof(sockstr)); sizeof(sockstr));
printf("Address: %s\n", sockstr); printf("Address: %s\n", sockstr);
printf("Aliases: \n\n"); printf("Aliases: \n\n");
printed_server = ISC_TRUE; printed_server = true;
} }
if (msg->rcode != 0) { if (msg->rcode != 0) {
@@ -456,22 +458,22 @@ printmessage(dig_query_t *query, dns_message_t *msg, isc_boolean_t headers) {
dns_name_copy(query->lookup->name, name, NULL); dns_name_copy(query->lookup->name, name, NULL);
chase_cnamechain(msg, name); chase_cnamechain(msg, name);
dns_name_format(name, namestr, sizeof(namestr)); dns_name_format(name, namestr, sizeof(namestr));
lookup = clone_lookup(query->lookup, ISC_FALSE); lookup = clone_lookup(query->lookup, false);
if (lookup != NULL) { if (lookup != NULL) {
strlcpy(lookup->textname, namestr, strlcpy(lookup->textname, namestr,
sizeof(lookup->textname)); sizeof(lookup->textname));
lookup->rdtype = dns_rdatatype_aaaa; lookup->rdtype = dns_rdatatype_aaaa;
lookup->rdtypeset = ISC_TRUE; lookup->rdtypeset = true;
lookup->origin = NULL; lookup->origin = NULL;
lookup->retries = tries; lookup->retries = tries;
ISC_LIST_APPEND(lookup_list, lookup, link); ISC_LIST_APPEND(lookup_list, lookup, link);
} }
lookup = clone_lookup(query->lookup, ISC_FALSE); lookup = clone_lookup(query->lookup, false);
if (lookup != NULL) { if (lookup != NULL) {
strlcpy(lookup->textname, namestr, strlcpy(lookup->textname, namestr,
sizeof(lookup->textname)); sizeof(lookup->textname));
lookup->rdtype = dns_rdatatype_mx; lookup->rdtype = dns_rdatatype_mx;
lookup->rdtypeset = ISC_TRUE; lookup->rdtypeset = true;
lookup->origin = NULL; lookup->origin = NULL;
lookup->retries = tries; lookup->retries = tries;
ISC_LIST_APPEND(lookup_list, lookup, link); ISC_LIST_APPEND(lookup_list, lookup, link);
@@ -485,31 +487,31 @@ printmessage(dig_query_t *query, dns_message_t *msg, isc_boolean_t headers) {
printf(";; flags: "); printf(";; flags: ");
if ((msg->flags & DNS_MESSAGEFLAG_QR) != 0) { if ((msg->flags & DNS_MESSAGEFLAG_QR) != 0) {
printf("qr"); printf("qr");
did_flag = ISC_TRUE; did_flag = true;
} }
if ((msg->flags & DNS_MESSAGEFLAG_AA) != 0) { if ((msg->flags & DNS_MESSAGEFLAG_AA) != 0) {
printf("%saa", did_flag ? " " : ""); printf("%saa", did_flag ? " " : "");
did_flag = ISC_TRUE; did_flag = true;
} }
if ((msg->flags & DNS_MESSAGEFLAG_TC) != 0) { if ((msg->flags & DNS_MESSAGEFLAG_TC) != 0) {
printf("%stc", did_flag ? " " : ""); printf("%stc", did_flag ? " " : "");
did_flag = ISC_TRUE; did_flag = true;
} }
if ((msg->flags & DNS_MESSAGEFLAG_RD) != 0) { if ((msg->flags & DNS_MESSAGEFLAG_RD) != 0) {
printf("%srd", did_flag ? " " : ""); printf("%srd", did_flag ? " " : "");
did_flag = ISC_TRUE; did_flag = true;
} }
if ((msg->flags & DNS_MESSAGEFLAG_RA) != 0) { if ((msg->flags & DNS_MESSAGEFLAG_RA) != 0) {
printf("%sra", did_flag ? " " : ""); printf("%sra", did_flag ? " " : "");
did_flag = ISC_TRUE; did_flag = true;
} }
if ((msg->flags & DNS_MESSAGEFLAG_AD) != 0) { if ((msg->flags & DNS_MESSAGEFLAG_AD) != 0) {
printf("%sad", did_flag ? " " : ""); printf("%sad", did_flag ? " " : "");
did_flag = ISC_TRUE; did_flag = true;
} }
if ((msg->flags & DNS_MESSAGEFLAG_CD) != 0) { if ((msg->flags & DNS_MESSAGEFLAG_CD) != 0) {
printf("%scd", did_flag ? " " : ""); printf("%scd", did_flag ? " " : "");
did_flag = ISC_TRUE; did_flag = true;
POST(did_flag); POST(did_flag);
} }
printf("; QUERY: %u, ANSWER: %u, " printf("; QUERY: %u, ANSWER: %u, "
@@ -532,7 +534,7 @@ printmessage(dig_query_t *query, dns_message_t *msg, isc_boolean_t headers) {
!short_form) { !short_form) {
printf("\n"); printf("\n");
result = printsection(msg, DNS_SECTION_QUESTION, "QUESTION", result = printsection(msg, DNS_SECTION_QUESTION, "QUESTION",
ISC_TRUE, query); true, query);
if (result != ISC_R_SUCCESS) if (result != ISC_R_SUCCESS)
return (result); return (result);
} }
@@ -540,7 +542,7 @@ printmessage(dig_query_t *query, dns_message_t *msg, isc_boolean_t headers) {
if (!short_form) if (!short_form)
printf("\n"); printf("\n");
result = printsection(msg, DNS_SECTION_ANSWER, "ANSWER", result = printsection(msg, DNS_SECTION_ANSWER, "ANSWER",
ISC_TF(!short_form), query); !short_form, query);
if (result != ISC_R_SUCCESS) if (result != ISC_R_SUCCESS)
return (result); return (result);
} }
@@ -549,7 +551,7 @@ printmessage(dig_query_t *query, dns_message_t *msg, isc_boolean_t headers) {
!short_form) { !short_form) {
printf("\n"); printf("\n");
result = printsection(msg, DNS_SECTION_AUTHORITY, "AUTHORITY", result = printsection(msg, DNS_SECTION_AUTHORITY, "AUTHORITY",
ISC_TRUE, query); true, query);
if (result != ISC_R_SUCCESS) if (result != ISC_R_SUCCESS)
return (result); return (result);
} }
@@ -557,14 +559,14 @@ printmessage(dig_query_t *query, dns_message_t *msg, isc_boolean_t headers) {
!short_form) { !short_form) {
printf("\n"); printf("\n");
result = printsection(msg, DNS_SECTION_ADDITIONAL, result = printsection(msg, DNS_SECTION_ADDITIONAL,
"ADDITIONAL", ISC_TRUE, query); "ADDITIONAL", true, query);
if (result != ISC_R_SUCCESS) if (result != ISC_R_SUCCESS)
return (result); return (result);
} }
if ((tsig != NULL) && !short_form) { if ((tsig != NULL) && !short_form) {
printf("\n"); printf("\n");
result = printrdata(msg, tsig, tsigname, result = printrdata(msg, tsig, tsigname,
"PSEUDOSECTION TSIG", ISC_TRUE); "PSEUDOSECTION TSIG", true);
if (result != ISC_R_SUCCESS) if (result != ISC_R_SUCCESS)
return (result); return (result);
} }
@@ -599,7 +601,7 @@ pre_parse_args(int argc, char **argv) {
while ((c = isc_commandline_parse(argc, argv, optstring)) != -1) { while ((c = isc_commandline_parse(argc, argv, optstring)) != -1) {
switch (c) { switch (c) {
case 'm': case 'm':
memdebugging = ISC_TRUE; memdebugging = true;
if (strcasecmp("trace", isc_commandline_argument) == 0) if (strcasecmp("trace", isc_commandline_argument) == 0)
isc_mem_debugging |= ISC_MEM_DEBUGTRACE; isc_mem_debugging |= ISC_MEM_DEBUGTRACE;
else if (strcasecmp("record", else if (strcasecmp("record",
@@ -613,12 +615,12 @@ pre_parse_args(int argc, char **argv) {
case '4': case '4':
if (ipv6only) if (ipv6only)
fatal("only one of -4 and -6 allowed"); fatal("only one of -4 and -6 allowed");
ipv4only = ISC_TRUE; ipv4only = true;
break; break;
case '6': case '6':
if (ipv4only) if (ipv4only)
fatal("only one of -4 and -6 allowed"); fatal("only one of -4 and -6 allowed");
ipv6only = ISC_TRUE; ipv6only = true;
break; break;
case 'a': break; case 'a': break;
case 'A': break; case 'A': break;
@@ -639,8 +641,8 @@ pre_parse_args(int argc, char **argv) {
case 'C': break; case 'C': break;
case 'D': case 'D':
if (debugging) if (debugging)
debugtiming = ISC_TRUE; debugtiming = true;
debugging = ISC_TRUE; debugging = true;
break; break;
case 'N': break; case 'N': break;
case 'R': break; case 'R': break;
@@ -650,12 +652,12 @@ pre_parse_args(int argc, char **argv) {
show_usage(); show_usage();
} }
} }
isc_commandline_reset = ISC_TRUE; isc_commandline_reset = true;
isc_commandline_index = 1; isc_commandline_index = 1;
} }
static void static void
parse_args(isc_boolean_t is_batchfile, int argc, char **argv) { parse_args(bool is_batchfile, int argc, char **argv) {
char hostname[MXNAME]; char hostname[MXNAME];
dig_lookup_t *lookup; dig_lookup_t *lookup;
int c; int c;
@@ -664,30 +666,30 @@ parse_args(isc_boolean_t is_batchfile, int argc, char **argv) {
isc_result_t result = ISC_R_SUCCESS; isc_result_t result = ISC_R_SUCCESS;
dns_rdatatype_t rdtype; dns_rdatatype_t rdtype;
dns_rdataclass_t rdclass; dns_rdataclass_t rdclass;
isc_uint32_t serial = 0; uint32_t serial = 0;
UNUSED(is_batchfile); UNUSED(is_batchfile);
lookup = make_empty_lookup(); lookup = make_empty_lookup();
lookup->servfail_stops = ISC_FALSE; lookup->servfail_stops = false;
lookup->comments = ISC_FALSE; lookup->comments = false;
short_form = !verbose; short_form = !verbose;
while ((c = isc_commandline_parse(argc, argv, optstring)) != -1) { while ((c = isc_commandline_parse(argc, argv, optstring)) != -1) {
switch (c) { switch (c) {
case 'l': case 'l':
lookup->tcp_mode = ISC_TRUE; lookup->tcp_mode = true;
lookup->rdtype = dns_rdatatype_axfr; lookup->rdtype = dns_rdatatype_axfr;
lookup->rdtypeset = ISC_TRUE; lookup->rdtypeset = true;
fatalexit = 3; fatalexit = 3;
break; break;
case 'v': case 'v':
case 'd': case 'd':
short_form = ISC_FALSE; short_form = false;
break; break;
case 'r': case 'r':
lookup->recurse = ISC_FALSE; lookup->recurse = false;
break; break;
case 't': case 't':
if (strncasecmp(isc_commandline_argument, if (strncasecmp(isc_commandline_argument,
@@ -712,23 +714,23 @@ parse_args(isc_boolean_t is_batchfile, int argc, char **argv) {
if (!lookup->rdtypeset || if (!lookup->rdtypeset ||
lookup->rdtype != dns_rdatatype_axfr) lookup->rdtype != dns_rdatatype_axfr)
lookup->rdtype = rdtype; lookup->rdtype = rdtype;
lookup->rdtypeset = ISC_TRUE; lookup->rdtypeset = true;
if (rdtype == dns_rdatatype_axfr) { if (rdtype == dns_rdatatype_axfr) {
/* -l -t any -v */ /* -l -t any -v */
list_type = dns_rdatatype_any; list_type = dns_rdatatype_any;
short_form = ISC_FALSE; short_form = false;
lookup->tcp_mode = ISC_TRUE; lookup->tcp_mode = true;
} else if (rdtype == dns_rdatatype_ixfr) { } else if (rdtype == dns_rdatatype_ixfr) {
lookup->ixfr_serial = serial; lookup->ixfr_serial = serial;
lookup->tcp_mode = ISC_TRUE; lookup->tcp_mode = true;
list_type = rdtype; list_type = rdtype;
} else if (rdtype == dns_rdatatype_any) { } else if (rdtype == dns_rdatatype_any) {
if (!lookup->tcp_mode_set) if (!lookup->tcp_mode_set)
lookup->tcp_mode = ISC_TRUE; lookup->tcp_mode = true;
} else } else
list_type = rdtype; list_type = rdtype;
list_addresses = ISC_FALSE; list_addresses = false;
default_lookups = ISC_FALSE; default_lookups = false;
break; break;
case 'c': case 'c':
tr.base = isc_commandline_argument; tr.base = isc_commandline_argument;
@@ -742,25 +744,25 @@ parse_args(isc_boolean_t is_batchfile, int argc, char **argv) {
isc_commandline_argument); isc_commandline_argument);
} else { } else {
lookup->rdclass = rdclass; lookup->rdclass = rdclass;
lookup->rdclassset = ISC_TRUE; lookup->rdclassset = true;
} }
default_lookups = ISC_FALSE; default_lookups = false;
break; break;
case 'A': case 'A':
list_almost_all = ISC_TRUE; list_almost_all = true;
/* FALL THROUGH */ /* FALL THROUGH */
case 'a': case 'a':
if (!lookup->rdtypeset || if (!lookup->rdtypeset ||
lookup->rdtype != dns_rdatatype_axfr) lookup->rdtype != dns_rdatatype_axfr)
lookup->rdtype = dns_rdatatype_any; lookup->rdtype = dns_rdatatype_any;
list_type = dns_rdatatype_any; list_type = dns_rdatatype_any;
list_addresses = ISC_FALSE; list_addresses = false;
lookup->rdtypeset = ISC_TRUE; lookup->rdtypeset = true;
short_form = ISC_FALSE; short_form = false;
default_lookups = ISC_FALSE; default_lookups = false;
break; break;
case 'i': case 'i':
lookup->ip6_int = ISC_TRUE; lookup->ip6_int = true;
break; break;
case 'n': case 'n':
/* deprecated */ /* deprecated */
@@ -786,23 +788,23 @@ parse_args(isc_boolean_t is_batchfile, int argc, char **argv) {
tries = 2; tries = 2;
break; break;
case 'T': case 'T':
lookup->tcp_mode = ISC_TRUE; lookup->tcp_mode = true;
lookup->tcp_mode_set = ISC_TRUE; lookup->tcp_mode_set = true;
break; break;
case 'U': case 'U':
lookup->tcp_mode = ISC_FALSE; lookup->tcp_mode = false;
lookup->tcp_mode_set = ISC_TRUE; lookup->tcp_mode_set = true;
break; break;
case 'C': case 'C':
debug("showing all SOAs"); debug("showing all SOAs");
lookup->rdtype = dns_rdatatype_ns; lookup->rdtype = dns_rdatatype_ns;
lookup->rdtypeset = ISC_TRUE; lookup->rdtypeset = true;
lookup->rdclass = dns_rdataclass_in; lookup->rdclass = dns_rdataclass_in;
lookup->rdclassset = ISC_TRUE; lookup->rdclassset = true;
lookup->ns_search_only = ISC_TRUE; lookup->ns_search_only = true;
lookup->trace_root = ISC_TRUE; lookup->trace_root = true;
lookup->identify_previous_line = ISC_TRUE; lookup->identify_previous_line = true;
default_lookups = ISC_FALSE; default_lookups = false;
break; break;
case 'N': case 'N':
debug("setting NDOTS to %s", debug("setting NDOTS to %s",
@@ -819,7 +821,7 @@ parse_args(isc_boolean_t is_batchfile, int argc, char **argv) {
/* Handled by pre_parse_args(). */ /* Handled by pre_parse_args(). */
break; break;
case 's': case 's':
lookup->servfail_stops = ISC_TRUE; lookup->servfail_stops = true;
break; break;
} }
} }
@@ -834,22 +836,22 @@ parse_args(isc_boolean_t is_batchfile, int argc, char **argv) {
if (argc > isc_commandline_index + 1) { if (argc > isc_commandline_index + 1) {
set_nameserver(argv[isc_commandline_index+1]); set_nameserver(argv[isc_commandline_index+1]);
debug("server is %s", argv[isc_commandline_index+1]); debug("server is %s", argv[isc_commandline_index+1]);
listed_server = ISC_TRUE; listed_server = true;
} else } else
check_ra = ISC_TRUE; check_ra = true;
lookup->pending = ISC_FALSE; lookup->pending = false;
if (get_reverse(store, sizeof(store), hostname, if (get_reverse(store, sizeof(store), hostname,
lookup->ip6_int, ISC_TRUE) == ISC_R_SUCCESS) { lookup->ip6_int, true) == ISC_R_SUCCESS) {
strlcpy(lookup->textname, store, sizeof(lookup->textname)); strlcpy(lookup->textname, store, sizeof(lookup->textname));
lookup->rdtype = dns_rdatatype_ptr; lookup->rdtype = dns_rdatatype_ptr;
lookup->rdtypeset = ISC_TRUE; lookup->rdtypeset = true;
default_lookups = ISC_FALSE; default_lookups = false;
} else { } else {
strlcpy(lookup->textname, hostname, sizeof(lookup->textname)); strlcpy(lookup->textname, hostname, sizeof(lookup->textname));
usesearch = ISC_TRUE; usesearch = true;
} }
lookup->new_search = ISC_TRUE; lookup->new_search = true;
ISC_LIST_APPEND(lookup_list, lookup, link); ISC_LIST_APPEND(lookup_list, lookup, link);
} }
@@ -878,7 +880,7 @@ main(int argc, char **argv) {
check_result(result, "isc_app_start"); check_result(result, "isc_app_start");
setup_libs(); setup_libs();
setup_system(ipv4only, ipv6only); setup_system(ipv4only, ipv6only);
parse_args(ISC_FALSE, argc, argv); parse_args(false, argc, argv);
if (keyfile[0] != 0) if (keyfile[0] != 0)
setup_file_key(); setup_file_key();
else if (keysecret[0] != 0) else if (keysecret[0] != 0)
+35 -33
View File
@@ -14,11 +14,13 @@
/*! \file */ /*! \file */
#include <inttypes.h>
#include <stdbool.h>
#include <dns/rdatalist.h> #include <dns/rdatalist.h>
#include <dst/dst.h> #include <dst/dst.h>
#include <isc/boolean.h>
#include <isc/buffer.h> #include <isc/buffer.h>
#include <isc/bufferlist.h> #include <isc/bufferlist.h>
#include <isc/formatcheck.h> #include <isc/formatcheck.h>
@@ -81,7 +83,7 @@ typedef struct dig_searchlist dig_searchlist_t;
/*% The dig_lookup structure */ /*% The dig_lookup structure */
struct dig_lookup { struct dig_lookup {
isc_boolean_t bool
pending, /*%< Pending a successful answer */ pending, /*%< Pending a successful answer */
waiting_connect, waiting_connect,
doing_xfr, doing_xfr,
@@ -139,8 +141,8 @@ struct dig_lookup {
dns_rdatatype_t rdtype; dns_rdatatype_t rdtype;
dns_rdatatype_t qrdtype; dns_rdatatype_t qrdtype;
dns_rdataclass_t rdclass; dns_rdataclass_t rdclass;
isc_boolean_t rdtypeset; bool rdtypeset;
isc_boolean_t rdclassset; bool rdclassset;
char name_space[BUFSIZE]; char name_space[BUFSIZE];
char oname_space[BUFSIZE]; char oname_space[BUFSIZE];
isc_buffer_t namebuf; isc_buffer_t namebuf;
@@ -158,17 +160,17 @@ struct dig_lookup {
dig_serverlist_t my_server_list; dig_serverlist_t my_server_list;
dig_searchlist_t *origin; dig_searchlist_t *origin;
dig_query_t *xfr_q; dig_query_t *xfr_q;
isc_uint32_t retries; uint32_t retries;
int nsfound; int nsfound;
isc_uint16_t udpsize; uint16_t udpsize;
isc_int16_t edns; int16_t edns;
isc_int16_t padding; int16_t padding;
isc_uint32_t ixfr_serial; uint32_t ixfr_serial;
isc_buffer_t rdatabuf; isc_buffer_t rdatabuf;
char rdatastore[MXNAME]; char rdatastore[MXNAME];
dst_context_t *tsigctx; dst_context_t *tsigctx;
isc_buffer_t *querysig; isc_buffer_t *querysig;
isc_uint32_t msgcounter; uint32_t msgcounter;
dns_fixedname_t fdomain; dns_fixedname_t fdomain;
isc_sockaddr_t *ecs_addr; isc_sockaddr_t *ecs_addr;
char *cookie; char *cookie;
@@ -184,7 +186,7 @@ struct dig_lookup {
/*% The dig_query structure */ /*% The dig_query structure */
struct dig_query { struct dig_query {
dig_lookup_t *lookup; dig_lookup_t *lookup;
isc_boolean_t waiting_connect, bool waiting_connect,
pending_free, pending_free,
waiting_senddone, waiting_senddone,
first_pass, first_pass,
@@ -194,11 +196,11 @@ struct dig_query {
recv_made, recv_made,
warn_id, warn_id,
timedout; timedout;
isc_uint32_t first_rr_serial; uint32_t first_rr_serial;
isc_uint32_t second_rr_serial; uint32_t second_rr_serial;
isc_uint32_t msg_count; uint32_t msg_count;
isc_uint32_t rr_count; uint32_t rr_count;
isc_boolean_t ixfr_axfr; bool ixfr_axfr;
char *servname; char *servname;
char *userarg; char *userarg;
isc_bufferlist_t sendlist, isc_bufferlist_t sendlist,
@@ -216,7 +218,7 @@ struct dig_query {
isc_sockaddr_t sockaddr; isc_sockaddr_t sockaddr;
isc_time_t time_sent; isc_time_t time_sent;
isc_time_t time_recv; isc_time_t time_recv;
isc_uint64_t byte_count; uint64_t byte_count;
isc_buffer_t sendbuf; isc_buffer_t sendbuf;
isc_timer_t *timer; isc_timer_t *timer;
}; };
@@ -244,7 +246,7 @@ extern dig_serverlist_t server_list;
extern dig_searchlistlist_t search_list; extern dig_searchlistlist_t search_list;
extern unsigned int extrabytes; extern unsigned int extrabytes;
extern isc_boolean_t check_ra, have_ipv4, have_ipv6, specified_source, extern bool check_ra, have_ipv4, have_ipv6, specified_source,
usesearch, showsearch; usesearch, showsearch;
extern in_port_t port; extern in_port_t port;
extern unsigned int timeout; extern unsigned int timeout;
@@ -260,17 +262,17 @@ extern char keysecret[MXNAME];
extern const dns_name_t *hmacname; extern const dns_name_t *hmacname;
extern unsigned int digestbits; extern unsigned int digestbits;
extern dns_tsigkey_t *tsigkey; extern dns_tsigkey_t *tsigkey;
extern isc_boolean_t validated; extern bool validated;
extern isc_taskmgr_t *taskmgr; extern isc_taskmgr_t *taskmgr;
extern isc_task_t *global_task; extern isc_task_t *global_task;
extern isc_boolean_t free_now; extern bool free_now;
extern isc_boolean_t debugging, debugtiming, memdebugging; extern bool debugging, debugtiming, memdebugging;
extern isc_boolean_t keep_open; extern bool keep_open;
extern char *progname; extern char *progname;
extern int tries; extern int tries;
extern int fatalexit; extern int fatalexit;
extern isc_boolean_t verbose; extern bool verbose;
/* /*
* Routines in dighost.c. * Routines in dighost.c.
@@ -282,8 +284,8 @@ int
getaddresses(dig_lookup_t *lookup, const char *host, isc_result_t *resultp); getaddresses(dig_lookup_t *lookup, const char *host, isc_result_t *resultp);
isc_result_t isc_result_t
get_reverse(char *reverse, size_t len, char *value, isc_boolean_t ip6_int, get_reverse(char *reverse, size_t len, char *value, bool ip6_int,
isc_boolean_t strict); bool strict);
ISC_PLATFORM_NORETURN_PRE void ISC_PLATFORM_NORETURN_PRE void
fatal(const char *format, ...) fatal(const char *format, ...)
@@ -302,7 +304,7 @@ debug(const char *format, ...) ISC_FORMAT_PRINTF(1, 2);
void void
check_result(isc_result_t result, const char *msg); check_result(isc_result_t result, const char *msg);
isc_boolean_t bool
setup_lookup(dig_lookup_t *lookup); setup_lookup(dig_lookup_t *lookup);
void void
@@ -324,14 +326,14 @@ void
setup_libs(void); setup_libs(void);
void void
setup_system(isc_boolean_t ipv4only, isc_boolean_t ipv6only); setup_system(bool ipv4only, bool ipv6only);
isc_result_t 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); const char *desc);
isc_result_t 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); const char *desc);
isc_result_t isc_result_t
@@ -341,13 +343,13 @@ void
parse_hmac(const char *hmacstr); parse_hmac(const char *hmacstr);
dig_lookup_t * dig_lookup_t *
requeue_lookup(dig_lookup_t *lookold, isc_boolean_t servers); requeue_lookup(dig_lookup_t *lookold, bool servers);
dig_lookup_t * dig_lookup_t *
make_empty_lookup(void); make_empty_lookup(void);
dig_lookup_t * dig_lookup_t *
clone_lookup(dig_lookup_t *lookold, isc_boolean_t servers); clone_lookup(dig_lookup_t *lookold, bool servers);
dig_server_t * dig_server_t *
make_server(const char *servname, const char *userarg); make_server(const char *servname, const char *userarg);
@@ -376,7 +378,7 @@ set_search_domain(char *domain);
* then assigned to the appropriate function pointer * then assigned to the appropriate function pointer
*/ */
extern isc_result_t extern isc_result_t
(*dighost_printmessage)(dig_query_t *query, dns_message_t *msg, isc_boolean_t headers); (*dighost_printmessage)(dig_query_t *query, dns_message_t *msg, bool headers);
/*%< /*%<
* Print the final result of the lookup. * Print the final result of the lookup.
*/ */
@@ -418,7 +420,7 @@ dig_setup(int argc, char **argv);
* Call to supply new parameters for the next lookup * Call to supply new parameters for the next lookup
*/ */
void void
dig_query_setup(isc_boolean_t, isc_boolean_t, int argc, char **argv); dig_query_setup(bool, bool, int argc, char **argv);
/*%< /*%<
* set the main application event cycle running * set the main application event cycle running
+88 -86
View File
@@ -11,6 +11,8 @@
#include <config.h> #include <config.h>
#include <inttypes.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h> #include <unistd.h>
@@ -53,18 +55,18 @@
#endif #endif
#endif #endif
static isc_boolean_t short_form = ISC_TRUE, static bool short_form = true,
tcpmode = ISC_FALSE, tcpmode_set = ISC_FALSE, tcpmode = false, tcpmode_set = false,
identify = ISC_FALSE, stats = ISC_TRUE, identify = false, stats = true,
comments = ISC_TRUE, section_question = ISC_TRUE, comments = true, section_question = true,
section_answer = ISC_TRUE, section_authority = ISC_TRUE, section_answer = true, section_authority = true,
section_additional = ISC_TRUE, recurse = ISC_TRUE, section_additional = true, recurse = true,
aaonly = ISC_FALSE, nofail = ISC_TRUE, aaonly = false, nofail = true,
default_lookups = ISC_TRUE, a_noanswer = ISC_FALSE; default_lookups = true, a_noanswer = false;
static isc_boolean_t interactive; static bool interactive;
static isc_boolean_t in_use = ISC_FALSE; static bool in_use = false;
static char defclass[MXRD] = "IN"; static char defclass[MXRD] = "IN";
static char deftype[MXRD] = "A"; static char deftype[MXRD] = "A";
static isc_event_t *global_event = NULL; static isc_event_t *global_event = NULL;
@@ -213,7 +215,7 @@ printrdata(dns_rdata_t *rdata) {
isc_result_t result; isc_result_t result;
isc_buffer_t *b = NULL; isc_buffer_t *b = NULL;
unsigned int size = 1024; unsigned int size = 1024;
isc_boolean_t done = ISC_FALSE; bool done = false;
if (rdata->type < N_KNOWN_RRTYPES) if (rdata->type < N_KNOWN_RRTYPES)
printf("%s", rtypetext[rdata->type]); printf("%s", rtypetext[rdata->type]);
@@ -228,7 +230,7 @@ printrdata(dns_rdata_t *rdata) {
if (result == ISC_R_SUCCESS) { if (result == ISC_R_SUCCESS) {
printf("%.*s\n", (int)isc_buffer_usedlength(b), printf("%.*s\n", (int)isc_buffer_usedlength(b),
(char *)isc_buffer_base(b)); (char *)isc_buffer_base(b));
done = ISC_TRUE; done = true;
} else if (result != ISC_R_NOSPACE) } else if (result != ISC_R_NOSPACE)
check_result(result, "dns_rdata_totext"); check_result(result, "dns_rdata_totext");
isc_buffer_free(&b); isc_buffer_free(&b);
@@ -237,7 +239,7 @@ printrdata(dns_rdata_t *rdata) {
} }
static isc_result_t static isc_result_t
printsection(dig_query_t *query, dns_message_t *msg, isc_boolean_t headers, printsection(dig_query_t *query, dns_message_t *msg, bool headers,
dns_section_t section) { dns_section_t section) {
isc_result_t result, loopresult; isc_result_t result, loopresult;
dns_name_t *name; dns_name_t *name;
@@ -304,7 +306,7 @@ printsection(dig_query_t *query, dns_message_t *msg, isc_boolean_t headers,
} }
static isc_result_t static isc_result_t
detailsection(dig_query_t *query, dns_message_t *msg, isc_boolean_t headers, detailsection(dig_query_t *query, dns_message_t *msg, bool headers,
dns_section_t section) { dns_section_t section) {
isc_result_t result, loopresult; isc_result_t result, loopresult;
dns_name_t *name; dns_name_t *name;
@@ -429,7 +431,7 @@ chase_cnamechain(dns_message_t *msg, dns_name_t *qname) {
} }
static isc_result_t static isc_result_t
printmessage(dig_query_t *query, dns_message_t *msg, isc_boolean_t headers) { printmessage(dig_query_t *query, dns_message_t *msg, bool headers) {
char servtext[ISC_SOCKADDR_FORMATSIZE]; char servtext[ISC_SOCKADDR_FORMATSIZE];
/* I've we've gotten this far, we've reached a server. */ /* I've we've gotten this far, we've reached a server. */
@@ -448,10 +450,10 @@ printmessage(dig_query_t *query, dns_message_t *msg, isc_boolean_t headers) {
if (!short_form) { if (!short_form) {
puts("------------"); puts("------------");
/* detailheader(query, msg);*/ /* detailheader(query, msg);*/
detailsection(query, msg, ISC_TRUE, DNS_SECTION_QUESTION); detailsection(query, msg, true, DNS_SECTION_QUESTION);
detailsection(query, msg, ISC_TRUE, DNS_SECTION_ANSWER); detailsection(query, msg, true, DNS_SECTION_ANSWER);
detailsection(query, msg, ISC_TRUE, DNS_SECTION_AUTHORITY); detailsection(query, msg, true, DNS_SECTION_AUTHORITY);
detailsection(query, msg, ISC_TRUE, DNS_SECTION_ADDITIONAL); detailsection(query, msg, true, DNS_SECTION_ADDITIONAL);
puts("------------"); puts("------------");
} }
@@ -479,12 +481,12 @@ printmessage(dig_query_t *query, dns_message_t *msg, isc_boolean_t headers) {
dns_name_copy(query->lookup->name, name, NULL); dns_name_copy(query->lookup->name, name, NULL);
chase_cnamechain(msg, name); chase_cnamechain(msg, name);
dns_name_format(name, namestr, sizeof(namestr)); dns_name_format(name, namestr, sizeof(namestr));
lookup = clone_lookup(query->lookup, ISC_FALSE); lookup = clone_lookup(query->lookup, false);
if (lookup != NULL) { if (lookup != NULL) {
strlcpy(lookup->textname, namestr, strlcpy(lookup->textname, namestr,
sizeof(lookup->textname)); sizeof(lookup->textname));
lookup->rdtype = dns_rdatatype_aaaa; lookup->rdtype = dns_rdatatype_aaaa;
lookup->rdtypeset = ISC_TRUE; lookup->rdtypeset = true;
lookup->origin = NULL; lookup->origin = NULL;
lookup->retries = tries; lookup->retries = tries;
ISC_LIST_APPEND(lookup_list, lookup, link); ISC_LIST_APPEND(lookup_list, lookup, link);
@@ -498,7 +500,7 @@ printmessage(dig_query_t *query, dns_message_t *msg, isc_boolean_t headers) {
printsection(query, msg, headers, DNS_SECTION_ANSWER); printsection(query, msg, headers, DNS_SECTION_ANSWER);
else { else {
if (default_lookups && query->lookup->rdtype == dns_rdatatype_a) if (default_lookups && query->lookup->rdtype == dns_rdatatype_a)
a_noanswer = ISC_TRUE; a_noanswer = true;
else if (!default_lookups || else if (!default_lookups ||
(query->lookup->rdtype == dns_rdatatype_aaaa && (query->lookup->rdtype == dns_rdatatype_aaaa &&
@@ -520,7 +522,7 @@ printmessage(dig_query_t *query, dns_message_t *msg, isc_boolean_t headers) {
} }
static void static void
show_settings(isc_boolean_t full, isc_boolean_t serv_only) { show_settings(bool full, bool serv_only) {
dig_server_t *srv; dig_server_t *srv;
isc_sockaddr_t sockaddr; isc_sockaddr_t sockaddr;
dig_searchlist_t *listent; dig_searchlist_t *listent;
@@ -565,7 +567,7 @@ show_settings(isc_boolean_t full, isc_boolean_t serv_only) {
printf("\n"); printf("\n");
} }
static isc_boolean_t static bool
testtype(char *typetext) { testtype(char *typetext) {
isc_result_t result; isc_result_t result;
isc_textregion_t tr; isc_textregion_t tr;
@@ -575,14 +577,14 @@ testtype(char *typetext) {
tr.length = strlen(typetext); tr.length = strlen(typetext);
result = dns_rdatatype_fromtext(&rdtype, &tr); result = dns_rdatatype_fromtext(&rdtype, &tr);
if (result == ISC_R_SUCCESS) if (result == ISC_R_SUCCESS)
return (ISC_TRUE); return (true);
else { else {
printf("unknown query type: %s\n", typetext); printf("unknown query type: %s\n", typetext);
return (ISC_FALSE); return (false);
} }
} }
static isc_boolean_t static bool
testclass(char *typetext) { testclass(char *typetext) {
isc_result_t result; isc_result_t result;
isc_textregion_t tr; isc_textregion_t tr;
@@ -592,24 +594,24 @@ testclass(char *typetext) {
tr.length = strlen(typetext); tr.length = strlen(typetext);
result = dns_rdataclass_fromtext(&rdclass, &tr); result = dns_rdataclass_fromtext(&rdclass, &tr);
if (result == ISC_R_SUCCESS) if (result == ISC_R_SUCCESS)
return (ISC_TRUE); return (true);
else { else {
printf("unknown query class: %s\n", typetext); printf("unknown query class: %s\n", typetext);
return (ISC_FALSE); return (false);
} }
} }
static void static void
set_port(const char *value) { set_port(const char *value) {
isc_uint32_t n; uint32_t n;
isc_result_t result = parse_uint(&n, value, 65535, "port"); isc_result_t result = parse_uint(&n, value, 65535, "port");
if (result == ISC_R_SUCCESS) if (result == ISC_R_SUCCESS)
port = (isc_uint16_t) n; port = (uint16_t) n;
} }
static void static void
set_timeout(const char *value) { set_timeout(const char *value) {
isc_uint32_t n; uint32_t n;
isc_result_t result = parse_uint(&n, value, UINT_MAX, "timeout"); isc_result_t result = parse_uint(&n, value, UINT_MAX, "timeout");
if (result == ISC_R_SUCCESS) if (result == ISC_R_SUCCESS)
timeout = n; timeout = n;
@@ -617,7 +619,7 @@ set_timeout(const char *value) {
static void static void
set_tries(const char *value) { set_tries(const char *value) {
isc_uint32_t n; uint32_t n;
isc_result_t result = parse_uint(&n, value, INT_MAX, "tries"); isc_result_t result = parse_uint(&n, value, INT_MAX, "tries");
if (result == ISC_R_SUCCESS) if (result == ISC_R_SUCCESS)
tries = n; tries = n;
@@ -625,7 +627,7 @@ set_tries(const char *value) {
static void static void
set_ndots(const char *value) { set_ndots(const char *value) {
isc_uint32_t n; uint32_t n;
isc_result_t result = parse_uint(&n, value, 128, "ndots"); isc_result_t result = parse_uint(&n, value, 128, "ndots");
if (result == ISC_R_SUCCESS) if (result == ISC_R_SUCCESS)
ndots = n; ndots = n;
@@ -644,7 +646,7 @@ setoption(char *opt) {
((l >= N) && (l < sizeof(A)) && (strncasecmp(opt, A, l) == 0)) ((l >= N) && (l < sizeof(A)) && (strncasecmp(opt, A, l) == 0))
if (CHECKOPT("all", 3)) { if (CHECKOPT("all", 3)) {
show_settings(ISC_TRUE, ISC_FALSE); show_settings(true, false);
} else if (strncasecmp(opt, "class=", 6) == 0) { } else if (strncasecmp(opt, "class=", 6) == 0) {
if (testclass(&opt[6])) if (testclass(&opt[6]))
strlcpy(defclass, &opt[6], sizeof(defclass)); strlcpy(defclass, &opt[6], sizeof(defclass));
@@ -654,41 +656,41 @@ setoption(char *opt) {
} else if (strncasecmp(opt, "type=", 5) == 0) { } else if (strncasecmp(opt, "type=", 5) == 0) {
if (testtype(&opt[5])) { if (testtype(&opt[5])) {
strlcpy(deftype, &opt[5], sizeof(deftype)); strlcpy(deftype, &opt[5], sizeof(deftype));
default_lookups = ISC_FALSE; default_lookups = false;
} }
} else if (strncasecmp(opt, "ty=", 3) == 0) { } else if (strncasecmp(opt, "ty=", 3) == 0) {
if (testtype(&opt[3])) { if (testtype(&opt[3])) {
strlcpy(deftype, &opt[3], sizeof(deftype)); strlcpy(deftype, &opt[3], sizeof(deftype));
default_lookups = ISC_FALSE; default_lookups = false;
} }
} else if (strncasecmp(opt, "querytype=", 10) == 0) { } else if (strncasecmp(opt, "querytype=", 10) == 0) {
if (testtype(&opt[10])) { if (testtype(&opt[10])) {
strlcpy(deftype, &opt[10], sizeof(deftype)); strlcpy(deftype, &opt[10], sizeof(deftype));
default_lookups = ISC_FALSE; default_lookups = false;
} }
} else if (strncasecmp(opt, "query=", 6) == 0) { } else if (strncasecmp(opt, "query=", 6) == 0) {
if (testtype(&opt[6])) { if (testtype(&opt[6])) {
strlcpy(deftype, &opt[6], sizeof(deftype)); strlcpy(deftype, &opt[6], sizeof(deftype));
default_lookups = ISC_FALSE; default_lookups = false;
} }
} else if (strncasecmp(opt, "qu=", 3) == 0) { } else if (strncasecmp(opt, "qu=", 3) == 0) {
if (testtype(&opt[3])) { if (testtype(&opt[3])) {
strlcpy(deftype, &opt[3], sizeof(deftype)); strlcpy(deftype, &opt[3], sizeof(deftype));
default_lookups = ISC_FALSE; default_lookups = false;
} }
} else if (strncasecmp(opt, "q=", 2) == 0) { } else if (strncasecmp(opt, "q=", 2) == 0) {
if (testtype(&opt[2])) { if (testtype(&opt[2])) {
strlcpy(deftype, &opt[2], sizeof(deftype)); strlcpy(deftype, &opt[2], sizeof(deftype));
default_lookups = ISC_FALSE; default_lookups = false;
} }
} else if (strncasecmp(opt, "domain=", 7) == 0) { } else if (strncasecmp(opt, "domain=", 7) == 0) {
strlcpy(domainopt, &opt[7], sizeof(domainopt)); strlcpy(domainopt, &opt[7], sizeof(domainopt));
set_search_domain(domainopt); set_search_domain(domainopt);
usesearch = ISC_TRUE; usesearch = true;
} else if (strncasecmp(opt, "do=", 3) == 0) { } else if (strncasecmp(opt, "do=", 3) == 0) {
strlcpy(domainopt, &opt[3], sizeof(domainopt)); strlcpy(domainopt, &opt[3], sizeof(domainopt));
set_search_domain(domainopt); set_search_domain(domainopt);
usesearch = ISC_TRUE; usesearch = true;
} else if (strncasecmp(opt, "port=", 5) == 0) { } else if (strncasecmp(opt, "port=", 5) == 0) {
set_port(&opt[5]); set_port(&opt[5]);
} else if (strncasecmp(opt, "po=", 3) == 0) { } else if (strncasecmp(opt, "po=", 3) == 0) {
@@ -698,43 +700,43 @@ setoption(char *opt) {
} else if (strncasecmp(opt, "t=", 2) == 0) { } else if (strncasecmp(opt, "t=", 2) == 0) {
set_timeout(&opt[2]); set_timeout(&opt[2]);
} else if (CHECKOPT("recurse", 3)) { } else if (CHECKOPT("recurse", 3)) {
recurse = ISC_TRUE; recurse = true;
} else if (CHECKOPT("norecurse", 5)) { } else if (CHECKOPT("norecurse", 5)) {
recurse = ISC_FALSE; recurse = false;
} else if (strncasecmp(opt, "retry=", 6) == 0) { } else if (strncasecmp(opt, "retry=", 6) == 0) {
set_tries(&opt[6]); set_tries(&opt[6]);
} else if (strncasecmp(opt, "ret=", 4) == 0) { } else if (strncasecmp(opt, "ret=", 4) == 0) {
set_tries(&opt[4]); set_tries(&opt[4]);
} else if (CHECKOPT("defname", 3)) { } else if (CHECKOPT("defname", 3)) {
usesearch = ISC_TRUE; usesearch = true;
} else if (CHECKOPT("nodefname", 5)) { } else if (CHECKOPT("nodefname", 5)) {
usesearch = ISC_FALSE; usesearch = false;
} else if (CHECKOPT("vc", 2)) { } else if (CHECKOPT("vc", 2)) {
tcpmode = ISC_TRUE; tcpmode = true;
tcpmode_set = ISC_TRUE; tcpmode_set = true;
} else if (CHECKOPT("novc", 4)) { } else if (CHECKOPT("novc", 4)) {
tcpmode = ISC_FALSE; tcpmode = false;
tcpmode_set = ISC_TRUE; tcpmode_set = true;
} else if (CHECKOPT("debug", 3)) { } else if (CHECKOPT("debug", 3)) {
short_form = ISC_FALSE; short_form = false;
showsearch = ISC_TRUE; showsearch = true;
} else if (CHECKOPT("nodebug", 5)) { } else if (CHECKOPT("nodebug", 5)) {
short_form = ISC_TRUE; short_form = true;
showsearch = ISC_FALSE; showsearch = false;
} else if (CHECKOPT("d2", 2)) { } else if (CHECKOPT("d2", 2)) {
debugging = ISC_TRUE; debugging = true;
} else if (CHECKOPT("nod2", 4)) { } else if (CHECKOPT("nod2", 4)) {
debugging = ISC_FALSE; debugging = false;
} else if (CHECKOPT("search", 3)) { } else if (CHECKOPT("search", 3)) {
usesearch = ISC_TRUE; usesearch = true;
} else if (CHECKOPT("nosearch", 5)) { } else if (CHECKOPT("nosearch", 5)) {
usesearch = ISC_FALSE; usesearch = false;
} else if (CHECKOPT("sil", 3)) { } else if (CHECKOPT("sil", 3)) {
/* deprecation_msg = ISC_FALSE; */ /* deprecation_msg = false; */
} else if (CHECKOPT("fail", 3)) { } else if (CHECKOPT("fail", 3)) {
nofail=ISC_FALSE; nofail=false;
} else if (CHECKOPT("nofail", 5)) { } else if (CHECKOPT("nofail", 5)) {
nofail=ISC_TRUE; nofail=true;
} else if (strncasecmp(opt, "ndots=", 6) == 0) { } else if (strncasecmp(opt, "ndots=", 6) == 0) {
set_ndots(&opt[6]); set_ndots(&opt[6]);
} else { } else {
@@ -753,7 +755,7 @@ addlookup(char *opt) {
debug("addlookup()"); debug("addlookup()");
a_noanswer = ISC_FALSE; a_noanswer = false;
tr.base = deftype; tr.base = deftype;
tr.length = strlen(deftype); tr.length = strlen(deftype);
@@ -770,21 +772,21 @@ addlookup(char *opt) {
rdclass = dns_rdataclass_in; rdclass = dns_rdataclass_in;
} }
lookup = make_empty_lookup(); lookup = make_empty_lookup();
if (get_reverse(store, sizeof(store), opt, lookup->ip6_int, ISC_TRUE) if (get_reverse(store, sizeof(store), opt, lookup->ip6_int, true)
== ISC_R_SUCCESS) { == ISC_R_SUCCESS) {
strlcpy(lookup->textname, store, sizeof(lookup->textname)); strlcpy(lookup->textname, store, sizeof(lookup->textname));
lookup->rdtype = dns_rdatatype_ptr; lookup->rdtype = dns_rdatatype_ptr;
lookup->rdtypeset = ISC_TRUE; lookup->rdtypeset = true;
} else { } else {
strlcpy(lookup->textname, opt, sizeof(lookup->textname)); strlcpy(lookup->textname, opt, sizeof(lookup->textname));
lookup->rdtype = rdtype; lookup->rdtype = rdtype;
lookup->rdtypeset = ISC_TRUE; lookup->rdtypeset = true;
} }
lookup->rdclass = rdclass; lookup->rdclass = rdclass;
lookup->rdclassset = ISC_TRUE; lookup->rdclassset = true;
lookup->trace = ISC_FALSE; lookup->trace = false;
lookup->trace_root = lookup->trace; lookup->trace_root = lookup->trace;
lookup->ns_search_only = ISC_FALSE; lookup->ns_search_only = false;
lookup->identify = identify; lookup->identify = identify;
lookup->recurse = recurse; lookup->recurse = recurse;
lookup->aaonly = aaonly; lookup->aaonly = aaonly;
@@ -792,7 +794,7 @@ addlookup(char *opt) {
lookup->udpsize = 0; lookup->udpsize = 0;
lookup->comments = comments; lookup->comments = comments;
if (lookup->rdtype == dns_rdatatype_any && !tcpmode_set) if (lookup->rdtype == dns_rdatatype_any && !tcpmode_set)
lookup->tcp_mode = ISC_TRUE; lookup->tcp_mode = true;
else else
lookup->tcp_mode = tcpmode; lookup->tcp_mode = tcpmode;
lookup->stats = stats; lookup->stats = stats;
@@ -800,9 +802,9 @@ addlookup(char *opt) {
lookup->section_answer = section_answer; lookup->section_answer = section_answer;
lookup->section_authority = section_authority; lookup->section_authority = section_authority;
lookup->section_additional = section_additional; lookup->section_additional = section_additional;
lookup->new_search = ISC_TRUE; lookup->new_search = true;
if (nofail) if (nofail)
lookup->servfail_stops = ISC_FALSE; lookup->servfail_stops = false;
ISC_LIST_INIT(lookup->q); ISC_LIST_INIT(lookup->q);
ISC_LINK_INIT(lookup, link); ISC_LINK_INIT(lookup, link);
ISC_LIST_APPEND(lookup_list, lookup, link); ISC_LIST_APPEND(lookup_list, lookup, link);
@@ -826,11 +828,11 @@ do_next_command(char *input) {
(strcasecmp(ptr, "lserver") == 0)) { (strcasecmp(ptr, "lserver") == 0)) {
isc_app_block(); isc_app_block();
set_nameserver(arg); set_nameserver(arg);
check_ra = ISC_FALSE; check_ra = false;
isc_app_unblock(); isc_app_unblock();
show_settings(ISC_TRUE, ISC_TRUE); show_settings(true, true);
} else if (strcasecmp(ptr, "exit") == 0) { } else if (strcasecmp(ptr, "exit") == 0) {
in_use = ISC_FALSE; in_use = false;
} else if (strcasecmp(ptr, "help") == 0 || } else if (strcasecmp(ptr, "help") == 0 ||
strcasecmp(ptr, "?") == 0) { strcasecmp(ptr, "?") == 0) {
printf("The '%s' command is not yet implemented.\n", ptr); printf("The '%s' command is not yet implemented.\n", ptr);
@@ -867,7 +869,7 @@ get_next_command(void) {
ptr = fgets(buf, COMMSIZE, stdin); ptr = fgets(buf, COMMSIZE, stdin);
isc_app_unblock(); isc_app_unblock();
if (ptr == NULL) { if (ptr == NULL) {
in_use = ISC_FALSE; in_use = false;
} else } else
do_next_command(ptr); do_next_command(ptr);
#ifdef HAVE_READLINE #ifdef HAVE_READLINE
@@ -879,9 +881,9 @@ get_next_command(void) {
static void static void
parse_args(int argc, char **argv) { parse_args(int argc, char **argv) {
isc_boolean_t have_lookup = ISC_FALSE; bool have_lookup = false;
usesearch = ISC_TRUE; usesearch = true;
for (argc--, argv++; argc > 0; argc--, argv++) { for (argc--, argv++; argc > 0; argc--, argv++) {
debug("main parsing %s", argv[0]); debug("main parsing %s", argv[0]);
if (argv[0][0] == '-') { if (argv[0][0] == '-') {
@@ -891,15 +893,15 @@ parse_args(int argc, char **argv) {
} else if (argv[0][1] != 0) { } else if (argv[0][1] != 0) {
setoption(&argv[0][1]); setoption(&argv[0][1]);
} else } else
have_lookup = ISC_TRUE; have_lookup = true;
} else { } else {
if (!have_lookup) { if (!have_lookup) {
have_lookup = ISC_TRUE; have_lookup = true;
in_use = ISC_TRUE; in_use = true;
addlookup(argv[0]); addlookup(argv[0]);
} else { } else {
set_nameserver(argv[0]); set_nameserver(argv[0]);
check_ra = ISC_FALSE; check_ra = false;
} }
} }
} }
@@ -970,13 +972,13 @@ int
main(int argc, char **argv) { main(int argc, char **argv) {
isc_result_t result; isc_result_t result;
interactive = ISC_TF(isatty(0)); interactive = isatty(0);
ISC_LIST_INIT(lookup_list); ISC_LIST_INIT(lookup_list);
ISC_LIST_INIT(server_list); ISC_LIST_INIT(server_list);
ISC_LIST_INIT(search_list); ISC_LIST_INIT(search_list);
check_ra = ISC_TRUE; check_ra = true;
/* setup dighost callbacks */ /* setup dighost callbacks */
dighost_printmessage = printmessage; dighost_printmessage = printmessage;
@@ -990,7 +992,7 @@ main(int argc, char **argv) {
setup_libs(); setup_libs();
progname = argv[0]; progname = argv[0];
setup_system(ISC_FALSE, ISC_FALSE); setup_system(false, false);
parse_args(argc, argv); parse_args(argc, argv);
if (keyfile[0] != 0) if (keyfile[0] != 0)
setup_file_key(); setup_file_key();
@@ -1004,7 +1006,7 @@ main(int argc, char **argv) {
else else
result = isc_app_onrun(mctx, global_task, getinput, NULL); result = isc_app_onrun(mctx, global_task, getinput, NULL);
check_result(result, "isc_app_onrun"); check_result(result, "isc_app_onrun");
in_use = ISC_TF(!in_use); in_use = !in_use;
(void)isc_app_run(); (void)isc_app_run();
+2 -2
View File
@@ -68,7 +68,7 @@
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\irs\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\irs\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>dighost.lib;libisc.lib;libisccfg.lib;libirs.lib;libdns.lib;libbind9.lib;@IDN_LIB@ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@dighost.lib;libisc.lib;libisccfg.lib;libirs.lib;libdns.lib;libbind9.lib;@IDN_LIB@ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'"> <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'">
@@ -98,7 +98,7 @@
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration> <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\irs\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\irs\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>dighost.lib;libisc.lib;libisccfg.lib;libirs.lib;libdns.lib;libbind9.lib;@IDN_LIB@ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@dighost.lib;libisc.lib;libisccfg.lib;libirs.lib;libdns.lib;libbind9.lib;@IDN_LIB@ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemGroup> <ItemGroup>
+2 -2
View File
@@ -68,7 +68,7 @@
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\irs\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\irs\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>dighost.lib;@IDN_LIB@libisc.lib;libisccfg.lib;libirs.lib;libdns.lib;libbind9.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@dighost.lib;@IDN_LIB@libisc.lib;libisccfg.lib;libirs.lib;libdns.lib;libbind9.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'"> <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'">
@@ -98,7 +98,7 @@
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration> <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\irs\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\irs\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>dighost.lib;@IDN_LIB@libisc.lib;libisccfg.lib;libirs.lib;libdns.lib;libbind9.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@dighost.lib;@IDN_LIB@libisc.lib;libisccfg.lib;libirs.lib;libdns.lib;libbind9.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemGroup> <ItemGroup>
+2 -2
View File
@@ -68,7 +68,7 @@
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<AdditionalLibraryDirectories>..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\irs\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\irs\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>@READLINE_LIBD@@IDN_LIB@libisc.lib;libisccfg.lib;libirs.lib;libdns.lib;libbind9.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@@READLINE_LIBD@@IDN_LIB@libisc.lib;libisccfg.lib;libirs.lib;libdns.lib;libbind9.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'"> <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'">
@@ -98,7 +98,7 @@
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration> <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
<AdditionalLibraryDirectories>..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\irs\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\irs\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>@READLINE_LIB@@IDN_LIB@libisc.lib;libisccfg.lib;libirs.lib;libdns.lib;libbind9.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@@READLINE_LIB@@IDN_LIB@libisc.lib;libisccfg.lib;libirs.lib;libdns.lib;libbind9.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemGroup> <ItemGroup>
+47 -45
View File
@@ -19,6 +19,8 @@
#include <config.h> #include <config.h>
#include <errno.h> #include <errno.h>
#include <inttypes.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <isc/buffer.h> #include <isc/buffer.h>
@@ -60,7 +62,7 @@
#include "dnssectool.h" #include "dnssectool.h"
#ifndef PATH_MAX #ifndef PATH_MAX
#define PATH_MAX 1024 /* AIX, WIN32, and others don't define this. */ #define PATH_MAX 1024 /* WIN32, and others don't define this. */
#endif #endif
const char *program = "dnssec-cds"; const char *program = "dnssec-cds";
@@ -84,7 +86,7 @@ static dns_rdataclass_t rdclass = dns_rdataclass_in;
* List of digest types used by ds_from_cdnskey(), filled in by add_dtype() * List of digest types used by ds_from_cdnskey(), filled in by add_dtype()
* from -a arguments. The size of the array is an arbitrary limit. * from -a arguments. The size of the array is an arbitrary limit.
*/ */
static isc_uint8_t dtype[8]; static uint8_t dtype[8];
static const char *startstr = NULL; /* from which we derive notbefore */ static const char *startstr = NULL; /* from which we derive notbefore */
static isc_stdtime_t notbefore = 0; /* restrict sig inception times */ static isc_stdtime_t notbefore = 0; /* restrict sig inception times */
@@ -127,7 +129,7 @@ static int nkey; /* number of child zone DNSKEY records */
typedef struct keyinfo { typedef struct keyinfo {
dns_rdata_t rdata; dns_rdata_t rdata;
dst_key_t *dst; dst_key_t *dst;
isc_uint8_t algo; uint8_t algo;
dns_keytag_t tag; dns_keytag_t tag;
} keyinfo_t; } keyinfo_t;
@@ -258,7 +260,7 @@ load_db(const char *filename, dns_db_t **dbp, dns_dbnode_t **nodep) {
isc_result_totext(result)); isc_result_totext(result));
} }
result = dns_db_findnode(*dbp, name, ISC_FALSE, nodep); result = dns_db_findnode(*dbp, name, false, nodep);
if (result != ISC_R_SUCCESS) { if (result != ISC_R_SUCCESS) {
fatal("can't find %s node in %s", namestr, filename); fatal("can't find %s node in %s", namestr, filename);
} }
@@ -312,7 +314,7 @@ get_dsset_name(char *filename, size_t size,
} }
isc_buffer_putstr(&buf, prefix); isc_buffer_putstr(&buf, prefix);
result = dns_name_tofilenametext(name, ISC_FALSE, &buf); result = dns_name_tofilenametext(name, false, &buf);
check_result(result, "dns_name_tofilenametext()"); check_result(result, "dns_name_tofilenametext()");
if (isc_buffer_availablelength(&buf) == 0) { if (isc_buffer_availablelength(&buf) == 0) {
fatal("%s: pathname too long", path); fatal("%s: pathname too long", path);
@@ -400,7 +402,7 @@ formatset(dns_rdataset_t *rdataset) {
static void static void
write_parent_set(const char *path, const char *inplace, write_parent_set(const char *path, const char *inplace,
isc_boolean_t nsupdate, dns_rdataset_t *rdataset) bool nsupdate, dns_rdataset_t *rdataset)
{ {
isc_result_t result; isc_result_t result;
isc_buffer_t *buf = NULL; isc_buffer_t *buf = NULL;
@@ -467,7 +469,7 @@ typedef enum { LOOSE, TIGHT } strictness_t;
/* /*
* Find out if any (C)DS record matches a particular (C)DNSKEY. * Find out if any (C)DS record matches a particular (C)DNSKEY.
*/ */
static isc_boolean_t static bool
match_key_dsset(keyinfo_t *ki, dns_rdataset_t *dsset, strictness_t strictness) match_key_dsset(keyinfo_t *ki, dns_rdataset_t *dsset, strictness_t strictness)
{ {
isc_result_t result; isc_result_t result;
@@ -481,7 +483,7 @@ match_key_dsset(keyinfo_t *ki, dns_rdataset_t *dsset, strictness_t strictness)
dns_rdata_t dsrdata = DNS_RDATA_INIT; dns_rdata_t dsrdata = DNS_RDATA_INIT;
dns_rdata_t newdsrdata = DNS_RDATA_INIT; dns_rdata_t newdsrdata = DNS_RDATA_INIT;
dns_rdatatype_t keytype; dns_rdatatype_t keytype;
isc_boolean_t c; bool c;
dns_rdataset_current(dsset, &dsrdata); dns_rdataset_current(dsset, &dsrdata);
result = dns_rdata_tostruct(&dsrdata, &ds, NULL); result = dns_rdata_tostruct(&dsrdata, &ds, NULL);
@@ -511,13 +513,13 @@ match_key_dsset(keyinfo_t *ki, dns_rdataset_t *dsset, strictness_t strictness)
vbprintf(1, "found matching %s %d %d %d\n", vbprintf(1, "found matching %s %d %d %d\n",
c ? "CDS" : "DS", c ? "CDS" : "DS",
ds.key_tag, ds.algorithm, ds.digest_type); ds.key_tag, ds.algorithm, ds.digest_type);
return (ISC_TRUE); return (true);
} else if (strictness == TIGHT) { } else if (strictness == TIGHT) {
vbprintf(0, "key does not match %s %d %d %d " vbprintf(0, "key does not match %s %d %d %d "
"when it looks like it should\n", "when it looks like it should\n",
c ? "CDS" : "DS", c ? "CDS" : "DS",
ds.key_tag, ds.algorithm, ds.digest_type); ds.key_tag, ds.algorithm, ds.digest_type);
return (ISC_FALSE); return (false);
} }
} }
@@ -528,7 +530,7 @@ match_key_dsset(keyinfo_t *ki, dns_rdataset_t *dsset, strictness_t strictness)
? "CDNSKEY" : "DNSKEY", ? "CDNSKEY" : "DNSKEY",
ki->tag, ki->algo); ki->tag, ki->algo);
return (ISC_FALSE); return (false);
} }
/* /*
@@ -617,12 +619,12 @@ free_keytable(keyinfo_t **keytable_p) {
* otherwise the key algorithm. This is used by the signature coverage * otherwise the key algorithm. This is used by the signature coverage
* check functions below. * check functions below.
*/ */
static isc_uint8_t * static uint8_t *
matching_sigs(keyinfo_t *keytbl, dns_rdataset_t *rdataset, matching_sigs(keyinfo_t *keytbl, dns_rdataset_t *rdataset,
dns_rdataset_t *sigset) dns_rdataset_t *sigset)
{ {
isc_result_t result; isc_result_t result;
isc_uint8_t *algo; uint8_t *algo;
int i; int i;
algo = isc_mem_get(mctx, nkey); algo = isc_mem_get(mctx, nkey);
@@ -668,7 +670,7 @@ matching_sigs(keyinfo_t *keytbl, dns_rdataset_t *rdataset,
} }
result = dns_dnssec_verify(name, rdataset, ki->dst, result = dns_dnssec_verify(name, rdataset, ki->dst,
ISC_FALSE, 0, mctx, false, 0, mctx,
&sigrdata, NULL); &sigrdata, NULL);
if (result != ISC_R_SUCCESS && if (result != ISC_R_SUCCESS &&
@@ -704,13 +706,13 @@ matching_sigs(keyinfo_t *keytbl, dns_rdataset_t *rdataset,
* Consume the result of matching_sigs(). When checking records * Consume the result of matching_sigs(). When checking records
* fetched from the child zone, any working signature is enough. * fetched from the child zone, any working signature is enough.
*/ */
static isc_boolean_t static bool
signed_loose(isc_uint8_t *algo) { signed_loose(uint8_t *algo) {
isc_boolean_t ok = ISC_FALSE; bool ok = false;
int i; int i;
for (i = 0; i < nkey; i++) { for (i = 0; i < nkey; i++) {
if (algo[i] != 0) { if (algo[i] != 0) {
ok = ISC_TRUE; ok = true;
} }
} }
isc_mem_put(mctx, algo, nkey); isc_mem_put(mctx, algo, nkey);
@@ -723,10 +725,10 @@ signed_loose(isc_uint8_t *algo) {
* key algorithm in the DS RRset must have a signature in the DNSKEY * key algorithm in the DS RRset must have a signature in the DNSKEY
* RRset. * RRset.
*/ */
static isc_boolean_t static bool
signed_strict(dns_rdataset_t *dsset, isc_uint8_t *algo) { signed_strict(dns_rdataset_t *dsset, uint8_t *algo) {
isc_result_t result; isc_result_t result;
isc_boolean_t all_ok = ISC_TRUE; bool all_ok = true;
for (result = dns_rdataset_first(dsset); for (result = dns_rdataset_first(dsset);
result == ISC_R_SUCCESS; result == ISC_R_SUCCESS;
@@ -734,23 +736,23 @@ signed_strict(dns_rdataset_t *dsset, isc_uint8_t *algo) {
{ {
dns_rdata_t dsrdata = DNS_RDATA_INIT; dns_rdata_t dsrdata = DNS_RDATA_INIT;
dns_rdata_ds_t ds; dns_rdata_ds_t ds;
isc_boolean_t ds_ok; bool ds_ok;
int i; int i;
dns_rdataset_current(dsset, &dsrdata); dns_rdataset_current(dsset, &dsrdata);
result = dns_rdata_tostruct(&dsrdata, &ds, NULL); result = dns_rdata_tostruct(&dsrdata, &ds, NULL);
check_result(result, "dns_rdata_tostruct(DS)"); check_result(result, "dns_rdata_tostruct(DS)");
ds_ok = ISC_FALSE; ds_ok = false;
for (i = 0; i < nkey; i++) { for (i = 0; i < nkey; i++) {
if (algo[i] == ds.algorithm) { if (algo[i] == ds.algorithm) {
ds_ok = ISC_TRUE; ds_ok = true;
} }
} }
if (!ds_ok) { if (!ds_ok) {
vbprintf(0, "missing signature for algorithm %d " vbprintf(0, "missing signature for algorithm %d "
"(key %d)\n", ds.algorithm, ds.key_tag); "(key %d)\n", ds.algorithm, ds.key_tag);
all_ok = ISC_FALSE; all_ok = false;
} }
} }
@@ -848,14 +850,14 @@ ds_from_cdnskey(dns_rdatalist_t *dslist, isc_buffer_t *buf,
*/ */
static int static int
cmp_dtype(const void *ap, const void *bp) { cmp_dtype(const void *ap, const void *bp) {
int a = *(const isc_uint8_t *)ap; int a = *(const uint8_t *)ap;
int b = *(const isc_uint8_t *)bp; int b = *(const uint8_t *)bp;
return (a - b); return (a - b);
} }
static void static void
add_dtype(const char *dn) { add_dtype(const char *dn) {
isc_uint8_t dt; uint8_t dt;
unsigned i, n; unsigned i, n;
dt = strtodsdigest(dn); dt = strtodsdigest(dn);
@@ -872,7 +874,7 @@ add_dtype(const char *dn) {
static void static void
make_new_ds_set(ds_maker_func_t *ds_from_rdata, make_new_ds_set(ds_maker_func_t *ds_from_rdata,
isc_uint32_t ttl, dns_rdataset_t *rdset) uint32_t ttl, dns_rdataset_t *rdset)
{ {
unsigned int size = 16; unsigned int size = 16;
for (;;) { for (;;) {
@@ -934,14 +936,14 @@ rdata_cmp(const void *rdata1, const void *rdata2) {
* Ensure that every key identified by the DS RRset has the same set of * Ensure that every key identified by the DS RRset has the same set of
* digest types. * digest types.
*/ */
static isc_boolean_t static bool
consistent_digests(dns_rdataset_t *dsset) { consistent_digests(dns_rdataset_t *dsset) {
isc_result_t result; isc_result_t result;
dns_rdata_t *arrdata; dns_rdata_t *arrdata;
dns_rdata_ds_t *ds; dns_rdata_ds_t *ds;
dns_keytag_t key_tag; dns_keytag_t key_tag;
isc_uint8_t algorithm; uint8_t algorithm;
isc_boolean_t match; bool match;
int i, j, n, d; int i, j, n, d;
/* /*
@@ -995,7 +997,7 @@ consistent_digests(dns_rdataset_t *dsset) {
/* /*
* Check subsequent keys match the first one * Check subsequent keys match the first one
*/ */
match = ISC_TRUE; match = true;
while (i < n) { while (i < n) {
key_tag = ds[i].key_tag; key_tag = ds[i].key_tag;
algorithm = ds[i].algorithm; algorithm = ds[i].algorithm;
@@ -1004,7 +1006,7 @@ consistent_digests(dns_rdataset_t *dsset) {
ds[i+j].algorithm != algorithm || ds[i+j].algorithm != algorithm ||
ds[i+j].digest_type != ds[j].digest_type) ds[i+j].digest_type != ds[j].digest_type)
{ {
match = ISC_FALSE; match = false;
} }
} }
i += d; i += d;
@@ -1039,7 +1041,7 @@ print_diff(const char *cmd, dns_rdataset_t *rdataset) {
} }
static void static void
update_diff(const char *cmd, isc_uint32_t ttl, update_diff(const char *cmd, uint32_t ttl,
dns_rdataset_t *addset, dns_rdataset_t *delset) dns_rdataset_t *addset, dns_rdataset_t *delset)
{ {
isc_result_t result; isc_result_t result;
@@ -1047,7 +1049,7 @@ update_diff(const char *cmd, isc_uint32_t ttl,
dns_dbnode_t *node; dns_dbnode_t *node;
dns_dbversion_t *ver; dns_dbversion_t *ver;
dns_rdataset_t diffset; dns_rdataset_t diffset;
isc_uint32_t save; uint32_t save;
db = NULL; db = NULL;
result = dns_db_create(mctx, "rbt", name, dns_dbtype_zone, result = dns_db_create(mctx, "rbt", name, dns_dbtype_zone,
@@ -1059,7 +1061,7 @@ update_diff(const char *cmd, isc_uint32_t ttl,
check_result(result, "dns_db_newversion()"); check_result(result, "dns_db_newversion()");
node = NULL; node = NULL;
result = dns_db_findnode(db, name, ISC_TRUE, &node); result = dns_db_findnode(db, name, true, &node);
check_result(result, "dns_db_findnode()"); check_result(result, "dns_db_findnode()");
dns_rdataset_init(&diffset); dns_rdataset_init(&diffset);
@@ -1083,12 +1085,12 @@ update_diff(const char *cmd, isc_uint32_t ttl,
} }
dns_db_detachnode(db, &node); dns_db_detachnode(db, &node);
dns_db_closeversion(db, &ver, ISC_FALSE); dns_db_closeversion(db, &ver, false);
dns_db_detach(&db); dns_db_detach(&db);
} }
static void static void
nsdiff(isc_uint32_t ttl, dns_rdataset_t *oldset, dns_rdataset_t *newset) { nsdiff(uint32_t ttl, dns_rdataset_t *oldset, dns_rdataset_t *newset) {
if (ttl == 0) { if (ttl == 0) {
vbprintf(1, "warning: no TTL in nsupdate script\n"); vbprintf(1, "warning: no TTL in nsupdate script\n");
} }
@@ -1136,9 +1138,9 @@ main(int argc, char *argv[]) {
const char *ds_path = NULL; const char *ds_path = NULL;
const char *inplace = NULL; const char *inplace = NULL;
isc_result_t result; isc_result_t result;
isc_boolean_t prefer_cdnskey = ISC_FALSE; bool prefer_cdnskey = false;
isc_boolean_t nsupdate = ISC_FALSE; bool nsupdate = false;
isc_uint32_t ttl = 0; uint32_t ttl = 0;
int ch; int ch;
char *endp; char *endp;
@@ -1152,7 +1154,7 @@ main(int argc, char *argv[]) {
#endif #endif
dns_result_register(); dns_result_register();
isc_commandline_errprint = ISC_FALSE; isc_commandline_errprint = false;
#define OPTIONS "a:c:Dd:f:i:ms:T:uv:V" #define OPTIONS "a:c:Dd:f:i:ms:T:uv:V"
while ((ch = isc_commandline_parse(argc, argv, OPTIONS)) != -1) { while ((ch = isc_commandline_parse(argc, argv, OPTIONS)) != -1) {
@@ -1164,7 +1166,7 @@ main(int argc, char *argv[]) {
rdclass = strtoclass(isc_commandline_argument); rdclass = strtoclass(isc_commandline_argument);
break; break;
case 'D': case 'D':
prefer_cdnskey = ISC_TRUE; prefer_cdnskey = true;
break; break;
case 'd': case 'd':
ds_path = isc_commandline_argument; ds_path = isc_commandline_argument;
@@ -1197,7 +1199,7 @@ main(int argc, char *argv[]) {
ttl = strtottl(isc_commandline_argument); ttl = strtottl(isc_commandline_argument);
break; break;
case 'u': case 'u':
nsupdate = ISC_TRUE; nsupdate = true;
break; break;
case 'V': case 'V':
/* Does not return. */ /* Does not return. */
+23 -21
View File
@@ -13,6 +13,8 @@
#include <config.h> #include <config.h>
#include <inttypes.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <isc/buffer.h> #include <isc/buffer.h>
@@ -48,7 +50,7 @@
#include "dnssectool.h" #include "dnssectool.h"
#ifndef PATH_MAX #ifndef PATH_MAX
#define PATH_MAX 1024 /* AIX, WIN32, and others don't define this. */ #define PATH_MAX 1024 /* WIN32, and others don't define this. */
#endif #endif
const char *program = "dnssec-dsfromkey"; const char *program = "dnssec-dsfromkey";
@@ -58,8 +60,8 @@ static dns_rdataclass_t rdclass;
static dns_fixedname_t fixed; static dns_fixedname_t fixed;
static dns_name_t *name = NULL; static dns_name_t *name = NULL;
static isc_mem_t *mctx = NULL; static isc_mem_t *mctx = NULL;
static isc_uint32_t ttl; static uint32_t ttl;
static isc_boolean_t emitttl = ISC_FALSE; static bool emitttl = false;
static isc_result_t static isc_result_t
initname(char *setname) { initname(char *setname) {
@@ -118,7 +120,7 @@ loadset(const char *filename, dns_rdataset_t *rdataset) {
isc_result_totext(result)); isc_result_totext(result));
} }
result = dns_db_findnode(db, name, ISC_FALSE, &node); result = dns_db_findnode(db, name, false, &node);
if (result != ISC_R_SUCCESS) if (result != ISC_R_SUCCESS)
fatal("can't find %s node in %s", setname, filename); fatal("can't find %s node in %s", setname, filename);
@@ -159,7 +161,7 @@ loadkeyset(char *dirname, dns_rdataset_t *rdataset) {
return (ISC_R_NOSPACE); return (ISC_R_NOSPACE);
isc_buffer_putstr(&buf, "keyset-"); isc_buffer_putstr(&buf, "keyset-");
result = dns_name_tofilenametext(name, ISC_FALSE, &buf); result = dns_name_tofilenametext(name, false, &buf);
check_result(result, "dns_name_tofilenametext()"); check_result(result, "dns_name_tofilenametext()");
if (isc_buffer_availablelength(&buf) == 0) if (isc_buffer_availablelength(&buf) == 0)
return (ISC_R_NOSPACE); return (ISC_R_NOSPACE);
@@ -233,8 +235,8 @@ logkey(dns_rdata_t *rdata)
} }
static void static void
emit(unsigned int dtype, isc_boolean_t showall, char *lookaside, emit(unsigned int dtype, bool showall, char *lookaside,
isc_boolean_t cds, dns_rdata_t *rdata) bool cds, dns_rdata_t *rdata)
{ {
isc_result_t result; isc_result_t result;
unsigned char buf[DNS_DS_BUFFERSIZE]; unsigned char buf[DNS_DS_BUFFERSIZE];
@@ -263,7 +265,7 @@ emit(unsigned int dtype, isc_boolean_t showall, char *lookaside,
if (result != ISC_R_SUCCESS) if (result != ISC_R_SUCCESS)
fatal("can't build record"); fatal("can't build record");
result = dns_name_totext(name, ISC_FALSE, &nameb); result = dns_name_totext(name, false, &nameb);
if (result != ISC_R_SUCCESS) if (result != ISC_R_SUCCESS)
fatal("can't print name"); fatal("can't print name");
@@ -352,10 +354,10 @@ main(int argc, char **argv) {
char *endp; char *endp;
int ch; int ch;
unsigned int dtype = DNS_DSDIGEST_SHA1; unsigned int dtype = DNS_DSDIGEST_SHA1;
isc_boolean_t cds = ISC_FALSE; bool cds = false;
isc_boolean_t both = ISC_TRUE; bool both = true;
isc_boolean_t usekeyset = ISC_FALSE; bool usekeyset = false;
isc_boolean_t showall = ISC_FALSE; bool showall = false;
isc_result_t result; isc_result_t result;
isc_log_t *log = NULL; isc_log_t *log = NULL;
dns_rdataset_t rdataset; dns_rdataset_t rdataset;
@@ -375,31 +377,31 @@ main(int argc, char **argv) {
#endif #endif
dns_result_register(); dns_result_register();
isc_commandline_errprint = ISC_FALSE; isc_commandline_errprint = false;
#define OPTIONS "12Aa:Cc:d:Ff:K:l:sT:v:hV" #define OPTIONS "12Aa:Cc:d:Ff:K:l:sT:v:hV"
while ((ch = isc_commandline_parse(argc, argv, OPTIONS)) != -1) { while ((ch = isc_commandline_parse(argc, argv, OPTIONS)) != -1) {
switch (ch) { switch (ch) {
case '1': case '1':
dtype = DNS_DSDIGEST_SHA1; dtype = DNS_DSDIGEST_SHA1;
both = ISC_FALSE; both = false;
break; break;
case '2': case '2':
dtype = DNS_DSDIGEST_SHA256; dtype = DNS_DSDIGEST_SHA256;
both = ISC_FALSE; both = false;
break; break;
case 'A': case 'A':
showall = ISC_TRUE; showall = true;
break; break;
case 'a': case 'a':
dtype = strtodsdigest(isc_commandline_argument); dtype = strtodsdigest(isc_commandline_argument);
both = ISC_FALSE; both = false;
break; break;
case 'C': case 'C':
if (lookaside != NULL) if (lookaside != NULL)
fatal("lookaside and CDS are mutually" fatal("lookaside and CDS are mutually"
" exclusive"); " exclusive");
cds = ISC_TRUE; cds = true;
break; break;
case 'c': case 'c':
classname = isc_commandline_argument; classname = isc_commandline_argument;
@@ -425,10 +427,10 @@ main(int argc, char **argv) {
fatal("lookaside must be a non-empty string"); fatal("lookaside must be a non-empty string");
break; break;
case 's': case 's':
usekeyset = ISC_TRUE; usekeyset = true;
break; break;
case 'T': case 'T':
emitttl = ISC_TRUE; emitttl = true;
ttl = strtottl(isc_commandline_argument); ttl = strtottl(isc_commandline_argument);
break; break;
case 'v': case 'v':
@@ -466,7 +468,7 @@ main(int argc, char **argv) {
/* When not using -f, -A is implicit */ /* When not using -f, -A is implicit */
if (filename == NULL) if (filename == NULL)
showall = ISC_TRUE; showall = true;
if (argc < isc_commandline_index + 1 && filename == NULL) if (argc < isc_commandline_index + 1 && filename == NULL)
fatal("the key file name was not specified"); fatal("the key file name was not specified");
+10 -9
View File
@@ -13,6 +13,7 @@
#include <config.h> #include <config.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <isc/buffer.h> #include <isc/buffer.h>
@@ -48,7 +49,7 @@
#include "dnssectool.h" #include "dnssectool.h"
#ifndef PATH_MAX #ifndef PATH_MAX
#define PATH_MAX 1024 /* AIX, WIN32, and others don't define this. */ #define PATH_MAX 1024 /* WIN32, and others don't define this. */
#endif #endif
const char *program = "dnssec-importkey"; const char *program = "dnssec-importkey";
@@ -58,13 +59,13 @@ static dns_rdataclass_t rdclass;
static dns_fixedname_t fixed; static dns_fixedname_t fixed;
static dns_name_t *name = NULL; static dns_name_t *name = NULL;
static isc_mem_t *mctx = NULL; static isc_mem_t *mctx = NULL;
static isc_boolean_t setpub = ISC_FALSE, setdel = ISC_FALSE; static bool setpub = false, setdel = false;
static isc_boolean_t setttl = ISC_FALSE; static bool setttl = false;
static isc_stdtime_t pub = 0, del = 0; static isc_stdtime_t pub = 0, del = 0;
static dns_ttl_t ttl = 0; static dns_ttl_t ttl = 0;
static isc_stdtime_t syncadd = 0, syncdel = 0; static isc_stdtime_t syncadd = 0, syncdel = 0;
static isc_boolean_t setsyncadd = ISC_FALSE; static bool setsyncadd = false;
static isc_boolean_t setsyncdel = ISC_FALSE; static bool setsyncdel = false;
static isc_result_t static isc_result_t
initname(char *setname) { initname(char *setname) {
@@ -124,7 +125,7 @@ loadset(const char *filename, dns_rdataset_t *rdataset) {
isc_result_totext(result)); isc_result_totext(result));
} }
result = dns_db_findnode(db, name, ISC_FALSE, &node); result = dns_db_findnode(db, name, false, &node);
if (result != ISC_R_SUCCESS) if (result != ISC_R_SUCCESS)
fatal("can't find %s node in %s", setname, filename); fatal("can't find %s node in %s", setname, filename);
@@ -226,7 +227,7 @@ emit(const char *dir, dns_rdata_t *rdata) {
dst_key_free(&tmp); dst_key_free(&tmp);
} }
dst_key_setexternal(key, ISC_TRUE); dst_key_setexternal(key, true);
if (setpub) if (setpub)
dst_key_settime(key, DST_TIME_PUBLISH, pub); dst_key_settime(key, DST_TIME_PUBLISH, pub);
if (setdel) if (setdel)
@@ -315,7 +316,7 @@ main(int argc, char **argv) {
#endif #endif
dns_result_register(); dns_result_register();
isc_commandline_errprint = ISC_FALSE; isc_commandline_errprint = false;
#define CMDLINE_FLAGS "D:f:hK:L:P:v:V" #define CMDLINE_FLAGS "D:f:hK:L:P:v:V"
while ((ch = isc_commandline_parse(argc, argv, CMDLINE_FLAGS)) != -1) { while ((ch = isc_commandline_parse(argc, argv, CMDLINE_FLAGS)) != -1) {
@@ -346,7 +347,7 @@ main(int argc, char **argv) {
break; break;
case 'L': case 'L':
ttl = strtottl(isc_commandline_argument); ttl = strtottl(isc_commandline_argument);
setttl = ISC_TRUE; setttl = true;
break; break;
case 'P': case 'P':
/* -Psync ? */ /* -Psync ? */
+26 -24
View File
@@ -14,6 +14,8 @@
#include <config.h> #include <config.h>
#include <ctype.h> #include <ctype.h>
#include <inttypes.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <isc/buffer.h> #include <isc/buffer.h>
@@ -127,9 +129,9 @@ main(int argc, char **argv) {
dst_key_t *key = NULL; dst_key_t *key = NULL;
dns_fixedname_t fname; dns_fixedname_t fname;
dns_name_t *name; 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; dns_secalg_t alg;
isc_boolean_t oldstyle = ISC_FALSE; bool oldstyle = false;
isc_mem_t *mctx = NULL; isc_mem_t *mctx = NULL;
int ch; int ch;
int protocol = -1, signatory = 0; int protocol = -1, signatory = 0;
@@ -146,20 +148,20 @@ main(int argc, char **argv) {
isc_stdtime_t inactive = 0, deltime = 0; isc_stdtime_t inactive = 0, deltime = 0;
isc_stdtime_t now; isc_stdtime_t now;
int prepub = -1; int prepub = -1;
isc_boolean_t setpub = ISC_FALSE, setact = ISC_FALSE; bool setpub = false, setact = false;
isc_boolean_t setrev = ISC_FALSE, setinact = ISC_FALSE; bool setrev = false, setinact = false;
isc_boolean_t setdel = ISC_FALSE, setttl = ISC_FALSE; bool setdel = false, setttl = false;
isc_boolean_t unsetpub = ISC_FALSE, unsetact = ISC_FALSE; bool unsetpub = false, unsetact = false;
isc_boolean_t unsetrev = ISC_FALSE, unsetinact = ISC_FALSE; bool unsetrev = false, unsetinact = false;
isc_boolean_t unsetdel = ISC_FALSE; bool unsetdel = false;
isc_boolean_t genonly = ISC_FALSE; bool genonly = false;
isc_boolean_t use_nsec3 = ISC_FALSE; bool use_nsec3 = false;
isc_boolean_t avoid_collisions = ISC_TRUE; bool avoid_collisions = true;
isc_boolean_t exact; bool exact;
unsigned char c; unsigned char c;
isc_stdtime_t syncadd = 0, syncdel = 0; isc_stdtime_t syncadd = 0, syncdel = 0;
isc_boolean_t unsetsyncadd = ISC_FALSE, setsyncadd = ISC_FALSE; bool unsetsyncadd = false, setsyncadd = false;
isc_boolean_t unsetsyncdel = ISC_FALSE, setsyncdel = ISC_FALSE; bool unsetsyncdel = false, setsyncdel = false;
if (argc == 1) if (argc == 1)
usage(); usage();
@@ -171,7 +173,7 @@ main(int argc, char **argv) {
#endif #endif
dns_result_register(); dns_result_register();
isc_commandline_errprint = ISC_FALSE; isc_commandline_errprint = false;
isc_stdtime_get(&now); isc_stdtime_get(&now);
@@ -179,13 +181,13 @@ main(int argc, char **argv) {
while ((ch = isc_commandline_parse(argc, argv, CMDLINE_FLAGS)) != -1) { while ((ch = isc_commandline_parse(argc, argv, CMDLINE_FLAGS)) != -1) {
switch (ch) { switch (ch) {
case '3': case '3':
use_nsec3 = ISC_TRUE; use_nsec3 = true;
break; break;
case 'a': case 'a':
algname = isc_commandline_argument; algname = isc_commandline_argument;
break; break;
case 'C': case 'C':
oldstyle = ISC_TRUE; oldstyle = true;
break; break;
case 'c': case 'c':
classname = isc_commandline_argument; classname = isc_commandline_argument;
@@ -215,7 +217,7 @@ main(int argc, char **argv) {
break; break;
case 'L': case 'L':
ttl = strtottl(isc_commandline_argument); ttl = strtottl(isc_commandline_argument);
setttl = ISC_TRUE; setttl = true;
break; break;
case 'l': case 'l':
label = isc_mem_strdup(mctx, isc_commandline_argument); label = isc_mem_strdup(mctx, isc_commandline_argument);
@@ -238,10 +240,10 @@ main(int argc, char **argv) {
fatal("-v must be followed by a number"); fatal("-v must be followed by a number");
break; break;
case 'y': case 'y':
avoid_collisions = ISC_FALSE; avoid_collisions = false;
break; break;
case 'G': case 'G':
genonly = ISC_TRUE; genonly = true;
break; break;
case 'P': case 'P':
/* -Psync ? */ /* -Psync ? */
@@ -442,14 +444,14 @@ main(int argc, char **argv) {
"prepublication interval."); "prepublication interval.");
if (!setpub && !setact) { if (!setpub && !setact) {
setpub = setact = ISC_TRUE; setpub = setact = true;
publish = now; publish = now;
activate = now + prepub; activate = now + prepub;
} else if (setpub && !setact) { } else if (setpub && !setact) {
setact = ISC_TRUE; setact = true;
activate = publish + prepub; activate = publish + prepub;
} else if (setact && !setpub) { } else if (setact && !setpub) {
setpub = ISC_TRUE; setpub = true;
publish = activate - prepub; publish = activate - prepub;
} }
@@ -532,7 +534,7 @@ main(int argc, char **argv) {
"You can use dnssec-settime -D to " "You can use dnssec-settime -D to "
"change this.\n", program, keystr); "change this.\n", program, keystr);
setpub = setact = ISC_TRUE; setpub = setact = true;
} }
if (nametype == NULL) { if (nametype == NULL) {
+37 -35
View File
@@ -28,6 +28,8 @@
#include <config.h> #include <config.h>
#include <ctype.h> #include <ctype.h>
#include <inttypes.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h> #include <unistd.h>
@@ -159,9 +161,9 @@ usage(void) {
exit (-1); exit (-1);
} }
static isc_boolean_t static bool
dsa_size_ok(int size) { dsa_size_ok(int size) {
return (ISC_TF(size >= 512 && size <= 1024 && size % 64 == 0)); return (size >= 512 && size <= 1024 && size % 64 == 0);
} }
static void static void
@@ -198,10 +200,10 @@ main(int argc, char **argv) {
dst_key_t *key = NULL; dst_key_t *key = NULL;
dns_fixedname_t fname; dns_fixedname_t fname;
dns_name_t *name; 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; dns_secalg_t alg;
isc_boolean_t conflict = ISC_FALSE, null_key = ISC_FALSE; bool conflict = false, null_key = false;
isc_boolean_t oldstyle = ISC_FALSE; bool oldstyle = false;
isc_mem_t *mctx = NULL; isc_mem_t *mctx = NULL;
int ch, generator = 0, param = 0; int ch, generator = 0, param = 0;
int protocol = -1, size = -1, signatory = 0; int protocol = -1, size = -1, signatory = 0;
@@ -218,24 +220,24 @@ main(int argc, char **argv) {
int options = DST_TYPE_PRIVATE | DST_TYPE_PUBLIC; int options = DST_TYPE_PRIVATE | DST_TYPE_PUBLIC;
int dbits = 0; int dbits = 0;
dns_ttl_t ttl = 0; dns_ttl_t ttl = 0;
isc_boolean_t use_nsec3 = ISC_FALSE; bool use_nsec3 = false;
isc_stdtime_t publish = 0, activate = 0, revokekey = 0; isc_stdtime_t publish = 0, activate = 0, revokekey = 0;
isc_stdtime_t inactive = 0, deltime = 0; isc_stdtime_t inactive = 0, deltime = 0;
isc_stdtime_t now; isc_stdtime_t now;
int prepub = -1; int prepub = -1;
isc_boolean_t setpub = ISC_FALSE, setact = ISC_FALSE; bool setpub = false, setact = false;
isc_boolean_t setrev = ISC_FALSE, setinact = ISC_FALSE; bool setrev = false, setinact = false;
isc_boolean_t setdel = ISC_FALSE, setttl = ISC_FALSE; bool setdel = false, setttl = false;
isc_boolean_t unsetpub = ISC_FALSE, unsetact = ISC_FALSE; bool unsetpub = false, unsetact = false;
isc_boolean_t unsetrev = ISC_FALSE, unsetinact = ISC_FALSE; bool unsetrev = false, unsetinact = false;
isc_boolean_t unsetdel = ISC_FALSE; bool unsetdel = false;
isc_boolean_t genonly = ISC_FALSE; bool genonly = false;
isc_boolean_t quiet = ISC_FALSE; bool quiet = false;
isc_boolean_t show_progress = ISC_FALSE; bool show_progress = false;
unsigned char c; unsigned char c;
isc_stdtime_t syncadd = 0, syncdel = 0; isc_stdtime_t syncadd = 0, syncdel = 0;
isc_boolean_t setsyncadd = ISC_FALSE; bool setsyncadd = false;
isc_boolean_t setsyncdel = ISC_FALSE; bool setsyncdel = false;
if (argc == 1) if (argc == 1)
usage(); usage();
@@ -245,7 +247,7 @@ main(int argc, char **argv) {
#endif #endif
dns_result_register(); dns_result_register();
isc_commandline_errprint = ISC_FALSE; isc_commandline_errprint = false;
/* /*
* Process memory debugging argument first. * Process memory debugging argument first.
@@ -270,7 +272,7 @@ main(int argc, char **argv) {
break; break;
} }
} }
isc_commandline_reset = ISC_TRUE; isc_commandline_reset = true;
RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS); RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS);
@@ -279,7 +281,7 @@ main(int argc, char **argv) {
while ((ch = isc_commandline_parse(argc, argv, CMDLINE_FLAGS)) != -1) { while ((ch = isc_commandline_parse(argc, argv, CMDLINE_FLAGS)) != -1) {
switch (ch) { switch (ch) {
case '3': case '3':
use_nsec3 = ISC_TRUE; use_nsec3 = true;
break; break;
case 'a': case 'a':
algname = isc_commandline_argument; algname = isc_commandline_argument;
@@ -290,7 +292,7 @@ main(int argc, char **argv) {
fatal("-b requires a non-negative number"); fatal("-b requires a non-negative number");
break; break;
case 'C': case 'C':
oldstyle = ISC_TRUE; oldstyle = true;
break; break;
case 'c': case 'c':
classname = isc_commandline_argument; classname = isc_commandline_argument;
@@ -338,7 +340,7 @@ main(int argc, char **argv) {
break; break;
case 'L': case 'L':
ttl = strtottl(isc_commandline_argument); ttl = strtottl(isc_commandline_argument);
setttl = ISC_TRUE; setttl = true;
break; break;
case 'n': case 'n':
nametype = isc_commandline_argument; nametype = isc_commandline_argument;
@@ -352,7 +354,7 @@ main(int argc, char **argv) {
"[0..255]"); "[0..255]");
break; break;
case 'q': case 'q':
quiet = ISC_TRUE; quiet = true;
break; break;
case 'r': case 'r':
fatal("The -r option has been deprecated.\n" fatal("The -r option has been deprecated.\n"
@@ -389,7 +391,7 @@ main(int argc, char **argv) {
/* already the default */ /* already the default */
break; break;
case 'G': case 'G':
genonly = ISC_TRUE; genonly = true;
break; break;
case 'P': case 'P':
/* -Psync ? */ /* -Psync ? */
@@ -483,7 +485,7 @@ main(int argc, char **argv) {
} }
if (!isatty(0)) if (!isatty(0))
quiet = ISC_TRUE; quiet = true;
ret = dst_lib_init(mctx, engine); ret = dst_lib_init(mctx, engine);
if (ret != ISC_R_SUCCESS) if (ret != ISC_R_SUCCESS)
@@ -614,14 +616,14 @@ main(int argc, char **argv) {
"prepublication interval."); "prepublication interval.");
if (!setpub && !setact) { if (!setpub && !setact) {
setpub = setact = ISC_TRUE; setpub = setact = true;
publish = now; publish = now;
activate = now + prepub; activate = now + prepub;
} else if (setpub && !setact) { } else if (setpub && !setact) {
setact = ISC_TRUE; setact = true;
activate = publish + prepub; activate = publish + prepub;
} else if (setact && !setpub) { } else if (setact && !setpub) {
setpub = ISC_TRUE; setpub = true;
publish = activate - prepub; publish = activate - prepub;
} }
@@ -707,7 +709,7 @@ main(int argc, char **argv) {
"You can use dnssec-settime -D to " "You can use dnssec-settime -D to "
"change this.\n", program, keystr); "change this.\n", program, keystr);
setpub = setact = ISC_TRUE; setpub = setact = true;
} }
switch (alg) { switch (alg) {
@@ -806,7 +808,7 @@ main(int argc, char **argv) {
case DNS_KEYALG_NSEC3RSASHA1: case DNS_KEYALG_NSEC3RSASHA1:
case DNS_KEYALG_RSASHA256: case DNS_KEYALG_RSASHA256:
case DNS_KEYALG_RSASHA512: case DNS_KEYALG_RSASHA512:
show_progress = ISC_TRUE; show_progress = true;
break; break;
case DNS_KEYALG_DH: case DNS_KEYALG_DH:
@@ -820,17 +822,17 @@ main(int argc, char **argv) {
case DST_ALG_ECDSA384: case DST_ALG_ECDSA384:
case DST_ALG_ED25519: case DST_ALG_ED25519:
case DST_ALG_ED448: case DST_ALG_ED448:
show_progress = ISC_TRUE; show_progress = true;
break; break;
} }
if ((flags & DNS_KEYFLAG_TYPEMASK) == DNS_KEYTYPE_NOKEY) if ((flags & DNS_KEYFLAG_TYPEMASK) == DNS_KEYTYPE_NOKEY)
null_key = ISC_TRUE; null_key = true;
isc_buffer_init(&buf, filename, sizeof(filename) - 1); isc_buffer_init(&buf, filename, sizeof(filename) - 1);
do { do {
conflict = ISC_FALSE; conflict = false;
if (!quiet && show_progress) { if (!quiet && show_progress) {
fprintf(stderr, "Generating key pair."); fprintf(stderr, "Generating key pair.");
@@ -951,7 +953,7 @@ main(int argc, char **argv) {
* or another key being revoked. * or another key being revoked.
*/ */
if (key_collision(key, name, directory, mctx, NULL)) { if (key_collision(key, name, directory, mctx, NULL)) {
conflict = ISC_TRUE; conflict = true;
if (null_key) { if (null_key) {
dst_key_free(&key); dst_key_free(&key);
break; break;
@@ -972,7 +974,7 @@ main(int argc, char **argv) {
dst_key_free(&key); dst_key_free(&key);
} }
} while (conflict == ISC_TRUE); } while (conflict == true);
if (conflict) if (conflict)
fatal("cannot generate a null key due to possible key ID " fatal("cannot generate a null key due to possible key ID "
+10 -8
View File
@@ -13,6 +13,8 @@
#include <config.h> #include <config.h>
#include <inttypes.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h> #include <unistd.h>
@@ -80,11 +82,11 @@ main(int argc, char **argv) {
char *endp; char *endp;
int ch; int ch;
dst_key_t *key = NULL; dst_key_t *key = NULL;
isc_uint32_t flags; uint32_t flags;
isc_buffer_t buf; isc_buffer_t buf;
isc_boolean_t force = ISC_FALSE; bool force = false;
isc_boolean_t removefile = ISC_FALSE; bool removefile = false;
isc_boolean_t id = ISC_FALSE; bool id = false;
if (argc == 1) if (argc == 1)
usage(); usage();
@@ -98,7 +100,7 @@ main(int argc, char **argv) {
#endif #endif
dns_result_register(); dns_result_register();
isc_commandline_errprint = ISC_FALSE; isc_commandline_errprint = false;
while ((ch = isc_commandline_parse(argc, argv, "E:fK:rRhv:V")) != -1) { while ((ch = isc_commandline_parse(argc, argv, "E:fK:rRhv:V")) != -1) {
switch (ch) { switch (ch) {
@@ -106,7 +108,7 @@ main(int argc, char **argv) {
engine = isc_commandline_argument; engine = isc_commandline_argument;
break; break;
case 'f': case 'f':
force = ISC_TRUE; force = true;
break; break;
case 'K': case 'K':
/* /*
@@ -120,10 +122,10 @@ main(int argc, char **argv) {
} }
break; break;
case 'r': case 'r':
removefile = ISC_TRUE; removefile = true;
break; break;
case 'R': case 'R':
id = ISC_TRUE; id = true;
break; break;
case 'v': case 'v':
verbose = strtol(isc_commandline_argument, &endp, 0); verbose = strtol(isc_commandline_argument, &endp, 0);
+51 -49
View File
@@ -13,6 +13,8 @@
#include <config.h> #include <config.h>
#include <inttypes.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h> #include <unistd.h>
#include <errno.h> #include <errno.h>
@@ -102,7 +104,7 @@ usage(void) {
} }
static void static void
printtime(dst_key_t *key, int type, const char *tag, isc_boolean_t epoch, printtime(dst_key_t *key, int type, const char *tag, bool epoch,
FILE *stream) FILE *stream)
{ {
isc_result_t result; isc_result_t result;
@@ -141,29 +143,29 @@ main(int argc, char **argv) {
dns_name_t *name = NULL; dns_name_t *name = NULL;
dns_secalg_t alg = 0; dns_secalg_t alg = 0;
unsigned int size = 0; unsigned int size = 0;
isc_uint16_t flags = 0; uint16_t flags = 0;
int prepub = -1; int prepub = -1;
dns_ttl_t ttl = 0; dns_ttl_t ttl = 0;
isc_stdtime_t now; isc_stdtime_t now;
isc_stdtime_t pub = 0, act = 0, rev = 0, inact = 0, del = 0; isc_stdtime_t pub = 0, act = 0, rev = 0, inact = 0, del = 0;
isc_stdtime_t prevact = 0, previnact = 0, prevdel = 0; isc_stdtime_t prevact = 0, previnact = 0, prevdel = 0;
isc_boolean_t setpub = ISC_FALSE, setact = ISC_FALSE; bool setpub = false, setact = false;
isc_boolean_t setrev = ISC_FALSE, setinact = ISC_FALSE; bool setrev = false, setinact = false;
isc_boolean_t setdel = ISC_FALSE, setttl = ISC_FALSE; bool setdel = false, setttl = false;
isc_boolean_t unsetpub = ISC_FALSE, unsetact = ISC_FALSE; bool unsetpub = false, unsetact = false;
isc_boolean_t unsetrev = ISC_FALSE, unsetinact = ISC_FALSE; bool unsetrev = false, unsetinact = false;
isc_boolean_t unsetdel = ISC_FALSE; bool unsetdel = false;
isc_boolean_t printcreate = ISC_FALSE, printpub = ISC_FALSE; bool printcreate = false, printpub = false;
isc_boolean_t printact = ISC_FALSE, printrev = ISC_FALSE; bool printact = false, printrev = false;
isc_boolean_t printinact = ISC_FALSE, printdel = ISC_FALSE; bool printinact = false, printdel = false;
isc_boolean_t force = ISC_FALSE; bool force = false;
isc_boolean_t epoch = ISC_FALSE; bool epoch = false;
isc_boolean_t changed = ISC_FALSE; bool changed = false;
isc_log_t *log = NULL; isc_log_t *log = NULL;
isc_stdtime_t syncadd = 0, syncdel = 0; isc_stdtime_t syncadd = 0, syncdel = 0;
isc_boolean_t unsetsyncadd = ISC_FALSE, setsyncadd = ISC_FALSE; bool unsetsyncadd = false, setsyncadd = false;
isc_boolean_t unsetsyncdel = ISC_FALSE, setsyncdel = ISC_FALSE; bool unsetsyncdel = false, setsyncdel = false;
isc_boolean_t printsyncadd = ISC_FALSE, printsyncdel = ISC_FALSE; bool printsyncadd = false, printsyncdel = false;
if (argc == 1) if (argc == 1)
usage(); usage();
@@ -179,7 +181,7 @@ main(int argc, char **argv) {
#endif #endif
dns_result_register(); dns_result_register();
isc_commandline_errprint = ISC_FALSE; isc_commandline_errprint = false;
isc_stdtime_get(&now); isc_stdtime_get(&now);
@@ -190,51 +192,51 @@ main(int argc, char **argv) {
engine = isc_commandline_argument; engine = isc_commandline_argument;
break; break;
case 'f': case 'f':
force = ISC_TRUE; force = true;
break; break;
case 'p': case 'p':
p = isc_commandline_argument; p = isc_commandline_argument;
if (!strcasecmp(p, "all")) { if (!strcasecmp(p, "all")) {
printcreate = ISC_TRUE; printcreate = true;
printpub = ISC_TRUE; printpub = true;
printact = ISC_TRUE; printact = true;
printrev = ISC_TRUE; printrev = true;
printinact = ISC_TRUE; printinact = true;
printdel = ISC_TRUE; printdel = true;
printsyncadd = ISC_TRUE; printsyncadd = true;
printsyncdel = ISC_TRUE; printsyncdel = true;
break; break;
} }
do { do {
switch (*p++) { switch (*p++) {
case 'C': case 'C':
printcreate = ISC_TRUE; printcreate = true;
break; break;
case 'P': case 'P':
if (!strncmp(p, "sync", 4)) { if (!strncmp(p, "sync", 4)) {
p += 4; p += 4;
printsyncadd = ISC_TRUE; printsyncadd = true;
break; break;
} }
printpub = ISC_TRUE; printpub = true;
break; break;
case 'A': case 'A':
printact = ISC_TRUE; printact = true;
break; break;
case 'R': case 'R':
printrev = ISC_TRUE; printrev = true;
break; break;
case 'I': case 'I':
printinact = ISC_TRUE; printinact = true;
break; break;
case 'D': case 'D':
if (!strncmp(p, "sync", 4)) { if (!strncmp(p, "sync", 4)) {
p += 4; p += 4;
printsyncdel = ISC_TRUE; printsyncdel = true;
break; break;
} }
printdel = ISC_TRUE; printdel = true;
break; break;
case ' ': case ' ':
break; break;
@@ -245,7 +247,7 @@ main(int argc, char **argv) {
} while (*p != '\0'); } while (*p != '\0');
break; break;
case 'u': case 'u':
epoch = ISC_TRUE; epoch = true;
break; break;
case 'K': case 'K':
/* /*
@@ -261,7 +263,7 @@ main(int argc, char **argv) {
break; break;
case 'L': case 'L':
ttl = strtottl(isc_commandline_argument); ttl = strtottl(isc_commandline_argument);
setttl = ISC_TRUE; setttl = true;
break; break;
case 'v': case 'v':
verbose = strtol(isc_commandline_argument, &endp, 0); verbose = strtol(isc_commandline_argument, &endp, 0);
@@ -275,7 +277,7 @@ main(int argc, char **argv) {
fatal("-P sync specified more than " fatal("-P sync specified more than "
"once"); "once");
changed = ISC_TRUE; changed = true;
syncadd = strtotime(isc_commandline_argument, syncadd = strtotime(isc_commandline_argument,
now, now, &setsyncadd); now, now, &setsyncadd);
unsetsyncadd = !setsyncadd; unsetsyncadd = !setsyncadd;
@@ -285,7 +287,7 @@ main(int argc, char **argv) {
if (setpub || unsetpub) if (setpub || unsetpub)
fatal("-P specified more than once"); fatal("-P specified more than once");
changed = ISC_TRUE; changed = true;
pub = strtotime(isc_commandline_argument, pub = strtotime(isc_commandline_argument,
now, now, &setpub); now, now, &setpub);
unsetpub = !setpub; unsetpub = !setpub;
@@ -294,7 +296,7 @@ main(int argc, char **argv) {
if (setact || unsetact) if (setact || unsetact)
fatal("-A specified more than once"); fatal("-A specified more than once");
changed = ISC_TRUE; changed = true;
act = strtotime(isc_commandline_argument, act = strtotime(isc_commandline_argument,
now, now, &setact); now, now, &setact);
unsetact = !setact; unsetact = !setact;
@@ -303,7 +305,7 @@ main(int argc, char **argv) {
if (setrev || unsetrev) if (setrev || unsetrev)
fatal("-R specified more than once"); fatal("-R specified more than once");
changed = ISC_TRUE; changed = true;
rev = strtotime(isc_commandline_argument, rev = strtotime(isc_commandline_argument,
now, now, &setrev); now, now, &setrev);
unsetrev = !setrev; unsetrev = !setrev;
@@ -312,7 +314,7 @@ main(int argc, char **argv) {
if (setinact || unsetinact) if (setinact || unsetinact)
fatal("-I specified more than once"); fatal("-I specified more than once");
changed = ISC_TRUE; changed = true;
inact = strtotime(isc_commandline_argument, inact = strtotime(isc_commandline_argument,
now, now, &setinact); now, now, &setinact);
unsetinact = !setinact; unsetinact = !setinact;
@@ -324,7 +326,7 @@ main(int argc, char **argv) {
fatal("-D sync specified more than " fatal("-D sync specified more than "
"once"); "once");
changed = ISC_TRUE; changed = true;
syncdel = strtotime(isc_commandline_argument, syncdel = strtotime(isc_commandline_argument,
now, now, &setsyncdel); now, now, &setsyncdel);
unsetsyncdel = !setsyncdel; unsetsyncdel = !setsyncdel;
@@ -335,7 +337,7 @@ main(int argc, char **argv) {
if (setdel || unsetdel) if (setdel || unsetdel)
fatal("-D specified more than once"); fatal("-D specified more than once");
changed = ISC_TRUE; changed = true;
del = strtotime(isc_commandline_argument, del = strtotime(isc_commandline_argument,
now, now, &setdel); now, now, &setdel);
unsetdel = !setdel; unsetdel = !setdel;
@@ -446,7 +448,7 @@ main(int argc, char **argv) {
"before it is scheduled to be " "before it is scheduled to be "
"inactive.\n", program); "inactive.\n", program);
changed = setpub = setact = ISC_TRUE; changed = setpub = setact = true;
} else { } else {
if (prepub < 0) if (prepub < 0)
prepub = 0; prepub = 0;
@@ -458,10 +460,10 @@ main(int argc, char **argv) {
"prepublication interval."); "prepublication interval.");
if (setpub && !setact) { if (setpub && !setact) {
setact = ISC_TRUE; setact = true;
act = pub + prepub; act = pub + prepub;
} else if (setact && !setpub) { } else if (setact && !setpub) {
setpub = ISC_TRUE; setpub = true;
pub = act - prepub; pub = act - prepub;
} }
@@ -592,11 +594,11 @@ main(int argc, char **argv) {
if (force && !changed) { if (force && !changed) {
dst_key_settime(key, DST_TIME_PUBLISH, now); dst_key_settime(key, DST_TIME_PUBLISH, now);
dst_key_settime(key, DST_TIME_ACTIVATE, now); dst_key_settime(key, DST_TIME_ACTIVATE, now);
changed = ISC_TRUE; changed = true;
} }
if (!changed && setttl) if (!changed && setttl)
changed = ISC_TRUE; changed = true;
/* /*
* Print out time values, if -p was used. * Print out time values, if -p was used.
File diff suppressed because it is too large Load Diff
+8 -8
View File
@@ -13,6 +13,7 @@
#include <config.h> #include <config.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <time.h> #include <time.h>
@@ -31,7 +32,6 @@
#include <isc/rwlock.h> #include <isc/rwlock.h>
#include <isc/serial.h> #include <isc/serial.h>
#include <isc/stdio.h> #include <isc/stdio.h>
#include <isc/stdlib.h>
#include <isc/string.h> #include <isc/string.h>
#include <isc/time.h> #include <isc/time.h>
#include <isc/util.h> #include <isc/util.h>
@@ -78,8 +78,8 @@ static dns_db_t *gdb; /* The database */
static dns_dbversion_t *gversion; /* The database version */ static dns_dbversion_t *gversion; /* The database version */
static dns_rdataclass_t gclass; /* The class */ static dns_rdataclass_t gclass; /* The class */
static dns_name_t *gorigin; /* The database origin */ static dns_name_t *gorigin; /* The database origin */
static isc_boolean_t ignore_kskflag = ISC_FALSE; static bool ignore_kskflag = false;
static isc_boolean_t keyset_kskonly = ISC_FALSE; static bool keyset_kskonly = false;
/*% /*%
* Load the zone file from disk * Load the zone file from disk
@@ -198,7 +198,7 @@ main(int argc, char *argv[]) {
break; break;
} }
} }
isc_commandline_reset = ISC_TRUE; isc_commandline_reset = true;
check_result(isc_app_start(), "isc_app_start"); check_result(isc_app_start(), "isc_app_start");
result = isc_mem_create(0, 0, &mctx); result = isc_mem_create(0, 0, &mctx);
@@ -210,7 +210,7 @@ main(int argc, char *argv[]) {
#endif #endif
dns_result_register(); dns_result_register();
isc_commandline_errprint = ISC_FALSE; isc_commandline_errprint = false;
while ((ch = isc_commandline_parse(argc, argv, CMDLINE_FLAGS)) != -1) { while ((ch = isc_commandline_parse(argc, argv, CMDLINE_FLAGS)) != -1) {
switch (ch) { switch (ch) {
@@ -241,11 +241,11 @@ main(int argc, char *argv[]) {
break; break;
case 'x': case 'x':
keyset_kskonly = ISC_TRUE; keyset_kskonly = true;
break; break;
case 'z': case 'z':
ignore_kskflag = ISC_TRUE; ignore_kskflag = true;
break; break;
case '?': case '?':
@@ -319,7 +319,7 @@ main(int argc, char *argv[]) {
result = dns_zoneverify_dnssec(NULL, gdb, gversion, gorigin, NULL, result = dns_zoneverify_dnssec(NULL, gdb, gversion, gorigin, NULL,
mctx, ignore_kskflag, keyset_kskonly); mctx, ignore_kskflag, keyset_kskonly);
dns_db_closeversion(gdb, &gversion, ISC_FALSE); dns_db_closeversion(gdb, &gversion, false);
dns_db_detach(&gdb); dns_db_detach(&gdb);
cleanup_logging(&log); cleanup_logging(&log);
+24 -22
View File
@@ -17,6 +17,8 @@
#include <config.h> #include <config.h>
#include <inttypes.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#ifdef _WIN32 #ifdef _WIN32
@@ -221,10 +223,10 @@ time_units(isc_stdtime_t offset, char *suffix, const char *str) {
return(0); /* silence compiler warning */ return(0); /* silence compiler warning */
} }
static inline isc_boolean_t static inline bool
isnone(const char *str) { isnone(const char *str) {
return (ISC_TF((strcasecmp(str, "none") == 0) || return ((strcasecmp(str, "none") == 0) ||
(strcasecmp(str, "never") == 0))); (strcasecmp(str, "never") == 0));
} }
dns_ttl_t dns_ttl_t
@@ -244,10 +246,10 @@ strtottl(const char *str) {
} }
isc_stdtime_t 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) bool *setp)
{ {
isc_int64_t val, offset; int64_t val, offset;
isc_result_t result; isc_result_t result;
const char *orig = str; const char *orig = str;
char *endp; char *endp;
@@ -255,12 +257,12 @@ strtotime(const char *str, isc_int64_t now, isc_int64_t base,
if (isnone(str)) { if (isnone(str)) {
if (setp != NULL) if (setp != NULL)
*setp = ISC_FALSE; *setp = false;
return ((isc_stdtime_t) 0); return ((isc_stdtime_t) 0);
} }
if (setp != NULL) if (setp != NULL)
*setp = ISC_TRUE; *setp = true;
if ((str[0] == '0' || str[0] == '-') && str[1] == '\0') if ((str[0] == '0' || str[0] == '-') && str[1] == '\0')
return ((isc_stdtime_t) 0); return ((isc_stdtime_t) 0);
@@ -397,23 +399,23 @@ set_keyversion(dst_key_t *key) {
} }
} }
isc_boolean_t bool
key_collision(dst_key_t *dstkey, dns_name_t *name, const char *dir, key_collision(dst_key_t *dstkey, dns_name_t *name, const char *dir,
isc_mem_t *mctx, isc_boolean_t *exact) isc_mem_t *mctx, bool *exact)
{ {
isc_result_t result; isc_result_t result;
isc_boolean_t conflict = ISC_FALSE; bool conflict = false;
dns_dnsseckeylist_t matchkeys; dns_dnsseckeylist_t matchkeys;
dns_dnsseckey_t *key = NULL; dns_dnsseckey_t *key = NULL;
isc_uint16_t id, oldid; uint16_t id, oldid;
isc_uint32_t rid, roldid; uint32_t rid, roldid;
dns_secalg_t alg; dns_secalg_t alg;
char filename[ISC_DIR_NAMEMAX]; char filename[NAME_MAX];
isc_buffer_t fileb; isc_buffer_t fileb;
isc_stdtime_t now; isc_stdtime_t now;
if (exact != NULL) if (exact != NULL)
*exact = ISC_FALSE; *exact = false;
id = dst_key_id(dstkey); id = dst_key_id(dstkey);
rid = dst_key_rid(dstkey); rid = dst_key_rid(dstkey);
@@ -429,7 +431,7 @@ key_collision(dst_key_t *dstkey, dns_name_t *name, const char *dir,
result = dst_key_buildfilename(dstkey, DST_TYPE_PRIVATE, result = dst_key_buildfilename(dstkey, DST_TYPE_PRIVATE,
dir, &fileb); dir, &fileb);
if (result != ISC_R_SUCCESS) if (result != ISC_R_SUCCESS)
return (ISC_TRUE); return (true);
return (isc_file_exists(filename)); return (isc_file_exists(filename));
} }
@@ -437,7 +439,7 @@ key_collision(dst_key_t *dstkey, dns_name_t *name, const char *dir,
isc_stdtime_get(&now); isc_stdtime_get(&now);
result = dns_dnssec_findmatchingkeys(name, dir, now, mctx, &matchkeys); result = dns_dnssec_findmatchingkeys(name, dir, now, mctx, &matchkeys);
if (result == ISC_R_NOTFOUND) if (result == ISC_R_NOTFOUND)
return (ISC_FALSE); return (false);
while (!ISC_LIST_EMPTY(matchkeys) && !conflict) { while (!ISC_LIST_EMPTY(matchkeys) && !conflict) {
key = ISC_LIST_HEAD(matchkeys); key = ISC_LIST_HEAD(matchkeys);
@@ -448,7 +450,7 @@ key_collision(dst_key_t *dstkey, dns_name_t *name, const char *dir,
roldid = dst_key_rid(key->key); roldid = dst_key_rid(key->key);
if (oldid == rid || roldid == id || id == oldid) { if (oldid == rid || roldid == id || id == oldid) {
conflict = ISC_TRUE; conflict = true;
if (id != oldid) { if (id != oldid) {
if (verbose > 1) if (verbose > 1)
fprintf(stderr, "Key ID %d could " fprintf(stderr, "Key ID %d could "
@@ -456,7 +458,7 @@ key_collision(dst_key_t *dstkey, dns_name_t *name, const char *dir,
id, oldid); id, oldid);
} else { } else {
if (exact != NULL) if (exact != NULL)
*exact = ISC_TRUE; *exact = true;
if (verbose > 1) if (verbose > 1)
fprintf(stderr, "Key ID %d exists\n", fprintf(stderr, "Key ID %d exists\n",
id); id);
@@ -478,7 +480,7 @@ key_collision(dst_key_t *dstkey, dns_name_t *name, const char *dir,
return (conflict); return (conflict);
} }
isc_boolean_t bool
isoptarg(const char *arg, char **argv, void(*usage)(void)) { isoptarg(const char *arg, char **argv, void(*usage)(void)) {
if (!strcasecmp(isc_commandline_argument, arg)) { if (!strcasecmp(isc_commandline_argument, arg)) {
if (argv[isc_commandline_index] == NULL) { if (argv[isc_commandline_index] == NULL) {
@@ -490,9 +492,9 @@ isoptarg(const char *arg, char **argv, void(*usage)(void)) {
isc_commandline_argument = argv[isc_commandline_index]; isc_commandline_argument = argv[isc_commandline_index];
/* skip to next arguement */ /* skip to next arguement */
isc_commandline_index++; isc_commandline_index++;
return (ISC_TRUE); return (true);
} }
return (ISC_FALSE); return (false);
} }
#ifdef _WIN32 #ifdef _WIN32
+8 -5
View File
@@ -13,6 +13,9 @@
#ifndef DNSSECTOOL_H #ifndef DNSSECTOOL_H
#define DNSSECTOOL_H 1 #define DNSSECTOOL_H 1
#include <inttypes.h>
#include <stdbool.h>
#include <isc/log.h> #include <isc/log.h>
#include <isc/stdtime.h> #include <isc/stdtime.h>
#include <dns/rdatastruct.h> #include <dns/rdatastruct.h>
@@ -49,8 +52,8 @@ cleanup_logging(isc_log_t **logp);
dns_ttl_t strtottl(const char *str); dns_ttl_t strtottl(const char *str);
isc_stdtime_t 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); bool *setp);
unsigned int unsigned int
strtodsdigest(const char *str); strtodsdigest(const char *str);
@@ -67,11 +70,11 @@ check_keyversion(dst_key_t *key, char *keystr);
void void
set_keyversion(dst_key_t *key); set_keyversion(dst_key_t *key);
isc_boolean_t bool
key_collision(dst_key_t *key, dns_name_t *name, const char *dir, key_collision(dst_key_t *key, dns_name_t *name, const char *dir,
isc_mem_t *mctx, isc_boolean_t *exact); isc_mem_t *mctx, bool *exact);
isc_boolean_t bool
isoptarg(const char *arg, char **argv, void (*usage)(void)); isoptarg(const char *arg, char **argv, void (*usage)(void));
#ifdef _WIN32 #ifdef _WIN32
+2 -2
View File
@@ -70,7 +70,7 @@
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
@IF PYTHON @IF PYTHON
<PostBuildEvent> <PostBuildEvent>
@@ -113,7 +113,7 @@ set PYTHONPATH=.
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration> <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
@IF PYTHON @IF PYTHON
<PostBuildEvent> <PostBuildEvent>
+2 -2
View File
@@ -70,7 +70,7 @@
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'"> <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'">
@@ -100,7 +100,7 @@
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration> <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemGroup> <ItemGroup>
+2 -2
View File
@@ -70,7 +70,7 @@
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'"> <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'">
@@ -100,7 +100,7 @@
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration> <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemGroup> <ItemGroup>
+2 -2
View File
@@ -69,7 +69,7 @@
<SubSystem>Console</SubSystem> <SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<AdditionalDependencies>dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
@@ -99,7 +99,7 @@
<OptimizeReferences>true</OptimizeReferences> <OptimizeReferences>true</OptimizeReferences>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration> <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
<AdditionalDependencies>dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
+2 -2
View File
@@ -70,7 +70,7 @@
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'"> <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'">
@@ -100,7 +100,7 @@
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration> <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemGroup> <ItemGroup>
+2 -2
View File
@@ -69,7 +69,7 @@
<SubSystem>Console</SubSystem> <SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<AdditionalDependencies>dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
@@ -99,7 +99,7 @@
<OptimizeReferences>true</OptimizeReferences> <OptimizeReferences>true</OptimizeReferences>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration> <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
<AdditionalDependencies>dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
+2 -2
View File
@@ -70,7 +70,7 @@
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'"> <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'">
@@ -100,7 +100,7 @@
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration> <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemGroup> <ItemGroup>
+2 -2
View File
@@ -69,7 +69,7 @@
<SubSystem>Console</SubSystem> <SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<AdditionalDependencies>dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
@@ -99,7 +99,7 @@
<OptimizeReferences>true</OptimizeReferences> <OptimizeReferences>true</OptimizeReferences>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration> <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
<AdditionalDependencies>dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@dnssectool.lib;libisc.lib;libdns.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
+18 -17
View File
@@ -13,6 +13,7 @@
#include <config.h> #include <config.h>
#include <inttypes.h>
#include <stdlib.h> #include <stdlib.h>
#include <isc/buffer.h> #include <isc/buffer.h>
@@ -447,7 +448,7 @@ isc_result_t
named_config_getiplist(const cfg_obj_t *config, const cfg_obj_t *list, named_config_getiplist(const cfg_obj_t *config, const cfg_obj_t *list,
in_port_t defport, isc_mem_t *mctx, in_port_t defport, isc_mem_t *mctx,
isc_sockaddr_t **addrsp, isc_dscp_t **dscpsp, isc_sockaddr_t **addrsp, isc_dscp_t **dscpsp,
isc_uint32_t *countp) uint32_t *countp)
{ {
int count, i = 0; int count, i = 0;
const cfg_obj_t *addrlist; const cfg_obj_t *addrlist;
@@ -467,8 +468,8 @@ named_config_getiplist(const cfg_obj_t *config, const cfg_obj_t *list,
portobj = cfg_tuple_get(list, "port"); portobj = cfg_tuple_get(list, "port");
if (cfg_obj_isuint32(portobj)) { if (cfg_obj_isuint32(portobj)) {
isc_uint32_t val = cfg_obj_asuint32(portobj); uint32_t val = cfg_obj_asuint32(portobj);
if (val > ISC_UINT16_MAX) { if (val > UINT16_MAX) {
cfg_obj_log(portobj, named_g_lctx, ISC_LOG_ERROR, cfg_obj_log(portobj, named_g_lctx, ISC_LOG_ERROR,
"port '%u' out of range", val); "port '%u' out of range", val);
return (ISC_R_RANGE); return (ISC_R_RANGE);
@@ -538,7 +539,7 @@ named_config_getiplist(const cfg_obj_t *config, const cfg_obj_t *list,
void void
named_config_putiplist(isc_mem_t *mctx, isc_sockaddr_t **addrsp, named_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(addrsp != NULL && *addrsp != NULL);
INSIST(dscpsp == NULL || *dscpsp != NULL); INSIST(dscpsp == NULL || *dscpsp != NULL);
@@ -584,9 +585,9 @@ isc_result_t
named_config_getipandkeylist(const cfg_obj_t *config, const cfg_obj_t *list, named_config_getipandkeylist(const cfg_obj_t *config, const cfg_obj_t *list,
isc_mem_t *mctx, dns_ipkeylist_t *ipkl) isc_mem_t *mctx, dns_ipkeylist_t *ipkl)
{ {
isc_uint32_t addrcount = 0, dscpcount = 0, keycount = 0, i = 0; uint32_t addrcount = 0, dscpcount = 0, keycount = 0, i = 0;
isc_uint32_t listcount = 0, l = 0, j; uint32_t listcount = 0, l = 0, j;
isc_uint32_t stackcount = 0, pushed = 0; uint32_t stackcount = 0, pushed = 0;
isc_result_t result; isc_result_t result;
const cfg_listelt_t *element; const cfg_listelt_t *element;
const cfg_obj_t *addrlist; const cfg_obj_t *addrlist;
@@ -630,8 +631,8 @@ named_config_getipandkeylist(const cfg_obj_t *config, const cfg_obj_t *list,
dscpobj = cfg_tuple_get(list, "dscp"); dscpobj = cfg_tuple_get(list, "dscp");
if (cfg_obj_isuint32(portobj)) { if (cfg_obj_isuint32(portobj)) {
isc_uint32_t val = cfg_obj_asuint32(portobj); uint32_t val = cfg_obj_asuint32(portobj);
if (val > ISC_UINT16_MAX) { if (val > UINT16_MAX) {
cfg_obj_log(portobj, named_g_lctx, ISC_LOG_ERROR, cfg_obj_log(portobj, named_g_lctx, ISC_LOG_ERROR,
"port '%u' out of range", val); "port '%u' out of range", val);
result = ISC_R_RANGE; result = ISC_R_RANGE;
@@ -675,7 +676,7 @@ named_config_getipandkeylist(const cfg_obj_t *config, const cfg_obj_t *list,
/* Grow lists? */ /* Grow lists? */
if (listcount == l) { if (listcount == l) {
void * tmp; void * tmp;
isc_uint32_t newlen = listcount + 16; uint32_t newlen = listcount + 16;
size_t newsize, oldsize; size_t newsize, oldsize;
newsize = newlen * sizeof(*lists); newsize = newlen * sizeof(*lists);
@@ -710,7 +711,7 @@ named_config_getipandkeylist(const cfg_obj_t *config, const cfg_obj_t *list,
/* Grow stack? */ /* Grow stack? */
if (stackcount == pushed) { if (stackcount == pushed) {
void * tmp; void * tmp;
isc_uint32_t newlen = stackcount + 16; uint32_t newlen = stackcount + 16;
size_t newsize, oldsize; size_t newsize, oldsize;
newsize = newlen * sizeof(*stack); newsize = newlen * sizeof(*stack);
@@ -738,7 +739,7 @@ named_config_getipandkeylist(const cfg_obj_t *config, const cfg_obj_t *list,
if (i == addrcount) { if (i == addrcount) {
void * tmp; void * tmp;
isc_uint32_t newlen = addrcount + 16; uint32_t newlen = addrcount + 16;
size_t newsize, oldsize; size_t newsize, oldsize;
newsize = newlen * sizeof(isc_sockaddr_t); newsize = newlen * sizeof(isc_sockaddr_t);
@@ -911,7 +912,7 @@ named_config_getport(const cfg_obj_t *config, in_port_t *portp) {
result = named_config_get(maps, "port", &portobj); result = named_config_get(maps, "port", &portobj);
INSIST(result == ISC_R_SUCCESS); INSIST(result == ISC_R_SUCCESS);
if (cfg_obj_asuint32(portobj) >= ISC_UINT16_MAX) { if (cfg_obj_asuint32(portobj) >= UINT16_MAX) {
cfg_obj_log(portobj, named_g_lctx, ISC_LOG_ERROR, cfg_obj_log(portobj, named_g_lctx, ISC_LOG_ERROR,
"port '%u' out of range", "port '%u' out of range",
cfg_obj_asuint32(portobj)); cfg_obj_asuint32(portobj));
@@ -951,7 +952,7 @@ struct keyalgorithms {
enum { hmacnone, hmacmd5, hmacsha1, hmacsha224, enum { hmacnone, hmacmd5, hmacsha1, hmacsha224,
hmacsha256, hmacsha384, hmacsha512 } hmac; hmacsha256, hmacsha384, hmacsha512 } hmac;
unsigned int type; unsigned int type;
isc_uint16_t size; uint16_t size;
} algorithms[] = { } algorithms[] = {
{ "hmac-md5", hmacmd5, DST_ALG_HMACMD5, 128 }, { "hmac-md5", hmacmd5, DST_ALG_HMACMD5, 128 },
{ "hmac-md5.sig-alg.reg.int", hmacmd5, DST_ALG_HMACMD5, 0 }, { "hmac-md5.sig-alg.reg.int", hmacmd5, DST_ALG_HMACMD5, 0 },
@@ -966,18 +967,18 @@ struct keyalgorithms {
isc_result_t isc_result_t
named_config_getkeyalgorithm(const char *str, const dns_name_t **name, named_config_getkeyalgorithm(const char *str, const dns_name_t **name,
isc_uint16_t *digestbits) uint16_t *digestbits)
{ {
return (named_config_getkeyalgorithm2(str, name, NULL, digestbits)); return (named_config_getkeyalgorithm2(str, name, NULL, digestbits));
} }
isc_result_t isc_result_t
named_config_getkeyalgorithm2(const char *str, const dns_name_t **name, named_config_getkeyalgorithm2(const char *str, const dns_name_t **name,
unsigned int *typep, isc_uint16_t *digestbits) unsigned int *typep, uint16_t *digestbits)
{ {
int i; int i;
size_t len = 0; size_t len = 0;
isc_uint16_t bits; uint16_t bits;
isc_result_t result; isc_result_t result;
for (i = 0; algorithms[i].str != NULL; i++) { for (i = 0; algorithms[i].str != NULL; i++) {
+10 -9
View File
@@ -14,6 +14,7 @@
#include <config.h> #include <config.h>
#include <stdbool.h>
#include <isc/app.h> #include <isc/app.h>
#include <isc/event.h> #include <isc/event.h>
@@ -59,9 +60,9 @@ getcommand(isc_lex_t *lex, char **cmdp) {
return (ISC_R_SUCCESS); return (ISC_R_SUCCESS);
} }
static inline isc_boolean_t static inline bool
command_compare(const char *str, const char *command) { command_compare(const char *str, const char *command) {
return ISC_TF(strcasecmp(str, command) == 0); return (strcasecmp(str, command) == 0);
} }
/*% /*%
@@ -69,7 +70,7 @@ command_compare(const char *str, const char *command) {
* when a control channel message is received. * when a control channel message is received.
*/ */
isc_result_t isc_result_t
named_control_docommand(isccc_sexpr_t *message, isc_boolean_t readonly, named_control_docommand(isccc_sexpr_t *message, bool readonly,
isc_buffer_t **text) isc_buffer_t **text)
{ {
isccc_sexpr_t *data; isccc_sexpr_t *data;
@@ -184,7 +185,7 @@ named_control_docommand(isccc_sexpr_t *message, isc_boolean_t readonly,
*/ */
#endif #endif
/* Do not flush master files */ /* Do not flush master files */
named_server_flushonshutdown(named_g_server, ISC_FALSE); named_server_flushonshutdown(named_g_server, false);
named_os_shutdownmsg(cmdline, *text); named_os_shutdownmsg(cmdline, *text);
isc_app_shutdown(); isc_app_shutdown();
result = ISC_R_SUCCESS; result = ISC_R_SUCCESS;
@@ -201,7 +202,7 @@ named_control_docommand(isccc_sexpr_t *message, isc_boolean_t readonly,
if (named_smf_got_instance == 1 && named_smf_chroot == 0) if (named_smf_got_instance == 1 && named_smf_chroot == 0)
named_smf_want_disable = 1; named_smf_want_disable = 1;
#endif #endif
named_server_flushonshutdown(named_g_server, ISC_TRUE); named_server_flushonshutdown(named_g_server, true);
named_os_shutdownmsg(cmdline, *text); named_os_shutdownmsg(cmdline, *text);
isc_app_shutdown(); isc_app_shutdown();
result = ISC_R_SUCCESS; result = ISC_R_SUCCESS;
@@ -223,9 +224,9 @@ named_control_docommand(isccc_sexpr_t *message, isc_boolean_t readonly,
} else if (command_compare(command, NAMED_COMMAND_FLUSH)) { } else if (command_compare(command, NAMED_COMMAND_FLUSH)) {
result = named_server_flushcache(named_g_server, lex); result = named_server_flushcache(named_g_server, lex);
} else if (command_compare(command, NAMED_COMMAND_FLUSHNAME)) { } else if (command_compare(command, NAMED_COMMAND_FLUSHNAME)) {
result = named_server_flushnode(named_g_server, lex, ISC_FALSE); result = named_server_flushnode(named_g_server, lex, false);
} else if (command_compare(command, NAMED_COMMAND_FLUSHTREE)) { } else if (command_compare(command, NAMED_COMMAND_FLUSHTREE)) {
result = named_server_flushnode(named_g_server, lex, ISC_TRUE); result = named_server_flushnode(named_g_server, lex, true);
} else if (command_compare(command, NAMED_COMMAND_STATUS)) { } else if (command_compare(command, NAMED_COMMAND_STATUS)) {
result = named_server_status(named_g_server, text); result = named_server_status(named_g_server, text);
} else if (command_compare(command, NAMED_COMMAND_TSIGLIST)) { } else if (command_compare(command, NAMED_COMMAND_TSIGLIST)) {
@@ -233,11 +234,11 @@ named_control_docommand(isccc_sexpr_t *message, isc_boolean_t readonly,
} else if (command_compare(command, NAMED_COMMAND_TSIGDELETE)) { } else if (command_compare(command, NAMED_COMMAND_TSIGDELETE)) {
result = named_server_tsigdelete(named_g_server, lex, text); result = named_server_tsigdelete(named_g_server, lex, text);
} else if (command_compare(command, NAMED_COMMAND_FREEZE)) { } else if (command_compare(command, NAMED_COMMAND_FREEZE)) {
result = named_server_freeze(named_g_server, ISC_TRUE, lex, result = named_server_freeze(named_g_server, true, lex,
text); text);
} else if (command_compare(command, NAMED_COMMAND_UNFREEZE) || } else if (command_compare(command, NAMED_COMMAND_UNFREEZE) ||
command_compare(command, NAMED_COMMAND_THAW)) { command_compare(command, NAMED_COMMAND_THAW)) {
result = named_server_freeze(named_g_server, ISC_FALSE, lex, result = named_server_freeze(named_g_server, false, lex,
text); text);
} else if (command_compare(command, NAMED_COMMAND_SCAN)) { } else if (command_compare(command, NAMED_COMMAND_SCAN)) {
result = ISC_R_SUCCESS; result = ISC_R_SUCCESS;
+36 -37
View File
@@ -13,6 +13,9 @@
#include <config.h> #include <config.h>
#include <inttypes.h>
#include <stdbool.h>
#include <isc/base64.h> #include <isc/base64.h>
#include <isc/buffer.h> #include <isc/buffer.h>
#include <isc/event.h> #include <isc/event.h>
@@ -65,7 +68,7 @@ typedef ISC_LIST(controllistener_t) controllistenerlist_t;
struct controlkey { struct controlkey {
char * keyname; char * keyname;
isc_uint32_t algorithm; uint32_t algorithm;
isc_region_t secret; isc_region_t secret;
ISC_LINK(controlkey_t) link; ISC_LINK(controlkey_t) link;
}; };
@@ -73,12 +76,12 @@ struct controlkey {
struct controlconnection { struct controlconnection {
isc_socket_t * sock; isc_socket_t * sock;
isccc_ccmsg_t ccmsg; isccc_ccmsg_t ccmsg;
isc_boolean_t ccmsg_valid; bool ccmsg_valid;
isc_boolean_t sending; bool sending;
isc_timer_t * timer; isc_timer_t * timer;
isc_buffer_t * buffer; isc_buffer_t * buffer;
controllistener_t * listener; controllistener_t * listener;
isc_uint32_t nonce; uint32_t nonce;
ISC_LINK(controlconnection_t) link; ISC_LINK(controlconnection_t) link;
}; };
@@ -89,22 +92,22 @@ struct controllistener {
isc_sockaddr_t address; isc_sockaddr_t address;
isc_socket_t * sock; isc_socket_t * sock;
dns_acl_t * acl; dns_acl_t * acl;
isc_boolean_t listening; bool listening;
isc_boolean_t exiting; bool exiting;
controlkeylist_t keys; controlkeylist_t keys;
controlconnectionlist_t connections; controlconnectionlist_t connections;
isc_sockettype_t type; isc_sockettype_t type;
isc_uint32_t perm; uint32_t perm;
isc_uint32_t owner; uint32_t owner;
isc_uint32_t group; uint32_t group;
isc_boolean_t readonly; bool readonly;
ISC_LINK(controllistener_t) link; ISC_LINK(controllistener_t) link;
}; };
struct named_controls { struct named_controls {
named_server_t *server; named_server_t *server;
controllistenerlist_t listeners; controllistenerlist_t listeners;
isc_boolean_t shuttingdown; bool shuttingdown;
isccc_symtab_t *symtab; isccc_symtab_t *symtab;
}; };
@@ -202,8 +205,8 @@ shutdown_listener(controllistener_t *listener) {
NAMED_LOGMODULE_CONTROL, ISC_LOG_NOTICE, NAMED_LOGMODULE_CONTROL, ISC_LOG_NOTICE,
"stopping command channel on %s", socktext); "stopping command channel on %s", socktext);
if (listener->type == isc_sockettype_unix) if (listener->type == isc_sockettype_unix)
isc_socket_cleanunix(&listener->address, ISC_TRUE); isc_socket_cleanunix(&listener->address, true);
listener->exiting = ISC_TRUE; listener->exiting = true;
} }
for (conn = ISC_LIST_HEAD(listener->connections); for (conn = ISC_LIST_HEAD(listener->connections);
@@ -221,7 +224,7 @@ shutdown_listener(controllistener_t *listener) {
maybe_free_listener(listener); maybe_free_listener(listener);
} }
static isc_boolean_t static bool
address_ok(isc_sockaddr_t *sockaddr, dns_acl_t *acl) { address_ok(isc_sockaddr_t *sockaddr, dns_acl_t *acl) {
dns_aclenv_t *env = dns_aclenv_t *env =
ns_interfacemgr_getaclenv(named_g_server->interfacemgr); ns_interfacemgr_getaclenv(named_g_server->interfacemgr);
@@ -232,11 +235,7 @@ address_ok(isc_sockaddr_t *sockaddr, dns_acl_t *acl) {
isc_netaddr_fromsockaddr(&netaddr, sockaddr); isc_netaddr_fromsockaddr(&netaddr, sockaddr);
result = dns_acl_match(&netaddr, NULL, acl, env, &match, NULL); result = dns_acl_match(&netaddr, NULL, acl, env, &match, NULL);
if (result != ISC_R_SUCCESS || match <= 0) { return (result == ISC_R_SUCCESS && match > 0);
return (ISC_FALSE);
} else {
return (ISC_TRUE);
}
} }
static isc_result_t static isc_result_t
@@ -250,7 +249,7 @@ control_accept(controllistener_t *listener) {
"isc_socket_accept() failed: %s", "isc_socket_accept() failed: %s",
isc_result_totext(result)); isc_result_totext(result));
else else
listener->listening = ISC_TRUE; listener->listening = true;
return (result); return (result);
} }
@@ -283,7 +282,7 @@ control_senddone(isc_task_t *task, isc_event_t *event) {
UNUSED(task); UNUSED(task);
conn->sending = ISC_FALSE; conn->sending = false;
if (sevent->result != ISC_R_SUCCESS && if (sevent->result != ISC_R_SUCCESS &&
sevent->result != ISC_R_CANCELED) sevent->result != ISC_R_CANCELED)
@@ -329,7 +328,7 @@ control_recvmessage(isc_task_t *task, isc_event_t *event) {
controlkey_t *key = NULL; controlkey_t *key = NULL;
isccc_sexpr_t *request = NULL; isccc_sexpr_t *request = NULL;
isccc_sexpr_t *response = NULL; isccc_sexpr_t *response = NULL;
isc_uint32_t algorithm; uint32_t algorithm;
isccc_region_t secret; isccc_region_t secret;
isc_stdtime_t now; isc_stdtime_t now;
isc_buffer_t b; isc_buffer_t b;
@@ -340,7 +339,7 @@ control_recvmessage(isc_task_t *task, isc_event_t *event) {
isccc_sexpr_t *_ctrl = NULL; isccc_sexpr_t *_ctrl = NULL;
isccc_time_t sent; isccc_time_t sent;
isccc_time_t exp; isccc_time_t exp;
isc_uint32_t nonce; uint32_t nonce;
isccc_sexpr_t *data = NULL; isccc_sexpr_t *data = NULL;
REQUIRE(event->ev_type == ISCCC_EVENT_CCMSG); REQUIRE(event->ev_type == ISCCC_EVENT_CCMSG);
@@ -520,7 +519,7 @@ control_recvmessage(isc_task_t *task, isc_event_t *event) {
result = isc_socket_send(conn->sock, &r, task, control_senddone, conn); result = isc_socket_send(conn->sock, &r, task, control_senddone, conn);
if (result != ISC_R_SUCCESS) if (result != ISC_R_SUCCESS)
goto cleanup_response; goto cleanup_response;
conn->sending = ISC_TRUE; conn->sending = true;
isc_mem_put(listener->mctx, secret.rstart, REGION_SIZE(secret)); isc_mem_put(listener->mctx, secret.rstart, REGION_SIZE(secret));
isccc_sexpr_free(&request); isccc_sexpr_free(&request);
@@ -540,7 +539,7 @@ control_recvmessage(isc_task_t *task, isc_event_t *event) {
cleanup: cleanup:
isc_socket_detach(&conn->sock); isc_socket_detach(&conn->sock);
isccc_ccmsg_invalidate(&conn->ccmsg); isccc_ccmsg_invalidate(&conn->ccmsg);
conn->ccmsg_valid = ISC_FALSE; conn->ccmsg_valid = false;
maybe_free_connection(conn); maybe_free_connection(conn);
maybe_free_listener(listener); maybe_free_listener(listener);
} }
@@ -573,8 +572,8 @@ newconnection(controllistener_t *listener, isc_socket_t *sock) {
/* Set a 32 KiB upper limit on incoming message. */ /* Set a 32 KiB upper limit on incoming message. */
isccc_ccmsg_setmaxsize(&conn->ccmsg, 32768); isccc_ccmsg_setmaxsize(&conn->ccmsg, 32768);
conn->ccmsg_valid = ISC_TRUE; conn->ccmsg_valid = true;
conn->sending = ISC_FALSE; conn->sending = false;
conn->buffer = NULL; conn->buffer = NULL;
conn->timer = NULL; conn->timer = NULL;
isc_interval_set(&interval, 60, 0); isc_interval_set(&interval, 60, 0);
@@ -621,7 +620,7 @@ control_newconn(isc_task_t *task, isc_event_t *event) {
UNUSED(task); UNUSED(task);
listener->listening = ISC_FALSE; listener->listening = false;
if (nevent->result != ISC_R_SUCCESS) { if (nevent->result != ISC_R_SUCCESS) {
if (nevent->result == ISC_R_CANCELED) { if (nevent->result == ISC_R_CANCELED) {
@@ -685,7 +684,7 @@ controls_shutdown(named_controls_t *controls) {
void void
named_controls_shutdown(named_controls_t *controls) { named_controls_shutdown(named_controls_t *controls) {
controls_shutdown(controls); controls_shutdown(controls);
controls->shuttingdown = ISC_TRUE; controls->shuttingdown = true;
} }
static isc_result_t static isc_result_t
@@ -1091,7 +1090,7 @@ update_listener(named_controls_t *cp, controllistener_t **listenerp,
socktext, isc_result_totext(result)); socktext, isc_result_totext(result));
if (result == ISC_R_SUCCESS && type == isc_sockettype_unix) { 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")); perm = cfg_obj_asuint32(cfg_tuple_get(control, "perm"));
owner = cfg_obj_asuint32(cfg_tuple_get(control, "owner")); owner = cfg_obj_asuint32(cfg_tuple_get(control, "owner"));
group = cfg_obj_asuint32(cfg_tuple_get(control, "group")); group = cfg_obj_asuint32(cfg_tuple_get(control, "group"));
@@ -1138,14 +1137,14 @@ add_listener(named_controls_t *cp, controllistener_t **listenerp,
listener->task = cp->server->task; listener->task = cp->server->task;
listener->address = *addr; listener->address = *addr;
listener->sock = NULL; listener->sock = NULL;
listener->listening = ISC_FALSE; listener->listening = false;
listener->exiting = ISC_FALSE; listener->exiting = false;
listener->acl = NULL; listener->acl = NULL;
listener->type = type; listener->type = type;
listener->perm = 0; listener->perm = 0;
listener->owner = 0; listener->owner = 0;
listener->group = 0; listener->group = 0;
listener->readonly = ISC_FALSE; listener->readonly = false;
ISC_LINK_INIT(listener, link); ISC_LINK_INIT(listener, link);
ISC_LIST_INIT(listener->keys); ISC_LIST_INIT(listener->keys);
ISC_LIST_INIT(listener->connections); ISC_LIST_INIT(listener->connections);
@@ -1208,7 +1207,7 @@ add_listener(named_controls_t *cp, controllistener_t **listenerp,
} }
if (result == ISC_R_SUCCESS && type == isc_sockettype_unix) if (result == ISC_R_SUCCESS && type == isc_sockettype_unix)
isc_socket_cleanunix(&listener->address, ISC_FALSE); isc_socket_cleanunix(&listener->address, false);
if (result == ISC_R_SUCCESS) if (result == ISC_R_SUCCESS)
result = isc_socket_create(named_g_socketmgr, result = isc_socket_create(named_g_socketmgr,
@@ -1219,7 +1218,7 @@ add_listener(named_controls_t *cp, controllistener_t **listenerp,
#ifndef ISC_ALLOW_MAPPED #ifndef ISC_ALLOW_MAPPED
if (result == ISC_R_SUCCESS) if (result == ISC_R_SUCCESS)
isc_socket_ipv6only(listener->sock, ISC_TRUE); isc_socket_ipv6only(listener->sock, true);
#endif #endif
if (result == ISC_R_SUCCESS) if (result == ISC_R_SUCCESS)
@@ -1250,7 +1249,7 @@ add_listener(named_controls_t *cp, controllistener_t **listenerp,
} else { } else {
if (listener != NULL) { if (listener != NULL) {
listener->exiting = ISC_TRUE; listener->exiting = true;
free_listener(listener); free_listener(listener);
} }
@@ -1510,7 +1509,7 @@ named_controls_create(named_server_t *server, named_controls_t **ctrlsp) {
return (ISC_R_NOMEMORY); return (ISC_R_NOMEMORY);
controls->server = server; controls->server = server;
ISC_LIST_INIT(controls->listeners); ISC_LIST_INIT(controls->listeners);
controls->shuttingdown = ISC_FALSE; controls->shuttingdown = false;
controls->symtab = NULL; controls->symtab = NULL;
result = isccc_cc_createsymtab(&controls->symtab); result = isccc_cc_createsymtab(&controls->symtab);
if (result != ISC_R_SUCCESS) { if (result != ISC_R_SUCCESS) {
+30 -25
View File
@@ -9,7 +9,10 @@
* information regarding copyright ownership. * information regarding copyright ownership.
*/ */
#include "config.h" #include <config.h>
#include <inttypes.h>
#include <stdbool.h>
#include <named/fuzz.h> #include <named/fuzz.h>
@@ -33,10 +36,6 @@
#include <unistd.h> #include <unistd.h>
#include <pthread.h> #include <pthread.h>
#ifndef __AFL_LOOP
#error To use American Fuzzy Lop you have to set CC to afl-clang-fast!!!
#endif
/* /*
* We are using pthreads directly because we might be using it with * We are using pthreads directly because we might be using it with
* unthreaded version of BIND, where all thread functions are * unthreaded version of BIND, where all thread functions are
@@ -44,7 +43,7 @@
*/ */
static pthread_cond_t cond; static pthread_cond_t cond;
static pthread_mutex_t mutex; static pthread_mutex_t mutex;
static isc_boolean_t ready; static bool ready;
/* /*
* In "client:" mode, this thread reads fuzzed query messages from AFL * In "client:" mode, this thread reads fuzzed query messages from AFL
@@ -58,7 +57,6 @@ fuzz_thread_client(void *arg) {
char *port; char *port;
struct sockaddr_in servaddr; struct sockaddr_in servaddr;
int sockfd; int sockfd;
int loop;
void *buf; void *buf;
UNUSED(arg); UNUSED(arg);
@@ -100,14 +98,18 @@ fuzz_thread_client(void *arg) {
* Processing fuzzed packets 100,000 times before shutting down * Processing fuzzed packets 100,000 times before shutting down
* the app. * the app.
*/ */
for (loop = 0; loop < 100000; loop++) { #ifdef __AFL_LOOP
for (int loop = 0; loop < 100000; loop++) {
#else
{
#endif
ssize_t length; ssize_t length;
ssize_t sent; ssize_t sent;
length = read(0, buf, 65536); length = read(0, buf, 65536);
if (length <= 0) { if (length <= 0) {
usleep(1000000); usleep(1000000);
continue; goto next;
} }
/* /*
@@ -122,17 +124,17 @@ fuzz_thread_client(void *arg) {
free(buf); free(buf);
close(sockfd); close(sockfd);
named_server_flushonshutdown(named_g_server, named_server_flushonshutdown(named_g_server,
ISC_FALSE); false);
isc_app_shutdown(); isc_app_shutdown();
return (NULL); return (NULL);
} }
raise(SIGSTOP); raise(SIGSTOP);
continue; goto next;
} }
RUNTIME_CHECK(pthread_mutex_lock(&mutex) == 0); RUNTIME_CHECK(pthread_mutex_lock(&mutex) == 0);
ready = ISC_FALSE; ready = false;
sent = sendto(sockfd, buf, length, 0, sent = sendto(sockfd, buf, length, 0,
(struct sockaddr *) &servaddr, sizeof(servaddr)); (struct sockaddr *) &servaddr, sizeof(servaddr));
@@ -148,12 +150,13 @@ fuzz_thread_client(void *arg) {
pthread_cond_wait(&cond, &mutex); pthread_cond_wait(&cond, &mutex);
RUNTIME_CHECK(pthread_mutex_unlock(&mutex) == 0); RUNTIME_CHECK(pthread_mutex_unlock(&mutex) == 0);
next: ;
} }
free(buf); free(buf);
close(sockfd); close(sockfd);
named_server_flushonshutdown(named_g_server, ISC_FALSE); named_server_flushonshutdown(named_g_server, false);
isc_app_shutdown(); isc_app_shutdown();
return (NULL); return (NULL);
@@ -200,7 +203,7 @@ fuzz_thread_resolver(void *arg) {
* have to be updated. 0x8d, 0xf6 at the start is the ID field * have to be updated. 0x8d, 0xf6 at the start is the ID field
* which will be made to match the query. * which will be made to match the query.
*/ */
const isc_uint8_t dnskey_wf[] = { const uint8_t dnskey_wf[] = {
0x8d, 0xf6, 0x84, 0x00, 0x00, 0x01, 0x00, 0x02, 0x8d, 0xf6, 0x84, 0x00, 0x00, 0x01, 0x00, 0x02,
0x00, 0x00, 0x00, 0x01, 0x07, 0x65, 0x78, 0x61, 0x00, 0x00, 0x00, 0x01, 0x07, 0x65, 0x78, 0x61,
0x6d, 0x70, 0x6c, 0x65, 0x00, 0x00, 0x30, 0x00, 0x6d, 0x70, 0x6c, 0x65, 0x00, 0x00, 0x30, 0x00,
@@ -282,12 +285,12 @@ fuzz_thread_resolver(void *arg) {
int sockfd; int sockfd;
int listenfd; int listenfd;
int loop; int loop;
isc_uint16_t qtype; uint16_t qtype;
char *buf, *rbuf; char *buf, *rbuf;
char *nameptr; char *nameptr;
unsigned int i; unsigned int i;
isc_uint8_t llen; uint8_t llen;
isc_uint64_t seed; uint64_t seed;
UNUSED(arg); UNUSED(arg);
@@ -385,7 +388,7 @@ fuzz_thread_resolver(void *arg) {
close(sockfd); close(sockfd);
close(listenfd); close(listenfd);
named_server_flushonshutdown(named_g_server, named_server_flushonshutdown(named_g_server,
ISC_FALSE); false);
isc_app_shutdown(); isc_app_shutdown();
return (NULL); return (NULL);
} }
@@ -399,7 +402,7 @@ fuzz_thread_resolver(void *arg) {
RUNTIME_CHECK(pthread_mutex_lock(&mutex) == 0); RUNTIME_CHECK(pthread_mutex_lock(&mutex) == 0);
ready = ISC_FALSE; ready = false;
/* Use a unique query ID. */ /* Use a unique query ID. */
seed = 1664525 * seed + 1013904223; seed = 1664525 * seed + 1013904223;
@@ -549,7 +552,7 @@ fuzz_thread_resolver(void *arg) {
* "example." * "example."
*/ */
if ((nameptr - buf) < (length - 2)) { if ((nameptr - buf) < (length - 2)) {
isc_uint8_t hb, lb; uint8_t hb, lb;
hb = *nameptr++; hb = *nameptr++;
lb = *nameptr++; lb = *nameptr++;
qtype = (hb << 8) | lb; qtype = (hb << 8) | lb;
@@ -580,9 +583,10 @@ fuzz_thread_resolver(void *arg) {
free(rbuf); free(rbuf);
close(sockfd); close(sockfd);
close(listenfd); close(listenfd);
named_server_flushonshutdown(named_g_server, ISC_FALSE); named_server_flushonshutdown(named_g_server, false);
isc_app_shutdown(); isc_app_shutdown();
#ifdef __AFL_LOOP
/* /*
* This is here just for the signature, that's how AFL detects * This is here just for the signature, that's how AFL detects
* if it's a 'persistent mode' binary. It has to occur somewhere * if it's a 'persistent mode' binary. It has to occur somewhere
@@ -591,6 +595,7 @@ fuzz_thread_resolver(void *arg) {
* in persistent mode if it's present. * in persistent mode if it's present.
*/ */
__AFL_LOOP(0); __AFL_LOOP(0);
#endif
return (NULL); return (NULL);
} }
@@ -687,7 +692,7 @@ fuzz_thread_tcp(void *arg) {
RUNTIME_CHECK(pthread_mutex_lock(&mutex) == 0); RUNTIME_CHECK(pthread_mutex_lock(&mutex) == 0);
ready = ISC_FALSE; ready = false;
yes = 1; yes = 1;
sockfd = socket(AF_INET, SOCK_STREAM, 0); sockfd = socket(AF_INET, SOCK_STREAM, 0);
@@ -718,7 +723,7 @@ fuzz_thread_tcp(void *arg) {
free(buf); free(buf);
close(sockfd); close(sockfd);
named_server_flushonshutdown(named_g_server, ISC_FALSE); named_server_flushonshutdown(named_g_server, false);
isc_app_shutdown(); isc_app_shutdown();
return (NULL); return (NULL);
@@ -735,7 +740,7 @@ void
named_fuzz_notify(void) { named_fuzz_notify(void) {
#ifdef ENABLE_AFL #ifdef ENABLE_AFL
if (getenv("AFL_CMIN")) { if (getenv("AFL_CMIN")) {
named_server_flushonshutdown(named_g_server, ISC_FALSE); named_server_flushonshutdown(named_g_server, false);
isc_app_shutdown(); isc_app_shutdown();
return; return;
} }
@@ -744,7 +749,7 @@ named_fuzz_notify(void) {
RUNTIME_CHECK(pthread_mutex_lock(&mutex) == 0); RUNTIME_CHECK(pthread_mutex_lock(&mutex) == 0);
ready = ISC_TRUE; ready = true;
RUNTIME_CHECK(pthread_cond_signal(&cond) == 0); RUNTIME_CHECK(pthread_cond_signal(&cond) == 0);
RUNTIME_CHECK(pthread_mutex_unlock(&mutex) == 0); RUNTIME_CHECK(pthread_mutex_unlock(&mutex) == 0);
+6 -4
View File
@@ -15,6 +15,8 @@
/*! \file */ /*! \file */
#include <inttypes.h>
#include <isccfg/cfg.h> #include <isccfg/cfg.h>
#include <dns/types.h> #include <dns/types.h>
@@ -49,11 +51,11 @@ isc_result_t
named_config_getiplist(const cfg_obj_t *config, const cfg_obj_t *list, named_config_getiplist(const cfg_obj_t *config, const cfg_obj_t *list,
in_port_t defport, isc_mem_t *mctx, in_port_t defport, isc_mem_t *mctx,
isc_sockaddr_t **addrsp, isc_dscp_t **dscpsp, isc_sockaddr_t **addrsp, isc_dscp_t **dscpsp,
isc_uint32_t *countp); uint32_t *countp);
void void
named_config_putiplist(isc_mem_t *mctx, isc_sockaddr_t **addrsp, named_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 isc_result_t
named_config_getipandkeylist(const cfg_obj_t *config, const cfg_obj_t *list, named_config_getipandkeylist(const cfg_obj_t *config, const cfg_obj_t *list,
@@ -64,10 +66,10 @@ named_config_getport(const cfg_obj_t *config, in_port_t *portp);
isc_result_t isc_result_t
named_config_getkeyalgorithm(const char *str, const dns_name_t **name, named_config_getkeyalgorithm(const char *str, const dns_name_t **name,
isc_uint16_t *digestbits); uint16_t *digestbits);
isc_result_t isc_result_t
named_config_getkeyalgorithm2(const char *str, const dns_name_t **name, named_config_getkeyalgorithm2(const char *str, const dns_name_t **name,
unsigned int *typep, isc_uint16_t *digestbits); unsigned int *typep, uint16_t *digestbits);
isc_result_t isc_result_t
named_config_getdscp(const cfg_obj_t *config, isc_dscp_t *dscpp); named_config_getdscp(const cfg_obj_t *config, isc_dscp_t *dscpp);
+3 -1
View File
@@ -17,6 +17,8 @@
* The name server command channel. * The name server command channel.
*/ */
#include <stdbool.h>
#include <isccc/types.h> #include <isccc/types.h>
#include <isccfg/aclconf.h> #include <isccfg/aclconf.h>
@@ -101,7 +103,7 @@ named_controls_shutdown(named_controls_t *controls);
*/ */
isc_result_t isc_result_t
named_control_docommand(isccc_sexpr_t *message, isc_boolean_t readonly, named_control_docommand(isccc_sexpr_t *message, bool readonly,
isc_buffer_t **text); isc_buffer_t **text);
#endif /* NAMED_CONTROL_H */ #endif /* NAMED_CONTROL_H */
+11 -9
View File
@@ -14,6 +14,8 @@
/*! \file */ /*! \file */
#include <stdbool.h>
#include <isc/rwlock.h> #include <isc/rwlock.h>
#include <isc/log.h> #include <isc/log.h>
#include <isc/net.h> #include <isc/net.h>
@@ -51,7 +53,7 @@ EXTERN dns_dispatchmgr_t * named_g_dispatchmgr INIT(NULL);
EXTERN unsigned int named_g_cpus_detected INIT(1); EXTERN unsigned int named_g_cpus_detected INIT(1);
#ifdef ENABLE_AFL #ifdef ENABLE_AFL
EXTERN isc_boolean_t named_g_run_done INIT(ISC_FALSE); EXTERN bool named_g_run_done INIT(false);
#endif #endif
/* /*
* XXXRTH We're going to want multiple timer managers eventually. One * XXXRTH We're going to want multiple timer managers eventually. One
@@ -94,7 +96,7 @@ EXTERN const char * named_g_keyfile INIT(NAMED_SYSCONFDIR
EXTERN dns_tsigkey_t * named_g_sessionkey INIT(NULL); EXTERN dns_tsigkey_t * named_g_sessionkey INIT(NULL);
EXTERN dns_name_t named_g_sessionkeyname; EXTERN dns_name_t named_g_sessionkeyname;
EXTERN isc_boolean_t named_g_conffileset INIT(ISC_FALSE); EXTERN bool named_g_conffileset INIT(false);
EXTERN cfg_aclconfctx_t * named_g_aclconfctx INIT(NULL); EXTERN cfg_aclconfctx_t * named_g_aclconfctx INIT(NULL);
/* /*
@@ -108,11 +110,11 @@ EXTERN isc_resourcevalue_t named_g_initopenfiles INIT(0);
/* /*
* Misc. * Misc.
*/ */
EXTERN isc_boolean_t named_g_coreok INIT(ISC_TRUE); EXTERN bool named_g_coreok INIT(true);
EXTERN const char * named_g_chrootdir INIT(NULL); EXTERN const char * named_g_chrootdir INIT(NULL);
EXTERN isc_boolean_t named_g_foreground INIT(ISC_FALSE); EXTERN bool named_g_foreground INIT(false);
EXTERN isc_boolean_t named_g_logstderr INIT(ISC_FALSE); EXTERN bool named_g_logstderr INIT(false);
EXTERN isc_boolean_t named_g_nosyslog INIT(ISC_FALSE); EXTERN bool named_g_nosyslog INIT(false);
EXTERN const char * named_g_logfile INIT(NULL); EXTERN const char * named_g_logfile INIT(NULL);
EXTERN const char * named_g_defaultsessionkeyfile EXTERN const char * named_g_defaultsessionkeyfile
@@ -121,7 +123,7 @@ EXTERN const char * named_g_defaultsessionkeyfile
EXTERN const char * named_g_defaultlockfile INIT(NAMED_LOCALSTATEDIR EXTERN const char * named_g_defaultlockfile INIT(NAMED_LOCALSTATEDIR
"/run/named/" "/run/named/"
"named.lock"); "named.lock");
EXTERN isc_boolean_t named_g_forcelock INIT(ISC_FALSE); EXTERN bool named_g_forcelock INIT(false);
#if NAMED_RUN_PID_DIR #if NAMED_RUN_PID_DIR
EXTERN const char * named_g_defaultpidfile INIT(NAMED_LOCALSTATEDIR EXTERN const char * named_g_defaultpidfile INIT(NAMED_LOCALSTATEDIR
@@ -146,8 +148,8 @@ EXTERN const char * named_g_engine INIT(NULL);
EXTERN isc_time_t named_g_boottime; EXTERN isc_time_t named_g_boottime;
EXTERN isc_time_t named_g_configtime; EXTERN isc_time_t named_g_configtime;
EXTERN isc_boolean_t named_g_memstatistics INIT(ISC_FALSE); EXTERN bool named_g_memstatistics INIT(false);
EXTERN isc_boolean_t named_g_keepstderr INIT(ISC_FALSE); EXTERN bool named_g_keepstderr INIT(false);
EXTERN unsigned int named_g_tat_interval INIT(24*3600); EXTERN unsigned int named_g_tat_interval INIT(24*3600);
+1 -1
View File
@@ -34,7 +34,7 @@
#define NAMED_LOGMODULE_CONTROL (&named_g_modules[2]) #define NAMED_LOGMODULE_CONTROL (&named_g_modules[2])
isc_result_t isc_result_t
named_log_init(isc_boolean_t safe); named_log_init(bool safe);
/*% /*%
* Initialize the logging system and set up an initial default * Initialize the logging system and set up an initial default
* logging default configuration that will be used until the * logging default configuration that will be used until the
+14 -11
View File
@@ -14,6 +14,9 @@
/*! \file */ /*! \file */
#include <inttypes.h>
#include <stdbool.h>
#include <isc/log.h> #include <isc/log.h>
#include <isc/magic.h> #include <isc/magic.h>
#include <isc/quota.h> #include <isc/quota.h>
@@ -53,9 +56,9 @@ struct named_server {
char * secrootsfile; /*%< Secroots file name */ char * secrootsfile; /*%< Secroots file name */
char * bindkeysfile; /*%< bind.keys file name */ char * bindkeysfile; /*%< bind.keys file name */
char * recfile; /*%< Recursive file name */ char * recfile; /*%< Recursive file name */
isc_boolean_t version_set; /*%< User has set version */ bool version_set; /*%< User has set version */
char * version; /*%< User-specified version */ char * version; /*%< User-specified version */
isc_boolean_t hostname_set; /*%< User has set hostname */ bool hostname_set; /*%< User has set hostname */
char * hostname; /*%< User-specified hostname */ char * hostname; /*%< User-specified hostname */
/* Server data structures. */ /* Server data structures. */
@@ -70,13 +73,13 @@ struct named_server {
isc_timer_t * pps_timer; isc_timer_t * pps_timer;
isc_timer_t * tat_timer; isc_timer_t * tat_timer;
isc_uint32_t interface_interval; uint32_t interface_interval;
isc_uint32_t heartbeat_interval; uint32_t heartbeat_interval;
isc_mutex_t reload_event_lock; isc_mutex_t reload_event_lock;
isc_event_t * reload_event; isc_event_t * reload_event;
isc_boolean_t flushonshutdown; bool flushonshutdown;
named_cachelist_t cachelist; /*%< Possibly shared caches */ named_cachelist_t cachelist; /*%< Possibly shared caches */
isc_stats_t * zonestats; /*% Zone management stats */ isc_stats_t * zonestats; /*% Zone management stats */
@@ -93,8 +96,8 @@ struct named_server {
char *session_keyfile; char *session_keyfile;
dns_name_t *session_keyname; dns_name_t *session_keyname;
unsigned int session_keyalg; unsigned int session_keyalg;
isc_uint16_t session_keybits; uint16_t session_keybits;
isc_boolean_t interface_auto; bool interface_auto;
unsigned char secret[32]; /*%< Server Cookie Secret */ unsigned char secret[32]; /*%< Server Cookie Secret */
ns_cookiealg_t cookiealg; ns_cookiealg_t cookiealg;
@@ -137,7 +140,7 @@ named_server_scan_interfaces(named_server_t *server);
*/ */
void void
named_server_flushonshutdown(named_server_t *server, isc_boolean_t flush); named_server_flushonshutdown(named_server_t *server, bool flush);
/*%< /*%<
* Inform the server that the zones should be flushed to disk on shutdown. * Inform the server that the zones should be flushed to disk on shutdown.
*/ */
@@ -234,7 +237,7 @@ named_server_flushcache(named_server_t *server, isc_lex_t *lex);
*/ */
isc_result_t isc_result_t
named_server_flushnode(named_server_t *server, isc_lex_t *lex, named_server_flushnode(named_server_t *server, isc_lex_t *lex,
isc_boolean_t tree); bool tree);
/*% /*%
* Report the server's status. * Report the server's status.
@@ -259,7 +262,7 @@ named_server_tsigdelete(named_server_t *server, isc_lex_t *lex,
* Enable or disable updates for a zone. * Enable or disable updates for a zone.
*/ */
isc_result_t isc_result_t
named_server_freeze(named_server_t *server, isc_boolean_t freeze, named_server_freeze(named_server_t *server, bool freeze,
isc_lex_t *lex, isc_buffer_t **text); isc_lex_t *lex, isc_buffer_t **text);
/*% /*%
@@ -339,7 +342,7 @@ named_server_zonestatus(named_server_t *server, isc_lex_t *lex,
*/ */
isc_result_t isc_result_t
named_server_nta(named_server_t *server, isc_lex_t *lex, named_server_nta(named_server_t *server, isc_lex_t *lex,
isc_boolean_t readonly, isc_buffer_t **text); bool readonly, isc_buffer_t **text);
/*% /*%
* Generates a test sequence that is only for use in system tests. The * Generates a test sequence that is only for use in system tests. The
+5 -3
View File
@@ -14,6 +14,8 @@
/*! \file */ /*! \file */
#include <stdbool.h>
#include <isc/lang.h> #include <isc/lang.h>
#include <isc/types.h> #include <isc/types.h>
@@ -41,13 +43,13 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
* \li 'zone' to be initialized. * \li 'zone' to be initialized.
*/ */
isc_boolean_t bool
named_zone_reusable(dns_zone_t *zone, const cfg_obj_t *zconfig); named_zone_reusable(dns_zone_t *zone, const cfg_obj_t *zconfig);
/*%< /*%<
* If 'zone' can be safely reconfigured according to the configuration * If 'zone' can be safely reconfigured according to the configuration
* data in 'zconfig', return ISC_TRUE. If the configuration data is so * data in 'zconfig', return true. If the configuration data is so
* different from the current zone state that the zone needs to be destroyed * different from the current zone state that the zone needs to be destroyed
* and recreated, return ISC_FALSE. * and recreated, return false.
*/ */
isc_result_t isc_result_t
+1 -1
View File
@@ -50,7 +50,7 @@ static isc_logmodule_t modules[] = {
}; };
isc_result_t isc_result_t
named_log_init(isc_boolean_t safe) { named_log_init(bool safe) {
isc_result_t result; isc_result_t result;
isc_logconfig_t *lcfg = NULL; isc_logconfig_t *lcfg = NULL;
+9 -6
View File
@@ -13,6 +13,9 @@
#include <config.h> #include <config.h>
#include <inttypes.h>
#include <stdbool.h>
#include <isc/file.h> #include <isc/file.h>
#include <isc/offset.h> #include <isc/offset.h>
#include <isc/print.h> #include <isc/print.h>
@@ -136,10 +139,10 @@ channel_fromconf(const cfg_obj_t *channel, isc_logconfig_t *logconfig) {
cfg_tuple_get(fileobj, "versions"); cfg_tuple_get(fileobj, "versions");
const cfg_obj_t *suffixobj = const cfg_obj_t *suffixobj =
cfg_tuple_get(fileobj, "suffix"); cfg_tuple_get(fileobj, "suffix");
isc_int32_t versions = ISC_LOG_ROLLNEVER; int32_t versions = ISC_LOG_ROLLNEVER;
isc_log_rollsuffix_t suffix = isc_log_rollsuffix_increment; isc_log_rollsuffix_t suffix = isc_log_rollsuffix_increment;
isc_offset_t size = 0; isc_offset_t size = 0;
isc_uint64_t maxoffset; uint64_t maxoffset;
/* /*
* isc_offset_t is a signed integer type, so the maximum * isc_offset_t is a signed integer type, so the maximum
@@ -302,8 +305,8 @@ named_logconfig(isc_logconfig_t *logconfig, const cfg_obj_t *logstmt) {
const cfg_obj_t *channels = NULL; const cfg_obj_t *channels = NULL;
const cfg_obj_t *categories = NULL; const cfg_obj_t *categories = NULL;
const cfg_listelt_t *element; const cfg_listelt_t *element;
isc_boolean_t default_set = ISC_FALSE; bool default_set = false;
isc_boolean_t unmatched_set = ISC_FALSE; bool unmatched_set = false;
const cfg_obj_t *catname; const cfg_obj_t *catname;
if (logconfig != NULL) if (logconfig != NULL)
@@ -328,12 +331,12 @@ named_logconfig(isc_logconfig_t *logconfig, const cfg_obj_t *logstmt) {
if (!default_set) { if (!default_set) {
catname = cfg_tuple_get(category, "name"); catname = cfg_tuple_get(category, "name");
if (strcmp(cfg_obj_asstring(catname), "default") == 0) if (strcmp(cfg_obj_asstring(catname), "default") == 0)
default_set = ISC_TRUE; default_set = true;
} }
if (!unmatched_set) { if (!unmatched_set) {
catname = cfg_tuple_get(category, "name"); catname = cfg_tuple_get(category, "name");
if (strcmp(cfg_obj_asstring(catname), "unmatched") == 0) if (strcmp(cfg_obj_asstring(catname), "unmatched") == 0)
unmatched_set = ISC_TRUE; unmatched_set = true;
} }
} }
+74 -68
View File
@@ -14,6 +14,8 @@
#include <config.h> #include <config.h>
#include <ctype.h> #include <ctype.h>
#include <inttypes.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
@@ -107,9 +109,9 @@ LIBDNS_EXTERNAL_DATA extern unsigned int dns_zone_mkey_hour;
LIBDNS_EXTERNAL_DATA extern unsigned int dns_zone_mkey_day; LIBDNS_EXTERNAL_DATA extern unsigned int dns_zone_mkey_day;
LIBDNS_EXTERNAL_DATA extern unsigned int dns_zone_mkey_month; LIBDNS_EXTERNAL_DATA extern unsigned int dns_zone_mkey_month;
static isc_boolean_t want_stats = ISC_FALSE; static bool want_stats = false;
static char program_name[ISC_DIR_NAMEMAX] = "named"; static char program_name[NAME_MAX] = "named";
static char absolute_conffile[ISC_DIR_PATHMAX]; static char absolute_conffile[PATH_MAX];
static char saved_command_line[512]; static char saved_command_line[512];
static char version[512]; static char version[512];
static unsigned int maxsocks = 0; static unsigned int maxsocks = 0;
@@ -118,22 +120,22 @@ static int maxudp = 0;
/* /*
* -T options: * -T options:
*/ */
static isc_boolean_t clienttest = ISC_FALSE; static bool clienttest = false;
static isc_boolean_t dropedns = ISC_FALSE; static bool dropedns = false;
static isc_boolean_t noedns = ISC_FALSE; static bool noedns = false;
static isc_boolean_t nosoa = ISC_FALSE; static bool nosoa = false;
static isc_boolean_t noaa = ISC_FALSE; static bool noaa = false;
static unsigned int delay = 0; static unsigned int delay = 0;
static isc_boolean_t nonearest = ISC_FALSE; static bool nonearest = false;
static isc_boolean_t notcp = ISC_FALSE; static bool notcp = false;
static isc_boolean_t fixedlocal = ISC_FALSE; static bool fixedlocal = false;
static isc_boolean_t sigvalinsecs = ISC_FALSE; static bool sigvalinsecs = false;
/* /*
* -4 and -6 * -4 and -6
*/ */
static isc_boolean_t disable6 = ISC_FALSE; static bool disable6 = false;
static isc_boolean_t disable4 = ISC_FALSE; static bool disable4 = false;
void void
named_main_earlywarning(const char *format, ...) { named_main_earlywarning(const char *format, ...) {
@@ -336,7 +338,7 @@ save_command_line(int argc, char *argv[]) {
char *dst; char *dst;
char *eob; char *eob;
const char truncated[] = "..."; const char truncated[] = "...";
isc_boolean_t quoted = ISC_FALSE; bool quoted = false;
dst = saved_command_line; dst = saved_command_line;
eob = saved_command_line + sizeof(saved_command_line); eob = saved_command_line + sizeof(saved_command_line);
@@ -356,10 +358,10 @@ save_command_line(int argc, char *argv[]) {
*src == '-' || *src == '_' || *src == '-' || *src == '_' ||
*src == '.' || *src == '/') { *src == '.' || *src == '/') {
*dst++ = *src++; *dst++ = *src++;
quoted = ISC_FALSE; quoted = false;
} else { } else {
*dst++ = '\\'; *dst++ = '\\';
quoted = ISC_TRUE; quoted = true;
} }
} }
} }
@@ -390,25 +392,25 @@ parse_int(char *arg, const char *desc) {
static struct flag_def { static struct flag_def {
const char *name; const char *name;
unsigned int value; unsigned int value;
isc_boolean_t negate; bool negate;
} mem_debug_flags[] = { } mem_debug_flags[] = {
{ "none", 0, ISC_FALSE }, { "none", 0, false },
{ "trace", ISC_MEM_DEBUGTRACE, ISC_FALSE }, { "trace", ISC_MEM_DEBUGTRACE, false },
{ "record", ISC_MEM_DEBUGRECORD, ISC_FALSE }, { "record", ISC_MEM_DEBUGRECORD, false },
{ "usage", ISC_MEM_DEBUGUSAGE, ISC_FALSE }, { "usage", ISC_MEM_DEBUGUSAGE, false },
{ "size", ISC_MEM_DEBUGSIZE, ISC_FALSE }, { "size", ISC_MEM_DEBUGSIZE, false },
{ "mctx", ISC_MEM_DEBUGCTX, ISC_FALSE }, { "mctx", ISC_MEM_DEBUGCTX, false },
{ NULL, 0, ISC_FALSE } { NULL, 0, false }
}, mem_context_flags[] = { }, mem_context_flags[] = {
{ "external", ISC_MEMFLAG_INTERNAL, ISC_TRUE }, { "external", ISC_MEMFLAG_INTERNAL, true },
{ "fill", ISC_MEMFLAG_FILL, ISC_FALSE }, { "fill", ISC_MEMFLAG_FILL, false },
{ "nofill", ISC_MEMFLAG_FILL, ISC_TRUE }, { "nofill", ISC_MEMFLAG_FILL, true },
{ NULL, 0, ISC_FALSE } { NULL, 0, false }
}; };
static void static void
set_flags(const char *arg, struct flag_def *defs, unsigned int *ret) { set_flags(const char *arg, struct flag_def *defs, unsigned int *ret) {
isc_boolean_t clear = ISC_FALSE; bool clear = false;
for (;;) { for (;;) {
const struct flag_def *def; const struct flag_def *def;
@@ -421,7 +423,7 @@ set_flags(const char *arg, struct flag_def *defs, unsigned int *ret) {
if (arglen == (int)strlen(def->name) && if (arglen == (int)strlen(def->name) &&
memcmp(arg, def->name, arglen) == 0) { memcmp(arg, def->name, arglen) == 0) {
if (def->value == 0) if (def->value == 0)
clear = ISC_TRUE; clear = true;
if (def->negate) if (def->negate)
*ret &= ~(def->value); *ret &= ~(def->value);
else else
@@ -479,29 +481,29 @@ parse_T_opt(char *option) {
* expected and assert otherwise. * expected and assert otherwise.
*/ */
if (!strcmp(option, "clienttest")) { if (!strcmp(option, "clienttest")) {
clienttest = ISC_TRUE; clienttest = true;
} else if (!strncmp(option, "delay=", 6)) { } else if (!strncmp(option, "delay=", 6)) {
delay = atoi(option + 6); delay = atoi(option + 6);
} else if (!strcmp(option, "dropedns")) { } else if (!strcmp(option, "dropedns")) {
dropedns = ISC_TRUE; dropedns = true;
} else if (!strncmp(option, "dscp=", 5)) { } else if (!strncmp(option, "dscp=", 5)) {
isc_dscp_check_value = atoi(option + 5); isc_dscp_check_value = atoi(option + 5);
} else if (!strcmp(option, "fixedlocal")) { } else if (!strcmp(option, "fixedlocal")) {
fixedlocal = ISC_TRUE; fixedlocal = true;
} else if (!strcmp(option, "keepstderr")) { } else if (!strcmp(option, "keepstderr")) {
named_g_keepstderr = ISC_TRUE; named_g_keepstderr = true;
} else if (!strcmp(option, "noaa")) { } else if (!strcmp(option, "noaa")) {
noaa = ISC_TRUE; noaa = true;
} else if (!strcmp(option, "noedns")) { } else if (!strcmp(option, "noedns")) {
noedns = ISC_TRUE; noedns = true;
} else if (!strcmp(option, "nonearest")) { } else if (!strcmp(option, "nonearest")) {
nonearest = ISC_TRUE; nonearest = true;
} else if (!strcmp(option, "nosoa")) { } else if (!strcmp(option, "nosoa")) {
nosoa = ISC_TRUE; nosoa = true;
} else if (!strcmp(option, "nosyslog")) { } else if (!strcmp(option, "nosyslog")) {
named_g_nosyslog = ISC_TRUE; named_g_nosyslog = true;
} else if (!strcmp(option, "notcp")) { } else if (!strcmp(option, "notcp")) {
notcp = ISC_TRUE; notcp = true;
} else if (!strcmp(option, "maxudp512")) { } else if (!strcmp(option, "maxudp512")) {
maxudp = 512; maxudp = 512;
} else if (!strcmp(option, "maxudp1460")) { } else if (!strcmp(option, "maxudp1460")) {
@@ -541,7 +543,7 @@ parse_T_opt(char *option) {
named_main_earlyfatal("bad mkeytimer"); named_main_earlyfatal("bad mkeytimer");
} }
} else if (!strcmp(option, "sigvalinsecs")) { } else if (!strcmp(option, "sigvalinsecs")) {
sigvalinsecs = ISC_TRUE; sigvalinsecs = true;
} else if (!strncmp(option, "tat=", 4)) { } else if (!strncmp(option, "tat=", 4)) {
named_g_tat_interval = atoi(option + 4); named_g_tat_interval = atoi(option + 4);
} else { } else {
@@ -561,7 +563,7 @@ parse_command_line(int argc, char *argv[]) {
* NAMED_MAIN_ARGS is defined in main.h, so that it can be used * NAMED_MAIN_ARGS is defined in main.h, so that it can be used
* both by named and by ntservice hooks. * both by named and by ntservice hooks.
*/ */
isc_commandline_errprint = ISC_FALSE; isc_commandline_errprint = false;
while ((ch = isc_commandline_parse(argc, argv, while ((ch = isc_commandline_parse(argc, argv,
NAMED_MAIN_ARGS)) != -1) NAMED_MAIN_ARGS)) != -1)
{ {
@@ -574,7 +576,7 @@ parse_command_line(int argc, char *argv[]) {
named_main_earlyfatal("IPv4 not supported " named_main_earlyfatal("IPv4 not supported "
"by OS"); "by OS");
isc_net_disableipv6(); isc_net_disableipv6();
disable6 = ISC_TRUE; disable6 = true;
break; break;
case '6': case '6':
if (disable6) if (disable6)
@@ -584,14 +586,14 @@ parse_command_line(int argc, char *argv[]) {
named_main_earlyfatal("IPv6 not supported " named_main_earlyfatal("IPv6 not supported "
"by OS"); "by OS");
isc_net_disableipv4(); isc_net_disableipv4();
disable4 = ISC_TRUE; disable4 = true;
break; break;
case 'A': case 'A':
parse_fuzz_arg(); parse_fuzz_arg();
break; break;
case 'c': case 'c':
named_g_conffile = isc_commandline_argument; named_g_conffile = isc_commandline_argument;
named_g_conffileset = ISC_TRUE; named_g_conffileset = true;
break; break;
case 'd': case 'd':
named_g_debuglevel = parse_int(isc_commandline_argument, named_g_debuglevel = parse_int(isc_commandline_argument,
@@ -604,11 +606,11 @@ parse_command_line(int argc, char *argv[]) {
named_g_engine = isc_commandline_argument; named_g_engine = isc_commandline_argument;
break; break;
case 'f': case 'f':
named_g_foreground = ISC_TRUE; named_g_foreground = true;
break; break;
case 'g': case 'g':
named_g_foreground = ISC_TRUE; named_g_foreground = true;
named_g_logstderr = ISC_TRUE; named_g_logstderr = true;
break; break;
case 'L': case 'L':
named_g_logfile = isc_commandline_argument; named_g_logfile = isc_commandline_argument;
@@ -637,7 +639,7 @@ parse_command_line(int argc, char *argv[]) {
break; break;
case 's': case 's':
/* XXXRTH temporary syntax */ /* XXXRTH temporary syntax */
want_stats = ISC_TRUE; want_stats = true;
break; break;
case 'S': case 'S':
maxsocks = parse_int(isc_commandline_argument, maxsocks = parse_int(isc_commandline_argument,
@@ -724,7 +726,7 @@ parse_command_line(int argc, char *argv[]) {
/* Obsolete. No longer in use. Ignore. */ /* Obsolete. No longer in use. Ignore. */
break; break;
case 'X': case 'X':
named_g_forcelock = ISC_TRUE; named_g_forcelock = true;
if (strcasecmp(isc_commandline_argument, "none") != 0) if (strcasecmp(isc_commandline_argument, "none") != 0)
named_g_defaultlockfile = named_g_defaultlockfile =
isc_commandline_argument; isc_commandline_argument;
@@ -820,7 +822,7 @@ create_managers(void) {
isc_result_totext(result)); isc_result_totext(result));
return (ISC_R_UNEXPECTED); return (ISC_R_UNEXPECTED);
} }
isc_socketmgr_maxudp(named_g_socketmgr, maxudp); isc__socketmgr_maxudp(named_g_socketmgr, maxudp);
result = isc_socketmgr_getmaxsockets(named_g_socketmgr, &socks); result = isc_socketmgr_getmaxsockets(named_g_socketmgr, &socks);
if (result == ISC_R_SUCCESS) { if (result == ISC_R_SUCCESS) {
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL, isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
@@ -922,7 +924,7 @@ setup(void) {
*/ */
named_os_minprivs(); named_os_minprivs();
result = named_log_init(ISC_TF(named_g_username != NULL)); result = named_log_init(named_g_username != NULL);
if (result != ISC_R_SUCCESS) if (result != ISC_R_SUCCESS)
named_main_earlyfatal("named_log_init() failed: %s", named_main_earlyfatal("named_log_init() failed: %s",
isc_result_totext(result)); isc_result_totext(result));
@@ -992,7 +994,6 @@ setup(void) {
NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE, NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
"compiled by Solaris Studio %x", __SUNPRO_C); "compiled by Solaris Studio %x", __SUNPRO_C);
#endif #endif
#ifdef OPENSSL
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL, isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE, NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
"compiled with OpenSSL version: %s", "compiled with OpenSSL version: %s",
@@ -1009,7 +1010,6 @@ setup(void) {
"linked to OpenSSL version: %s", "linked to OpenSSL version: %s",
SSLeay_version(SSLEAY_VERSION)); SSLeay_version(SSLEAY_VERSION));
#endif /* OPENSSL_VERSION_NUMBER >= 0x10100000L */ #endif /* OPENSSL_VERSION_NUMBER >= 0x10100000L */
#endif
#ifdef HAVE_LIBXML2 #ifdef HAVE_LIBXML2
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL, isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE, NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
@@ -1035,9 +1035,15 @@ setup(void) {
NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE, NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
"linked to zlib version: %s", zlibVersion()); "linked to zlib version: %s", zlibVersion());
#endif #endif
#ifdef ISC_PLATFORM_USETHREADS
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL, isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE, NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
"threads support is enabled"); "threads support is enabled");
#else
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
"threads support is disabled");
#endif
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL, isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE, NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
@@ -1084,8 +1090,8 @@ setup(void) {
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL, isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE, NAMED_LOGMODULE_MAIN, ISC_LOG_NOTICE,
"adjusted limit on open files from " "adjusted limit on open files from "
"%" ISC_PRINT_QUADFORMAT "u to " "%" PRIu64 " to "
"%" ISC_PRINT_QUADFORMAT "u", "%" PRIu64,
old_openfiles, named_g_initopenfiles); old_openfiles, named_g_initopenfiles);
} }
@@ -1152,27 +1158,27 @@ setup(void) {
* Modify server context according to command line options * Modify server context according to command line options
*/ */
if (clienttest) if (clienttest)
ns_server_setoption(sctx, NS_SERVER_CLIENTTEST, ISC_TRUE); ns_server_setoption(sctx, NS_SERVER_CLIENTTEST, true);
if (dropedns) if (dropedns)
ns_server_setoption(sctx, NS_SERVER_DROPEDNS, ISC_TRUE); ns_server_setoption(sctx, NS_SERVER_DROPEDNS, true);
if (noedns) if (noedns)
ns_server_setoption(sctx, NS_SERVER_NOEDNS, ISC_TRUE); ns_server_setoption(sctx, NS_SERVER_NOEDNS, true);
if (nosoa) if (nosoa)
ns_server_setoption(sctx, NS_SERVER_NOSOA, ISC_TRUE); ns_server_setoption(sctx, NS_SERVER_NOSOA, true);
if (noaa) if (noaa)
ns_server_setoption(sctx, NS_SERVER_NOAA, ISC_TRUE); ns_server_setoption(sctx, NS_SERVER_NOAA, true);
if (nonearest) if (nonearest)
ns_server_setoption(sctx, NS_SERVER_NONEAREST, ISC_TRUE); ns_server_setoption(sctx, NS_SERVER_NONEAREST, true);
if (notcp) if (notcp)
ns_server_setoption(sctx, NS_SERVER_NOTCP, ISC_TRUE); ns_server_setoption(sctx, NS_SERVER_NOTCP, true);
if (fixedlocal) if (fixedlocal)
ns_server_setoption(sctx, NS_SERVER_FIXEDLOCAL, ISC_TRUE); ns_server_setoption(sctx, NS_SERVER_FIXEDLOCAL, true);
if (disable4) if (disable4)
ns_server_setoption(sctx, NS_SERVER_DISABLE4, ISC_TRUE); ns_server_setoption(sctx, NS_SERVER_DISABLE4, true);
if (disable6) if (disable6)
ns_server_setoption(sctx, NS_SERVER_DISABLE6, ISC_TRUE); ns_server_setoption(sctx, NS_SERVER_DISABLE6, true);
if (sigvalinsecs) if (sigvalinsecs)
ns_server_setoption(sctx, NS_SERVER_SIGVALINSECS, ISC_TRUE); ns_server_setoption(sctx, NS_SERVER_SIGVALINSECS, true);
named_g_server->sctx->delay = delay; named_g_server->sctx->delay = delay;
} }
+23 -23
View File
@@ -13,7 +13,7 @@
<refentry xmlns:db="http://docbook.org/ns/docbook" version="5.0" xml:id="man.named.conf"> <refentry xmlns:db="http://docbook.org/ns/docbook" version="5.0" xml:id="man.named.conf">
<info> <info>
<date>2018-05-29</date> <date>2018-06-21</date>
</info> </info>
<refentryinfo> <refentryinfo>
<corpname>ISC</corpname> <corpname>ISC</corpname>
@@ -224,9 +224,9 @@ options {
coresize ( default | unlimited | <replaceable>sizeval</replaceable> ); coresize ( default | unlimited | <replaceable>sizeval</replaceable> );
datasize ( default | unlimited | <replaceable>sizeval</replaceable> ); datasize ( default | unlimited | <replaceable>sizeval</replaceable> );
deny-answer-addresses { <replaceable>address_match_element</replaceable>; ... } [ deny-answer-addresses { <replaceable>address_match_element</replaceable>; ... } [
except-from { <replaceable>quoted_string</replaceable>; ... } ]; except-from { <replaceable>string</replaceable>; ... } ];
deny-answer-aliases { <replaceable>quoted_string</replaceable>; ... } [ except-from { deny-answer-aliases { <replaceable>string</replaceable>; ... } [ except-from { <replaceable>string</replaceable>; ...
<replaceable>quoted_string</replaceable>; ... } ]; } ];
dialup ( notify | notify-passive | passive | refresh | <replaceable>boolean</replaceable> ); dialup ( notify | notify-passive | passive | refresh | <replaceable>boolean</replaceable> );
directory <replaceable>quoted_string</replaceable>; directory <replaceable>quoted_string</replaceable>;
disable-algorithms <replaceable>string</replaceable> { <replaceable>string</replaceable>; disable-algorithms <replaceable>string</replaceable> { <replaceable>string</replaceable>;
@@ -257,14 +257,12 @@ options {
dnssec-secure-to-insecure <replaceable>boolean</replaceable>; dnssec-secure-to-insecure <replaceable>boolean</replaceable>;
dnssec-update-mode ( maintain | no-resign ); dnssec-update-mode ( maintain | no-resign );
dnssec-validation ( yes | no | auto ); dnssec-validation ( yes | no | auto );
dnstap { ( all | auth | client | forwarder | dnstap { ( all | auth | client | forwarder | resolver ) [ ( query |
resolver ) [ ( query | response ) ]; ... }; response ) ]; ... };
dnstap-identity ( <replaceable>quoted_string</replaceable> | none | dnstap-identity ( <replaceable>quoted_string</replaceable> | none | hostname );
hostname ); dnstap-output ( file | unix ) <replaceable>quoted_string</replaceable> [ size ( unlimited |
dnstap-output ( file | unix ) <replaceable>quoted_string</replaceable> [ <replaceable>size</replaceable> ) ] [ versions ( unlimited | <replaceable>integer</replaceable> ) ] [ suffix (
size ( unlimited | <replaceable>size</replaceable> ) ] [ versions ( increment | timestamp ) ];
unlimited | <replaceable>integer</replaceable> ) ] [ suffix ( increment
| timestamp ) ];
dnstap-version ( <replaceable>quoted_string</replaceable> | none ); dnstap-version ( <replaceable>quoted_string</replaceable> | none );
dscp <replaceable>integer</replaceable>; dscp <replaceable>integer</replaceable>;
dual-stack-servers [ port <replaceable>integer</replaceable> ] { ( <replaceable>quoted_string</replaceable> [ port dual-stack-servers [ port <replaceable>integer</replaceable> ] { ( <replaceable>quoted_string</replaceable> [ port
@@ -362,7 +360,7 @@ options {
preferred-glue <replaceable>string</replaceable>; preferred-glue <replaceable>string</replaceable>;
prefetch <replaceable>integer</replaceable> [ <replaceable>integer</replaceable> ]; prefetch <replaceable>integer</replaceable> [ <replaceable>integer</replaceable> ];
provide-ixfr <replaceable>boolean</replaceable>; provide-ixfr <replaceable>boolean</replaceable>;
qname-minimization ( strict | relaxed | disabled ); qname-minimization ( strict | relaxed | disabled | off );
query-source ( ( [ address ] ( <replaceable>ipv4_address</replaceable> | * ) [ port ( query-source ( ( [ address ] ( <replaceable>ipv4_address</replaceable> | * ) [ port (
<replaceable>integer</replaceable> | * ) ] ) | ( [ [ address ] ( <replaceable>ipv4_address</replaceable> | * ) ] <replaceable>integer</replaceable> | * ) ] ) | ( [ [ address ] ( <replaceable>ipv4_address</replaceable> | * ) ]
port ( <replaceable>integer</replaceable> | * ) ) ) [ dscp <replaceable>integer</replaceable> ]; port ( <replaceable>integer</replaceable> | * ) ) ) [ dscp <replaceable>integer</replaceable> ];
@@ -413,7 +411,7 @@ options {
nsip-enable <replaceable>boolean</replaceable> ] [ nsdname-enable <replaceable>boolean</replaceable> ] [ nsip-enable <replaceable>boolean</replaceable> ] [ nsdname-enable <replaceable>boolean</replaceable> ] [
dnsrps-enable <replaceable>boolean</replaceable> ] [ dnsrps-options { <replaceable>unspecified-text</replaceable> dnsrps-enable <replaceable>boolean</replaceable> ] [ dnsrps-options { <replaceable>unspecified-text</replaceable>
} ]; } ];
root-delegation-only [ exclude { <replaceable>quoted_string</replaceable>; ... } ]; root-delegation-only [ exclude { <replaceable>string</replaceable>; ... } ];
root-key-sentinel <replaceable>boolean</replaceable>; root-key-sentinel <replaceable>boolean</replaceable>;
rrset-order { [ class <replaceable>string</replaceable> ] [ type <replaceable>string</replaceable> ] [ name rrset-order { [ class <replaceable>string</replaceable> ] [ type <replaceable>string</replaceable> ] [ name
<replaceable>quoted_string</replaceable> ] <replaceable>string</replaceable> <replaceable>string</replaceable>; ... }; <replaceable>quoted_string</replaceable> ] <replaceable>string</replaceable> <replaceable>string</replaceable>; ... };
@@ -463,6 +461,7 @@ options {
use-v4-udp-ports { <replaceable>portrange</replaceable>; ... }; use-v4-udp-ports { <replaceable>portrange</replaceable>; ... };
use-v6-udp-ports { <replaceable>portrange</replaceable>; ... }; use-v6-udp-ports { <replaceable>portrange</replaceable>; ... };
v6-bias <replaceable>integer</replaceable>; v6-bias <replaceable>integer</replaceable>;
validate-except { <replaceable>string</replaceable>; ... };
version ( <replaceable>quoted_string</replaceable> | none ); version ( <replaceable>quoted_string</replaceable> | none );
zero-no-soa-ttl <replaceable>boolean</replaceable>; zero-no-soa-ttl <replaceable>boolean</replaceable>;
zero-no-soa-ttl-cache <replaceable>boolean</replaceable>; zero-no-soa-ttl-cache <replaceable>boolean</replaceable>;
@@ -574,9 +573,9 @@ view <replaceable>string</replaceable> [ <replaceable>class</replaceable> ] {
cleaning-interval <replaceable>integer</replaceable>; cleaning-interval <replaceable>integer</replaceable>;
clients-per-query <replaceable>integer</replaceable>; clients-per-query <replaceable>integer</replaceable>;
deny-answer-addresses { <replaceable>address_match_element</replaceable>; ... } [ deny-answer-addresses { <replaceable>address_match_element</replaceable>; ... } [
except-from { <replaceable>quoted_string</replaceable>; ... } ]; except-from { <replaceable>string</replaceable>; ... } ];
deny-answer-aliases { <replaceable>quoted_string</replaceable>; ... } [ except-from { deny-answer-aliases { <replaceable>string</replaceable>; ... } [ except-from { <replaceable>string</replaceable>; ...
<replaceable>quoted_string</replaceable>; ... } ]; } ];
dialup ( notify | notify-passive | passive | refresh | <replaceable>boolean</replaceable> ); dialup ( notify | notify-passive | passive | refresh | <replaceable>boolean</replaceable> );
disable-algorithms <replaceable>string</replaceable> { <replaceable>string</replaceable>; disable-algorithms <replaceable>string</replaceable> { <replaceable>string</replaceable>;
... }; ... };
@@ -610,8 +609,8 @@ view <replaceable>string</replaceable> [ <replaceable>class</replaceable> ] {
dnssec-secure-to-insecure <replaceable>boolean</replaceable>; dnssec-secure-to-insecure <replaceable>boolean</replaceable>;
dnssec-update-mode ( maintain | no-resign ); dnssec-update-mode ( maintain | no-resign );
dnssec-validation ( yes | no | auto ); dnssec-validation ( yes | no | auto );
dnstap { ( all | auth | client | forwarder | dnstap { ( all | auth | client | forwarder | resolver ) [ ( query |
resolver ) [ ( query | response ) ]; ... }; response ) ]; ... };
dual-stack-servers [ port <replaceable>integer</replaceable> ] { ( <replaceable>quoted_string</replaceable> [ port dual-stack-servers [ port <replaceable>integer</replaceable> ] { ( <replaceable>quoted_string</replaceable> [ port
<replaceable>integer</replaceable> ] [ dscp <replaceable>integer</replaceable> ] | <replaceable>ipv4_address</replaceable> [ port <replaceable>integer</replaceable> ] [ dscp <replaceable>integer</replaceable> ] | <replaceable>ipv4_address</replaceable> [ port
<replaceable>integer</replaceable> ] [ dscp <replaceable>integer</replaceable> ] | <replaceable>ipv6_address</replaceable> [ port <replaceable>integer</replaceable> ] [ dscp <replaceable>integer</replaceable> ] | <replaceable>ipv6_address</replaceable> [ port
@@ -689,7 +688,7 @@ view <replaceable>string</replaceable> [ <replaceable>class</replaceable> ] {
preferred-glue <replaceable>string</replaceable>; preferred-glue <replaceable>string</replaceable>;
prefetch <replaceable>integer</replaceable> [ <replaceable>integer</replaceable> ]; prefetch <replaceable>integer</replaceable> [ <replaceable>integer</replaceable> ];
provide-ixfr <replaceable>boolean</replaceable>; provide-ixfr <replaceable>boolean</replaceable>;
qname-minimization ( strict | relaxed | disabled ); qname-minimization ( strict | relaxed | disabled | off );
query-source ( ( [ address ] ( <replaceable>ipv4_address</replaceable> | * ) [ port ( query-source ( ( [ address ] ( <replaceable>ipv4_address</replaceable> | * ) [ port (
<replaceable>integer</replaceable> | * ) ] ) | ( [ [ address ] ( <replaceable>ipv4_address</replaceable> | * ) ] <replaceable>integer</replaceable> | * ) ] ) | ( [ [ address ] ( <replaceable>ipv4_address</replaceable> | * ) ]
port ( <replaceable>integer</replaceable> | * ) ) ) [ dscp <replaceable>integer</replaceable> ]; port ( <replaceable>integer</replaceable> | * ) ) ) [ dscp <replaceable>integer</replaceable> ];
@@ -735,7 +734,7 @@ view <replaceable>string</replaceable> [ <replaceable>class</replaceable> ] {
nsip-enable <replaceable>boolean</replaceable> ] [ nsdname-enable <replaceable>boolean</replaceable> ] [ nsip-enable <replaceable>boolean</replaceable> ] [ nsdname-enable <replaceable>boolean</replaceable> ] [
dnsrps-enable <replaceable>boolean</replaceable> ] [ dnsrps-options { <replaceable>unspecified-text</replaceable> dnsrps-enable <replaceable>boolean</replaceable> ] [ dnsrps-options { <replaceable>unspecified-text</replaceable>
} ]; } ];
root-delegation-only [ exclude { <replaceable>quoted_string</replaceable>; ... } ]; root-delegation-only [ exclude { <replaceable>string</replaceable>; ... } ];
root-key-sentinel <replaceable>boolean</replaceable>; root-key-sentinel <replaceable>boolean</replaceable>;
rrset-order { [ class <replaceable>string</replaceable> ] [ type <replaceable>string</replaceable> ] [ name rrset-order { [ class <replaceable>string</replaceable> ] [ type <replaceable>string</replaceable> ] [ name
<replaceable>quoted_string</replaceable> ] <replaceable>string</replaceable> <replaceable>string</replaceable>; ... }; <replaceable>quoted_string</replaceable> ] <replaceable>string</replaceable> <replaceable>string</replaceable>; ... };
@@ -797,6 +796,7 @@ view <replaceable>string</replaceable> [ <replaceable>class</replaceable> ] {
update-check-ksk <replaceable>boolean</replaceable>; update-check-ksk <replaceable>boolean</replaceable>;
use-alt-transfer-source <replaceable>boolean</replaceable>; use-alt-transfer-source <replaceable>boolean</replaceable>;
v6-bias <replaceable>integer</replaceable>; v6-bias <replaceable>integer</replaceable>;
validate-except { <replaceable>string</replaceable>; ... };
zero-no-soa-ttl <replaceable>boolean</replaceable>; zero-no-soa-ttl <replaceable>boolean</replaceable>;
zero-no-soa-ttl-cache <replaceable>boolean</replaceable>; zero-no-soa-ttl-cache <replaceable>boolean</replaceable>;
zone <replaceable>string</replaceable> [ <replaceable>class</replaceable> ] { zone <replaceable>string</replaceable> [ <replaceable>class</replaceable> ] {
@@ -878,7 +878,7 @@ view <replaceable>string</replaceable> [ <replaceable>class</replaceable> ] {
serial-update-method ( date | increment | unixtime ); serial-update-method ( date | increment | unixtime );
server-addresses { ( <replaceable>ipv4_address</replaceable> | <replaceable>ipv6_address</replaceable> ) [ server-addresses { ( <replaceable>ipv4_address</replaceable> | <replaceable>ipv6_address</replaceable> ) [
port <replaceable>integer</replaceable> ]; ... }; port <replaceable>integer</replaceable> ]; ... };
server-names { <replaceable>quoted_string</replaceable>; ... }; server-names { <replaceable>string</replaceable>; ... };
sig-signing-nodes <replaceable>integer</replaceable>; sig-signing-nodes <replaceable>integer</replaceable>;
sig-signing-signatures <replaceable>integer</replaceable>; sig-signing-signatures <replaceable>integer</replaceable>;
sig-signing-type <replaceable>integer</replaceable>; sig-signing-type <replaceable>integer</replaceable>;
@@ -982,7 +982,7 @@ zone <replaceable>string</replaceable> [ <replaceable>class</replaceable> ] {
serial-update-method ( date | increment | unixtime ); serial-update-method ( date | increment | unixtime );
server-addresses { ( <replaceable>ipv4_address</replaceable> | <replaceable>ipv6_address</replaceable> ) [ port server-addresses { ( <replaceable>ipv4_address</replaceable> | <replaceable>ipv6_address</replaceable> ) [ port
<replaceable>integer</replaceable> ]; ... }; <replaceable>integer</replaceable> ]; ... };
server-names { <replaceable>quoted_string</replaceable>; ... }; server-names { <replaceable>string</replaceable>; ... };
sig-signing-nodes <replaceable>integer</replaceable>; sig-signing-nodes <replaceable>integer</replaceable>;
sig-signing-signatures <replaceable>integer</replaceable>; sig-signing-signatures <replaceable>integer</replaceable>;
sig-signing-type <replaceable>integer</replaceable>; sig-signing-type <replaceable>integer</replaceable>;
+593 -544
View File
File diff suppressed because it is too large Load Diff
+72 -69
View File
@@ -13,6 +13,9 @@
#include <config.h> #include <config.h>
#include <inttypes.h>
#include <stdbool.h>
#include <isc/buffer.h> #include <isc/buffer.h>
#include <isc/httpd.h> #include <isc/httpd.h>
#include <isc/json.h> #include <isc/json.h>
@@ -67,7 +70,7 @@ stats_dumparg {
void *arg; /* type dependent argument */ void *arg; /* type dependent argument */
int ncounters; /* for general statistics */ int ncounters; /* for general statistics */
int *counterindices; /* 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; isc_result_t result;
} stats_dumparg_t; } stats_dumparg_t;
@@ -1048,7 +1051,7 @@ init_desc(void) {
* Dump callback functions. * Dump callback functions.
*/ */
static void 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; stats_dumparg_t *dumparg = arg;
REQUIRE(counter < dumparg->ncounters); REQUIRE(counter < dumparg->ncounters);
@@ -1058,10 +1061,10 @@ generalstat_dump(isc_statscounter_t counter, isc_uint64_t val, void *arg) {
static isc_result_t static isc_result_t
dump_counters(isc_stats_t *stats, isc_statsformat_t type, void *arg, dump_counters(isc_stats_t *stats, isc_statsformat_t type, void *arg,
const char *category, const char **desc, int ncounters, 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; int i, idx;
isc_uint64_t value; uint64_t value;
stats_dumparg_t dumparg; stats_dumparg_t dumparg;
FILE *fp; FILE *fp;
#ifdef HAVE_LIBXML2 #ifdef HAVE_LIBXML2
@@ -1106,7 +1109,7 @@ dump_counters(isc_stats_t *stats, isc_statsformat_t type, void *arg,
switch (dumparg.type) { switch (dumparg.type) {
case isc_statsformat_file: case isc_statsformat_file:
fp = arg; fp = arg;
fprintf(fp, "%20" ISC_PRINT_QUADFORMAT "u %s\n", fprintf(fp, "%20" PRIu64 " %s\n",
value, desc[idx]); value, desc[idx]);
break; break;
case isc_statsformat_xml: case isc_statsformat_xml:
@@ -1134,7 +1137,7 @@ dump_counters(isc_stats_t *stats, isc_statsformat_t type, void *arg,
ISC_XMLCHAR ISC_XMLCHAR
"counter")); "counter"));
TRY0(xmlTextWriterWriteFormatString(writer, TRY0(xmlTextWriterWriteFormatString(writer,
"%" ISC_PRINT_QUADFORMAT "u", value)); "%" PRIu64, value));
TRY0(xmlTextWriterEndElement(writer)); TRY0(xmlTextWriterEndElement(writer));
/* </counter> */ /* </counter> */
@@ -1151,7 +1154,7 @@ dump_counters(isc_stats_t *stats, isc_statsformat_t type, void *arg,
ISC_XMLCHAR ISC_XMLCHAR
desc[idx])); desc[idx]));
TRY0(xmlTextWriterWriteFormatString(writer, TRY0(xmlTextWriterWriteFormatString(writer,
"%" ISC_PRINT_QUADFORMAT "u", value)); "%" PRIu64, value));
TRY0(xmlTextWriterEndElement(writer)); TRY0(xmlTextWriterEndElement(writer));
/* counter */ /* counter */
} }
@@ -1179,7 +1182,7 @@ dump_counters(isc_stats_t *stats, isc_statsformat_t type, void *arg,
} }
static void 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]; char typebuf[64];
const char *typestr; const char *typestr;
stats_dumparg_t *dumparg = arg; stats_dumparg_t *dumparg = arg;
@@ -1203,7 +1206,7 @@ rdtypestat_dump(dns_rdatastatstype_t type, isc_uint64_t val, void *arg) {
switch (dumparg->type) { switch (dumparg->type) {
case isc_statsformat_file: case isc_statsformat_file:
fp = dumparg->arg; fp = dumparg->arg;
fprintf(fp, "%20" ISC_PRINT_QUADFORMAT "u %s\n", val, typestr); fprintf(fp, "%20" PRIu64 " %s\n", val, typestr);
break; break;
case isc_statsformat_xml: case isc_statsformat_xml:
#ifdef HAVE_LIBXML2 #ifdef HAVE_LIBXML2
@@ -1215,7 +1218,7 @@ rdtypestat_dump(dns_rdatastatstype_t type, isc_uint64_t val, void *arg) {
ISC_XMLCHAR typestr)); ISC_XMLCHAR typestr));
TRY0(xmlTextWriterWriteFormatString(writer, TRY0(xmlTextWriterWriteFormatString(writer,
"%" ISC_PRINT_QUADFORMAT "u", "%" PRIu64,
val)); val));
TRY0(xmlTextWriterEndElement(writer)); /* type */ TRY0(xmlTextWriterEndElement(writer)); /* type */
@@ -1243,13 +1246,13 @@ rdtypestat_dump(dns_rdatastatstype_t type, isc_uint64_t val, void *arg) {
} }
static void 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; stats_dumparg_t *dumparg = arg;
FILE *fp; FILE *fp;
char typebuf[64]; char typebuf[64];
const char *typestr; const char *typestr;
isc_boolean_t nxrrset = ISC_FALSE; bool nxrrset = false;
isc_boolean_t stale = ISC_FALSE; bool stale = false;
#ifdef HAVE_LIBXML2 #ifdef HAVE_LIBXML2
xmlTextWriterPtr writer; xmlTextWriterPtr writer;
int xmlrc; int xmlrc;
@@ -1273,16 +1276,16 @@ rdatasetstats_dump(dns_rdatastatstype_t type, isc_uint64_t val, void *arg) {
if ((DNS_RDATASTATSTYPE_ATTR(type) & DNS_RDATASTATSTYPE_ATTR_NXRRSET) if ((DNS_RDATASTATSTYPE_ATTR(type) & DNS_RDATASTATSTYPE_ATTR_NXRRSET)
!= 0) != 0)
nxrrset = ISC_TRUE; nxrrset = true;
if ((DNS_RDATASTATSTYPE_ATTR(type) & DNS_RDATASTATSTYPE_ATTR_STALE) if ((DNS_RDATASTATSTYPE_ATTR(type) & DNS_RDATASTATSTYPE_ATTR_STALE)
!= 0) != 0)
stale = ISC_TRUE; stale = true;
switch (dumparg->type) { switch (dumparg->type) {
case isc_statsformat_file: case isc_statsformat_file:
fp = dumparg->arg; fp = dumparg->arg;
fprintf(fp, "%20" ISC_PRINT_QUADFORMAT "u %s%s%s\n", val, fprintf(fp, "%20" PRIu64 " %s%s%s\n", val,
stale ? "#" : "", nxrrset ? "!" : "", typestr); stale ? "#" : "", nxrrset ? "!" : "", typestr);
break; break;
case isc_statsformat_xml: case isc_statsformat_xml:
@@ -1298,7 +1301,7 @@ rdatasetstats_dump(dns_rdatastatstype_t type, isc_uint64_t val, void *arg) {
TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "counter")); TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "counter"));
TRY0(xmlTextWriterWriteFormatString(writer, TRY0(xmlTextWriterWriteFormatString(writer,
"%" ISC_PRINT_QUADFORMAT "u", "%" PRIu64,
val)); val));
TRY0(xmlTextWriterEndElement(writer)); /* counter */ TRY0(xmlTextWriterEndElement(writer)); /* counter */
@@ -1329,7 +1332,7 @@ rdatasetstats_dump(dns_rdatastatstype_t type, isc_uint64_t val, void *arg) {
} }
static void 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; FILE *fp;
isc_buffer_t b; isc_buffer_t b;
char codebuf[64]; char codebuf[64];
@@ -1349,7 +1352,7 @@ opcodestat_dump(dns_opcode_t code, isc_uint64_t val, void *arg) {
switch (dumparg->type) { switch (dumparg->type) {
case isc_statsformat_file: case isc_statsformat_file:
fp = dumparg->arg; fp = dumparg->arg;
fprintf(fp, "%20" ISC_PRINT_QUADFORMAT "u %s\n", val, codebuf); fprintf(fp, "%20" PRIu64 " %s\n", val, codebuf);
break; break;
case isc_statsformat_xml: case isc_statsformat_xml:
#ifdef HAVE_LIBXML2 #ifdef HAVE_LIBXML2
@@ -1358,7 +1361,7 @@ opcodestat_dump(dns_opcode_t code, isc_uint64_t val, void *arg) {
TRY0(xmlTextWriterWriteAttribute(writer, ISC_XMLCHAR "name", TRY0(xmlTextWriterWriteAttribute(writer, ISC_XMLCHAR "name",
ISC_XMLCHAR codebuf )); ISC_XMLCHAR codebuf ));
TRY0(xmlTextWriterWriteFormatString(writer, TRY0(xmlTextWriterWriteFormatString(writer,
"%" ISC_PRINT_QUADFORMAT "u", "%" PRIu64,
val)); val));
TRY0(xmlTextWriterEndElement(writer)); /* counter */ TRY0(xmlTextWriterEndElement(writer)); /* counter */
#endif #endif
@@ -1386,7 +1389,7 @@ opcodestat_dump(dns_opcode_t code, isc_uint64_t val, void *arg) {
} }
static void 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; FILE *fp;
isc_buffer_t b; isc_buffer_t b;
char codebuf[64]; char codebuf[64];
@@ -1406,7 +1409,7 @@ rcodestat_dump(dns_rcode_t code, isc_uint64_t val, void *arg) {
switch (dumparg->type) { switch (dumparg->type) {
case isc_statsformat_file: case isc_statsformat_file:
fp = dumparg->arg; fp = dumparg->arg;
fprintf(fp, "%20" ISC_PRINT_QUADFORMAT "u %s\n", val, codebuf); fprintf(fp, "%20" PRIu64 " %s\n", val, codebuf);
break; break;
case isc_statsformat_xml: case isc_statsformat_xml:
#ifdef HAVE_LIBXML2 #ifdef HAVE_LIBXML2
@@ -1415,7 +1418,7 @@ rcodestat_dump(dns_rcode_t code, isc_uint64_t val, void *arg) {
TRY0(xmlTextWriterWriteAttribute(writer, ISC_XMLCHAR "name", TRY0(xmlTextWriterWriteAttribute(writer, ISC_XMLCHAR "name",
ISC_XMLCHAR codebuf )); ISC_XMLCHAR codebuf ));
TRY0(xmlTextWriterWriteFormatString(writer, TRY0(xmlTextWriterWriteFormatString(writer,
"%" ISC_PRINT_QUADFORMAT "u", "%" PRIu64,
val)); val));
TRY0(xmlTextWriterEndElement(writer)); /* counter */ TRY0(xmlTextWriterEndElement(writer)); /* counter */
#endif #endif
@@ -1460,7 +1463,7 @@ zone_xmlrender(dns_zone_t *zone, void *arg) {
isc_result_t result; isc_result_t result;
char buf[1024 + 32]; /* sufficiently large for zone name and class */ char buf[1024 + 32]; /* sufficiently large for zone name and class */
dns_rdataclass_t rdclass; dns_rdataclass_t rdclass;
isc_uint32_t serial; uint32_t serial;
xmlTextWriterPtr writer = arg; xmlTextWriterPtr writer = arg;
dns_zonestat_level_t statlevel; dns_zonestat_level_t statlevel;
int xmlrc; int xmlrc;
@@ -1504,8 +1507,8 @@ zone_xmlrender(dns_zone_t *zone, void *arg) {
isc_stats_t *zonestats; isc_stats_t *zonestats;
isc_stats_t *gluecachestats; isc_stats_t *gluecachestats;
dns_stats_t *rcvquerystats; dns_stats_t *rcvquerystats;
isc_uint64_t nsstat_values[ns_statscounter_max]; uint64_t nsstat_values[ns_statscounter_max];
isc_uint64_t gluecachestats_values[dns_gluecachestatscounter_max]; uint64_t gluecachestats_values[dns_gluecachestatscounter_max];
zonestats = dns_zone_getrequeststats(zone); zonestats = dns_zone_getrequeststats(zone);
if (zonestats != NULL) { if (zonestats != NULL) {
@@ -1578,7 +1581,7 @@ zone_xmlrender(dns_zone_t *zone, void *arg) {
} }
static isc_result_t static isc_result_t
generatexml(named_server_t *server, isc_uint32_t flags, generatexml(named_server_t *server, uint32_t flags,
int *buflen, xmlChar **buf) int *buflen, xmlChar **buf)
{ {
char boottime[sizeof "yyyy-mm-ddThh:mm:ss.sssZ"]; char boottime[sizeof "yyyy-mm-ddThh:mm:ss.sssZ"];
@@ -1591,17 +1594,17 @@ generatexml(named_server_t *server, isc_uint32_t flags,
dns_view_t *view; dns_view_t *view;
stats_dumparg_t dumparg; stats_dumparg_t dumparg;
dns_stats_t *cacherrstats; dns_stats_t *cacherrstats;
isc_uint64_t nsstat_values[ns_statscounter_max]; uint64_t nsstat_values[ns_statscounter_max];
isc_uint64_t resstat_values[dns_resstatscounter_max]; uint64_t resstat_values[dns_resstatscounter_max];
isc_uint64_t adbstat_values[dns_adbstats_max]; uint64_t adbstat_values[dns_adbstats_max];
isc_uint64_t zonestat_values[dns_zonestatscounter_max]; uint64_t zonestat_values[dns_zonestatscounter_max];
isc_uint64_t sockstat_values[isc_sockstatscounter_max]; uint64_t sockstat_values[isc_sockstatscounter_max];
isc_uint64_t udpinsizestat_values[dns_sizecounter_in_max]; uint64_t udpinsizestat_values[dns_sizecounter_in_max];
isc_uint64_t udpoutsizestat_values[dns_sizecounter_out_max]; uint64_t udpoutsizestat_values[dns_sizecounter_out_max];
isc_uint64_t tcpinsizestat_values[dns_sizecounter_in_max]; uint64_t tcpinsizestat_values[dns_sizecounter_in_max];
isc_uint64_t tcpoutsizestat_values[dns_sizecounter_out_max]; uint64_t tcpoutsizestat_values[dns_sizecounter_out_max];
#ifdef HAVE_DNSTAP #ifdef HAVE_DNSTAP
isc_uint64_t dnstapstat_values[dns_dnstapcounter_max]; uint64_t dnstapstat_values[dns_dnstapcounter_max];
#endif #endif
isc_result_t result; isc_result_t result;
@@ -1915,7 +1918,7 @@ generatexml(named_server_t *server, isc_uint32_t flags,
if ((flags & STATS_XML_ZONES) != 0) { if ((flags & STATS_XML_ZONES) != 0) {
TRY0(xmlTextWriterStartElement(writer, TRY0(xmlTextWriterStartElement(writer,
ISC_XMLCHAR "zones")); ISC_XMLCHAR "zones"));
result = dns_zt_apply(view->zonetable, ISC_TRUE, result = dns_zt_apply(view->zonetable, true,
NULL, zone_xmlrender, writer); NULL, zone_xmlrender, writer);
if (result != ISC_R_SUCCESS) if (result != ISC_R_SUCCESS)
goto error; goto error;
@@ -2053,7 +2056,7 @@ wrap_xmlfree(isc_buffer_t *buffer, void *arg) {
} }
static isc_result_t 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, const char *querystring, const char *headers, void *arg,
unsigned int *retcode, const char **retmsg, unsigned int *retcode, const char **retmsg,
const char **mimetype, isc_buffer_t *b, const char **mimetype, isc_buffer_t *b,
@@ -2228,7 +2231,7 @@ wrap_jsonfree(isc_buffer_t *buffer, void *arg) {
static json_object * static json_object *
addzone(char *name, char *classname, const char *ztype, addzone(char *name, char *classname, const char *ztype,
isc_uint32_t serial, isc_boolean_t add_serial) uint32_t serial, bool add_serial)
{ {
json_object *node = json_object_new_object(); json_object *node = json_object_new_object();
@@ -2255,7 +2258,7 @@ zone_jsonrender(dns_zone_t *zone, void *arg) {
char *zone_name_only = NULL; char *zone_name_only = NULL;
char *class_only = NULL; char *class_only = NULL;
dns_rdataclass_t rdclass; dns_rdataclass_t rdclass;
isc_uint32_t serial; uint32_t serial;
json_object *zonearray = (json_object *) arg; json_object *zonearray = (json_object *) arg;
json_object *zoneobj = NULL; json_object *zoneobj = NULL;
dns_zonestat_level_t statlevel; dns_zonestat_level_t statlevel;
@@ -2273,10 +2276,10 @@ zone_jsonrender(dns_zone_t *zone, void *arg) {
if (dns_zone_getserial(zone, &serial) != ISC_R_SUCCESS) if (dns_zone_getserial(zone, &serial) != ISC_R_SUCCESS)
zoneobj = addzone(zone_name_only, class_only, zoneobj = addzone(zone_name_only, class_only,
user_zonetype(zone), 0, ISC_FALSE); user_zonetype(zone), 0, false);
else else
zoneobj = addzone(zone_name_only, class_only, zoneobj = addzone(zone_name_only, class_only,
user_zonetype(zone), serial, ISC_TRUE); user_zonetype(zone), serial, true);
if (zoneobj == NULL) if (zoneobj == NULL)
return (ISC_R_NOMEMORY); return (ISC_R_NOMEMORY);
@@ -2285,8 +2288,8 @@ zone_jsonrender(dns_zone_t *zone, void *arg) {
isc_stats_t *zonestats; isc_stats_t *zonestats;
isc_stats_t *gluecachestats; isc_stats_t *gluecachestats;
dns_stats_t *rcvquerystats; dns_stats_t *rcvquerystats;
isc_uint64_t nsstat_values[ns_statscounter_max]; uint64_t nsstat_values[ns_statscounter_max];
isc_uint64_t gluecachestats_values[dns_gluecachestatscounter_max]; uint64_t gluecachestats_values[dns_gluecachestatscounter_max];
zonestats = dns_zone_getrequeststats(zone); zonestats = dns_zone_getrequeststats(zone);
if (zonestats != NULL) { if (zonestats != NULL) {
@@ -2376,7 +2379,7 @@ zone_jsonrender(dns_zone_t *zone, void *arg) {
static isc_result_t static isc_result_t
generatejson(named_server_t *server, size_t *msglen, generatejson(named_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; dns_view_t *view;
isc_result_t result = ISC_R_SUCCESS; isc_result_t result = ISC_R_SUCCESS;
@@ -2386,17 +2389,17 @@ generatejson(named_server_t *server, size_t *msglen,
json_object *tcpreq4 = NULL, *tcpresp4 = NULL; json_object *tcpreq4 = NULL, *tcpresp4 = NULL;
json_object *udpreq6 = NULL, *udpresp6 = NULL; json_object *udpreq6 = NULL, *udpresp6 = NULL;
json_object *tcpreq6 = NULL, *tcpresp6 = NULL; json_object *tcpreq6 = NULL, *tcpresp6 = NULL;
isc_uint64_t nsstat_values[ns_statscounter_max]; uint64_t nsstat_values[ns_statscounter_max];
isc_uint64_t resstat_values[dns_resstatscounter_max]; uint64_t resstat_values[dns_resstatscounter_max];
isc_uint64_t adbstat_values[dns_adbstats_max]; uint64_t adbstat_values[dns_adbstats_max];
isc_uint64_t zonestat_values[dns_zonestatscounter_max]; uint64_t zonestat_values[dns_zonestatscounter_max];
isc_uint64_t sockstat_values[isc_sockstatscounter_max]; uint64_t sockstat_values[isc_sockstatscounter_max];
isc_uint64_t udpinsizestat_values[dns_sizecounter_in_max]; uint64_t udpinsizestat_values[dns_sizecounter_in_max];
isc_uint64_t udpoutsizestat_values[dns_sizecounter_out_max]; uint64_t udpoutsizestat_values[dns_sizecounter_out_max];
isc_uint64_t tcpinsizestat_values[dns_sizecounter_in_max]; uint64_t tcpinsizestat_values[dns_sizecounter_in_max];
isc_uint64_t tcpoutsizestat_values[dns_sizecounter_out_max]; uint64_t tcpoutsizestat_values[dns_sizecounter_out_max];
#ifdef HAVE_DNSTAP #ifdef HAVE_DNSTAP
isc_uint64_t dnstapstat_values[dns_dnstapcounter_max]; uint64_t dnstapstat_values[dns_dnstapcounter_max];
#endif #endif
stats_dumparg_t dumparg; stats_dumparg_t dumparg;
char boottime[sizeof "yyyy-mm-ddThh:mm:ss.sssZ"]; char boottime[sizeof "yyyy-mm-ddThh:mm:ss.sssZ"];
@@ -2610,7 +2613,7 @@ generatejson(named_server_t *server, size_t *msglen,
if ((flags & STATS_JSON_ZONES) != 0) { if ((flags & STATS_JSON_ZONES) != 0) {
result = dns_zt_apply(view->zonetable, result = dns_zt_apply(view->zonetable,
ISC_TRUE, true,
NULL, zone_jsonrender, NULL, zone_jsonrender,
za); za);
if (result != ISC_R_SUCCESS) { if (result != ISC_R_SUCCESS) {
@@ -2955,7 +2958,7 @@ generatejson(named_server_t *server, size_t *msglen,
} }
static isc_result_t static isc_result_t
render_json(isc_uint32_t flags, render_json(uint32_t flags,
const char *url, isc_httpdurl_t *urlinfo, const char *url, isc_httpdurl_t *urlinfo,
const char *querystring, const char *headers, const char *querystring, const char *headers,
void *arg, unsigned int *retcode, const char **retmsg, void *arg, unsigned int *retcode, const char **retmsg,
@@ -3182,7 +3185,7 @@ shutdown_listener(named_statschannel_t *listener) {
isc_httpdmgr_shutdown(&listener->httpdmgr); isc_httpdmgr_shutdown(&listener->httpdmgr);
} }
static isc_boolean_t static bool
client_ok(const isc_sockaddr_t *fromaddr, void *arg) { client_ok(const isc_sockaddr_t *fromaddr, void *arg) {
named_statschannel_t *listener = arg; named_statschannel_t *listener = arg;
dns_aclenv_t *env = dns_aclenv_t *env =
@@ -3200,7 +3203,7 @@ client_ok(const isc_sockaddr_t *fromaddr, void *arg) {
&match, NULL) == ISC_R_SUCCESS) && match > 0) &match, NULL) == ISC_R_SUCCESS) && match > 0)
{ {
UNLOCK(&listener->lock); UNLOCK(&listener->lock);
return (ISC_TRUE); return (true);
} }
UNLOCK(&listener->lock); UNLOCK(&listener->lock);
@@ -3209,7 +3212,7 @@ client_ok(const isc_sockaddr_t *fromaddr, void *arg) {
NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING, NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
"rejected statistics connection from %s", socktext); "rejected statistics connection from %s", socktext);
return (ISC_FALSE); return (false);
} }
static void static void
@@ -3281,7 +3284,7 @@ add_listener(named_server_t *server, named_statschannel_t **listenerp,
isc_socket_setname(sock, "statchannel", NULL); isc_socket_setname(sock, "statchannel", NULL);
#ifndef ISC_ALLOW_MAPPED #ifndef ISC_ALLOW_MAPPED
isc_socket_ipv6only(sock, ISC_TRUE); isc_socket_ipv6only(sock, true);
#endif #endif
result = isc_socket_bind(sock, addr, ISC_SOCKET_REUSEADDRESS); result = isc_socket_bind(sock, addr, ISC_SOCKET_REUSEADDRESS);
@@ -3336,7 +3339,7 @@ add_listener(named_server_t *server, named_statschannel_t **listenerp,
isc_httpdmgr_addurl(listener->httpdmgr, "/json/v1/traffic", isc_httpdmgr_addurl(listener->httpdmgr, "/json/v1/traffic",
render_json_traffic, server); render_json_traffic, server);
#endif #endif
isc_httpdmgr_addurl2(listener->httpdmgr, "/bind9.xsl", ISC_TRUE, isc_httpdmgr_addurl2(listener->httpdmgr, "/bind9.xsl", true,
render_xsl, server); render_xsl, server);
*listenerp = listener; *listenerp = listener;
@@ -3566,12 +3569,12 @@ named_stats_dump(named_server_t *server, FILE *fp) {
dns_view_t *view; dns_view_t *view;
dns_zone_t *zone, *next; dns_zone_t *zone, *next;
stats_dumparg_t dumparg; stats_dumparg_t dumparg;
isc_uint64_t nsstat_values[ns_statscounter_max]; uint64_t nsstat_values[ns_statscounter_max];
isc_uint64_t resstat_values[dns_resstatscounter_max]; uint64_t resstat_values[dns_resstatscounter_max];
isc_uint64_t adbstat_values[dns_adbstats_max]; uint64_t adbstat_values[dns_adbstats_max];
isc_uint64_t zonestat_values[dns_zonestatscounter_max]; uint64_t zonestat_values[dns_zonestatscounter_max];
isc_uint64_t sockstat_values[isc_sockstatscounter_max]; uint64_t sockstat_values[isc_sockstatscounter_max];
isc_uint64_t gluecachestats_values[dns_gluecachestatscounter_max]; uint64_t gluecachestats_values[dns_gluecachestatscounter_max];
RUNTIME_CHECK(isc_once_do(&once, init_desc) == ISC_R_SUCCESS); RUNTIME_CHECK(isc_once_do(&once, init_desc) == ISC_R_SUCCESS);
+4 -2
View File
@@ -14,6 +14,8 @@
#include <config.h> #include <config.h>
#include <inttypes.h>
#include <isc/buffer.h> #include <isc/buffer.h>
#include <isc/string.h> /* Required for HP/UX (and others?) */ #include <isc/string.h> /* Required for HP/UX (and others?) */
#include <isc/mem.h> #include <isc/mem.h>
@@ -50,7 +52,7 @@ named_tkeyctx_fromconfig(const cfg_obj_t *options, isc_mem_t *mctx,
isc_result_t result; isc_result_t result;
dns_tkeyctx_t *tctx = NULL; dns_tkeyctx_t *tctx = NULL;
const char *s; const char *s;
isc_uint32_t n; uint32_t n;
dns_fixedname_t fname; dns_fixedname_t fname;
dns_name_t *name; dns_name_t *name;
isc_buffer_t b; isc_buffer_t b;
@@ -101,7 +103,7 @@ named_tkeyctx_fromconfig(const cfg_obj_t *options, isc_mem_t *mctx,
isc_buffer_add(&b, strlen(s)); isc_buffer_add(&b, strlen(s));
name = dns_fixedname_initname(&fname); name = dns_fixedname_initname(&fname);
RETERR(dns_name_fromtext(name, &b, dns_rootname, 0, NULL)); RETERR(dns_name_fromtext(name, &b, dns_rootname, 0, NULL));
RETERR(dst_gssapi_acquirecred(name, ISC_FALSE, &tctx->gsscred)); RETERR(dst_gssapi_acquirecred(name, false, &tctx->gsscred));
} }
obj = NULL; obj = NULL;
+4 -2
View File
@@ -14,6 +14,8 @@
#include <config.h> #include <config.h>
#include <inttypes.h>
#include <isc/base64.h> #include <isc/base64.h>
#include <isc/buffer.h> #include <isc/buffer.h>
#include <isc/mem.h> #include <isc/mem.h>
@@ -43,7 +45,7 @@ add_initial_keys(const cfg_obj_t *list, dns_tsig_keyring_t *ring,
int secretlen = 0; int secretlen = 0;
isc_result_t ret; isc_result_t ret;
isc_stdtime_t now; isc_stdtime_t now;
isc_uint16_t bits; uint16_t bits;
for (element = cfg_list_first(list); for (element = cfg_list_first(list);
element != NULL; element != NULL;
@@ -109,7 +111,7 @@ add_initial_keys(const cfg_obj_t *list, dns_tsig_keyring_t *ring,
isc_stdtime_get(&now); isc_stdtime_get(&now);
ret = dns_tsigkey_create(&keyname, alg, secret, secretlen, ret = dns_tsigkey_create(&keyname, alg, secret, secretlen,
ISC_FALSE, NULL, now, now, false, NULL, now, now,
mctx, ring, &tsigkey); mctx, ring, &tsigkey);
isc_mem_put(mctx, secret, secretalloc); isc_mem_put(mctx, secret, secretalloc);
secret = NULL; secret = NULL;
+29 -27
View File
@@ -12,9 +12,11 @@
#include <config.h> #include <config.h>
#include <stdbool.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <inttypes.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h>
#include <dlfcn.h> #include <dlfcn.h>
#include <dns/log.h> #include <dns/log.h>
@@ -43,7 +45,7 @@ typedef struct dlopen_data {
unsigned int flags; unsigned int flags;
isc_mutex_t lock; isc_mutex_t lock;
int version; int version;
isc_boolean_t in_configure; bool in_configure;
dlz_dlopen_version_t *dlz_version; dlz_dlopen_version_t *dlz_version;
dlz_dlopen_create_t *dlz_create; dlz_dlopen_create_t *dlz_create;
@@ -66,14 +68,14 @@ typedef struct dlopen_data {
#define MAYBE_LOCK(cd) \ #define MAYBE_LOCK(cd) \
do { \ do { \
if ((cd->flags & DNS_SDLZFLAG_THREADSAFE) == 0 && \ if ((cd->flags & DNS_SDLZFLAG_THREADSAFE) == 0 && \
cd->in_configure == ISC_FALSE) \ cd->in_configure == false) \
LOCK(&cd->lock); \ LOCK(&cd->lock); \
} while (0) } while (0)
#define MAYBE_UNLOCK(cd) \ #define MAYBE_UNLOCK(cd) \
do { \ do { \
if ((cd->flags & DNS_SDLZFLAG_THREADSAFE) == 0 && \ if ((cd->flags & DNS_SDLZFLAG_THREADSAFE) == 0 && \
cd->in_configure == ISC_FALSE) \ cd->in_configure == false) \
UNLOCK(&cd->lock); \ UNLOCK(&cd->lock); \
} while (0) } while (0)
@@ -193,7 +195,7 @@ dlopen_dlz_lookup(const char *zone, const char *name, void *driverarg,
* Load a symbol from the library * Load a symbol from the library
*/ */
static void * static void *
dl_load_symbol(dlopen_data_t *cd, const char *symbol, isc_boolean_t mandatory) { dl_load_symbol(dlopen_data_t *cd, const char *symbol, bool mandatory) {
void *ptr = dlsym(cd->dl_handle, symbol); void *ptr = dlsym(cd->dl_handle, symbol);
if (ptr == NULL && mandatory) { if (ptr == NULL && mandatory) {
dlopen_log(ISC_LOG_ERROR, dlopen_log(ISC_LOG_ERROR,
@@ -281,13 +283,13 @@ dlopen_dlz_create(const char *dlzname, unsigned int argc, char *argv[],
/* Find the symbols */ /* Find the symbols */
cd->dlz_version = (dlz_dlopen_version_t *) cd->dlz_version = (dlz_dlopen_version_t *)
dl_load_symbol(cd, "dlz_version", ISC_TRUE); dl_load_symbol(cd, "dlz_version", true);
cd->dlz_create = (dlz_dlopen_create_t *) cd->dlz_create = (dlz_dlopen_create_t *)
dl_load_symbol(cd, "dlz_create", ISC_TRUE); dl_load_symbol(cd, "dlz_create", true);
cd->dlz_lookup = (dlz_dlopen_lookup_t *) cd->dlz_lookup = (dlz_dlopen_lookup_t *)
dl_load_symbol(cd, "dlz_lookup", ISC_TRUE); dl_load_symbol(cd, "dlz_lookup", true);
cd->dlz_findzonedb = (dlz_dlopen_findzonedb_t *) cd->dlz_findzonedb = (dlz_dlopen_findzonedb_t *)
dl_load_symbol(cd, "dlz_findzonedb", ISC_TRUE); dl_load_symbol(cd, "dlz_findzonedb", true);
if (cd->dlz_create == NULL || if (cd->dlz_create == NULL ||
cd->dlz_version == NULL || cd->dlz_version == NULL ||
@@ -300,29 +302,29 @@ dlopen_dlz_create(const char *dlzname, unsigned int argc, char *argv[],
} }
cd->dlz_allowzonexfr = (dlz_dlopen_allowzonexfr_t *) cd->dlz_allowzonexfr = (dlz_dlopen_allowzonexfr_t *)
dl_load_symbol(cd, "dlz_allowzonexfr", ISC_FALSE); dl_load_symbol(cd, "dlz_allowzonexfr", false);
cd->dlz_allnodes = (dlz_dlopen_allnodes_t *) cd->dlz_allnodes = (dlz_dlopen_allnodes_t *)
dl_load_symbol(cd, "dlz_allnodes", dl_load_symbol(cd, "dlz_allnodes",
ISC_TF(cd->dlz_allowzonexfr != NULL)); (cd->dlz_allowzonexfr != NULL));
cd->dlz_authority = (dlz_dlopen_authority_t *) cd->dlz_authority = (dlz_dlopen_authority_t *)
dl_load_symbol(cd, "dlz_authority", ISC_FALSE); dl_load_symbol(cd, "dlz_authority", false);
cd->dlz_newversion = (dlz_dlopen_newversion_t *) cd->dlz_newversion = (dlz_dlopen_newversion_t *)
dl_load_symbol(cd, "dlz_newversion", ISC_FALSE); dl_load_symbol(cd, "dlz_newversion", false);
cd->dlz_closeversion = (dlz_dlopen_closeversion_t *) cd->dlz_closeversion = (dlz_dlopen_closeversion_t *)
dl_load_symbol(cd, "dlz_closeversion", dl_load_symbol(cd, "dlz_closeversion",
ISC_TF(cd->dlz_newversion != NULL)); (cd->dlz_newversion != NULL));
cd->dlz_configure = (dlz_dlopen_configure_t *) cd->dlz_configure = (dlz_dlopen_configure_t *)
dl_load_symbol(cd, "dlz_configure", ISC_FALSE); dl_load_symbol(cd, "dlz_configure", false);
cd->dlz_ssumatch = (dlz_dlopen_ssumatch_t *) cd->dlz_ssumatch = (dlz_dlopen_ssumatch_t *)
dl_load_symbol(cd, "dlz_ssumatch", ISC_FALSE); dl_load_symbol(cd, "dlz_ssumatch", false);
cd->dlz_addrdataset = (dlz_dlopen_addrdataset_t *) cd->dlz_addrdataset = (dlz_dlopen_addrdataset_t *)
dl_load_symbol(cd, "dlz_addrdataset", ISC_FALSE); dl_load_symbol(cd, "dlz_addrdataset", false);
cd->dlz_subrdataset = (dlz_dlopen_subrdataset_t *) cd->dlz_subrdataset = (dlz_dlopen_subrdataset_t *)
dl_load_symbol(cd, "dlz_subrdataset", ISC_FALSE); dl_load_symbol(cd, "dlz_subrdataset", false);
cd->dlz_delrdataset = (dlz_dlopen_delrdataset_t *) cd->dlz_delrdataset = (dlz_dlopen_delrdataset_t *)
dl_load_symbol(cd, "dlz_delrdataset", ISC_FALSE); dl_load_symbol(cd, "dlz_delrdataset", false);
cd->dlz_destroy = (dlz_dlopen_destroy_t *) cd->dlz_destroy = (dlz_dlopen_destroy_t *)
dl_load_symbol(cd, "dlz_destroy", ISC_FALSE); dl_load_symbol(cd, "dlz_destroy", false);
/* Check the version of the API is the same */ /* Check the version of the API is the same */
cd->version = cd->dlz_version(&cd->flags); cd->version = cd->dlz_version(&cd->flags);
@@ -435,7 +437,7 @@ dlopen_dlz_newversion(const char *zone, void *driverarg, void *dbdata,
* Called to end a transaction * Called to end a transaction
*/ */
static void static void
dlopen_dlz_closeversion(const char *zone, isc_boolean_t commit, dlopen_dlz_closeversion(const char *zone, bool commit,
void *driverarg, void *dbdata, void **versionp) void *driverarg, void *dbdata, void **versionp)
{ {
dlopen_data_t *cd = (dlopen_data_t *) dbdata; dlopen_data_t *cd = (dlopen_data_t *) dbdata;
@@ -468,9 +470,9 @@ dlopen_dlz_configure(dns_view_t *view, dns_dlzdb_t *dlzdb,
return (ISC_R_SUCCESS); return (ISC_R_SUCCESS);
MAYBE_LOCK(cd); MAYBE_LOCK(cd);
cd->in_configure = ISC_TRUE; cd->in_configure = true;
result = cd->dlz_configure(view, dlzdb, cd->dbdata); result = cd->dlz_configure(view, dlzdb, cd->dbdata);
cd->in_configure = ISC_FALSE; cd->in_configure = false;
MAYBE_UNLOCK(cd); MAYBE_UNLOCK(cd);
return (result); return (result);
@@ -480,18 +482,18 @@ dlopen_dlz_configure(dns_view_t *view, dns_dlzdb_t *dlzdb,
/* /*
* Check for authority to change a name. * Check for authority to change a name.
*/ */
static isc_boolean_t static bool
dlopen_dlz_ssumatch(const char *signer, const char *name, const char *tcpaddr, 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) unsigned char *keydata, void *driverarg, void *dbdata)
{ {
dlopen_data_t *cd = (dlopen_data_t *) dbdata; dlopen_data_t *cd = (dlopen_data_t *) dbdata;
isc_boolean_t ret; bool ret;
UNUSED(driverarg); UNUSED(driverarg);
if (cd->dlz_ssumatch == NULL) if (cd->dlz_ssumatch == NULL)
return (ISC_FALSE); return (false);
MAYBE_LOCK(cd); MAYBE_LOCK(cd);
ret = cd->dlz_ssumatch(signer, name, tcpaddr, type, key, keydatalen, ret = cd->dlz_ssumatch(signer, name, tcpaddr, type, key, keydatalen,
+4 -3
View File
@@ -15,6 +15,7 @@
/*! \file */ /*! \file */
#include <pwd.h> #include <pwd.h>
#include <stdbool.h>
#include <isc/types.h> #include <isc/types.h>
@@ -49,12 +50,12 @@ void
named_os_minprivs(void); named_os_minprivs(void);
FILE * FILE *
named_os_openfile(const char *filename, mode_t mode, isc_boolean_t switch_user); named_os_openfile(const char *filename, mode_t mode, bool switch_user);
void void
named_os_writepidfile(const char *filename, isc_boolean_t first_time); named_os_writepidfile(const char *filename, bool first_time);
isc_boolean_t bool
named_os_issingleton(const char *filename); named_os_issingleton(const char *filename);
void void
+53 -52
View File
@@ -13,6 +13,7 @@
#include <config.h> #include <config.h>
#include <stdarg.h> #include <stdarg.h>
#include <stdbool.h>
#include <sys/types.h> /* dev_t FreeBSD 2.1 */ #include <sys/types.h> /* dev_t FreeBSD 2.1 */
#include <sys/stat.h> #include <sys/stat.h>
@@ -22,8 +23,8 @@
#include <ctype.h> #include <ctype.h>
#include <errno.h> #include <errno.h>
#include <grp.h>
#include <fcntl.h> #include <fcntl.h>
#include <grp.h> /* Required for initgroups() on IRIX. */
#include <pwd.h> #include <pwd.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
@@ -39,7 +40,7 @@
#include <isc/print.h> #include <isc/print.h>
#include <isc/resource.h> #include <isc/resource.h>
#include <isc/result.h> #include <isc/result.h>
#include <isc/strerror.h> #include <isc/strerr.h>
#include <isc/string.h> #include <isc/string.h>
#include <named/globals.h> #include <named/globals.h>
@@ -107,13 +108,13 @@ static pid_t mainpid = 0;
#endif #endif
static struct passwd *runas_pw = NULL; static struct passwd *runas_pw = NULL;
static isc_boolean_t done_setuid = ISC_FALSE; static bool done_setuid = false;
static int dfd[2] = { -1, -1 }; static int dfd[2] = { -1, -1 };
#ifdef HAVE_SYS_CAPABILITY_H #ifdef HAVE_SYS_CAPABILITY_H
static isc_boolean_t non_root = ISC_FALSE; static bool non_root = false;
static isc_boolean_t non_root_caps = ISC_FALSE; static bool non_root_caps = false;
#include <sys/capability.h> #include <sys/capability.h>
@@ -129,7 +130,7 @@ linux_setcaps(cap_t caps) {
return; return;
} }
if (cap_set_proc(caps) < 0) { if (cap_set_proc(caps) < 0) {
isc__strerror(errno, strbuf, sizeof(strbuf)); strerror_r(errno, strbuf, sizeof(strbuf));
named_main_earlyfatal("cap_set_proc() failed: %s:" named_main_earlyfatal("cap_set_proc() failed: %s:"
" please ensure that the capset kernel" " please ensure that the capset kernel"
" module is loaded. see insmod(8)", " module is loaded. see insmod(8)",
@@ -145,13 +146,13 @@ linux_setcaps(cap_t caps) {
if (err != -1 && curval) { \ if (err != -1 && curval) { \
err = cap_set_flag(caps, CAP_EFFECTIVE, 1, &capval, CAP_SET); \ err = cap_set_flag(caps, CAP_EFFECTIVE, 1, &capval, CAP_SET); \
if (err == -1) { \ if (err == -1) { \
isc__strerror(errno, strbuf, sizeof(strbuf)); \ strerror_r(errno, strbuf, sizeof(strbuf)); \
named_main_earlyfatal("cap_set_proc failed: %s", strbuf); \ named_main_earlyfatal("cap_set_proc failed: %s", strbuf); \
} \ } \
\ \
err = cap_set_flag(caps, CAP_PERMITTED, 1, &capval, CAP_SET); \ err = cap_set_flag(caps, CAP_PERMITTED, 1, &capval, CAP_SET); \
if (err == -1) { \ if (err == -1) { \
isc__strerror(errno, strbuf, sizeof(strbuf)); \ strerror_r(errno, strbuf, sizeof(strbuf)); \
named_main_earlyfatal("cap_set_proc failed: %s", strbuf); \ named_main_earlyfatal("cap_set_proc failed: %s", strbuf); \
} \ } \
} \ } \
@@ -160,12 +161,12 @@ linux_setcaps(cap_t caps) {
do { \ do { \
caps = cap_init(); \ caps = cap_init(); \
if (caps == NULL) { \ if (caps == NULL) { \
isc__strerror(errno, strbuf, sizeof(strbuf)); \ strerror_r(errno, strbuf, sizeof(strbuf)); \
named_main_earlyfatal("cap_init failed: %s", strbuf); \ named_main_earlyfatal("cap_init failed: %s", strbuf); \
} \ } \
curcaps = cap_get_proc(); \ curcaps = cap_get_proc(); \
if (curcaps == NULL) { \ if (curcaps == NULL) { \
isc__strerror(errno, strbuf, sizeof(strbuf)); \ strerror_r(errno, strbuf, sizeof(strbuf)); \
named_main_earlyfatal("cap_get_proc failed: %s", strbuf); \ named_main_earlyfatal("cap_get_proc failed: %s", strbuf); \
} \ } \
} while (0) } while (0)
@@ -285,13 +286,13 @@ linux_keepcaps(void) {
if (prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0) < 0) { if (prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0) < 0) {
if (errno != EINVAL) { if (errno != EINVAL) {
isc__strerror(errno, strbuf, sizeof(strbuf)); strerror_r(errno, strbuf, sizeof(strbuf));
named_main_earlyfatal("prctl() failed: %s", strbuf); named_main_earlyfatal("prctl() failed: %s", strbuf);
} }
} else { } else {
non_root_caps = ISC_TRUE; non_root_caps = true;
if (getuid() != 0) if (getuid() != 0)
non_root = ISC_TRUE; non_root = true;
} }
} }
#endif #endif
@@ -330,13 +331,13 @@ named_os_daemonize(void) {
char strbuf[ISC_STRERRORSIZE]; char strbuf[ISC_STRERRORSIZE];
if (pipe(dfd) == -1) { if (pipe(dfd) == -1) {
isc__strerror(errno, strbuf, sizeof(strbuf)); strerror_r(errno, strbuf, sizeof(strbuf));
named_main_earlyfatal("pipe(): %s", strbuf); named_main_earlyfatal("pipe(): %s", strbuf);
} }
pid = fork(); pid = fork();
if (pid == -1) { if (pid == -1) {
isc__strerror(errno, strbuf, sizeof(strbuf)); strerror_r(errno, strbuf, sizeof(strbuf));
named_main_earlyfatal("fork(): %s", strbuf); named_main_earlyfatal("fork(): %s", strbuf);
} }
if (pid != 0) { if (pid != 0) {
@@ -366,7 +367,7 @@ named_os_daemonize(void) {
#endif #endif
if (setsid() == -1) { if (setsid() == -1) {
isc__strerror(errno, strbuf, sizeof(strbuf)); strerror_r(errno, strbuf, sizeof(strbuf));
named_main_earlyfatal("setsid(): %s", strbuf); named_main_earlyfatal("setsid(): %s", strbuf);
} }
@@ -428,16 +429,16 @@ named_os_closedevnull(void) {
} }
} }
static isc_boolean_t static bool
all_digits(const char *s) { all_digits(const char *s) {
if (*s == '\0') if (*s == '\0')
return (ISC_FALSE); return (false);
while (*s != '\0') { while (*s != '\0') {
if (!isdigit((*s)&0xff)) if (!isdigit((*s)&0xff))
return (ISC_FALSE); return (false);
s++; s++;
} }
return (ISC_TRUE); return (true);
} }
void void
@@ -449,14 +450,14 @@ named_os_chroot(const char *root) {
if (root != NULL) { if (root != NULL) {
#ifdef HAVE_CHROOT #ifdef HAVE_CHROOT
if (chroot(root) < 0) { if (chroot(root) < 0) {
isc__strerror(errno, strbuf, sizeof(strbuf)); strerror_r(errno, strbuf, sizeof(strbuf));
named_main_earlyfatal("chroot(): %s", strbuf); named_main_earlyfatal("chroot(): %s", strbuf);
} }
#else #else
named_main_earlyfatal("chroot(): disabled"); named_main_earlyfatal("chroot(): disabled");
#endif #endif
if (chdir("/") < 0) { if (chdir("/") < 0) {
isc__strerror(errno, strbuf, sizeof(strbuf)); strerror_r(errno, strbuf, sizeof(strbuf));
named_main_earlyfatal("chdir(/): %s", strbuf); named_main_earlyfatal("chdir(/): %s", strbuf);
} }
#ifdef HAVE_LIBSCF #ifdef HAVE_LIBSCF
@@ -483,7 +484,7 @@ named_os_inituserinfo(const char *username) {
if (getuid() == 0) { if (getuid() == 0) {
if (initgroups(runas_pw->pw_name, runas_pw->pw_gid) < 0) { if (initgroups(runas_pw->pw_name, runas_pw->pw_gid) < 0) {
isc__strerror(errno, strbuf, sizeof(strbuf)); strerror_r(errno, strbuf, sizeof(strbuf));
named_main_earlyfatal("initgroups(): %s", strbuf); named_main_earlyfatal("initgroups(): %s", strbuf);
} }
} }
@@ -496,7 +497,7 @@ named_os_changeuser(void) {
if (runas_pw == NULL || done_setuid) if (runas_pw == NULL || done_setuid)
return; return;
done_setuid = ISC_TRUE; done_setuid = true;
#ifdef HAVE_LINUXTHREADS #ifdef HAVE_LINUXTHREADS
#ifdef HAVE_SYS_CAPABILITY_H #ifdef HAVE_SYS_CAPABILITY_H
@@ -513,12 +514,12 @@ named_os_changeuser(void) {
#endif #endif
if (setgid(runas_pw->pw_gid) < 0) { if (setgid(runas_pw->pw_gid) < 0) {
isc__strerror(errno, strbuf, sizeof(strbuf)); strerror_r(errno, strbuf, sizeof(strbuf));
named_main_earlyfatal("setgid(): %s", strbuf); named_main_earlyfatal("setgid(): %s", strbuf);
} }
if (setuid(runas_pw->pw_uid) < 0) { if (setuid(runas_pw->pw_uid) < 0) {
isc__strerror(errno, strbuf, sizeof(strbuf)); strerror_r(errno, strbuf, sizeof(strbuf));
named_main_earlyfatal("setuid(): %s", strbuf); named_main_earlyfatal("setuid(): %s", strbuf);
} }
@@ -528,7 +529,7 @@ named_os_changeuser(void) {
* call has disabled it. * call has disabled it.
*/ */
if (prctl(PR_SET_DUMPABLE,1,0,0,0) < 0) { if (prctl(PR_SET_DUMPABLE,1,0,0,0) < 0) {
isc__strerror(errno, strbuf, sizeof(strbuf)); strerror_r(errno, strbuf, sizeof(strbuf));
named_main_earlywarning("prctl(PR_SET_DUMPABLE) failed: %s", named_main_earlywarning("prctl(PR_SET_DUMPABLE) failed: %s",
strbuf); strbuf);
} }
@@ -579,7 +580,7 @@ named_os_minprivs(void) {
} }
static int static int
safe_open(const char *filename, mode_t mode, isc_boolean_t append) { safe_open(const char *filename, mode_t mode, bool append) {
int fd; int fd;
struct stat sb; struct stat sb;
@@ -647,7 +648,7 @@ mkdirpath(char *filename, void (*report)(const char *, ...)) {
if (stat(filename, &sb) == -1) { if (stat(filename, &sb) == -1) {
if (errno != ENOENT) { if (errno != ENOENT) {
isc__strerror(errno, strbuf, sizeof(strbuf)); strerror_r(errno, strbuf, sizeof(strbuf));
(*report)("couldn't stat '%s': %s", filename, (*report)("couldn't stat '%s': %s", filename,
strbuf); strbuf);
goto error; goto error;
@@ -667,7 +668,7 @@ mkdirpath(char *filename, void (*report)(const char *, ...)) {
mode |= S_IRGRP | S_IXGRP; /* g=rx */ mode |= S_IRGRP | S_IXGRP; /* g=rx */
mode |= S_IROTH | S_IXOTH; /* o=rx */ mode |= S_IROTH | S_IXOTH; /* o=rx */
if (mkdir(filename, mode) == -1) { if (mkdir(filename, mode) == -1) {
isc__strerror(errno, strbuf, sizeof(strbuf)); strerror_r(errno, strbuf, sizeof(strbuf));
(*report)("couldn't mkdir '%s': %s", filename, (*report)("couldn't mkdir '%s': %s", filename,
strbuf); strbuf);
goto error; goto error;
@@ -675,7 +676,7 @@ mkdirpath(char *filename, void (*report)(const char *, ...)) {
if (runas_pw != NULL && if (runas_pw != NULL &&
chown(filename, runas_pw->pw_uid, chown(filename, runas_pw->pw_uid,
runas_pw->pw_gid) == -1) { runas_pw->pw_gid) == -1) {
isc__strerror(errno, strbuf, sizeof(strbuf)); strerror_r(errno, strbuf, sizeof(strbuf));
(*report)("couldn't chown '%s': %s", filename, (*report)("couldn't chown '%s': %s", filename,
strbuf); strbuf);
} }
@@ -702,7 +703,7 @@ setperms(uid_t uid, gid_t gid) {
#endif #endif
#if defined(HAVE_SETEGID) #if defined(HAVE_SETEGID)
if (getegid() != gid && setegid(gid) == -1) { if (getegid() != gid && setegid(gid) == -1) {
isc__strerror(errno, strbuf, sizeof(strbuf)); strerror_r(errno, strbuf, sizeof(strbuf));
named_main_earlywarning("unable to set effective " named_main_earlywarning("unable to set effective "
"gid to %ld: %s", "gid to %ld: %s",
(long)gid, strbuf); (long)gid, strbuf);
@@ -710,7 +711,7 @@ setperms(uid_t uid, gid_t gid) {
#elif defined(HAVE_SETRESGID) #elif defined(HAVE_SETRESGID)
if (getresgid(&tmpg, &oldgid, &tmpg) == -1 || oldgid != gid) { if (getresgid(&tmpg, &oldgid, &tmpg) == -1 || oldgid != gid) {
if (setresgid(-1, gid, -1) == -1) { if (setresgid(-1, gid, -1) == -1) {
isc__strerror(errno, strbuf, sizeof(strbuf)); strerror_r(errno, strbuf, sizeof(strbuf));
named_main_earlywarning("unable to set effective " named_main_earlywarning("unable to set effective "
"gid to %d: %s", gid, strbuf); "gid to %d: %s", gid, strbuf);
} }
@@ -719,7 +720,7 @@ setperms(uid_t uid, gid_t gid) {
#if defined(HAVE_SETEUID) #if defined(HAVE_SETEUID)
if (geteuid() != uid && seteuid(uid) == -1) { if (geteuid() != uid && seteuid(uid) == -1) {
isc__strerror(errno, strbuf, sizeof(strbuf)); strerror_r(errno, strbuf, sizeof(strbuf));
named_main_earlywarning("unable to set effective " named_main_earlywarning("unable to set effective "
"uid to %ld: %s", "uid to %ld: %s",
(long)uid, strbuf); (long)uid, strbuf);
@@ -727,7 +728,7 @@ setperms(uid_t uid, gid_t gid) {
#elif defined(HAVE_SETRESUID) #elif defined(HAVE_SETRESUID)
if (getresuid(&tmpu, &olduid, &tmpu) == -1 || olduid != uid) { if (getresuid(&tmpu, &olduid, &tmpu) == -1 || olduid != uid) {
if (setresuid(-1, uid, -1) == -1) { if (setresuid(-1, uid, -1) == -1) {
isc__strerror(errno, strbuf, sizeof(strbuf)); strerror_r(errno, strbuf, sizeof(strbuf));
named_main_earlywarning("unable to set effective " named_main_earlywarning("unable to set effective "
"uid to %d: %s", uid, strbuf); "uid to %d: %s", uid, strbuf);
} }
@@ -736,7 +737,7 @@ setperms(uid_t uid, gid_t gid) {
} }
FILE * FILE *
named_os_openfile(const char *filename, mode_t mode, isc_boolean_t switch_user) { named_os_openfile(const char *filename, mode_t mode, bool switch_user) {
char strbuf[ISC_STRERRORSIZE], *f; char strbuf[ISC_STRERRORSIZE], *f;
FILE *fp; FILE *fp;
int fd; int fd;
@@ -746,7 +747,7 @@ named_os_openfile(const char *filename, mode_t mode, isc_boolean_t switch_user)
*/ */
f = strdup(filename); f = strdup(filename);
if (f == NULL) { if (f == NULL) {
isc__strerror(errno, strbuf, sizeof(strbuf)); strerror_r(errno, strbuf, sizeof(strbuf));
named_main_earlywarning("couldn't strdup() '%s': %s", named_main_earlywarning("couldn't strdup() '%s': %s",
filename, strbuf); filename, strbuf);
return (NULL); return (NULL);
@@ -764,7 +765,7 @@ named_os_openfile(const char *filename, mode_t mode, isc_boolean_t switch_user)
/* Set UID/GID to the one we'll be running with eventually */ /* Set UID/GID to the one we'll be running with eventually */
setperms(runas_pw->pw_uid, runas_pw->pw_gid); setperms(runas_pw->pw_uid, runas_pw->pw_gid);
fd = safe_open(filename, mode, ISC_FALSE); fd = safe_open(filename, mode, false);
#ifndef HAVE_LINUXTHREADS #ifndef HAVE_LINUXTHREADS
/* Restore UID/GID to root */ /* Restore UID/GID to root */
@@ -773,7 +774,7 @@ named_os_openfile(const char *filename, mode_t mode, isc_boolean_t switch_user)
if (fd == -1) { if (fd == -1) {
#ifndef HAVE_LINUXTHREADS #ifndef HAVE_LINUXTHREADS
fd = safe_open(filename, mode, ISC_FALSE); fd = safe_open(filename, mode, false);
if (fd != -1) { if (fd != -1) {
named_main_earlywarning("Required root " named_main_earlywarning("Required root "
"permissions to open " "permissions to open "
@@ -794,11 +795,11 @@ named_os_openfile(const char *filename, mode_t mode, isc_boolean_t switch_user)
#endif /* HAVE_LINUXTHREADS */ #endif /* HAVE_LINUXTHREADS */
} }
} else { } else {
fd = safe_open(filename, mode, ISC_FALSE); fd = safe_open(filename, mode, false);
} }
if (fd < 0) { if (fd < 0) {
isc__strerror(errno, strbuf, sizeof(strbuf)); strerror_r(errno, strbuf, sizeof(strbuf));
named_main_earlywarning("could not open file '%s': %s", named_main_earlywarning("could not open file '%s': %s",
filename, strbuf); filename, strbuf);
return (NULL); return (NULL);
@@ -806,7 +807,7 @@ named_os_openfile(const char *filename, mode_t mode, isc_boolean_t switch_user)
fp = fdopen(fd, "w"); fp = fdopen(fd, "w");
if (fp == NULL) { if (fp == NULL) {
isc__strerror(errno, strbuf, sizeof(strbuf)); strerror_r(errno, strbuf, sizeof(strbuf));
named_main_earlywarning("could not fdopen() file '%s': %s", named_main_earlywarning("could not fdopen() file '%s': %s",
filename, strbuf); filename, strbuf);
} }
@@ -815,7 +816,7 @@ named_os_openfile(const char *filename, mode_t mode, isc_boolean_t switch_user)
} }
void void
named_os_writepidfile(const char *filename, isc_boolean_t first_time) { named_os_writepidfile(const char *filename, bool first_time) {
FILE *fh; FILE *fh;
pid_t pid; pid_t pid;
char strbuf[ISC_STRERRORSIZE]; char strbuf[ISC_STRERRORSIZE];
@@ -834,7 +835,7 @@ named_os_writepidfile(const char *filename, isc_boolean_t first_time) {
pidfile = strdup(filename); pidfile = strdup(filename);
if (pidfile == NULL) { if (pidfile == NULL) {
isc__strerror(errno, strbuf, sizeof(strbuf)); strerror_r(errno, strbuf, sizeof(strbuf));
(*report)("couldn't strdup() '%s': %s", filename, strbuf); (*report)("couldn't strdup() '%s': %s", filename, strbuf);
return; return;
} }
@@ -865,23 +866,23 @@ named_os_writepidfile(const char *filename, isc_boolean_t first_time) {
(void)fclose(fh); (void)fclose(fh);
} }
isc_boolean_t bool
named_os_issingleton(const char *filename) { named_os_issingleton(const char *filename) {
char strbuf[ISC_STRERRORSIZE]; char strbuf[ISC_STRERRORSIZE];
struct flock lock; struct flock lock;
if (singletonfd != -1) if (singletonfd != -1)
return (ISC_TRUE); return (true);
if (strcasecmp(filename, "none") == 0) if (strcasecmp(filename, "none") == 0)
return (ISC_TRUE); return (true);
/* /*
* Make the containing directory if it doesn't exist. * Make the containing directory if it doesn't exist.
*/ */
lockfile = strdup(filename); lockfile = strdup(filename);
if (lockfile == NULL) { if (lockfile == NULL) {
isc__strerror(errno, strbuf, sizeof(strbuf)); strerror_r(errno, strbuf, sizeof(strbuf));
named_main_earlyfatal("couldn't allocate memory for '%s': %s", named_main_earlyfatal("couldn't allocate memory for '%s': %s",
filename, strbuf); filename, strbuf);
} else { } else {
@@ -890,7 +891,7 @@ named_os_issingleton(const char *filename) {
named_main_earlywarning("couldn't create '%s'", named_main_earlywarning("couldn't create '%s'",
filename); filename);
cleanup_lockfile(); cleanup_lockfile();
return (ISC_FALSE); return (false);
} }
} }
@@ -902,7 +903,7 @@ named_os_issingleton(const char *filename) {
S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH); S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
if (singletonfd == -1) { if (singletonfd == -1) {
cleanup_lockfile(); cleanup_lockfile();
return (ISC_FALSE); return (false);
} }
memset(&lock, 0, sizeof(lock)); memset(&lock, 0, sizeof(lock));
@@ -915,10 +916,10 @@ named_os_issingleton(const char *filename) {
if (fcntl(singletonfd, F_SETLK, &lock) == -1) { if (fcntl(singletonfd, F_SETLK, &lock) == -1) {
close(singletonfd); close(singletonfd);
singletonfd = -1; singletonfd = -1;
return (ISC_FALSE); return (false);
} }
return (ISC_TRUE); return (true);
} }
void void
+30 -28
View File
@@ -14,9 +14,11 @@
#include <windows.h> #include <windows.h>
#include <stdbool.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <inttypes.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h>
#include <dns/log.h> #include <dns/log.h>
#include <dns/result.h> #include <dns/result.h>
@@ -44,7 +46,7 @@ typedef struct dlopen_data {
unsigned int flags; unsigned int flags;
isc_mutex_t lock; isc_mutex_t lock;
int version; int version;
isc_boolean_t in_configure; bool in_configure;
dlz_dlopen_version_t *dlz_version; dlz_dlopen_version_t *dlz_version;
dlz_dlopen_create_t *dlz_create; dlz_dlopen_create_t *dlz_create;
@@ -67,14 +69,14 @@ typedef struct dlopen_data {
#define MAYBE_LOCK(cd) \ #define MAYBE_LOCK(cd) \
do { \ do { \
if ((cd->flags & DNS_SDLZFLAG_THREADSAFE) == 0 && \ if ((cd->flags & DNS_SDLZFLAG_THREADSAFE) == 0 && \
cd->in_configure == ISC_FALSE) \ cd->in_configure == false) \
LOCK(&cd->lock); \ LOCK(&cd->lock); \
} while (0) } while (0)
#define MAYBE_UNLOCK(cd) \ #define MAYBE_UNLOCK(cd) \
do { \ do { \
if ((cd->flags & DNS_SDLZFLAG_THREADSAFE) == 0 && \ if ((cd->flags & DNS_SDLZFLAG_THREADSAFE) == 0 && \
cd->in_configure == ISC_FALSE) \ cd->in_configure == false) \
UNLOCK(&cd->lock); \ UNLOCK(&cd->lock); \
} while (0) } while (0)
@@ -194,7 +196,7 @@ dlopen_dlz_lookup(const char *zone, const char *name, void *driverarg,
* Load a symbol from the library * Load a symbol from the library
*/ */
static void * static void *
dl_load_symbol(dlopen_data_t *cd, const char *symbol, isc_boolean_t mandatory) { dl_load_symbol(dlopen_data_t *cd, const char *symbol, bool mandatory) {
void *ptr = GetProcAddress(cd->dl_handle, symbol); void *ptr = GetProcAddress(cd->dl_handle, symbol);
if (ptr == NULL && mandatory) { if (ptr == NULL && mandatory) {
dlopen_log(ISC_LOG_ERROR, dlopen_log(ISC_LOG_ERROR,
@@ -214,7 +216,7 @@ dlopen_dlz_create(const char *dlzname, unsigned int argc, char *argv[],
dlopen_data_t *cd; dlopen_data_t *cd;
isc_mem_t *mctx = NULL; isc_mem_t *mctx = NULL;
isc_result_t result = ISC_R_FAILURE; isc_result_t result = ISC_R_FAILURE;
isc_boolean_t triedload = ISC_FALSE; bool triedload = false;
UNUSED(driverarg); UNUSED(driverarg);
@@ -248,7 +250,7 @@ dlopen_dlz_create(const char *dlzname, unsigned int argc, char *argv[],
goto failed; goto failed;
} }
triedload = ISC_TRUE; triedload = true;
/* Initialize the lock */ /* Initialize the lock */
result = isc_mutex_init(&cd->lock); result = isc_mutex_init(&cd->lock);
@@ -269,13 +271,13 @@ dlopen_dlz_create(const char *dlzname, unsigned int argc, char *argv[],
/* Find the symbols */ /* Find the symbols */
cd->dlz_version = (dlz_dlopen_version_t *) cd->dlz_version = (dlz_dlopen_version_t *)
dl_load_symbol(cd, "dlz_version", ISC_TRUE); dl_load_symbol(cd, "dlz_version", true);
cd->dlz_create = (dlz_dlopen_create_t *) cd->dlz_create = (dlz_dlopen_create_t *)
dl_load_symbol(cd, "dlz_create", ISC_TRUE); dl_load_symbol(cd, "dlz_create", true);
cd->dlz_lookup = (dlz_dlopen_lookup_t *) cd->dlz_lookup = (dlz_dlopen_lookup_t *)
dl_load_symbol(cd, "dlz_lookup", ISC_TRUE); dl_load_symbol(cd, "dlz_lookup", true);
cd->dlz_findzonedb = (dlz_dlopen_findzonedb_t *) cd->dlz_findzonedb = (dlz_dlopen_findzonedb_t *)
dl_load_symbol(cd, "dlz_findzonedb", ISC_TRUE); dl_load_symbol(cd, "dlz_findzonedb", true);
if (cd->dlz_create == NULL || if (cd->dlz_create == NULL ||
cd->dlz_version == NULL || cd->dlz_version == NULL ||
@@ -288,27 +290,27 @@ dlopen_dlz_create(const char *dlzname, unsigned int argc, char *argv[],
} }
cd->dlz_allowzonexfr = (dlz_dlopen_allowzonexfr_t *) cd->dlz_allowzonexfr = (dlz_dlopen_allowzonexfr_t *)
dl_load_symbol(cd, "dlz_allowzonexfr", ISC_FALSE); dl_load_symbol(cd, "dlz_allowzonexfr", false);
cd->dlz_allnodes = (dlz_dlopen_allnodes_t *) cd->dlz_allnodes = (dlz_dlopen_allnodes_t *)
dl_load_symbol(cd, "dlz_allnodes", dl_load_symbol(cd, "dlz_allnodes",
ISC_TF(cd->dlz_allowzonexfr != NULL)); (cd->dlz_allowzonexfr != NULL));
cd->dlz_authority = (dlz_dlopen_authority_t *) cd->dlz_authority = (dlz_dlopen_authority_t *)
dl_load_symbol(cd, "dlz_authority", ISC_FALSE); dl_load_symbol(cd, "dlz_authority", false);
cd->dlz_newversion = (dlz_dlopen_newversion_t *) cd->dlz_newversion = (dlz_dlopen_newversion_t *)
dl_load_symbol(cd, "dlz_newversion", ISC_FALSE); dl_load_symbol(cd, "dlz_newversion", false);
cd->dlz_closeversion = (dlz_dlopen_closeversion_t *) cd->dlz_closeversion = (dlz_dlopen_closeversion_t *)
dl_load_symbol(cd, "dlz_closeversion", dl_load_symbol(cd, "dlz_closeversion",
ISC_TF(cd->dlz_newversion != NULL)); (cd->dlz_newversion != NULL));
cd->dlz_configure = (dlz_dlopen_configure_t *) cd->dlz_configure = (dlz_dlopen_configure_t *)
dl_load_symbol(cd, "dlz_configure", ISC_FALSE); dl_load_symbol(cd, "dlz_configure", false);
cd->dlz_ssumatch = (dlz_dlopen_ssumatch_t *) cd->dlz_ssumatch = (dlz_dlopen_ssumatch_t *)
dl_load_symbol(cd, "dlz_ssumatch", ISC_FALSE); dl_load_symbol(cd, "dlz_ssumatch", false);
cd->dlz_addrdataset = (dlz_dlopen_addrdataset_t *) cd->dlz_addrdataset = (dlz_dlopen_addrdataset_t *)
dl_load_symbol(cd, "dlz_addrdataset", ISC_FALSE); dl_load_symbol(cd, "dlz_addrdataset", false);
cd->dlz_subrdataset = (dlz_dlopen_subrdataset_t *) cd->dlz_subrdataset = (dlz_dlopen_subrdataset_t *)
dl_load_symbol(cd, "dlz_subrdataset", ISC_FALSE); dl_load_symbol(cd, "dlz_subrdataset", false);
cd->dlz_delrdataset = (dlz_dlopen_delrdataset_t *) cd->dlz_delrdataset = (dlz_dlopen_delrdataset_t *)
dl_load_symbol(cd, "dlz_delrdataset", ISC_FALSE); dl_load_symbol(cd, "dlz_delrdataset", false);
/* Check the version of the API is the same */ /* Check the version of the API is the same */
cd->version = cd->dlz_version(&cd->flags); cd->version = cd->dlz_version(&cd->flags);
@@ -420,7 +422,7 @@ dlopen_dlz_newversion(const char *zone, void *driverarg, void *dbdata,
* Called to end a transaction * Called to end a transaction
*/ */
static void static void
dlopen_dlz_closeversion(const char *zone, isc_boolean_t commit, dlopen_dlz_closeversion(const char *zone, bool commit,
void *driverarg, void *dbdata, void **versionp) void *driverarg, void *dbdata, void **versionp)
{ {
dlopen_data_t *cd = (dlopen_data_t *) dbdata; dlopen_data_t *cd = (dlopen_data_t *) dbdata;
@@ -453,9 +455,9 @@ dlopen_dlz_configure(dns_view_t *view, dns_dlzdb_t *dlzdb,
return (ISC_R_SUCCESS); return (ISC_R_SUCCESS);
MAYBE_LOCK(cd); MAYBE_LOCK(cd);
cd->in_configure = ISC_TRUE; cd->in_configure = true;
result = cd->dlz_configure(view, dlzdb, cd->dbdata); result = cd->dlz_configure(view, dlzdb, cd->dbdata);
cd->in_configure = ISC_FALSE; cd->in_configure = false;
MAYBE_UNLOCK(cd); MAYBE_UNLOCK(cd);
return (result); return (result);
@@ -465,18 +467,18 @@ dlopen_dlz_configure(dns_view_t *view, dns_dlzdb_t *dlzdb,
/* /*
* Check for authority to change a name * Check for authority to change a name
*/ */
static isc_boolean_t static bool
dlopen_dlz_ssumatch(const char *signer, const char *name, const char *tcpaddr, 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) unsigned char *keydata, void *driverarg, void *dbdata)
{ {
dlopen_data_t *cd = (dlopen_data_t *) dbdata; dlopen_data_t *cd = (dlopen_data_t *) dbdata;
isc_boolean_t ret; bool ret;
UNUSED(driverarg); UNUSED(driverarg);
if (cd->dlz_ssumatch == NULL) if (cd->dlz_ssumatch == NULL)
return (ISC_FALSE); return (false);
MAYBE_LOCK(cd); MAYBE_LOCK(cd);
ret = cd->dlz_ssumatch(signer, name, tcpaddr, type, key, keydatalen, ret = cd->dlz_ssumatch(signer, name, tcpaddr, type, key, keydatalen,
+5 -3
View File
@@ -12,6 +12,8 @@
#ifndef NAMED_OS_H #ifndef NAMED_OS_H
#define NAMED_OS_H 1 #define NAMED_OS_H 1
#include <stdbool.h>
#include <isc/types.h> #include <isc/types.h>
void void
@@ -45,12 +47,12 @@ void
named_os_minprivs(void); named_os_minprivs(void);
FILE * FILE *
named_os_openfile(const char *filename, int mode, isc_boolean_t switch_user); named_os_openfile(const char *filename, int mode, bool switch_user);
void void
named_os_writepidfile(const char *filename, isc_boolean_t first_time); named_os_writepidfile(const char *filename, bool first_time);
isc_boolean_t bool
named_os_issingleton(const char *filename); named_os_issingleton(const char *filename);
void void
+2 -2
View File
@@ -68,7 +68,7 @@
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<AdditionalLibraryDirectories>..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccc\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);..\..\..\lib\ns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccc\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);..\..\..\lib\ns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>@LIBXML2_LIB@@OPENSSL_LIB@@GSSAPI_LIB@@GEOIP_LIB@libisc.lib;libdns.lib;libisccc.lib;libisccfg.lib;libbind9.lib;libns.lib;version.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@@LIBXML2_LIB@@GSSAPI_LIB@@GEOIP_LIB@libisc.lib;libdns.lib;libisccc.lib;libisccfg.lib;libbind9.lib;libns.lib;version.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'"> <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'">
@@ -98,7 +98,7 @@
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration> <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
<AdditionalLibraryDirectories>..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccc\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);..\..\..\lib\ns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccc\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);..\..\..\lib\ns\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>@LIBXML2_LIB@@OPENSSL_LIB@@GSSAPI_LIB@@GEOIP_LIB@libisc.lib;libdns.lib;libisccc.lib;libisccfg.lib;libbind9.lib;libns.lib;version.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@@LIBXML2_LIB@@GSSAPI_LIB@@GEOIP_LIB@libisc.lib;libdns.lib;libisccc.lib;libisccfg.lib;libbind9.lib;libns.lib;version.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemGroup> <ItemGroup>
+3 -3
View File
@@ -80,7 +80,7 @@ ServiceControl(DWORD dwCtrlCode) {
case SERVICE_CONTROL_SHUTDOWN: case SERVICE_CONTROL_SHUTDOWN:
case SERVICE_CONTROL_STOP: case SERVICE_CONTROL_STOP:
named_server_flushonshutdown(named_g_server, ISC_TRUE); named_server_flushonshutdown(named_g_server, true);
isc_app_shutdown(); isc_app_shutdown();
UpdateSCM(SERVICE_STOPPED); UpdateSCM(SERVICE_STOPPED);
break; break;
@@ -131,7 +131,7 @@ int main(int argc, char *argv[])
int rc, ch; int rc, ch;
/* Command line users should put -f in the options. */ /* Command line users should put -f in the options. */
isc_commandline_errprint = ISC_FALSE; isc_commandline_errprint = false;
while ((ch = isc_commandline_parse(argc, argv, while ((ch = isc_commandline_parse(argc, argv,
NAMED_MAIN_ARGS)) != -1) NAMED_MAIN_ARGS)) != -1)
{ {
@@ -146,7 +146,7 @@ int main(int argc, char *argv[])
break; break;
} }
} }
isc_commandline_reset = ISC_TRUE; isc_commandline_reset = true;
if (foreground) { if (foreground) {
/* run in console window */ /* run in console window */
+16 -16
View File
@@ -20,13 +20,13 @@
#include <io.h> #include <io.h>
#include <process.h> #include <process.h>
#include <fcntl.h> #include <fcntl.h>
#include <stdbool.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <syslog.h> #include <syslog.h>
#include <isc/print.h> #include <isc/print.h>
#include <isc/result.h> #include <isc/result.h>
#include <isc/strerror.h>
#include <isc/string.h> #include <isc/string.h>
#include <isc/ntpaths.h> #include <isc/ntpaths.h>
#include <isc/util.h> #include <isc/util.h>
@@ -176,7 +176,7 @@ named_os_minprivs(void) {
} }
static int static int
safe_open(const char *filename, int mode, isc_boolean_t append) { safe_open(const char *filename, int mode, bool append) {
int fd; int fd;
struct stat sb; struct stat sb;
@@ -222,15 +222,15 @@ cleanup_lockfile(void) {
} }
FILE * FILE *
named_os_openfile(const char *filename, int mode, isc_boolean_t switch_user) { named_os_openfile(const char *filename, int mode, bool switch_user) {
char strbuf[ISC_STRERRORSIZE]; char strbuf[ISC_STRERRORSIZE];
FILE *fp; FILE *fp;
int fd; int fd;
UNUSED(switch_user); UNUSED(switch_user);
fd = safe_open(filename, mode, ISC_FALSE); fd = safe_open(filename, mode, false);
if (fd < 0) { if (fd < 0) {
isc__strerror(errno, strbuf, sizeof(strbuf)); strerror_s(strbuf, sizeof(strbuf), errno);
named_main_earlywarning("could not open file '%s': %s", named_main_earlywarning("could not open file '%s': %s",
filename, strbuf); filename, strbuf);
return (NULL); return (NULL);
@@ -238,7 +238,7 @@ named_os_openfile(const char *filename, int mode, isc_boolean_t switch_user) {
fp = fdopen(fd, "w"); fp = fdopen(fd, "w");
if (fp == NULL) { if (fp == NULL) {
isc__strerror(errno, strbuf, sizeof(strbuf)); strerror_s(strbuf, sizeof(strbuf), errno);
named_main_earlywarning("could not fdopen() file '%s': %s", named_main_earlywarning("could not fdopen() file '%s': %s",
filename, strbuf); filename, strbuf);
close(fd); close(fd);
@@ -248,7 +248,7 @@ named_os_openfile(const char *filename, int mode, isc_boolean_t switch_user) {
} }
void void
named_os_writepidfile(const char *filename, isc_boolean_t first_time) { named_os_writepidfile(const char *filename, bool first_time) {
FILE *pidlockfile; FILE *pidlockfile;
pid_t pid; pid_t pid;
char strbuf[ISC_STRERRORSIZE]; char strbuf[ISC_STRERRORSIZE];
@@ -267,14 +267,14 @@ named_os_writepidfile(const char *filename, isc_boolean_t first_time) {
pidfile = strdup(filename); pidfile = strdup(filename);
if (pidfile == NULL) { if (pidfile == NULL) {
isc__strerror(errno, strbuf, sizeof(strbuf)); strerror_s(strbuf, sizeof(strbuf), errno);
(*report)("couldn't strdup() '%s': %s", filename, strbuf); (*report)("couldn't strdup() '%s': %s", filename, strbuf);
return; return;
} }
pidlockfile = named_os_openfile(filename, pidlockfile = named_os_openfile(filename,
S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH,
ISC_FALSE); false);
if (pidlockfile == NULL) { if (pidlockfile == NULL) {
free(pidfile); free(pidfile);
pidfile = NULL; pidfile = NULL;
@@ -298,20 +298,20 @@ named_os_writepidfile(const char *filename, isc_boolean_t first_time) {
(void)fclose(pidlockfile); (void)fclose(pidlockfile);
} }
isc_boolean_t bool
named_os_issingleton(const char *filename) { named_os_issingleton(const char *filename) {
char strbuf[ISC_STRERRORSIZE]; char strbuf[ISC_STRERRORSIZE];
OVERLAPPED o; OVERLAPPED o;
if (lockfilefd != -1) if (lockfilefd != -1)
return (ISC_TRUE); return (true);
if (strcasecmp(filename, "none") == 0) if (strcasecmp(filename, "none") == 0)
return (ISC_TRUE); return (true);
lockfile = strdup(filename); lockfile = strdup(filename);
if (lockfile == NULL) { if (lockfile == NULL) {
isc__strerror(errno, strbuf, sizeof(strbuf)); strerror_s(strbuf, sizeof(strbuf), errno);
named_main_earlyfatal("couldn't allocate memory for '%s': %s", named_main_earlyfatal("couldn't allocate memory for '%s': %s",
filename, strbuf); filename, strbuf);
} }
@@ -324,7 +324,7 @@ named_os_issingleton(const char *filename) {
S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH); S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
if (lockfilefd == -1) { if (lockfilefd == -1) {
cleanup_lockfile(); cleanup_lockfile();
return (ISC_FALSE); return (false);
} }
memset(&o, 0, sizeof(o)); memset(&o, 0, sizeof(o));
@@ -333,10 +333,10 @@ named_os_issingleton(const char *filename) {
LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY, LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY,
0, 0, 1, &o)) { 0, 0, 1, &o)) {
cleanup_lockfile(); cleanup_lockfile();
return (ISC_FALSE); return (false);
} }
return (ISC_TRUE); return (true);
} }
+81 -78
View File
@@ -11,6 +11,9 @@
#include <config.h> #include <config.h>
#include <inttypes.h>
#include <stdbool.h>
#include <isc/buffer.h> #include <isc/buffer.h>
#include <isc/file.h> #include <isc/file.h>
#include <isc/mem.h> #include <isc/mem.h>
@@ -188,7 +191,7 @@ configure_zone_ssutable(const cfg_obj_t *zconfig, dns_zone_t *zone,
const cfg_listelt_t *element, *element2; const cfg_listelt_t *element, *element2;
dns_ssutable_t *table = NULL; dns_ssutable_t *table = NULL;
isc_mem_t *mctx = dns_zone_getmctx(zone); isc_mem_t *mctx = dns_zone_getmctx(zone);
isc_boolean_t autoddns = ISC_FALSE; bool autoddns = false;
isc_result_t result; isc_result_t result;
(void)cfg_map_get(zconfig, "update-policy", &updatepolicy); (void)cfg_map_get(zconfig, "update-policy", &updatepolicy);
@@ -200,7 +203,7 @@ configure_zone_ssutable(const cfg_obj_t *zconfig, dns_zone_t *zone,
if (cfg_obj_isstring(updatepolicy) && if (cfg_obj_isstring(updatepolicy) &&
strcmp("local", cfg_obj_asstring(updatepolicy)) == 0) { strcmp("local", cfg_obj_asstring(updatepolicy)) == 0) {
autoddns = ISC_TRUE; autoddns = true;
updatepolicy = NULL; updatepolicy = NULL;
} }
@@ -219,8 +222,8 @@ configure_zone_ssutable(const cfg_obj_t *zconfig, dns_zone_t *zone,
const cfg_obj_t *dname = cfg_tuple_get(stmt, "name"); const cfg_obj_t *dname = cfg_tuple_get(stmt, "name");
const cfg_obj_t *typelist = cfg_tuple_get(stmt, "types"); const cfg_obj_t *typelist = cfg_tuple_get(stmt, "types");
const char *str; const char *str;
isc_boolean_t grant = ISC_FALSE; bool grant = false;
isc_boolean_t usezone = ISC_FALSE; bool usezone = false;
unsigned int mtype = dns_ssumatchtype_name; unsigned int mtype = dns_ssumatchtype_name;
dns_fixedname_t fname, fident; dns_fixedname_t fname, fident;
isc_buffer_t b; isc_buffer_t b;
@@ -229,16 +232,16 @@ configure_zone_ssutable(const cfg_obj_t *zconfig, dns_zone_t *zone,
str = cfg_obj_asstring(mode); str = cfg_obj_asstring(mode);
if (strcasecmp(str, "grant") == 0) if (strcasecmp(str, "grant") == 0)
grant = ISC_TRUE; grant = true;
else if (strcasecmp(str, "deny") == 0) else if (strcasecmp(str, "deny") == 0)
grant = ISC_FALSE; grant = false;
else else
INSIST(0); INSIST(0);
str = cfg_obj_asstring(matchtype); str = cfg_obj_asstring(matchtype);
CHECK(dns_ssu_mtypefromstring(str, &mtype)); CHECK(dns_ssu_mtypefromstring(str, &mtype));
if (mtype == dns_ssumatchtype_subdomain) { if (mtype == dns_ssumatchtype_subdomain) {
usezone = ISC_TRUE; usezone = true;
} }
dns_fixedname_init(&fident); dns_fixedname_init(&fident);
@@ -347,7 +350,7 @@ configure_zone_ssutable(const cfg_obj_t *zconfig, dns_zone_t *zone,
goto cleanup; goto cleanup;
} }
result = dns_ssutable_addrule(table, ISC_TRUE, result = dns_ssutable_addrule(table, true,
named_g_server->session_keyname, named_g_server->session_keyname,
dns_ssumatchtype_local, dns_ssumatchtype_local,
dns_zone_getorigin(zone), dns_zone_getorigin(zone),
@@ -625,7 +628,7 @@ configure_staticstub(const cfg_obj_t *zconfig, dns_zone_t *zone,
goto cleanup; goto cleanup;
dns_name_init(&apexname, NULL); dns_name_init(&apexname, NULL);
dns_name_clone(dns_zone_getorigin(zone), &apexname); dns_name_clone(dns_zone_getorigin(zone), &apexname);
result = dns_db_findnode(db, &apexname, ISC_FALSE, &apexnode); result = dns_db_findnode(db, &apexname, false, &apexnode);
if (result != ISC_R_SUCCESS) if (result != ISC_R_SUCCESS)
goto cleanup; goto cleanup;
@@ -668,7 +671,7 @@ configure_staticstub(const cfg_obj_t *zconfig, dns_zone_t *zone,
if (apexnode != NULL) if (apexnode != NULL)
dns_db_detachnode(db, &apexnode); dns_db_detachnode(db, &apexnode);
if (dbversion != NULL) if (dbversion != NULL)
dns_db_closeversion(db, &dbversion, ISC_TRUE); dns_db_closeversion(db, &dbversion, true);
if (db != NULL) if (db != NULL)
dns_db_detach(&db); dns_db_detach(&db);
for (i = 0; rdatalists[i] != NULL; i++) { for (i = 0; rdatalists[i] != NULL; i++) {
@@ -769,7 +772,7 @@ checknames(dns_zonetype_t ztype, const cfg_obj_t **maps,
* We run this unlocked as both the view list and the interface list * We run this unlocked as both the view list and the interface list
* are updated when the appropriate task has exclusivity. * are updated when the appropriate task has exclusivity.
*/ */
static isc_boolean_t static bool
isself(dns_view_t *myview, dns_tsigkey_t *mykey, isself(dns_view_t *myview, dns_tsigkey_t *mykey,
const isc_sockaddr_t *srcaddr, const isc_sockaddr_t *dstaddr, const isc_sockaddr_t *srcaddr, const isc_sockaddr_t *dstaddr,
dns_rdataclass_t rdclass, void *arg) dns_rdataclass_t rdclass, void *arg)
@@ -783,10 +786,10 @@ isself(dns_view_t *myview, dns_tsigkey_t *mykey,
isc_netaddr_t netdst; isc_netaddr_t netdst;
if (interfacemgr == NULL) if (interfacemgr == NULL)
return (ISC_TRUE); return (true);
if (!ns_interfacemgr_listeningon(interfacemgr, dstaddr)) if (!ns_interfacemgr_listeningon(interfacemgr, dstaddr))
return (ISC_FALSE); return (false);
isc_netaddr_fromsockaddr(&netsrc, srcaddr); isc_netaddr_fromsockaddr(&netsrc, srcaddr);
isc_netaddr_fromsockaddr(&netdst, dstaddr); isc_netaddr_fromsockaddr(&netdst, dstaddr);
@@ -802,7 +805,7 @@ isself(dns_view_t *myview, dns_tsigkey_t *mykey,
continue; continue;
if (mykey != NULL) { if (mykey != NULL) {
isc_boolean_t match; bool match;
isc_result_t result; isc_result_t result;
result = dns_view_gettsig(view, &mykey->name, &key); result = dns_view_gettsig(view, &mykey->name, &key);
@@ -822,7 +825,7 @@ isself(dns_view_t *myview, dns_tsigkey_t *mykey,
break; break;
} }
} }
return (ISC_TF(view == myview)); return (view == myview);
} }
@@ -843,7 +846,7 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
const char *filename = NULL; const char *filename = NULL;
const char *dupcheck; const char *dupcheck;
dns_notifytype_t notifytype = dns_notifytype_yes; dns_notifytype_t notifytype = dns_notifytype_yes;
isc_uint32_t count; uint32_t count;
unsigned int dbargc; unsigned int dbargc;
char **dbargv; char **dbargv;
static char default_dbtype[] = "rbt"; static char default_dbtype[] = "rbt";
@@ -853,13 +856,13 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
dns_dialuptype_t dialup = dns_dialuptype_no; dns_dialuptype_t dialup = dns_dialuptype_no;
dns_zonetype_t ztype; dns_zonetype_t ztype;
int i; int i;
isc_int32_t journal_size; int32_t journal_size;
isc_boolean_t multi; bool multi;
isc_boolean_t alt; bool alt;
dns_view_t *view; dns_view_t *view;
isc_boolean_t check = ISC_FALSE, fail = ISC_FALSE; bool check = false, fail = false;
isc_boolean_t warn = ISC_FALSE, ignore = ISC_FALSE; bool warn = false, ignore = false;
isc_boolean_t ixfrdiff; bool ixfrdiff;
dns_masterformat_t masterformat; dns_masterformat_t masterformat;
const dns_master_style_t *masterstyle = &dns_master_style_default; const dns_master_style_t *masterstyle = &dns_master_style_default;
isc_stats_t *zoneqrystats; isc_stats_t *zoneqrystats;
@@ -1272,12 +1275,12 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
cfg_obj_log(obj, named_g_lctx, cfg_obj_log(obj, named_g_lctx,
ISC_LOG_ERROR, ISC_LOG_ERROR,
"'max-journal-size " "'max-journal-size "
"%" ISC_PRINT_QUADFORMAT "d' " "%" PRId64 "' "
"is too large", "is too large",
value); value);
RETERR(ISC_R_RANGE); RETERR(ISC_R_RANGE);
} }
journal_size = (isc_uint32_t)value; journal_size = (uint32_t)value;
} }
if (raw != NULL) if (raw != NULL)
dns_zone_setjournalsize(raw, journal_size); dns_zone_setjournalsize(raw, journal_size);
@@ -1294,22 +1297,22 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
"master") == 0) && "master") == 0) &&
ztype == dns_zone_master) ztype == dns_zone_master)
{ {
ixfrdiff = ISC_TRUE; ixfrdiff = true;
} else if ((strcasecmp(cfg_obj_asstring(obj), } else if ((strcasecmp(cfg_obj_asstring(obj),
"secondary") == 0 || "secondary") == 0 ||
strcasecmp(cfg_obj_asstring(obj), strcasecmp(cfg_obj_asstring(obj),
"slave") == 0) && "slave") == 0) &&
ztype == dns_zone_slave) ztype == dns_zone_slave)
{ {
ixfrdiff = ISC_TRUE; ixfrdiff = true;
} else { } else {
ixfrdiff = ISC_FALSE; ixfrdiff = false;
} }
if (raw != NULL) { if (raw != NULL) {
dns_zone_setoption(raw, DNS_ZONEOPT_IXFRFROMDIFFS, dns_zone_setoption(raw, DNS_ZONEOPT_IXFRFROMDIFFS,
ISC_TRUE); true);
dns_zone_setoption(zone, DNS_ZONEOPT_IXFRFROMDIFFS, dns_zone_setoption(zone, DNS_ZONEOPT_IXFRFROMDIFFS,
ISC_FALSE); false);
} else } else
dns_zone_setoption(zone, DNS_ZONEOPT_IXFRFROMDIFFS, dns_zone_setoption(zone, DNS_ZONEOPT_IXFRFROMDIFFS,
ixfrdiff); ixfrdiff);
@@ -1327,12 +1330,12 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
checknames(ztype, maps, &obj); checknames(ztype, maps, &obj);
INSIST(obj != NULL); INSIST(obj != NULL);
if (strcasecmp(cfg_obj_asstring(obj), "warn") == 0) { if (strcasecmp(cfg_obj_asstring(obj), "warn") == 0) {
fail = ISC_FALSE; fail = false;
check = ISC_TRUE; check = true;
} else if (strcasecmp(cfg_obj_asstring(obj), "fail") == 0) { } else if (strcasecmp(cfg_obj_asstring(obj), "fail") == 0) {
fail = check = ISC_TRUE; fail = check = true;
} else if (strcasecmp(cfg_obj_asstring(obj), "ignore") == 0) { } else if (strcasecmp(cfg_obj_asstring(obj), "ignore") == 0) {
fail = check = ISC_FALSE; fail = check = false;
} else } else
INSIST(0); INSIST(0);
if (raw != NULL) { if (raw != NULL) {
@@ -1341,9 +1344,9 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
dns_zone_setoption(raw, DNS_ZONEOPT_CHECKNAMESFAIL, dns_zone_setoption(raw, DNS_ZONEOPT_CHECKNAMESFAIL,
fail); fail);
dns_zone_setoption(zone, DNS_ZONEOPT_CHECKNAMES, dns_zone_setoption(zone, DNS_ZONEOPT_CHECKNAMES,
ISC_FALSE); false);
dns_zone_setoption(zone, DNS_ZONEOPT_CHECKNAMESFAIL, dns_zone_setoption(zone, DNS_ZONEOPT_CHECKNAMESFAIL,
ISC_FALSE); false);
} else { } else {
dns_zone_setoption(zone, DNS_ZONEOPT_CHECKNAMES, dns_zone_setoption(zone, DNS_ZONEOPT_CHECKNAMES,
check); check);
@@ -1366,9 +1369,9 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
result = named_config_get(maps, "check-spf", &obj); result = named_config_get(maps, "check-spf", &obj);
INSIST(result == ISC_R_SUCCESS && obj != NULL); INSIST(result == ISC_R_SUCCESS && obj != NULL);
if (strcasecmp(cfg_obj_asstring(obj), "warn") == 0) { if (strcasecmp(cfg_obj_asstring(obj), "warn") == 0) {
check = ISC_TRUE; check = true;
} else if (strcasecmp(cfg_obj_asstring(obj), "ignore") == 0) { } else if (strcasecmp(cfg_obj_asstring(obj), "ignore") == 0) {
check = ISC_FALSE; check = false;
} else } else
INSIST(0); INSIST(0);
dns_zone_setoption(zone, DNS_ZONEOPT_CHECKSPF, check); dns_zone_setoption(zone, DNS_ZONEOPT_CHECKSPF, check);
@@ -1405,12 +1408,12 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
cfg_obj_log(obj, named_g_lctx, cfg_obj_log(obj, named_g_lctx,
ISC_LOG_ERROR, ISC_LOG_ERROR,
"'max-journal-size " "'max-journal-size "
"%" ISC_PRINT_QUADFORMAT "d' " "%" PRId64 "' "
"is too large", "is too large",
value); value);
RETERR(ISC_R_RANGE); RETERR(ISC_R_RANGE);
} }
journal_size = (isc_uint32_t)value; journal_size = (uint32_t)value;
} }
dns_zone_setjournalsize(zone, journal_size); dns_zone_setjournalsize(zone, journal_size);
} }
@@ -1440,8 +1443,8 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
if (ztype == dns_zone_master || raw != NULL) { if (ztype == dns_zone_master || raw != NULL) {
const cfg_obj_t *validity, *resign; const cfg_obj_t *validity, *resign;
isc_boolean_t allow = ISC_FALSE, maint = ISC_FALSE; bool allow = false, maint = false;
isc_boolean_t sigvalinsecs; bool sigvalinsecs;
obj = NULL; obj = NULL;
result = named_config_get(maps, "dnskey-sig-validity", &obj); result = named_config_get(maps, "dnskey-sig-validity", &obj);
@@ -1522,9 +1525,9 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
if (result == ISC_R_SUCCESS) { if (result == ISC_R_SUCCESS) {
const char *arg = cfg_obj_asstring(obj); const char *arg = cfg_obj_asstring(obj);
if (strcasecmp(arg, "allow") == 0) if (strcasecmp(arg, "allow") == 0)
allow = ISC_TRUE; allow = true;
else if (strcasecmp(arg, "maintain") == 0) else if (strcasecmp(arg, "maintain") == 0)
allow = maint = ISC_TRUE; allow = maint = true;
else if (strcasecmp(arg, "off") == 0) else if (strcasecmp(arg, "off") == 0)
; ;
else else
@@ -1550,7 +1553,7 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
if (result == ISC_R_SUCCESS) if (result == ISC_R_SUCCESS)
check = cfg_obj_asboolean(obj); check = cfg_obj_asboolean(obj);
else else
check = ISC_FALSE; check = false;
dns_zone_setoption(mayberaw, DNS_ZONEOPT_CHECKWILDCARD, check); dns_zone_setoption(mayberaw, DNS_ZONEOPT_CHECKWILDCARD, check);
/* /*
@@ -1575,12 +1578,12 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
} }
if (strcasecmp(dupcheck, "warn") == 0) { if (strcasecmp(dupcheck, "warn") == 0) {
fail = ISC_FALSE; fail = false;
check = ISC_TRUE; check = true;
} else if (strcasecmp(dupcheck, "fail") == 0) { } else if (strcasecmp(dupcheck, "fail") == 0) {
fail = check = ISC_TRUE; fail = check = true;
} else if (strcasecmp(dupcheck, "ignore") == 0) { } else if (strcasecmp(dupcheck, "ignore") == 0) {
fail = check = ISC_FALSE; fail = check = false;
} else } else
INSIST(0); INSIST(0);
dns_zone_setoption(mayberaw, DNS_ZONEOPT_CHECKDUPRR, check); dns_zone_setoption(mayberaw, DNS_ZONEOPT_CHECKDUPRR, check);
@@ -1590,12 +1593,12 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
result = named_config_get(maps, "check-mx", &obj); result = named_config_get(maps, "check-mx", &obj);
INSIST(result == ISC_R_SUCCESS && obj != NULL); INSIST(result == ISC_R_SUCCESS && obj != NULL);
if (strcasecmp(cfg_obj_asstring(obj), "warn") == 0) { if (strcasecmp(cfg_obj_asstring(obj), "warn") == 0) {
fail = ISC_FALSE; fail = false;
check = ISC_TRUE; check = true;
} else if (strcasecmp(cfg_obj_asstring(obj), "fail") == 0) { } else if (strcasecmp(cfg_obj_asstring(obj), "fail") == 0) {
fail = check = ISC_TRUE; fail = check = true;
} else if (strcasecmp(cfg_obj_asstring(obj), "ignore") == 0) { } else if (strcasecmp(cfg_obj_asstring(obj), "ignore") == 0) {
fail = check = ISC_FALSE; fail = check = false;
} else } else
INSIST(0); INSIST(0);
dns_zone_setoption(mayberaw, DNS_ZONEOPT_CHECKMX, check); dns_zone_setoption(mayberaw, DNS_ZONEOPT_CHECKMX, check);
@@ -1614,7 +1617,7 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
dns_zone_setoption(mayberaw, DNS_ZONEOPT_CHECKINTEGRITY, dns_zone_setoption(mayberaw, DNS_ZONEOPT_CHECKINTEGRITY,
cfg_obj_asboolean(obj)); cfg_obj_asboolean(obj));
} else { } else {
check = ISC_FALSE; check = false;
result = named_config_get(nodefault, "check-integrity", result = named_config_get(nodefault, "check-integrity",
&obj); &obj);
if (result == ISC_R_SUCCESS) if (result == ISC_R_SUCCESS)
@@ -1627,12 +1630,12 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
result = named_config_get(maps, "check-mx-cname", &obj); result = named_config_get(maps, "check-mx-cname", &obj);
INSIST(result == ISC_R_SUCCESS && obj != NULL); INSIST(result == ISC_R_SUCCESS && obj != NULL);
if (strcasecmp(cfg_obj_asstring(obj), "warn") == 0) { if (strcasecmp(cfg_obj_asstring(obj), "warn") == 0) {
warn = ISC_TRUE; warn = true;
ignore = ISC_FALSE; ignore = false;
} else if (strcasecmp(cfg_obj_asstring(obj), "fail") == 0) { } else if (strcasecmp(cfg_obj_asstring(obj), "fail") == 0) {
warn = ignore = ISC_FALSE; warn = ignore = false;
} else if (strcasecmp(cfg_obj_asstring(obj), "ignore") == 0) { } else if (strcasecmp(cfg_obj_asstring(obj), "ignore") == 0) {
warn = ignore = ISC_TRUE; warn = ignore = true;
} else } else
INSIST(0); INSIST(0);
dns_zone_setoption(mayberaw, DNS_ZONEOPT_WARNMXCNAME, warn); dns_zone_setoption(mayberaw, DNS_ZONEOPT_WARNMXCNAME, warn);
@@ -1642,12 +1645,12 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
result = named_config_get(maps, "check-srv-cname", &obj); result = named_config_get(maps, "check-srv-cname", &obj);
INSIST(result == ISC_R_SUCCESS && obj != NULL); INSIST(result == ISC_R_SUCCESS && obj != NULL);
if (strcasecmp(cfg_obj_asstring(obj), "warn") == 0) { if (strcasecmp(cfg_obj_asstring(obj), "warn") == 0) {
warn = ISC_TRUE; warn = true;
ignore = ISC_FALSE; ignore = false;
} else if (strcasecmp(cfg_obj_asstring(obj), "fail") == 0) { } else if (strcasecmp(cfg_obj_asstring(obj), "fail") == 0) {
warn = ignore = ISC_FALSE; warn = ignore = false;
} else if (strcasecmp(cfg_obj_asstring(obj), "ignore") == 0) { } else if (strcasecmp(cfg_obj_asstring(obj), "ignore") == 0) {
warn = ignore = ISC_TRUE; warn = ignore = true;
} else } else
INSIST(0); INSIST(0);
dns_zone_setoption(mayberaw, DNS_ZONEOPT_WARNSRVCNAME, warn); dns_zone_setoption(mayberaw, DNS_ZONEOPT_WARNSRVCNAME, warn);
@@ -1667,7 +1670,7 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
const char *arg = cfg_obj_asstring(obj); const char *arg = cfg_obj_asstring(obj);
if (strcasecmp(arg, "no-resign") == 0) if (strcasecmp(arg, "no-resign") == 0)
dns_zone_setkeyopt(zone, DNS_ZONEKEY_NORESIGN, dns_zone_setkeyopt(zone, DNS_ZONEKEY_NORESIGN,
ISC_TRUE); true);
else if (strcasecmp(arg, "maintain") == 0) else if (strcasecmp(arg, "maintain") == 0)
; ;
else else
@@ -1715,7 +1718,7 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
result = dns_zone_setmasters(mayberaw, NULL, 0); result = dns_zone_setmasters(mayberaw, NULL, 0);
RETERR(result); RETERR(result);
multi = ISC_FALSE; multi = false;
if (count > 1) { if (count > 1) {
obj = NULL; obj = NULL;
result = named_config_get(maps, "multi-master", &obj); result = named_config_get(maps, "multi-master", &obj);
@@ -1727,7 +1730,7 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
obj = NULL; obj = NULL;
(void)cfg_map_get(zoptions, "mirror", &obj); (void)cfg_map_get(zoptions, "mirror", &obj);
if (obj != NULL) { if (obj != NULL) {
isc_boolean_t mirror = cfg_obj_asboolean(obj); bool mirror = cfg_obj_asboolean(obj);
dns_zone_setoption(mayberaw, DNS_ZONEOPT_MIRROR, dns_zone_setoption(mayberaw, DNS_ZONEOPT_MIRROR,
mirror); mirror);
if (mirror) { if (mirror) {
@@ -1836,9 +1839,9 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
*/ */
view = dns_zone_getview(zone); view = dns_zone_getview(zone);
if (view != NULL && strcmp(view->name, "_default") == 0) if (view != NULL && strcmp(view->name, "_default") == 0)
alt = ISC_TRUE; alt = true;
else else
alt = ISC_FALSE; alt = false;
} else } else
alt = cfg_obj_asboolean(obj); alt = cfg_obj_asboolean(obj);
dns_zone_setoption(mayberaw, DNS_ZONEOPT_USEALTXFRSRC, alt); dns_zone_setoption(mayberaw, DNS_ZONEOPT_USEALTXFRSRC, alt);
@@ -1885,14 +1888,14 @@ named_zone_configure_writeable_dlz(dns_dlzdb_t *dlzdatabase,
return (result); return (result);
} }
isc_boolean_t bool
named_zone_reusable(dns_zone_t *zone, const cfg_obj_t *zconfig) { named_zone_reusable(dns_zone_t *zone, const cfg_obj_t *zconfig) {
const cfg_obj_t *zoptions = NULL; const cfg_obj_t *zoptions = NULL;
const cfg_obj_t *obj = NULL; const cfg_obj_t *obj = NULL;
const char *cfilename; const char *cfilename;
const char *zfilename; const char *zfilename;
dns_zone_t *raw = NULL; dns_zone_t *raw = NULL;
isc_boolean_t has_raw, mirror; bool has_raw, mirror;
dns_zonetype_t ztype; dns_zonetype_t ztype;
zoptions = cfg_tuple_get(zconfig, "options"); zoptions = cfg_tuple_get(zconfig, "options");
@@ -1904,7 +1907,7 @@ named_zone_reusable(dns_zone_t *zone, const cfg_obj_t *zconfig) {
if (zonetype_fromconfig(zoptions) == dns_zone_staticstub) { if (zonetype_fromconfig(zoptions) == dns_zone_staticstub) {
dns_zone_log(zone, ISC_LOG_DEBUG(1), dns_zone_log(zone, ISC_LOG_DEBUG(1),
"not reusable: staticstub"); "not reusable: staticstub");
return (ISC_FALSE); return (false);
} }
/* If there's a raw zone, use that for filename and type comparison */ /* If there's a raw zone, use that for filename and type comparison */
@@ -1913,11 +1916,11 @@ named_zone_reusable(dns_zone_t *zone, const cfg_obj_t *zconfig) {
zfilename = dns_zone_getfile(raw); zfilename = dns_zone_getfile(raw);
ztype = dns_zone_gettype(raw); ztype = dns_zone_gettype(raw);
dns_zone_detach(&raw); dns_zone_detach(&raw);
has_raw = ISC_TRUE; has_raw = true;
} else { } else {
zfilename = dns_zone_getfile(zone); zfilename = dns_zone_getfile(zone);
ztype = dns_zone_gettype(zone); ztype = dns_zone_gettype(zone);
has_raw = ISC_FALSE; has_raw = false;
} }
obj = NULL; obj = NULL;
@@ -1925,18 +1928,18 @@ named_zone_reusable(dns_zone_t *zone, const cfg_obj_t *zconfig) {
if ((obj == NULL || !cfg_obj_asboolean(obj)) && has_raw) { if ((obj == NULL || !cfg_obj_asboolean(obj)) && has_raw) {
dns_zone_log(zone, ISC_LOG_DEBUG(1), dns_zone_log(zone, ISC_LOG_DEBUG(1),
"not reusable: old zone was inline-signing"); "not reusable: old zone was inline-signing");
return (ISC_FALSE); return (false);
} else if ((obj != NULL && cfg_obj_asboolean(obj)) && !has_raw) { } else if ((obj != NULL && cfg_obj_asboolean(obj)) && !has_raw) {
dns_zone_log(zone, ISC_LOG_DEBUG(1), dns_zone_log(zone, ISC_LOG_DEBUG(1),
"not reusable: old zone was not inline-signing"); "not reusable: old zone was not inline-signing");
return (ISC_FALSE); return (false);
} }
/* /*
* Do not reuse a zone whose "mirror" setting was changed. * Do not reuse a zone whose "mirror" setting was changed.
*/ */
obj = NULL; obj = NULL;
mirror = ISC_FALSE; mirror = false;
(void)cfg_map_get(zoptions, "mirror", &obj); (void)cfg_map_get(zoptions, "mirror", &obj);
if (obj != NULL) { if (obj != NULL) {
mirror = cfg_obj_asboolean(obj); mirror = cfg_obj_asboolean(obj);
@@ -1944,13 +1947,13 @@ named_zone_reusable(dns_zone_t *zone, const cfg_obj_t *zconfig) {
if (dns_zone_ismirror(zone) != mirror) { if (dns_zone_ismirror(zone) != mirror) {
dns_zone_log(zone, ISC_LOG_DEBUG(1), dns_zone_log(zone, ISC_LOG_DEBUG(1),
"not reusable: mirror setting changed"); "not reusable: mirror setting changed");
return (ISC_FALSE); return (false);
} }
if (zonetype_fromconfig(zoptions) != ztype) { if (zonetype_fromconfig(zoptions) != ztype) {
dns_zone_log(zone, ISC_LOG_DEBUG(1), dns_zone_log(zone, ISC_LOG_DEBUG(1),
"not reusable: type mismatch"); "not reusable: type mismatch");
return (ISC_FALSE); return (false);
} }
obj = NULL; obj = NULL;
@@ -1965,8 +1968,8 @@ named_zone_reusable(dns_zone_t *zone, const cfg_obj_t *zconfig) {
{ {
dns_zone_log(zone, ISC_LOG_DEBUG(1), dns_zone_log(zone, ISC_LOG_DEBUG(1),
"not reusable: filename mismatch"); "not reusable: filename mismatch");
return (ISC_FALSE); return (false);
} }
return (ISC_TRUE); return (true);
} }
+155 -167
View File
@@ -16,6 +16,8 @@
#include <ctype.h> #include <ctype.h>
#include <errno.h> #include <errno.h>
#include <limits.h> #include <limits.h>
#include <inttypes.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h> #include <unistd.h>
@@ -97,20 +99,6 @@
#endif #endif
#endif #endif
#ifdef HAVE_ADDRINFO
#ifdef HAVE_GETADDRINFO
#ifdef HAVE_GAISTRERROR
#define USE_GETADDRINFO
#endif
#endif
#endif
#ifndef USE_GETADDRINFO
#ifndef ISC_PLATFORM_NONSTDHERRNO
extern int h_errno;
#endif
#endif
#define MAXCMD (128 * 1024) #define MAXCMD (128 * 1024)
#define MAXWIRE (64 * 1024) #define MAXWIRE (64 * 1024)
#define PACKETSIZE ((64 * 1024) - 1) #define PACKETSIZE ((64 * 1024) - 1)
@@ -124,22 +112,22 @@ extern int h_errno;
/* Number of addresses to request from bind9_getaddresses() */ /* Number of addresses to request from bind9_getaddresses() */
#define MAX_SERVERADDRS 4 #define MAX_SERVERADDRS 4
static isc_uint16_t dnsport = DNSDEFAULTPORT; static uint16_t dnsport = DNSDEFAULTPORT;
#ifndef RESOLV_CONF #ifndef RESOLV_CONF
#define RESOLV_CONF "/etc/resolv.conf" #define RESOLV_CONF "/etc/resolv.conf"
#endif #endif
static isc_boolean_t debugging = ISC_FALSE, ddebugging = ISC_FALSE; static bool debugging = false, ddebugging = false;
static isc_boolean_t memdebugging = ISC_FALSE; static bool memdebugging = false;
static isc_boolean_t have_ipv4 = ISC_FALSE; static bool have_ipv4 = false;
static isc_boolean_t have_ipv6 = ISC_FALSE; static bool have_ipv6 = false;
static isc_boolean_t is_dst_up = ISC_FALSE; static bool is_dst_up = false;
static isc_boolean_t usevc = ISC_FALSE; static bool usevc = false;
static isc_boolean_t usegsstsig = ISC_FALSE; static bool usegsstsig = false;
static isc_boolean_t use_win2k_gsstsig = ISC_FALSE; static bool use_win2k_gsstsig = false;
static isc_boolean_t tried_other_gsstsig = ISC_FALSE; static bool tried_other_gsstsig = false;
static isc_boolean_t local_only = ISC_FALSE; static bool local_only = false;
static isc_taskmgr_t *taskmgr = NULL; static isc_taskmgr_t *taskmgr = NULL;
static isc_task_t *global_task = NULL; static isc_task_t *global_task = NULL;
static isc_event_t *global_event = NULL; static isc_event_t *global_event = NULL;
@@ -163,7 +151,7 @@ static dns_tsigkey_t *tsigkey = NULL;
static dst_key_t *sig0key = NULL; static dst_key_t *sig0key = NULL;
static isc_sockaddr_t *servers = NULL; static isc_sockaddr_t *servers = NULL;
static isc_sockaddr_t *master_servers = NULL; static isc_sockaddr_t *master_servers = NULL;
static isc_boolean_t default_servers = ISC_TRUE; static bool default_servers = true;
static int ns_inuse = 0; static int ns_inuse = 0;
static int master_inuse = 0; static int master_inuse = 0;
static int ns_total = 0; static int ns_total = 0;
@@ -174,10 +162,10 @@ static isc_sockaddr_t *localaddr4 = NULL;
static isc_sockaddr_t *localaddr6 = NULL; static isc_sockaddr_t *localaddr6 = NULL;
static const char *keyfile = NULL; static const char *keyfile = NULL;
static char *keystr = NULL; static char *keystr = NULL;
static isc_boolean_t shuttingdown = ISC_FALSE; static bool shuttingdown = false;
static FILE *input; static FILE *input;
static isc_boolean_t interactive = ISC_TRUE; static bool interactive = true;
static isc_boolean_t seenerror = ISC_FALSE; static bool seenerror = false;
static const dns_master_style_t *style; static const dns_master_style_t *style;
static int requests = 0; static int requests = 0;
static unsigned int logdebuglevel = 0; static unsigned int logdebuglevel = 0;
@@ -187,9 +175,9 @@ static unsigned int udp_retries = 3;
static dns_rdataclass_t defaultclass = dns_rdataclass_in; static dns_rdataclass_t defaultclass = dns_rdataclass_in;
static dns_rdataclass_t zoneclass = dns_rdataclass_none; static dns_rdataclass_t zoneclass = dns_rdataclass_none;
static dns_message_t *answer = NULL; 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 bool default_ttl_set = false;
static isc_boolean_t checknames = ISC_TRUE; static bool checknames = true;
typedef struct nsu_requestinfo { typedef struct nsu_requestinfo {
dns_message_t *msg; dns_message_t *msg;
@@ -238,10 +226,10 @@ recvgss(isc_task_t *task, isc_event_t *event);
static void static void
error(const char *format, ...) ISC_FORMAT_PRINTF(1, 2); error(const char *format, ...) ISC_FORMAT_PRINTF(1, 2);
#define STATUS_MORE (isc_uint16_t)0 #define STATUS_MORE (uint16_t)0
#define STATUS_SEND (isc_uint16_t)1 #define STATUS_SEND (uint16_t)1
#define STATUS_QUIT (isc_uint16_t)2 #define STATUS_QUIT (uint16_t)2
#define STATUS_SYNTAX (isc_uint16_t)3 #define STATUS_SYNTAX (uint16_t)3
static void static void
master_from_servers(void) { master_from_servers(void) {
@@ -262,14 +250,14 @@ getzoneclass(void) {
return (zoneclass); return (zoneclass);
} }
static isc_boolean_t static bool
setzoneclass(dns_rdataclass_t rdclass) { setzoneclass(dns_rdataclass_t rdclass) {
if (zoneclass == dns_rdataclass_none || if (zoneclass == dns_rdataclass_none ||
rdclass == dns_rdataclass_none) rdclass == dns_rdataclass_none)
zoneclass = rdclass; zoneclass = rdclass;
if (zoneclass != rdclass) if (zoneclass != rdclass)
return (ISC_FALSE); return (false);
return (ISC_TRUE); return (true);
} }
static void static void
@@ -376,15 +364,15 @@ reset_system(void) {
dns_tsigkey_detach(&tsigkey); dns_tsigkey_detach(&tsigkey);
if (gssring != NULL) if (gssring != NULL)
dns_tsigkeyring_detach(&gssring); dns_tsigkeyring_detach(&gssring);
tried_other_gsstsig = ISC_FALSE; tried_other_gsstsig = false;
} }
} }
static isc_boolean_t static bool
parse_hmac(const dns_name_t **hmac, const char *hmacstr, size_t len, parse_hmac(const dns_name_t **hmac, const char *hmacstr, size_t len,
isc_uint16_t *digestbitsp) uint16_t *digestbitsp)
{ {
isc_uint16_t digestbits = 0; uint16_t digestbits = 0;
isc_result_t result; isc_result_t result;
char buf[20]; char buf[20];
@@ -393,7 +381,7 @@ parse_hmac(const dns_name_t **hmac, const char *hmacstr, size_t len,
if (len >= sizeof(buf)) { if (len >= sizeof(buf)) {
error("unknown key type '%.*s'", (int)(len), hmacstr); error("unknown key type '%.*s'", (int)(len), hmacstr);
return (ISC_FALSE); return (false);
} }
/* Copy len bytes and NUL terminate. */ /* Copy len bytes and NUL terminate. */
@@ -406,7 +394,7 @@ parse_hmac(const dns_name_t **hmac, const char *hmacstr, size_t len,
result = isc_parse_uint16(&digestbits, &buf[9], 10); result = isc_parse_uint16(&digestbits, &buf[9], 10);
if (result != ISC_R_SUCCESS || digestbits > 128) { if (result != ISC_R_SUCCESS || digestbits > 128) {
error("digest-bits out of range [0..128]"); error("digest-bits out of range [0..128]");
return (ISC_FALSE); return (false);
} }
*digestbitsp = (digestbits + 7) & ~0x7U; *digestbitsp = (digestbits + 7) & ~0x7U;
} else if (strcasecmp(buf, "hmac-sha1") == 0) { } else if (strcasecmp(buf, "hmac-sha1") == 0) {
@@ -416,7 +404,7 @@ parse_hmac(const dns_name_t **hmac, const char *hmacstr, size_t len,
result = isc_parse_uint16(&digestbits, &buf[10], 10); result = isc_parse_uint16(&digestbits, &buf[10], 10);
if (result != ISC_R_SUCCESS || digestbits > 160) { if (result != ISC_R_SUCCESS || digestbits > 160) {
error("digest-bits out of range [0..160]"); error("digest-bits out of range [0..160]");
return (ISC_FALSE); return (false);
} }
*digestbitsp = (digestbits + 7) & ~0x7U; *digestbitsp = (digestbits + 7) & ~0x7U;
} else if (strcasecmp(buf, "hmac-sha224") == 0) { } else if (strcasecmp(buf, "hmac-sha224") == 0) {
@@ -426,7 +414,7 @@ parse_hmac(const dns_name_t **hmac, const char *hmacstr, size_t len,
result = isc_parse_uint16(&digestbits, &buf[12], 10); result = isc_parse_uint16(&digestbits, &buf[12], 10);
if (result != ISC_R_SUCCESS || digestbits > 224) { if (result != ISC_R_SUCCESS || digestbits > 224) {
error("digest-bits out of range [0..224]"); error("digest-bits out of range [0..224]");
return (ISC_FALSE); return (false);
} }
*digestbitsp = (digestbits + 7) & ~0x7U; *digestbitsp = (digestbits + 7) & ~0x7U;
} else if (strcasecmp(buf, "hmac-sha256") == 0) { } else if (strcasecmp(buf, "hmac-sha256") == 0) {
@@ -436,7 +424,7 @@ parse_hmac(const dns_name_t **hmac, const char *hmacstr, size_t len,
result = isc_parse_uint16(&digestbits, &buf[12], 10); result = isc_parse_uint16(&digestbits, &buf[12], 10);
if (result != ISC_R_SUCCESS || digestbits > 256) { if (result != ISC_R_SUCCESS || digestbits > 256) {
error("digest-bits out of range [0..256]"); error("digest-bits out of range [0..256]");
return (ISC_FALSE); return (false);
} }
*digestbitsp = (digestbits + 7) & ~0x7U; *digestbitsp = (digestbits + 7) & ~0x7U;
} else if (strcasecmp(buf, "hmac-sha384") == 0) { } else if (strcasecmp(buf, "hmac-sha384") == 0) {
@@ -446,7 +434,7 @@ parse_hmac(const dns_name_t **hmac, const char *hmacstr, size_t len,
result = isc_parse_uint16(&digestbits, &buf[12], 10); result = isc_parse_uint16(&digestbits, &buf[12], 10);
if (result != ISC_R_SUCCESS || digestbits > 384) { if (result != ISC_R_SUCCESS || digestbits > 384) {
error("digest-bits out of range [0..384]"); error("digest-bits out of range [0..384]");
return (ISC_FALSE); return (false);
} }
*digestbitsp = (digestbits + 7) & ~0x7U; *digestbitsp = (digestbits + 7) & ~0x7U;
} else if (strcasecmp(buf, "hmac-sha512") == 0) { } else if (strcasecmp(buf, "hmac-sha512") == 0) {
@@ -456,14 +444,14 @@ parse_hmac(const dns_name_t **hmac, const char *hmacstr, size_t len,
result = isc_parse_uint16(&digestbits, &buf[12], 10); result = isc_parse_uint16(&digestbits, &buf[12], 10);
if (result != ISC_R_SUCCESS || digestbits > 512) { if (result != ISC_R_SUCCESS || digestbits > 512) {
error("digest-bits out of range [0..512]"); error("digest-bits out of range [0..512]");
return (ISC_FALSE); return (false);
} }
*digestbitsp = (digestbits + 7) & ~0x7U; *digestbitsp = (digestbits + 7) & ~0x7U;
} else { } else {
error("unknown key type '%s'", buf); error("unknown key type '%s'", buf);
return (ISC_FALSE); return (false);
} }
return (ISC_TRUE); return (true);
} }
static int static int
@@ -492,7 +480,7 @@ setup_keystr(void) {
dns_name_t *mykeyname; dns_name_t *mykeyname;
char *name; char *name;
const dns_name_t *hmacname = NULL; const dns_name_t *hmacname = NULL;
isc_uint16_t digestbits = 0; uint16_t digestbits = 0;
mykeyname = dns_fixedname_initname(&fkeyname); mykeyname = dns_fixedname_initname(&fkeyname);
@@ -542,7 +530,7 @@ setup_keystr(void) {
debug("keycreate"); debug("keycreate");
result = dns_tsigkey_create(mykeyname, hmacname, secret, secretlen, result = dns_tsigkey_create(mykeyname, hmacname, secret, secretlen,
ISC_FALSE, NULL, 0, 0, gmctx, NULL, false, NULL, 0, 0, gmctx, NULL,
&tsigkey); &tsigkey);
if (result != ISC_R_SUCCESS) if (result != ISC_R_SUCCESS)
fprintf(stderr, "could not create key from %s: %s\n", fprintf(stderr, "could not create key from %s: %s\n",
@@ -667,7 +655,7 @@ setup_keyfile(isc_mem_t *mctx, isc_log_t *lctx) {
} }
if (hmacname != NULL) { if (hmacname != NULL) {
result = dns_tsigkey_createfromkey(dst_key_name(dstkey), result = dns_tsigkey_createfromkey(dst_key_name(dstkey),
hmacname, dstkey, ISC_FALSE, hmacname, dstkey, false,
NULL, 0, 0, mctx, NULL, NULL, 0, 0, mctx, NULL,
&tsigkey); &tsigkey);
dst_key_free(&dstkey); dst_key_free(&dstkey);
@@ -720,7 +708,7 @@ doshutdown(void) {
if (is_dst_up) { if (is_dst_up) {
ddebug("Destroy DST lib"); ddebug("Destroy DST lib");
dst_lib_destroy(); dst_lib_destroy();
is_dst_up = ISC_FALSE; is_dst_up = false;
} }
ddebug("Destroying request manager"); ddebug("Destroying request manager");
@@ -756,7 +744,7 @@ shutdown_program(isc_task_t *task, isc_event_t *event) {
ddebug("shutdown_program()"); ddebug("shutdown_program()");
isc_event_free(&event); isc_event_free(&event);
shuttingdown = ISC_TRUE; shuttingdown = true;
maybeshutdown(); maybeshutdown();
} }
@@ -908,7 +896,7 @@ setup_system(void) {
result = dst_lib_init(gmctx, NULL); result = dst_lib_init(gmctx, NULL);
check_result(result, "dst_lib_init"); check_result(result, "dst_lib_init");
is_dst_up = ISC_TRUE; is_dst_up = true;
attrmask = DNS_DISPATCHATTR_UDP | DNS_DISPATCHATTR_TCP; attrmask = DNS_DISPATCHATTR_UDP | DNS_DISPATCHATTR_TCP;
attrmask |= DNS_DISPATCHATTR_IPV4 | DNS_DISPATCHATTR_IPV6; attrmask |= DNS_DISPATCHATTR_IPV4 | DNS_DISPATCHATTR_IPV6;
@@ -981,15 +969,15 @@ pre_parse_args(int argc, char **argv) {
dns_rdatatype_t t; dns_rdatatype_t t;
int ch; int ch;
char buf[100]; char buf[100];
isc_boolean_t doexit = ISC_FALSE; bool doexit = false;
isc_boolean_t ipv4only = ISC_FALSE, ipv6only = ISC_FALSE; bool ipv4only = false, ipv6only = false;
while ((ch = isc_commandline_parse(argc, argv, PARSE_ARGS_FMT)) != -1) { while ((ch = isc_commandline_parse(argc, argv, PARSE_ARGS_FMT)) != -1) {
switch (ch) { switch (ch) {
case 'M': /* was -dm */ case 'M': /* was -dm */
debugging = ISC_TRUE; debugging = true;
ddebugging = ISC_TRUE; ddebugging = true;
memdebugging = ISC_TRUE; memdebugging = true;
isc_mem_debugging = ISC_MEM_DEBUGTRACE | isc_mem_debugging = ISC_MEM_DEBUGTRACE |
ISC_MEM_DEBUGRECORD; ISC_MEM_DEBUGRECORD;
break; break;
@@ -998,14 +986,14 @@ pre_parse_args(int argc, char **argv) {
if (ipv6only) { if (ipv6only) {
fatal("only one of -4 and -6 allowed"); fatal("only one of -4 and -6 allowed");
} }
ipv4only = ISC_TRUE; ipv4only = true;
break; break;
case '6': case '6':
if (ipv4only) { if (ipv4only) {
fatal("only one of -4 and -6 allowed"); fatal("only one of -4 and -6 allowed");
} }
ipv6only = ISC_TRUE; ipv6only = true;
break; break;
case '?': case '?':
@@ -1026,7 +1014,7 @@ pre_parse_args(int argc, char **argv) {
if (strncmp(buf, "TYPE", 4) != 0) if (strncmp(buf, "TYPE", 4) != 0)
fprintf(stdout, "%s\n", buf); fprintf(stdout, "%s\n", buf);
} }
doexit = ISC_TRUE; doexit = true;
break; break;
case 'T': case 'T':
@@ -1037,12 +1025,12 @@ pre_parse_args(int argc, char **argv) {
if (strncmp(buf, "TYPE", 4) != 0) if (strncmp(buf, "TYPE", 4) != 0)
fprintf(stdout, "%s\n", buf); fprintf(stdout, "%s\n", buf);
} }
doexit = ISC_TRUE; doexit = true;
break; break;
case 'V': case 'V':
version(); version();
doexit = ISC_TRUE; doexit = true;
break; break;
default: default:
@@ -1051,16 +1039,16 @@ pre_parse_args(int argc, char **argv) {
} }
if (doexit) if (doexit)
exit(0); exit(0);
isc_commandline_reset = ISC_TRUE; isc_commandline_reset = true;
isc_commandline_index = 1; isc_commandline_index = 1;
} }
static void static void
parse_args(int argc, char **argv) { parse_args(int argc, char **argv) {
int ch; int ch;
isc_uint32_t i; uint32_t i;
isc_result_t result; isc_result_t result;
isc_boolean_t force_interactive = ISC_FALSE; bool force_interactive = false;
debug("parse_args"); debug("parse_args");
while ((ch = isc_commandline_parse(argc, argv, PARSE_ARGS_FMT)) != -1) { while ((ch = isc_commandline_parse(argc, argv, PARSE_ARGS_FMT)) != -1) {
@@ -1068,7 +1056,7 @@ parse_args(int argc, char **argv) {
case '4': case '4':
if (have_ipv4) { if (have_ipv4) {
isc_net_disableipv6(); isc_net_disableipv6();
have_ipv6 = ISC_FALSE; have_ipv6 = false;
} else { } else {
fatal("can't find IPv4 networking"); fatal("can't find IPv4 networking");
} }
@@ -1076,26 +1064,26 @@ parse_args(int argc, char **argv) {
case '6': case '6':
if (have_ipv6) { if (have_ipv6) {
isc_net_disableipv4(); isc_net_disableipv4();
have_ipv4 = ISC_FALSE; have_ipv4 = false;
} else { } else {
fatal("can't find IPv6 networking"); fatal("can't find IPv6 networking");
} }
break; break;
case 'd': case 'd':
debugging = ISC_TRUE; debugging = true;
break; break;
case 'D': /* was -dd */ case 'D': /* was -dd */
debugging = ISC_TRUE; debugging = true;
ddebugging = ISC_TRUE; ddebugging = true;
break; break;
case 'M': case 'M':
break; break;
case 'i': case 'i':
force_interactive = ISC_TRUE; force_interactive = true;
interactive = ISC_TRUE; interactive = true;
break; break;
case 'l': case 'l':
local_only = ISC_TRUE; local_only = true;
break; break;
case 'L': case 'L':
result = isc_parse_uint32(&i, isc_commandline_argument, result = isc_parse_uint32(&i, isc_commandline_argument,
@@ -1111,18 +1099,18 @@ parse_args(int argc, char **argv) {
keystr = isc_commandline_argument; keystr = isc_commandline_argument;
break; break;
case 'v': case 'v':
usevc = ISC_TRUE; usevc = true;
break; break;
case 'k': case 'k':
keyfile = isc_commandline_argument; keyfile = isc_commandline_argument;
break; break;
case 'g': case 'g':
usegsstsig = ISC_TRUE; usegsstsig = true;
use_win2k_gsstsig = ISC_FALSE; use_win2k_gsstsig = false;
break; break;
case 'o': case 'o':
usegsstsig = ISC_TRUE; usegsstsig = true;
use_win2k_gsstsig = ISC_TRUE; use_win2k_gsstsig = true;
break; break;
case 'p': case 'p':
result = isc_parse_uint16(&dnsport, result = isc_parse_uint16(&dnsport,
@@ -1207,12 +1195,12 @@ parse_args(int argc, char **argv) {
} }
} }
if (!force_interactive) { if (!force_interactive) {
interactive = ISC_FALSE; interactive = false;
} }
} }
} }
static isc_uint16_t static uint16_t
parse_name(char **cmdlinep, dns_message_t *msg, dns_name_t **namep) { parse_name(char **cmdlinep, dns_message_t *msg, dns_name_t **namep) {
isc_result_t result; isc_result_t result;
char *word; char *word;
@@ -1245,7 +1233,7 @@ parse_name(char **cmdlinep, dns_message_t *msg, dns_name_t **namep) {
return (STATUS_MORE); return (STATUS_MORE);
} }
static isc_uint16_t static uint16_t
parse_rdata(char **cmdlinep, dns_rdataclass_t rdataclass, parse_rdata(char **cmdlinep, dns_rdataclass_t rdataclass,
dns_rdatatype_t rdatatype, dns_message_t *msg, dns_rdatatype_t rdatatype, dns_message_t *msg,
dns_rdata_t *rdata) dns_rdata_t *rdata)
@@ -1301,8 +1289,8 @@ parse_rdata(char **cmdlinep, dns_rdataclass_t rdataclass,
return (STATUS_MORE); return (STATUS_MORE);
} }
static isc_uint16_t static uint16_t
make_prereq(char *cmdline, isc_boolean_t ispositive, isc_boolean_t isrrset) { make_prereq(char *cmdline, bool ispositive, bool isrrset) {
isc_result_t result; isc_result_t result;
char *word; char *word;
dns_name_t *name = NULL; dns_name_t *name = NULL;
@@ -1312,7 +1300,7 @@ make_prereq(char *cmdline, isc_boolean_t ispositive, isc_boolean_t isrrset) {
dns_rdataclass_t rdataclass; dns_rdataclass_t rdataclass;
dns_rdatatype_t rdatatype; dns_rdatatype_t rdatatype;
dns_rdata_t *rdata = NULL; dns_rdata_t *rdata = NULL;
isc_uint16_t retval; uint16_t retval;
ddebug("make_prereq()"); ddebug("make_prereq()");
@@ -1406,10 +1394,10 @@ make_prereq(char *cmdline, isc_boolean_t ispositive, isc_boolean_t isrrset) {
return (STATUS_SYNTAX); return (STATUS_SYNTAX);
} }
static isc_uint16_t static uint16_t
evaluate_prereq(char *cmdline) { evaluate_prereq(char *cmdline) {
char *word; char *word;
isc_boolean_t ispositive, isrrset; bool ispositive, isrrset;
ddebug("evaluate_prereq()"); ddebug("evaluate_prereq()");
word = nsu_strsep(&cmdline, " \t\r\n"); word = nsu_strsep(&cmdline, " \t\r\n");
@@ -1418,17 +1406,17 @@ evaluate_prereq(char *cmdline) {
return (STATUS_SYNTAX); return (STATUS_SYNTAX);
} }
if (strcasecmp(word, "nxdomain") == 0) { if (strcasecmp(word, "nxdomain") == 0) {
ispositive = ISC_FALSE; ispositive = false;
isrrset = ISC_FALSE; isrrset = false;
} else if (strcasecmp(word, "yxdomain") == 0) { } else if (strcasecmp(word, "yxdomain") == 0) {
ispositive = ISC_TRUE; ispositive = true;
isrrset = ISC_FALSE; isrrset = false;
} else if (strcasecmp(word, "nxrrset") == 0) { } else if (strcasecmp(word, "nxrrset") == 0) {
ispositive = ISC_FALSE; ispositive = false;
isrrset = ISC_TRUE; isrrset = true;
} else if (strcasecmp(word, "yxrrset") == 0) { } else if (strcasecmp(word, "yxrrset") == 0) {
ispositive = ISC_TRUE; ispositive = true;
isrrset = ISC_TRUE; isrrset = true;
} else { } else {
fprintf(stderr, "incorrect operation code: %s\n", word); fprintf(stderr, "incorrect operation code: %s\n", word);
return (STATUS_SYNTAX); return (STATUS_SYNTAX);
@@ -1436,7 +1424,7 @@ evaluate_prereq(char *cmdline) {
return (make_prereq(cmdline, ispositive, isrrset)); return (make_prereq(cmdline, ispositive, isrrset));
} }
static isc_uint16_t static uint16_t
evaluate_server(char *cmdline) { evaluate_server(char *cmdline) {
char *word, *server; char *word, *server;
long port; long port;
@@ -1475,7 +1463,7 @@ evaluate_server(char *cmdline) {
isc_mem_put(gmctx, servers, ns_alloc * sizeof(isc_sockaddr_t)); isc_mem_put(gmctx, servers, ns_alloc * sizeof(isc_sockaddr_t));
} }
default_servers = ISC_FALSE; default_servers = false;
ns_alloc = MAX_SERVERADDRS; ns_alloc = MAX_SERVERADDRS;
ns_inuse = 0; ns_inuse = 0;
@@ -1492,7 +1480,7 @@ evaluate_server(char *cmdline) {
return (STATUS_MORE); return (STATUS_MORE);
} }
static isc_uint16_t static uint16_t
evaluate_local(char *cmdline) { evaluate_local(char *cmdline) {
char *word, *local; char *word, *local;
long port; long port;
@@ -1542,7 +1530,7 @@ evaluate_local(char *cmdline) {
return (STATUS_MORE); return (STATUS_MORE);
} }
static isc_uint16_t static uint16_t
evaluate_key(char *cmdline) { evaluate_key(char *cmdline) {
char *namestr; char *namestr;
char *secretstr; char *secretstr;
@@ -1554,7 +1542,7 @@ evaluate_key(char *cmdline) {
unsigned char *secret = NULL; unsigned char *secret = NULL;
isc_buffer_t secretbuf; isc_buffer_t secretbuf;
const dns_name_t *hmacname = NULL; const dns_name_t *hmacname = NULL;
isc_uint16_t digestbits = 0; uint16_t digestbits = 0;
char *n; char *n;
namestr = nsu_strsep(&cmdline, " \t\r\n"); namestr = nsu_strsep(&cmdline, " \t\r\n");
@@ -1607,7 +1595,7 @@ evaluate_key(char *cmdline) {
if (tsigkey != NULL) if (tsigkey != NULL)
dns_tsigkey_detach(&tsigkey); dns_tsigkey_detach(&tsigkey);
result = dns_tsigkey_create(mykeyname, hmacname, secret, secretlen, result = dns_tsigkey_create(mykeyname, hmacname, secret, secretlen,
ISC_FALSE, NULL, 0, 0, gmctx, NULL, false, NULL, 0, 0, gmctx, NULL,
&tsigkey); &tsigkey);
isc_mem_free(gmctx, secret); isc_mem_free(gmctx, secret);
if (result != ISC_R_SUCCESS) { if (result != ISC_R_SUCCESS) {
@@ -1619,7 +1607,7 @@ evaluate_key(char *cmdline) {
return (STATUS_MORE); return (STATUS_MORE);
} }
static isc_uint16_t static uint16_t
evaluate_zone(char *cmdline) { evaluate_zone(char *cmdline) {
char *word; char *word;
isc_buffer_t b; isc_buffer_t b;
@@ -1644,7 +1632,7 @@ evaluate_zone(char *cmdline) {
return (STATUS_MORE); return (STATUS_MORE);
} }
static isc_uint16_t static uint16_t
evaluate_realm(char *cmdline) { evaluate_realm(char *cmdline) {
#ifdef GSSAPI #ifdef GSSAPI
char *word; char *word;
@@ -1675,11 +1663,11 @@ evaluate_realm(char *cmdline) {
#endif #endif
} }
static isc_uint16_t static uint16_t
evaluate_ttl(char *cmdline) { evaluate_ttl(char *cmdline) {
char *word; char *word;
isc_result_t result; isc_result_t result;
isc_uint32_t ttl; uint32_t ttl;
word = nsu_strsep(&cmdline, " \t\r\n"); word = nsu_strsep(&cmdline, " \t\r\n");
if (word == NULL || *word == 0) { if (word == NULL || *word == 0) {
@@ -1689,7 +1677,7 @@ evaluate_ttl(char *cmdline) {
if (!strcasecmp(word, "none")) { if (!strcasecmp(word, "none")) {
default_ttl = 0; default_ttl = 0;
default_ttl_set = ISC_FALSE; default_ttl_set = false;
return (STATUS_MORE); return (STATUS_MORE);
} }
@@ -1703,12 +1691,12 @@ evaluate_ttl(char *cmdline) {
return (STATUS_SYNTAX); return (STATUS_SYNTAX);
} }
default_ttl = ttl; default_ttl = ttl;
default_ttl_set = ISC_TRUE; default_ttl_set = true;
return (STATUS_MORE); return (STATUS_MORE);
} }
static isc_uint16_t static uint16_t
evaluate_class(char *cmdline) { evaluate_class(char *cmdline) {
char *word; char *word;
isc_textregion_t r; isc_textregion_t r;
@@ -1741,11 +1729,11 @@ evaluate_class(char *cmdline) {
return (STATUS_MORE); return (STATUS_MORE);
} }
static isc_uint16_t static uint16_t
update_addordelete(char *cmdline, isc_boolean_t isdelete) { update_addordelete(char *cmdline, bool isdelete) {
isc_result_t result; isc_result_t result;
dns_name_t *name = NULL; dns_name_t *name = NULL;
isc_uint32_t ttl; uint32_t ttl;
char *word; char *word;
dns_rdataclass_t rdataclass; dns_rdataclass_t rdataclass;
dns_rdatatype_t rdatatype; dns_rdatatype_t rdatatype;
@@ -1753,7 +1741,7 @@ update_addordelete(char *cmdline, isc_boolean_t isdelete) {
dns_rdatalist_t *rdatalist = NULL; dns_rdatalist_t *rdatalist = NULL;
dns_rdataset_t *rdataset = NULL; dns_rdataset_t *rdataset = NULL;
isc_textregion_t region; isc_textregion_t region;
isc_uint16_t retval; uint16_t retval;
ddebug("update_addordelete()"); ddebug("update_addordelete()");
@@ -1890,7 +1878,7 @@ update_addordelete(char *cmdline, isc_boolean_t isdelete) {
dns_name_t *bad; dns_name_t *bad;
if (!dns_rdata_checkowner(name, rdata->rdclass, rdata->type, if (!dns_rdata_checkowner(name, rdata->rdclass, rdata->type,
ISC_TRUE)) true))
{ {
char namebuf[DNS_NAME_FORMATSIZE]; char namebuf[DNS_NAME_FORMATSIZE];
@@ -1935,10 +1923,10 @@ update_addordelete(char *cmdline, isc_boolean_t isdelete) {
return (STATUS_SYNTAX); return (STATUS_SYNTAX);
} }
static isc_uint16_t static uint16_t
evaluate_update(char *cmdline) { evaluate_update(char *cmdline) {
char *word; char *word;
isc_boolean_t isdelete; bool isdelete;
ddebug("evaluate_update()"); ddebug("evaluate_update()");
word = nsu_strsep(&cmdline, " \t\r\n"); word = nsu_strsep(&cmdline, " \t\r\n");
@@ -1947,11 +1935,11 @@ evaluate_update(char *cmdline) {
return (STATUS_SYNTAX); return (STATUS_SYNTAX);
} }
if (strcasecmp(word, "delete") == 0) if (strcasecmp(word, "delete") == 0)
isdelete = ISC_TRUE; isdelete = true;
else if (strcasecmp(word, "del") == 0) else if (strcasecmp(word, "del") == 0)
isdelete = ISC_TRUE; isdelete = true;
else if (strcasecmp(word, "add") == 0) else if (strcasecmp(word, "add") == 0)
isdelete = ISC_FALSE; isdelete = false;
else { else {
fprintf(stderr, "incorrect operation code: %s\n", word); fprintf(stderr, "incorrect operation code: %s\n", word);
return (STATUS_SYNTAX); return (STATUS_SYNTAX);
@@ -1959,7 +1947,7 @@ evaluate_update(char *cmdline) {
return (update_addordelete(cmdline, isdelete)); return (update_addordelete(cmdline, isdelete));
} }
static isc_uint16_t static uint16_t
evaluate_checknames(char *cmdline) { evaluate_checknames(char *cmdline) {
char *word; char *word;
@@ -1972,11 +1960,11 @@ evaluate_checknames(char *cmdline) {
if (strcasecmp(word, "yes") == 0 || if (strcasecmp(word, "yes") == 0 ||
strcasecmp(word, "true") == 0 || strcasecmp(word, "true") == 0 ||
strcasecmp(word, "on") == 0) { strcasecmp(word, "on") == 0) {
checknames = ISC_TRUE; checknames = true;
} else if (strcasecmp(word, "no") == 0 || } else if (strcasecmp(word, "no") == 0 ||
strcasecmp(word, "false") == 0 || strcasecmp(word, "false") == 0 ||
strcasecmp(word, "off") == 0) { strcasecmp(word, "off") == 0) {
checknames = ISC_FALSE; checknames = false;
} else { } else {
fprintf(stderr, "incorrect check-names directive: %s\n", word); fprintf(stderr, "incorrect check-names directive: %s\n", word);
return (STATUS_SYNTAX); return (STATUS_SYNTAX);
@@ -2054,7 +2042,7 @@ show_message(FILE *stream, dns_message_t *msg, const char *description) {
isc_buffer_free(&buf); isc_buffer_free(&buf);
} }
static isc_uint16_t static uint16_t
do_next_command(char *cmdline) { do_next_command(char *cmdline) {
char *word; char *word;
@@ -2070,21 +2058,21 @@ do_next_command(char *cmdline) {
if (strcasecmp(word, "prereq") == 0) if (strcasecmp(word, "prereq") == 0)
return (evaluate_prereq(cmdline)); return (evaluate_prereq(cmdline));
if (strcasecmp(word, "nxdomain") == 0) if (strcasecmp(word, "nxdomain") == 0)
return (make_prereq(cmdline, ISC_FALSE, ISC_FALSE)); return (make_prereq(cmdline, false, false));
if (strcasecmp(word, "yxdomain") == 0) if (strcasecmp(word, "yxdomain") == 0)
return (make_prereq(cmdline, ISC_TRUE, ISC_FALSE)); return (make_prereq(cmdline, true, false));
if (strcasecmp(word, "nxrrset") == 0) if (strcasecmp(word, "nxrrset") == 0)
return (make_prereq(cmdline, ISC_FALSE, ISC_TRUE)); return (make_prereq(cmdline, false, true));
if (strcasecmp(word, "yxrrset") == 0) if (strcasecmp(word, "yxrrset") == 0)
return (make_prereq(cmdline, ISC_TRUE, ISC_TRUE)); return (make_prereq(cmdline, true, true));
if (strcasecmp(word, "update") == 0) if (strcasecmp(word, "update") == 0)
return (evaluate_update(cmdline)); return (evaluate_update(cmdline));
if (strcasecmp(word, "delete") == 0) if (strcasecmp(word, "delete") == 0)
return (update_addordelete(cmdline, ISC_TRUE)); return (update_addordelete(cmdline, true));
if (strcasecmp(word, "del") == 0) if (strcasecmp(word, "del") == 0)
return (update_addordelete(cmdline, ISC_TRUE)); return (update_addordelete(cmdline, true));
if (strcasecmp(word, "add") == 0) if (strcasecmp(word, "add") == 0)
return (update_addordelete(cmdline, ISC_FALSE)); return (update_addordelete(cmdline, false));
if (strcasecmp(word, "server") == 0) if (strcasecmp(word, "server") == 0)
return (evaluate_server(cmdline)); return (evaluate_server(cmdline));
if (strcasecmp(word, "local") == 0) if (strcasecmp(word, "local") == 0)
@@ -2097,9 +2085,9 @@ do_next_command(char *cmdline) {
return (STATUS_SEND); return (STATUS_SEND);
if (strcasecmp(word, "debug") == 0) { if (strcasecmp(word, "debug") == 0) {
if (debugging) if (debugging)
ddebugging = ISC_TRUE; ddebugging = true;
else else
debugging = ISC_TRUE; debugging = true;
return (STATUS_MORE); return (STATUS_MORE);
} }
if (strcasecmp(word, "ttl") == 0) if (strcasecmp(word, "ttl") == 0)
@@ -2114,7 +2102,7 @@ do_next_command(char *cmdline) {
return (STATUS_MORE); return (STATUS_MORE);
} }
if (strcasecmp(word, "key") == 0) { if (strcasecmp(word, "key") == 0) {
usegsstsig = ISC_FALSE; usegsstsig = false;
return (evaluate_key(cmdline)); return (evaluate_key(cmdline));
} }
if (strcasecmp(word, "realm") == 0) if (strcasecmp(word, "realm") == 0)
@@ -2124,8 +2112,8 @@ do_next_command(char *cmdline) {
return (evaluate_checknames(cmdline)); return (evaluate_checknames(cmdline));
if (strcasecmp(word, "gsstsig") == 0) { if (strcasecmp(word, "gsstsig") == 0) {
#ifdef GSSAPI #ifdef GSSAPI
usegsstsig = ISC_TRUE; usegsstsig = true;
use_win2k_gsstsig = ISC_FALSE; use_win2k_gsstsig = false;
#else #else
fprintf(stderr, "gsstsig not supported\n"); fprintf(stderr, "gsstsig not supported\n");
#endif #endif
@@ -2133,8 +2121,8 @@ do_next_command(char *cmdline) {
} }
if (strcasecmp(word, "oldgsstsig") == 0) { if (strcasecmp(word, "oldgsstsig") == 0) {
#ifdef GSSAPI #ifdef GSSAPI
usegsstsig = ISC_TRUE; usegsstsig = true;
use_win2k_gsstsig = ISC_TRUE; use_win2k_gsstsig = true;
#else #else
fprintf(stderr, "gsstsig not supported\n"); fprintf(stderr, "gsstsig not supported\n");
#endif #endif
@@ -2172,9 +2160,9 @@ do_next_command(char *cmdline) {
return (STATUS_SYNTAX); return (STATUS_SYNTAX);
} }
static isc_uint16_t static uint16_t
get_next_command(void) { get_next_command(void) {
isc_uint16_t result = STATUS_QUIT; uint16_t result = STATUS_QUIT;
char cmdlinebuf[MAXCMD]; char cmdlinebuf[MAXCMD];
char *cmdline; char *cmdline;
@@ -2210,9 +2198,9 @@ get_next_command(void) {
return (result); return (result);
} }
static isc_boolean_t static bool
user_interaction(void) { user_interaction(void) {
isc_uint16_t result = STATUS_MORE; uint16_t result = STATUS_MORE;
ddebug("user_interaction()"); ddebug("user_interaction()");
while ((result == STATUS_MORE) || (result == STATUS_SYNTAX)) { while ((result == STATUS_MORE) || (result == STATUS_SYNTAX)) {
@@ -2221,8 +2209,8 @@ user_interaction(void) {
fatal("syntax error"); fatal("syntax error");
} }
if (result == STATUS_SEND) if (result == STATUS_SEND)
return (ISC_TRUE); return (true);
return (ISC_FALSE); return (false);
} }
@@ -2256,7 +2244,7 @@ check_tsig_error(dns_rdataset_t *rdataset, isc_buffer_t *b) {
} }
} }
static isc_boolean_t static bool
next_master(const char *caller, isc_sockaddr_t *addr, isc_result_t eresult) { next_master(const char *caller, isc_sockaddr_t *addr, isc_result_t eresult) {
char addrbuf[ISC_SOCKADDR_FORMATSIZE]; char addrbuf[ISC_SOCKADDR_FORMATSIZE];
@@ -2264,9 +2252,9 @@ next_master(const char *caller, isc_sockaddr_t *addr, isc_result_t eresult) {
fprintf(stderr, "; Communication with %s failed: %s\n", fprintf(stderr, "; Communication with %s failed: %s\n",
addrbuf, isc_result_totext(eresult)); addrbuf, isc_result_totext(eresult));
if (++master_inuse >= master_total) if (++master_inuse >= master_total)
return (ISC_FALSE); return (false);
ddebug("%s: trying next server", caller); ddebug("%s: trying next server", caller);
return (ISC_TRUE); return (true);
} }
static void static void
@@ -2297,7 +2285,7 @@ update_completed(isc_task_t *task, isc_event_t *event) {
&master_servers[master_inuse], &master_servers[master_inuse],
reqev->result)) reqev->result))
{ {
seenerror = ISC_TRUE; seenerror = true;
goto done; goto done;
} }
@@ -2335,14 +2323,14 @@ update_completed(isc_task_t *task, isc_event_t *event) {
#endif #endif
fprintf(stderr, "; TSIG error with server: %s\n", fprintf(stderr, "; TSIG error with server: %s\n",
isc_result_totext(result)); isc_result_totext(result));
seenerror = ISC_TRUE; seenerror = true;
break; break;
default: default:
check_result(result, "dns_request_getresponse"); check_result(result, "dns_request_getresponse");
} }
if (answer->rcode != dns_rcode_noerror) { if (answer->rcode != dns_rcode_noerror) {
seenerror = ISC_TRUE; seenerror = true;
if (!debugging) { if (!debugging) {
char buf[64]; char buf[64];
isc_buffer_t b; isc_buffer_t b;
@@ -2446,7 +2434,7 @@ recvsoa(isc_task_t *task, isc_event_t *event) {
dns_message_t *soaquery = NULL; dns_message_t *soaquery = NULL;
isc_sockaddr_t *addr; isc_sockaddr_t *addr;
isc_sockaddr_t *srcaddr; isc_sockaddr_t *srcaddr;
isc_boolean_t seencname = ISC_FALSE; bool seencname = false;
dns_name_t tname; dns_name_t tname;
unsigned int nlabels; unsigned int nlabels;
@@ -2543,7 +2531,7 @@ recvsoa(isc_task_t *task, isc_event_t *event) {
dns_message_destroy(&soaquery); dns_message_destroy(&soaquery);
ddebug("Out of recvsoa"); ddebug("Out of recvsoa");
done_update(); done_update();
seenerror = ISC_TRUE; seenerror = true;
return; return;
} }
@@ -2574,7 +2562,7 @@ recvsoa(isc_task_t *task, isc_event_t *event) {
&tset) == ISC_R_SUCCESS || &tset) == ISC_R_SUCCESS ||
dns_message_findtype(name, dns_rdatatype_dname, 0, dns_message_findtype(name, dns_rdatatype_dname, 0,
&tset) == ISC_R_SUCCESS ) { &tset) == ISC_R_SUCCESS ) {
seencname = ISC_TRUE; seencname = true;
break; break;
} }
} }
@@ -2630,7 +2618,7 @@ recvsoa(isc_task_t *task, isc_event_t *event) {
size_t size; size_t size;
isc_buffer_init(&buf, serverstr, sizeof(serverstr)); isc_buffer_init(&buf, serverstr, sizeof(serverstr));
result = dns_name_totext(&master, ISC_TRUE, &buf); result = dns_name_totext(&master, true, &buf);
check_result(result, "dns_name_totext"); check_result(result, "dns_name_totext");
serverstr[isc_buffer_usedlength(&buf)] = 0; serverstr[isc_buffer_usedlength(&buf)] = 0;
@@ -2777,7 +2765,7 @@ get_ticket_realm(isc_mem_t *mctx) {
static void static void
failed_gssrequest() { failed_gssrequest() {
seenerror = ISC_TRUE; seenerror = true;
dns_name_free(&tmpzonename, gmctx); dns_name_free(&tmpzonename, gmctx);
dns_name_free(&restart_master, gmctx); dns_name_free(&restart_master, gmctx);
@@ -2790,7 +2778,7 @@ start_gssrequest(dns_name_t *master) {
gss_ctx_id_t context; gss_ctx_id_t context;
isc_buffer_t buf; isc_buffer_t buf;
isc_result_t result; isc_result_t result;
isc_uint32_t val = 0; uint32_t val = 0;
dns_message_t *rmsg = NULL; dns_message_t *rmsg = NULL;
dns_request_t *request = NULL; dns_request_t *request = NULL;
dns_name_t *servname; dns_name_t *servname;
@@ -2800,7 +2788,7 @@ start_gssrequest(dns_name_t *master) {
char *err_message = NULL; char *err_message = NULL;
debug("start_gssrequest"); debug("start_gssrequest");
usevc = ISC_TRUE; usevc = true;
if (gssring != NULL) if (gssring != NULL)
dns_tsigkeyring_detach(&gssring); dns_tsigkeyring_detach(&gssring);
@@ -2998,10 +2986,10 @@ recvgss(isc_task_t *task, isc_event_t *event) {
ddebug("recvgss trying %s GSS-TSIG", ddebug("recvgss trying %s GSS-TSIG",
use_win2k_gsstsig ? "Standard" : "Win2k"); use_win2k_gsstsig ? "Standard" : "Win2k");
if (use_win2k_gsstsig) if (use_win2k_gsstsig)
use_win2k_gsstsig = ISC_FALSE; use_win2k_gsstsig = false;
else else
use_win2k_gsstsig = ISC_TRUE; use_win2k_gsstsig = true;
tried_other_gsstsig = ISC_TRUE; tried_other_gsstsig = true;
start_gssrequest(&restart_master); start_gssrequest(&restart_master);
goto done; goto done;
} }
@@ -3221,7 +3209,7 @@ cleanup(void) {
static void static void
getinput(isc_task_t *task, isc_event_t *event) { getinput(isc_task_t *task, isc_event_t *event) {
isc_boolean_t more; bool more;
UNUSED(task); UNUSED(task);
@@ -3250,15 +3238,15 @@ main(int argc, char **argv) {
input = stdin; input = stdin;
interactive = ISC_TF(isatty(0)); interactive = isatty(0);
isc_app_start(); isc_app_start();
if (isc_net_probeipv4() == ISC_R_SUCCESS) { if (isc_net_probeipv4() == ISC_R_SUCCESS) {
have_ipv4 = ISC_TRUE; have_ipv4 = true;
} }
if (isc_net_probeipv6() == ISC_R_SUCCESS) { if (isc_net_probeipv6() == ISC_R_SUCCESS) {
have_ipv6 = ISC_TRUE; have_ipv6 = true;
} }
if (!have_ipv4 && !have_ipv6) { if (!have_ipv4 && !have_ipv6) {
fatal("could not find either IPv4 or IPv6"); fatal("could not find either IPv4 or IPv6");
+2 -2
View File
@@ -68,7 +68,7 @@
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<AdditionalLibraryDirectories>..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\irs\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\irs\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>@READLINE_LIBD@@GSSAPI_LIB@@KRB5_LIB@libisc.lib;libdns.lib;libbind9.lib;libisccfg.lib;libirs.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@@READLINE_LIBD@@GSSAPI_LIB@@KRB5_LIB@libisc.lib;libdns.lib;libbind9.lib;libisccfg.lib;libirs.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'"> <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'">
@@ -98,7 +98,7 @@
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration> <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
<AdditionalLibraryDirectories>..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\irs\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\irs\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>@READLINE_LIB@@GSSAPI_LIB@@KRB5_LIB@libisc.lib;libdns.lib;libbind9.lib;libisccfg.lib;libirs.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@@READLINE_LIB@@GSSAPI_LIB@@KRB5_LIB@libisc.lib;libdns.lib;libbind9.lib;libisccfg.lib;libirs.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemGroup> <ItemGroup>
+2 -2
View File
@@ -149,8 +149,8 @@ main(int argc, char *argv[]) {
pin = getpass("Enter Pin: "); pin = getpass("Enter Pin: ");
} }
result = pk11_get_session(&pctx, OP_ANY, ISC_FALSE, ISC_TRUE, result = pk11_get_session(&pctx, OP_ANY, false, true,
ISC_TRUE, (const char *) pin, slot); true, (const char *) pin, slot);
if (result == PK11_R_NORANDOMSERVICE || if (result == PK11_R_NORANDOMSERVICE ||
result == PK11_R_NODIGESTSERVICE || result == PK11_R_NODIGESTSERVICE ||
result == PK11_R_NOAESSERVICE) { result == PK11_R_NOAESSERVICE) {
+2 -2
View File
@@ -563,8 +563,8 @@ main(int argc, char *argv[]) {
pin = getpass("Enter Pin: "); pin = getpass("Enter Pin: ");
} }
result = pk11_get_session(&pctx, op_type, ISC_FALSE, ISC_TRUE, result = pk11_get_session(&pctx, op_type, false, true,
ISC_TRUE, (const char *) pin, slot); true, (const char *) pin, slot);
if (result == PK11_R_NORANDOMSERVICE || if (result == PK11_R_NORANDOMSERVICE ||
result == PK11_R_NODIGESTSERVICE || result == PK11_R_NODIGESTSERVICE ||
result == PK11_R_NOAESSERVICE) { result == PK11_R_NOAESSERVICE) {
+5 -4
View File
@@ -41,6 +41,7 @@
#include <config.h> #include <config.h>
#include <stdio.h> #include <stdio.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <fcntl.h> #include <fcntl.h>
#include <errno.h> #include <errno.h>
@@ -67,7 +68,7 @@ main(int argc, char *argv[]) {
char *lib_name = NULL; char *lib_name = NULL;
char *label = NULL; char *label = NULL;
char *pin = NULL; char *pin = NULL;
isc_boolean_t error = ISC_FALSE, logon = ISC_TRUE, all = ISC_FALSE; bool error = false, logon = true, all = false;
unsigned int i = 0, id = 0; unsigned int i = 0, id = 0;
int c, errflg = 0; int c, errflg = 0;
CK_ULONG ulObjectCount; CK_ULONG ulObjectCount;
@@ -78,7 +79,7 @@ main(int argc, char *argv[]) {
while ((c = isc_commandline_parse(argc, argv, ":m:s:i:l:p:P")) != -1) { while ((c = isc_commandline_parse(argc, argv, ":m:s:i:l:p:P")) != -1) {
switch (c) { switch (c) {
case 'P': case 'P':
logon = ISC_FALSE; logon = false;
break; break;
case 'm': case 'm':
lib_name = isc_commandline_argument; lib_name = isc_commandline_argument;
@@ -117,7 +118,7 @@ main(int argc, char *argv[]) {
} }
if (!id && (label == NULL)) if (!id && (label == NULL))
all = ISC_TRUE; all = true;
if (slot) if (slot)
printf("slot %lu\n", slot); printf("slot %lu\n", slot);
@@ -143,7 +144,7 @@ main(int argc, char *argv[]) {
pin = getpass("Enter Pin: "); pin = getpass("Enter Pin: ");
} }
result = pk11_get_session(&pctx, OP_ANY, ISC_FALSE, ISC_FALSE, result = pk11_get_session(&pctx, OP_ANY, false, false,
logon, pin, slot); logon, pin, slot);
if (result == PK11_R_NORANDOMSERVICE || if (result == PK11_R_NORANDOMSERVICE ||
result == PK11_R_NODIGESTSERVICE || result == PK11_R_NODIGESTSERVICE ||
+3 -3
View File
@@ -46,7 +46,7 @@ main(int argc, char *argv[]) {
lib_name = isc_commandline_argument; lib_name = isc_commandline_argument;
break; break;
case 'v': case 'v':
pk11_verbose_init = ISC_TRUE; pk11_verbose_init = true;
break; break;
case ':': case ':':
fprintf(stderr, "Option -%c requires an operand\n", fprintf(stderr, "Option -%c requires an operand\n",
@@ -78,8 +78,8 @@ main(int argc, char *argv[]) {
if (lib_name != NULL) if (lib_name != NULL)
pk11_set_lib_name(lib_name); pk11_set_lib_name(lib_name);
result = pk11_get_session(&pctx, OP_ANY, ISC_TRUE, ISC_FALSE, result = pk11_get_session(&pctx, OP_ANY, true, false,
ISC_FALSE, NULL, 0); false, NULL, 0);
if (result == PK11_R_NORANDOMSERVICE || if (result == PK11_R_NORANDOMSERVICE ||
result == PK11_R_NODIGESTSERVICE || result == PK11_R_NODIGESTSERVICE ||
result == PK11_R_NOAESSERVICE) { result == PK11_R_NOAESSERVICE) {
+2 -2
View File
@@ -70,7 +70,7 @@
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>libisc.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@libisc.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'"> <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'">
@@ -100,7 +100,7 @@
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration> <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>libisc.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@libisc.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemGroup> <ItemGroup>
+2 -2
View File
@@ -70,7 +70,7 @@
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>libisc.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@libisc.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'"> <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'">
@@ -100,7 +100,7 @@
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration> <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>libisc.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@libisc.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemGroup> <ItemGroup>
+2 -2
View File
@@ -70,7 +70,7 @@
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>libisc.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@libisc.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'"> <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'">
@@ -100,7 +100,7 @@
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration> <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>libisc.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@libisc.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemGroup> <ItemGroup>
+2 -2
View File
@@ -70,7 +70,7 @@
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>libisc.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@libisc.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'"> <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'">
@@ -100,7 +100,7 @@
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration> <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>libisc.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@libisc.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemGroup> <ItemGroup>
+32 -30
View File
@@ -13,6 +13,8 @@
#include <config.h> #include <config.h>
#include <inttypes.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <isc/app.h> #include <isc/app.h>
@@ -53,7 +55,7 @@
#define SERVERADDRS 10 #define SERVERADDRS 10
const char *progname; const char *progname;
isc_boolean_t verbose; bool verbose;
static const char *admin_conffile; static const char *admin_conffile;
static const char *admin_keyfile; static const char *admin_keyfile;
@@ -61,26 +63,26 @@ static const char *version = VERSION;
static const char *servername = NULL; static const char *servername = NULL;
static isc_sockaddr_t serveraddrs[SERVERADDRS]; static isc_sockaddr_t serveraddrs[SERVERADDRS];
static isc_sockaddr_t local4, local6; static isc_sockaddr_t local4, local6;
static isc_boolean_t local4set = ISC_FALSE, local6set = ISC_FALSE; static bool local4set = false, local6set = false;
static int nserveraddrs; static int nserveraddrs;
static int currentaddr = 0; static int currentaddr = 0;
static unsigned int remoteport = 0; static unsigned int remoteport = 0;
static isc_socketmgr_t *socketmgr = NULL; static isc_socketmgr_t *socketmgr = NULL;
static isc_buffer_t *databuf; static isc_buffer_t *databuf;
static isccc_ccmsg_t ccmsg; static isccc_ccmsg_t ccmsg;
static isc_uint32_t algorithm; static uint32_t algorithm;
static isccc_region_t secret; static isccc_region_t secret;
static isc_boolean_t failed = ISC_FALSE; static bool failed = false;
static isc_boolean_t c_flag = ISC_FALSE; static bool c_flag = false;
static isc_mem_t *rndc_mctx; static isc_mem_t *rndc_mctx;
static int sends, recvs, connects; static int sends, recvs, connects;
static char *command; static char *command;
static char *args; static char *args;
static char program[256]; static char program[256];
static isc_socket_t *sock = NULL; static isc_socket_t *sock = NULL;
static isc_uint32_t serial; static uint32_t serial;
static isc_boolean_t quiet = ISC_FALSE; static bool quiet = false;
static isc_boolean_t showresult = ISC_FALSE; static bool showresult = false;
static void rndc_startconnect(isc_sockaddr_t *addr, isc_task_t *task); static void rndc_startconnect(isc_sockaddr_t *addr, isc_task_t *task);
@@ -216,7 +218,7 @@ Version: %s\n",
static void static void
preparse_args(int argc, char **argv) { preparse_args(int argc, char **argv) {
isc_boolean_t ipv4only = ISC_FALSE, ipv6only = ISC_FALSE; bool ipv4only = false, ipv6only = false;
int ch; int ch;
while ((ch = isc_commandline_parse(argc, argv, CMDLINE_FLAGS)) != -1) { while ((ch = isc_commandline_parse(argc, argv, CMDLINE_FLAGS)) != -1) {
@@ -225,20 +227,20 @@ preparse_args(int argc, char **argv) {
if (ipv6only) { if (ipv6only) {
fatal("only one of -4 and -6 allowed"); fatal("only one of -4 and -6 allowed");
} }
ipv4only = ISC_TRUE; ipv4only = true;
break; break;
case '6': case '6':
if (ipv4only) { if (ipv4only) {
fatal("only one of -4 and -6 allowed"); fatal("only one of -4 and -6 allowed");
} }
ipv6only = ISC_TRUE; ipv6only = true;
break; break;
default: default:
break; break;
} }
} }
isc_commandline_reset = ISC_TRUE; isc_commandline_reset = true;
isc_commandline_index = 1; isc_commandline_index = 1;
} }
@@ -316,7 +318,7 @@ rndc_recvdone(isc_task_t *task, isc_event_t *event) {
fatal("bad or missing data section in response"); fatal("bad or missing data section in response");
result = isccc_cc_lookupstring(data, "err", &errormsg); result = isccc_cc_lookupstring(data, "err", &errormsg);
if (result == ISC_R_SUCCESS) { if (result == ISC_R_SUCCESS) {
failed = ISC_TRUE; failed = true;
fprintf(stderr, "%s: '%s' failed: %s\n", fprintf(stderr, "%s: '%s' failed: %s\n",
progname, command, errormsg); progname, command, errormsg);
} }
@@ -357,7 +359,7 @@ rndc_recvnonce(isc_task_t *task, isc_event_t *event) {
isccc_sexpr_t *_ctrl; isccc_sexpr_t *_ctrl;
isccc_region_t source; isccc_region_t source;
isc_result_t result; isc_result_t result;
isc_uint32_t nonce; uint32_t nonce;
isccc_sexpr_t *request = NULL; isccc_sexpr_t *request = NULL;
isccc_time_t now; isccc_time_t now;
isc_region_t r; isc_region_t r;
@@ -565,7 +567,7 @@ parse_config(isc_mem_t *mctx, isc_log_t *log, const char *keyname,
const char *algorithmstr; const char *algorithmstr;
static char secretarray[1024]; static char secretarray[1024];
const cfg_type_t *conftype = &cfg_type_rndcconf; const cfg_type_t *conftype = &cfg_type_rndcconf;
isc_boolean_t key_only = ISC_FALSE; bool key_only = false;
const cfg_listelt_t *element; const cfg_listelt_t *element;
if (! isc_file_exists(conffile)) { if (! isc_file_exists(conffile)) {
@@ -578,7 +580,7 @@ parse_config(isc_mem_t *mctx, isc_log_t *log, const char *keyname,
if (! isc_file_exists(conffile)) if (! isc_file_exists(conffile))
fatal("neither %s nor %s was found", fatal("neither %s nor %s was found",
admin_conffile, admin_keyfile); admin_conffile, admin_keyfile);
key_only = ISC_TRUE; key_only = true;
} else if (! c_flag && isc_file_exists(admin_keyfile)) { } else if (! c_flag && isc_file_exists(admin_keyfile)) {
fprintf(stderr, "WARNING: key file (%s) exists, but using " fprintf(stderr, "WARNING: key file (%s) exists, but using "
"default configuration file (%s)\n", "default configuration file (%s)\n",
@@ -730,7 +732,7 @@ parse_config(isc_mem_t *mctx, isc_log_t *log, const char *keyname,
obj = cfg_tuple_get(address, "port"); obj = cfg_tuple_get(address, "port");
if (cfg_obj_isuint32(obj)) { if (cfg_obj_isuint32(obj)) {
myport = cfg_obj_asuint32(obj); myport = cfg_obj_asuint32(obj);
if (myport > ISC_UINT16_MAX || if (myport > UINT16_MAX ||
myport == 0) myport == 0)
fatal("port %u out of range", fatal("port %u out of range",
myport); myport);
@@ -765,7 +767,7 @@ parse_config(isc_mem_t *mctx, isc_log_t *log, const char *keyname,
cfg_map_get(server, "source-address", &address); cfg_map_get(server, "source-address", &address);
if (address != NULL) { if (address != NULL) {
local4 = *cfg_obj_assockaddr(address); local4 = *cfg_obj_assockaddr(address);
local4set = ISC_TRUE; local4set = true;
} }
} }
if (!local4set && options != NULL) { if (!local4set && options != NULL) {
@@ -773,7 +775,7 @@ parse_config(isc_mem_t *mctx, isc_log_t *log, const char *keyname,
cfg_map_get(options, "default-source-address", &address); cfg_map_get(options, "default-source-address", &address);
if (address != NULL) { if (address != NULL) {
local4 = *cfg_obj_assockaddr(address); local4 = *cfg_obj_assockaddr(address);
local4set = ISC_TRUE; local4set = true;
} }
} }
@@ -782,7 +784,7 @@ parse_config(isc_mem_t *mctx, isc_log_t *log, const char *keyname,
cfg_map_get(server, "source-address-v6", &address); cfg_map_get(server, "source-address-v6", &address);
if (address != NULL) { if (address != NULL) {
local6 = *cfg_obj_assockaddr(address); local6 = *cfg_obj_assockaddr(address);
local6set = ISC_TRUE; local6set = true;
} }
} }
if (!local6set && options != NULL) { if (!local6set && options != NULL) {
@@ -790,7 +792,7 @@ parse_config(isc_mem_t *mctx, isc_log_t *log, const char *keyname,
cfg_map_get(options, "default-source-address-v6", &address); cfg_map_get(options, "default-source-address-v6", &address);
if (address != NULL) { if (address != NULL) {
local6 = *cfg_obj_assockaddr(address); local6 = *cfg_obj_assockaddr(address);
local6set = ISC_TRUE; local6set = true;
} }
} }
@@ -800,7 +802,7 @@ parse_config(isc_mem_t *mctx, isc_log_t *log, const char *keyname,
int int
main(int argc, char **argv) { main(int argc, char **argv) {
isc_result_t result = ISC_R_SUCCESS; isc_result_t result = ISC_R_SUCCESS;
isc_boolean_t show_final_mem = ISC_FALSE; bool show_final_mem = false;
isc_taskmgr_t *taskmgr = NULL; isc_taskmgr_t *taskmgr = NULL;
isc_task_t *task = NULL; isc_task_t *task = NULL;
isc_log_t *log = NULL; isc_log_t *log = NULL;
@@ -831,7 +833,7 @@ main(int argc, char **argv) {
if (result != ISC_R_SUCCESS) if (result != ISC_R_SUCCESS)
fatal("isc_app_start() failed: %s", isc_result_totext(result)); fatal("isc_app_start() failed: %s", isc_result_totext(result));
isc_commandline_errprint = ISC_FALSE; isc_commandline_errprint = false;
preparse_args(argc, argv); preparse_args(argc, argv);
@@ -853,17 +855,17 @@ main(int argc, char **argv) {
if (inet_pton(AF_INET, isc_commandline_argument, if (inet_pton(AF_INET, isc_commandline_argument,
&in) == 1) { &in) == 1) {
isc_sockaddr_fromin(&local4, &in, 0); isc_sockaddr_fromin(&local4, &in, 0);
local4set = ISC_TRUE; local4set = true;
} else if (inet_pton(AF_INET6, isc_commandline_argument, } else if (inet_pton(AF_INET6, isc_commandline_argument,
&in6) == 1) { &in6) == 1) {
isc_sockaddr_fromin6(&local6, &in6, 0); isc_sockaddr_fromin6(&local6, &in6, 0);
local6set = ISC_TRUE; local6set = true;
} }
break; break;
case 'c': case 'c':
admin_conffile = isc_commandline_argument; admin_conffile = isc_commandline_argument;
c_flag = ISC_TRUE; c_flag = true;
break; break;
case 'k': case 'k':
@@ -875,7 +877,7 @@ main(int argc, char **argv) {
break; break;
case 'm': case 'm':
show_final_mem = ISC_TRUE; show_final_mem = true;
break; break;
case 'p': case 'p':
@@ -886,11 +888,11 @@ main(int argc, char **argv) {
break; break;
case 'q': case 'q':
quiet = ISC_TRUE; quiet = true;
break; break;
case 'r': case 'r':
showresult = ISC_TRUE; showresult = true;
break; break;
case 's': case 's':
@@ -898,7 +900,7 @@ main(int argc, char **argv) {
break; break;
case 'V': case 'V':
verbose = ISC_TRUE; verbose = true;
break; break;
case 'y': case 'y':
+2 -2
View File
@@ -15,15 +15,15 @@
#include <config.h> #include <config.h>
#include <stdarg.h> #include <stdarg.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <isc/boolean.h>
#include <isc/print.h> #include <isc/print.h>
#include "util.h" #include "util.h"
extern isc_boolean_t verbose; extern bool verbose;
extern const char *progname; extern const char *progname;
void void
+2 -2
View File
@@ -68,7 +68,7 @@
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\isccc\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\isccc\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>util.lib;libisc.lib;libdns.lib;libisccfg.lib;libisccc.lib;libbind9.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@util.lib;libisc.lib;libdns.lib;libisccfg.lib;libisccc.lib;libbind9.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'"> <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|@PLATFORM@'">
@@ -98,7 +98,7 @@
<OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile> <OutputFile>..\..\..\Build\$(Configuration)\$(TargetName)$(TargetExt)</OutputFile>
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration> <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
<AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\isccc\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>$(Configuration);..\..\..\lib\isc\win32\$(Configuration);..\..\..\lib\dns\win32\$(Configuration);..\..\..\lib\isccfg\win32\$(Configuration);..\..\..\lib\isccc\win32\$(Configuration);..\..\..\lib\bind9\win32\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>util.lib;libisc.lib;libdns.lib;libisccfg.lib;libisccc.lib;libbind9.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>@OPENSSL_LIB@util.lib;libisc.lib;libdns.lib;libisccfg.lib;libisccc.lib;libbind9.lib;ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemGroup> <ItemGroup>
+5 -4
View File
@@ -15,6 +15,7 @@
#include <config.h> #include <config.h>
#include <errno.h> #include <errno.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <isc/mem.h> #include <isc/mem.h>
@@ -64,8 +65,8 @@ main(int argc, char **argv) {
cfg_parser_t *pctx = NULL; cfg_parser_t *pctx = NULL;
cfg_obj_t *cfg = NULL; cfg_obj_t *cfg = NULL;
cfg_type_t *type = NULL; cfg_type_t *type = NULL;
isc_boolean_t grammar = ISC_FALSE; bool grammar = false;
isc_boolean_t memstats = ISC_FALSE; bool memstats = false;
char *filename = NULL; char *filename = NULL;
unsigned int zonetype = 0; unsigned int zonetype = 0;
@@ -100,7 +101,7 @@ main(int argc, char **argv) {
while (argc > 1) { while (argc > 1) {
if (strcmp(argv[1], "--grammar") == 0) { if (strcmp(argv[1], "--grammar") == 0) {
grammar = ISC_TRUE; grammar = true;
} else if (strcmp(argv[1], "--zonegrammar") == 0) { } else if (strcmp(argv[1], "--zonegrammar") == 0) {
argv++, argc--; argv++, argc--;
if (argc <= 1) { if (argc <= 1) {
@@ -132,7 +133,7 @@ main(int argc, char **argv) {
usage(); usage();
} }
} else if (strcmp(argv[1], "--memstats") == 0) { } else if (strcmp(argv[1], "--memstats") == 0) {
memstats = ISC_TRUE; memstats = true;
} else if (strcmp(argv[1], "--named") == 0) { } else if (strcmp(argv[1], "--named") == 0) {
type = &cfg_type_namedconf; type = &cfg_type_namedconf;
} else if (strcmp(argv[1], "--rndc") == 0) { } else if (strcmp(argv[1], "--rndc") == 0) {
+5 -3
View File
@@ -12,6 +12,8 @@
/*! \file */ /*! \file */
#include <config.h> #include <config.h>
#include <stdbool.h>
#include <isc/hash.h> #include <isc/hash.h>
#include <isc/log.h> #include <isc/log.h>
#include <isc/mem.h> #include <isc/mem.h>
@@ -38,7 +40,7 @@
isc_mem_t *mctx = NULL; isc_mem_t *mctx = NULL;
isc_log_t *lctx = NULL; isc_log_t *lctx = NULL;
static isc_boolean_t dst_active = ISC_FALSE; static bool dst_active = false;
/* /*
* Logging categories: this needs to match the list in bin/named/log.c. * Logging categories: this needs to match the list in bin/named/log.c.
@@ -98,7 +100,7 @@ main(int argc, char **argv) {
CHECK(isc_mem_create(0, 0, &mctx)); CHECK(isc_mem_create(0, 0, &mctx));
CHECK(dst_lib_init(mctx, NULL)); CHECK(dst_lib_init(mctx, NULL));
dst_active = ISC_TRUE; dst_active = true;
CHECK(isc_log_create(mctx, &lctx, &logconfig)); CHECK(isc_log_create(mctx, &lctx, &logconfig));
isc_log_registercategories(lctx, categories); isc_log_registercategories(lctx, categories);
@@ -144,7 +146,7 @@ main(int argc, char **argv) {
isc_log_destroy(&lctx); isc_log_destroy(&lctx);
if (dst_active) { if (dst_active) {
dst_lib_destroy(); dst_lib_destroy();
dst_active = ISC_FALSE; dst_active = false;
} }
if (mctx != NULL) if (mctx != NULL)
isc_mem_destroy(&mctx); isc_mem_destroy(&mctx);
+2 -7
View File
@@ -20,6 +20,7 @@ CDEFINES = @USE_GSSAPI@
CWARNINGS = CWARNINGS =
BACKTRACECFLAGS = @BACKTRACECFLAGS@ BACKTRACECFLAGS = @BACKTRACECFLAGS@
PTHREAD_CFLAGS = @PTHREAD_CFLAGS@
DNSLIBS = ../../../lib/dns/libdns.@A@ @DNS_CRYPTO_LIBS@ DNSLIBS = ../../../lib/dns/libdns.@A@ @DNS_CRYPTO_LIBS@
ISCLIBS = ../../../lib/isc/libisc.@A@ @OPENSSL_LIBS@ ISCLIBS = ../../../lib/isc/libisc.@A@ @OPENSSL_LIBS@
@@ -51,7 +52,6 @@ XTARGETS = adb_test@EXEEXT@ \
hash_test@EXEEXT@ \ hash_test@EXEEXT@ \
fsaccess_test@EXEEXT@ \ fsaccess_test@EXEEXT@ \
inter_test@EXEEXT@ \ inter_test@EXEEXT@ \
keyboard_test@EXEEXT@ \
lex_test@EXEEXT@ \ lex_test@EXEEXT@ \
lfsr_test@EXEEXT@ \ lfsr_test@EXEEXT@ \
log_test@EXEEXT@ \ log_test@EXEEXT@ \
@@ -82,7 +82,6 @@ XSRCS = adb_test.c \
fsaccess_test.c \ fsaccess_test.c \
gsstest.c \ gsstest.c \
inter_test.c \ inter_test.c \
keyboard_test.c \
lex_test.c \ lex_test.c \
lfsr_test.c \ lfsr_test.c \
log_test.c \ log_test.c \
@@ -106,7 +105,7 @@ XSRCS = adb_test.c \
# disable optimization for backtrace test to get the expected result # disable optimization for backtrace test to get the expected result
BTTEST_CFLAGS = ${BACKTRACECFLAGS} ${EXT_CFLAGS} ${ALL_CPPFLAGS} -g \ BTTEST_CFLAGS = ${BACKTRACECFLAGS} ${EXT_CFLAGS} ${ALL_CPPFLAGS} -g \
${ALWAYS_WARNINGS} ${STD_CWARNINGS} ${CWARNINGS} ${ALWAYS_WARNINGS} ${STD_CWARNINGS} ${CWARNINGS} ${PTHREAD_CFLAGS}
all_tests: ${XTARGETS} all_tests: ${XTARGETS}
@@ -240,10 +239,6 @@ inter_test@EXEEXT@: inter_test.@O@ ${ISCDEPLIBS}
${LIBTOOL_MODE_LINK} ${PURIFY} ${CC} ${CFLAGS} ${LDFLAGS} -o $@ inter_test.@O@ \ ${LIBTOOL_MODE_LINK} ${PURIFY} ${CC} ${CFLAGS} ${LDFLAGS} -o $@ inter_test.@O@ \
${ISCLIBS} ${LIBS} ${ISCLIBS} ${LIBS}
keyboard_test@EXEEXT@: keyboard_test.@O@ ${ISCDEPLIBS}
${LIBTOOL_MODE_LINK} ${PURIFY} ${CC} ${CFLAGS} ${LDFLAGS} -o $@ keyboard_test.@O@ \
${ISCLIBS} ${LIBS}
sig0_test@EXEEXT@: sig0_test.@O@ ${ISCDEPLIBS} ${DNSDEPLIBS} sig0_test@EXEEXT@: sig0_test.@O@ ${ISCDEPLIBS} ${DNSDEPLIBS}
${LIBTOOL_MODE_LINK} ${PURIFY} ${CC} ${CFLAGS} ${LDFLAGS} -o $@ sig0_test.@O@ \ ${LIBTOOL_MODE_LINK} ${PURIFY} ${CC} ${CFLAGS} ${LDFLAGS} -o $@ sig0_test.@O@ \
${DNSLIBS} ${ISCLIBS} ${LIBS} ${DNSLIBS} ${ISCLIBS} ${LIBS}
+1 -1
View File
@@ -182,7 +182,7 @@ create_view(void) {
dns_rdataclass_in, "", "rbt", 0, NULL, dns_rdataclass_in, "", "rbt", 0, NULL,
&cache); &cache);
check_result(result, "dns_cache_create"); check_result(result, "dns_cache_create");
dns_view_setcache(view, cache, ISC_FALSE); dns_view_setcache(view, cache, false);
dns_cache_detach(&cache); dns_cache_detach(&cache);
{ {
+4 -3
View File
@@ -14,6 +14,7 @@
#include <config.h> #include <config.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <isc/app.h> #include <isc/app.h>
@@ -68,7 +69,7 @@ done(isc_task_t *task, isc_event_t *event) {
int int
main(int argc, char *argv[]) { main(int argc, char *argv[]) {
isc_mem_t *mctx; isc_mem_t *mctx;
isc_boolean_t verbose = ISC_FALSE; bool verbose = false;
unsigned int workers = 2; unsigned int workers = 2;
isc_taskmgr_t *taskmgr; isc_taskmgr_t *taskmgr;
isc_task_t *task; isc_task_t *task;
@@ -98,7 +99,7 @@ main(int argc, char *argv[]) {
*/ */
break; break;
case 'v': case 'v':
verbose = ISC_TRUE; verbose = true;
break; break;
case 'w': case 'w':
workers = (unsigned int)atoi(isc_commandline_argument); workers = (unsigned int)atoi(isc_commandline_argument);
@@ -203,7 +204,7 @@ main(int argc, char *argv[]) {
== ISC_R_SUCCESS); == ISC_R_SUCCESS);
} }
dns_view_setcache(view, cache, ISC_FALSE); dns_view_setcache(view, cache, false);
dns_view_freeze(view); dns_view_freeze(view);
dns_cache_detach(&cache); dns_cache_detach(&cache);
+12 -11
View File
@@ -14,6 +14,7 @@
#include <config.h> #include <config.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
@@ -103,9 +104,9 @@ print_name(dns_name_t *name) {
} }
static void static void
do_find(isc_boolean_t want_event) { do_find(bool want_event) {
isc_result_t result; isc_result_t result;
isc_boolean_t done = ISC_FALSE; bool done = false;
unsigned int options; unsigned int options;
options = DNS_ADBFIND_INET | DNS_ADBFIND_INET6; options = DNS_ADBFIND_INET | DNS_ADBFIND_INET6;
@@ -125,7 +126,7 @@ do_find(isc_boolean_t want_event) {
*/ */
INSIST((find->options & DNS_ADBFIND_WANTEVENT) == 0); INSIST((find->options & DNS_ADBFIND_WANTEVENT) == 0);
print_addresses(find); print_addresses(find);
done = ISC_TRUE; done = true;
} else { } else {
/* /*
* We don't know any of the addresses for this * We don't know any of the addresses for this
@@ -136,7 +137,7 @@ do_find(isc_boolean_t want_event) {
* And ADB isn't going to send us any events * And ADB isn't going to send us any events
* either. This query loses. * either. This query loses.
*/ */
done = ISC_TRUE; done = true;
} }
/* /*
* If the DNS_ADBFIND_WANTEVENT flag was set, we'll * If the DNS_ADBFIND_WANTEVENT flag was set, we'll
@@ -145,11 +146,11 @@ do_find(isc_boolean_t want_event) {
} }
} else if (result == DNS_R_ALIAS) { } else if (result == DNS_R_ALIAS) {
print_name(dns_fixedname_name(&target)); print_name(dns_fixedname_name(&target));
done = ISC_TRUE; done = true;
} else { } else {
printf("dns_adb_createfind() returned %s\n", printf("dns_adb_createfind() returned %s\n",
isc_result_totext(result)); isc_result_totext(result));
done = ISC_TRUE; done = true;
} }
if (done) { if (done) {
@@ -169,7 +170,7 @@ adb_callback(isc_task_t *etask, isc_event_t *event) {
dns_adb_destroyfind(&find); dns_adb_destroyfind(&find);
if (type == DNS_EVENT_ADBMOREADDRESSES) if (type == DNS_EVENT_ADBMOREADDRESSES)
do_find(ISC_FALSE); do_find(false);
else if (type == DNS_EVENT_ADBNOMOREADDRESSES) { else if (type == DNS_EVENT_ADBNOMOREADDRESSES) {
printf("no more addresses\n"); printf("no more addresses\n");
isc_app_shutdown(); isc_app_shutdown();
@@ -182,13 +183,13 @@ adb_callback(isc_task_t *etask, isc_event_t *event) {
static void static void
run(isc_task_t *xtask, isc_event_t *event) { run(isc_task_t *xtask, isc_event_t *event) {
UNUSED(xtask); UNUSED(xtask);
do_find(ISC_TRUE); do_find(true);
isc_event_free(&event); isc_event_free(&event);
} }
int int
main(int argc, char *argv[]) { main(int argc, char *argv[]) {
isc_boolean_t verbose = ISC_FALSE; bool verbose = false;
unsigned int workers = 2; unsigned int workers = 2;
isc_timermgr_t *timermgr; isc_timermgr_t *timermgr;
int ch; int ch;
@@ -210,7 +211,7 @@ main(int argc, char *argv[]) {
level = (unsigned int)atoi(isc_commandline_argument); level = (unsigned int)atoi(isc_commandline_argument);
break; break;
case 'v': case 'v':
verbose = ISC_TRUE; verbose = true;
break; break;
case 'w': case 'w':
workers = (unsigned int)atoi(isc_commandline_argument); workers = (unsigned int)atoi(isc_commandline_argument);
@@ -316,7 +317,7 @@ main(int argc, char *argv[]) {
== ISC_R_SUCCESS); == ISC_R_SUCCESS);
} }
dns_view_setcache(view, cache, ISC_FALSE); dns_view_setcache(view, cache, false);
dns_view_freeze(view); dns_view_freeze(view);
dns_cache_detach(&cache); dns_cache_detach(&cache);
+58 -56
View File
@@ -14,6 +14,8 @@
#include <config.h> #include <config.h>
#include <inttypes.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <isc/commandline.h> #include <isc/commandline.h>
@@ -47,7 +49,7 @@ typedef struct dbinfo {
dns_dbiterator_t * dbiterator; dns_dbiterator_t * dbiterator;
dns_dbversion_t * iversion; dns_dbversion_t * iversion;
int pause_every; int pause_every;
isc_boolean_t ascending; bool ascending;
ISC_LINK(struct dbinfo) link; ISC_LINK(struct dbinfo) link;
} dbinfo; } dbinfo;
@@ -57,7 +59,7 @@ static dns_dbtable_t * dbtable;
static ISC_LIST(dbinfo) dbs; static ISC_LIST(dbinfo) dbs;
static dbinfo * cache_dbi = NULL; static dbinfo * cache_dbi = NULL;
static int pause_every = 0; static int pause_every = 0;
static isc_boolean_t ascending = ISC_TRUE; static bool ascending = true;
static void static void
print_result(const char *message, isc_result_t result) { print_result(const char *message, isc_result_t result) {
@@ -76,7 +78,7 @@ print_rdataset(dns_name_t *name, dns_rdataset_t *rdataset) {
isc_region_t r; isc_region_t r;
isc_buffer_init(&text, t, sizeof(t)); isc_buffer_init(&text, t, sizeof(t));
result = dns_rdataset_totext(rdataset, name, ISC_FALSE, ISC_FALSE, result = dns_rdataset_totext(rdataset, name, false, false,
&text); &text);
isc_buffer_usedregion(&text, &r); isc_buffer_usedregion(&text, &r);
if (result == ISC_R_SUCCESS) if (result == ISC_R_SUCCESS)
@@ -217,11 +219,11 @@ list(dbinfo *dbi, char *seektext) {
dns_dbiterator_destroy(&dbi->dbiterator); dns_dbiterator_destroy(&dbi->dbiterator);
if (dbi->iversion != NULL) if (dbi->iversion != NULL)
dns_db_closeversion(dbi->db, &dbi->iversion, ISC_FALSE); dns_db_closeversion(dbi->db, &dbi->iversion, false);
} }
static isc_result_t static isc_result_t
load(const char *filename, const char *origintext, isc_boolean_t cache) { load(const char *filename, const char *origintext, bool cache) {
dns_fixedname_t forigin; dns_fixedname_t forigin;
dns_name_t *origin; dns_name_t *origin;
isc_result_t result; isc_result_t result;
@@ -332,17 +334,17 @@ main(int argc, char *argv[]) {
dns_rdataset_t rdataset, sigrdataset; dns_rdataset_t rdataset, sigrdataset;
int ch; int ch;
dns_rdatatype_t type = 1; dns_rdatatype_t type = 1;
isc_boolean_t printnode = ISC_FALSE; bool printnode = false;
isc_boolean_t addmode = ISC_FALSE; bool addmode = false;
isc_boolean_t delmode = ISC_FALSE; bool delmode = false;
isc_boolean_t holdmode = ISC_FALSE; bool holdmode = false;
isc_boolean_t verbose = ISC_FALSE; bool verbose = false;
isc_boolean_t done = ISC_FALSE; bool done = false;
isc_boolean_t quiet = ISC_FALSE; bool quiet = false;
isc_boolean_t time_lookups = ISC_FALSE; bool time_lookups = false;
isc_boolean_t found_as; bool found_as;
isc_boolean_t find_zonecut = ISC_FALSE; bool find_zonecut = false;
isc_boolean_t noexact_zonecut = ISC_FALSE; bool noexact_zonecut = false;
int i, v; int i, v;
dns_rdatasetiter_t *rdsiter; dns_rdatasetiter_t *rdsiter;
char t1[256]; char t1[256];
@@ -374,7 +376,7 @@ main(int argc, char *argv[]) {
!= -1) { != -1) {
switch (ch) { switch (ch) {
case 'c': case 'c':
result = load(isc_commandline_argument, ".", ISC_TRUE); result = load(isc_commandline_argument, ".", true);
if (result != ISC_R_SUCCESS) if (result != ISC_R_SUCCESS)
printf("cache load(%s) %08x: %s\n", printf("cache load(%s) %08x: %s\n",
isc_commandline_argument, result, isc_commandline_argument, result,
@@ -400,11 +402,11 @@ main(int argc, char *argv[]) {
dns_log_setcontext(lctx); dns_log_setcontext(lctx);
break; break;
case 'q': case 'q':
quiet = ISC_TRUE; quiet = true;
verbose = ISC_FALSE; verbose = false;
break; break;
case 'p': case 'p':
printnode = ISC_TRUE; printnode = true;
break; break;
case 'P': case 'P':
pause_every = atoi(isc_commandline_argument); pause_every = atoi(isc_commandline_argument);
@@ -417,10 +419,10 @@ main(int argc, char *argv[]) {
type = atoi(isc_commandline_argument); type = atoi(isc_commandline_argument);
break; break;
case 'T': case 'T':
time_lookups = ISC_TRUE; time_lookups = true;
break; break;
case 'v': case 'v':
verbose = ISC_TRUE; verbose = true;
break; break;
case 'z': case 'z':
origintext = strrchr(isc_commandline_argument, '/'); origintext = strrchr(isc_commandline_argument, '/');
@@ -429,7 +431,7 @@ main(int argc, char *argv[]) {
else else
origintext++; /* Skip '/'. */ origintext++; /* Skip '/'. */
result = load(isc_commandline_argument, origintext, result = load(isc_commandline_argument, origintext,
ISC_FALSE); false);
if (result != ISC_R_SUCCESS) if (result != ISC_R_SUCCESS)
printf("zone load(%s) %08x: %s\n", printf("zone load(%s) %08x: %s\n",
isc_commandline_argument, result, isc_commandline_argument, result,
@@ -461,7 +463,7 @@ main(int argc, char *argv[]) {
if (!quiet) if (!quiet)
printf("\n"); printf("\n");
if (fgets(s, sizeof(s), stdin) == NULL) { if (fgets(s, sizeof(s), stdin) == NULL) {
done = ISC_TRUE; done = true;
continue; continue;
} }
len = strlen(s); len = strlen(s);
@@ -509,8 +511,8 @@ main(int argc, char *argv[]) {
continue; continue;
} else if (strcmp(s, "!C") == 0) { } else if (strcmp(s, "!C") == 0) {
DBI_CHECK(dbi); DBI_CHECK(dbi);
addmode = ISC_FALSE; addmode = false;
delmode = ISC_FALSE; delmode = false;
if (dbi->version == NULL) if (dbi->version == NULL)
continue; continue;
if (dbi->version == dbi->wversion) { if (dbi->version == dbi->wversion) {
@@ -527,13 +529,13 @@ main(int argc, char *argv[]) {
} }
} }
} }
dns_db_closeversion(dbi->db, &dbi->version, ISC_TRUE); dns_db_closeversion(dbi->db, &dbi->version, true);
version = NULL; version = NULL;
continue; continue;
} else if (strcmp(s, "!X") == 0) { } else if (strcmp(s, "!X") == 0) {
DBI_CHECK(dbi); DBI_CHECK(dbi);
addmode = ISC_FALSE; addmode = false;
delmode = ISC_FALSE; delmode = false;
if (dbi->version == NULL) if (dbi->version == NULL)
continue; continue;
if (dbi->version == dbi->wversion) { if (dbi->version == dbi->wversion) {
@@ -550,33 +552,33 @@ main(int argc, char *argv[]) {
} }
} }
} }
dns_db_closeversion(dbi->db, &dbi->version, ISC_FALSE); dns_db_closeversion(dbi->db, &dbi->version, false);
version = NULL; version = NULL;
continue; continue;
} else if (strcmp(s, "!A") == 0) { } else if (strcmp(s, "!A") == 0) {
DBI_CHECK(dbi); DBI_CHECK(dbi);
delmode = ISC_FALSE; delmode = false;
if (addmode) if (addmode)
addmode = ISC_FALSE; addmode = false;
else else
addmode = ISC_TRUE; addmode = true;
printf("addmode = %s\n", addmode ? "TRUE" : "FALSE"); printf("addmode = %s\n", addmode ? "TRUE" : "FALSE");
continue; continue;
} else if (strcmp(s, "!D") == 0) { } else if (strcmp(s, "!D") == 0) {
DBI_CHECK(dbi); DBI_CHECK(dbi);
addmode = ISC_FALSE; addmode = false;
if (delmode) if (delmode)
delmode = ISC_FALSE; delmode = false;
else else
delmode = ISC_TRUE; delmode = true;
printf("delmode = %s\n", delmode ? "TRUE" : "FALSE"); printf("delmode = %s\n", delmode ? "TRUE" : "FALSE");
continue; continue;
} else if (strcmp(s, "!H") == 0) { } else if (strcmp(s, "!H") == 0) {
DBI_CHECK(dbi); DBI_CHECK(dbi);
if (holdmode) if (holdmode)
holdmode = ISC_FALSE; holdmode = false;
else else
holdmode = ISC_TRUE; holdmode = true;
printf("holdmode = %s\n", holdmode ? "TRUE" : "FALSE"); printf("holdmode = %s\n", holdmode ? "TRUE" : "FALSE");
continue; continue;
} else if (strcmp(s, "!HR") == 0) { } else if (strcmp(s, "!HR") == 0) {
@@ -585,7 +587,7 @@ main(int argc, char *argv[]) {
dns_db_detachnode(dbi->db, dns_db_detachnode(dbi->db,
&dbi->hold_nodes[i]); &dbi->hold_nodes[i]);
dbi->hold_count = 0; dbi->hold_count = 0;
holdmode = ISC_FALSE; holdmode = false;
printf("held nodes have been detached\n"); printf("held nodes have been detached\n");
continue; continue;
} else if (strcmp(s, "!VC") == 0) { } else if (strcmp(s, "!VC") == 0) {
@@ -662,9 +664,9 @@ main(int argc, char *argv[]) {
continue; continue;
} else if (strcmp(s, "!PN") == 0) { } else if (strcmp(s, "!PN") == 0) {
if (printnode) if (printnode)
printnode = ISC_FALSE; printnode = false;
else else
printnode = ISC_TRUE; printnode = true;
printf("printnode = %s\n", printf("printnode = %s\n",
printnode ? "TRUE" : "FALSE"); printnode ? "TRUE" : "FALSE");
continue; continue;
@@ -675,11 +677,11 @@ main(int argc, char *argv[]) {
continue; continue;
} else if (strcmp(s, "!+") == 0) { } else if (strcmp(s, "!+") == 0) {
DBI_CHECK(dbi); DBI_CHECK(dbi);
dbi->ascending = ISC_TRUE; dbi->ascending = true;
continue; continue;
} else if (strcmp(s, "!-") == 0) { } else if (strcmp(s, "!-") == 0) {
DBI_CHECK(dbi); DBI_CHECK(dbi);
dbi->ascending = ISC_FALSE; dbi->ascending = false;
continue; continue;
} else if (strcmp(s, "!DB") == 0) { } else if (strcmp(s, "!DB") == 0) {
dbi = NULL; dbi = NULL;
@@ -693,9 +695,9 @@ main(int argc, char *argv[]) {
db = dbi->db; db = dbi->db;
origin = dns_db_origin(dbi->db); origin = dns_db_origin(dbi->db);
version = dbi->version; version = dbi->version;
addmode = ISC_FALSE; addmode = false;
delmode = ISC_FALSE; delmode = false;
holdmode = ISC_FALSE; holdmode = false;
} else { } else {
db = NULL; db = NULL;
version = NULL; version = NULL;
@@ -706,17 +708,17 @@ main(int argc, char *argv[]) {
continue; continue;
} else if (strcmp(s, "!ZC") == 0) { } else if (strcmp(s, "!ZC") == 0) {
if (find_zonecut) if (find_zonecut)
find_zonecut = ISC_FALSE; find_zonecut = false;
else else
find_zonecut = ISC_TRUE; find_zonecut = true;
printf("find_zonecut = %s\n", printf("find_zonecut = %s\n",
find_zonecut ? "TRUE" : "FALSE"); find_zonecut ? "TRUE" : "FALSE");
continue; continue;
} else if (strcmp(s, "!NZ") == 0) { } else if (strcmp(s, "!NZ") == 0) {
if (noexact_zonecut) if (noexact_zonecut)
noexact_zonecut = ISC_FALSE; noexact_zonecut = false;
else else
noexact_zonecut = ISC_TRUE; noexact_zonecut = true;
printf("noexact_zonecut = %s\n", printf("noexact_zonecut = %s\n",
noexact_zonecut ? "TRUE" : "FALSE"); noexact_zonecut ? "TRUE" : "FALSE");
continue; continue;
@@ -747,7 +749,7 @@ main(int argc, char *argv[]) {
continue; continue;
} }
isc_buffer_init(&tb1, t1, sizeof(t1)); isc_buffer_init(&tb1, t1, sizeof(t1));
result = dns_name_totext(dns_db_origin(db), ISC_FALSE, result = dns_name_totext(dns_db_origin(db), false,
&tb1); &tb1);
if (result != ISC_R_SUCCESS) { if (result != ISC_R_SUCCESS) {
printf("\n"); printf("\n");
@@ -783,7 +785,7 @@ main(int argc, char *argv[]) {
print_result("", result); print_result("", result);
} }
found_as = ISC_FALSE; found_as = false;
switch (result) { switch (result) {
case ISC_R_SUCCESS: case ISC_R_SUCCESS:
case DNS_R_GLUE: case DNS_R_GLUE:
@@ -792,7 +794,7 @@ main(int argc, char *argv[]) {
break; break;
case DNS_R_DNAME: case DNS_R_DNAME:
case DNS_R_DELEGATION: case DNS_R_DELEGATION:
found_as = ISC_TRUE; found_as = true;
break; break;
case DNS_R_NXRRSET: case DNS_R_NXRRSET:
if (dns_rdataset_isassociated(&rdataset)) if (dns_rdataset_isassociated(&rdataset))
@@ -825,7 +827,7 @@ main(int argc, char *argv[]) {
if (found_as && !quiet) { if (found_as && !quiet) {
isc_buffer_init(&tb1, t1, sizeof(t1)); isc_buffer_init(&tb1, t1, sizeof(t1));
isc_buffer_init(&tb2, t2, sizeof(t2)); isc_buffer_init(&tb2, t2, sizeof(t2));
result = dns_name_totext(&name, ISC_FALSE, &tb1); result = dns_name_totext(&name, false, &tb1);
if (result != ISC_R_SUCCESS) { if (result != ISC_R_SUCCESS) {
print_result("", result); print_result("", result);
dns_db_detachnode(db, &node); dns_db_detachnode(db, &node);
@@ -833,7 +835,7 @@ main(int argc, char *argv[]) {
dns_db_detach(&db); dns_db_detach(&db);
continue; continue;
} }
result = dns_name_totext(fname, ISC_FALSE, &tb2); result = dns_name_totext(fname, false, &tb2);
if (result != ISC_R_SUCCESS) { if (result != ISC_R_SUCCESS) {
print_result("", result); print_result("", result);
dns_db_detachnode(db, &node); dns_db_detachnode(db, &node);
@@ -909,7 +911,7 @@ main(int argc, char *argv[]) {
} }
if (time_lookups) { if (time_lookups) {
isc_uint64_t usec; uint64_t usec;
TIME_NOW(&finish); TIME_NOW(&finish);
+7 -7
View File
@@ -11,9 +11,9 @@
#include <config.h> #include <config.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h>
#include <unistd.h> /* XXX */
#include <isc/buffer.h> #include <isc/buffer.h>
#include <isc/mem.h> #include <isc/mem.h>
@@ -52,7 +52,7 @@ use(dst_key_t *key, isc_mem_t *mctx) {
isc_buffer_usedregion(&databuf, &datareg); isc_buffer_usedregion(&databuf, &datareg);
ret = dst_context_create(key, mctx, ret = dst_context_create(key, mctx,
DNS_LOGCATEGORY_GENERAL, ISC_TRUE, 0, &ctx); DNS_LOGCATEGORY_GENERAL, true, 0, &ctx);
if (ret != ISC_R_SUCCESS) { if (ret != ISC_R_SUCCESS) {
printf("contextcreate(%u) returned: %s\n", dst_key_alg(key), printf("contextcreate(%u) returned: %s\n", dst_key_alg(key),
isc_result_totext(ret)); isc_result_totext(ret));
@@ -73,7 +73,7 @@ use(dst_key_t *key, isc_mem_t *mctx) {
isc_buffer_forward(&sigbuf, 1); isc_buffer_forward(&sigbuf, 1);
isc_buffer_remainingregion(&sigbuf, &sigreg); isc_buffer_remainingregion(&sigbuf, &sigreg);
ret = dst_context_create(key, mctx, ret = dst_context_create(key, mctx,
DNS_LOGCATEGORY_GENERAL, ISC_FALSE, 0, &ctx); DNS_LOGCATEGORY_GENERAL, false, 0, &ctx);
if (ret != ISC_R_SUCCESS) { if (ret != ISC_R_SUCCESS) {
printf("contextcreate(%u) returned: %s\n", dst_key_alg(key), printf("contextcreate(%u) returned: %s\n", dst_key_alg(key),
isc_result_totext(ret)); isc_result_totext(ret));
@@ -100,7 +100,7 @@ dns(dst_key_t *key, isc_mem_t *mctx) {
isc_region_t r1, r2; isc_region_t r1, r2;
dst_key_t *newkey = NULL; dst_key_t *newkey = NULL;
isc_result_t ret; isc_result_t ret;
isc_boolean_t match; bool match;
isc_buffer_init(&buf1, buffer1, sizeof(buffer1)); isc_buffer_init(&buf1, buffer1, sizeof(buffer1));
ret = dst_key_todns(key, &buf1); ret = dst_key_todns(key, &buf1);
@@ -122,8 +122,8 @@ dns(dst_key_t *key, isc_mem_t *mctx) {
return; return;
isc_buffer_usedregion(&buf1, &r1); isc_buffer_usedregion(&buf1, &r1);
isc_buffer_usedregion(&buf2, &r2); isc_buffer_usedregion(&buf2, &r2);
match = ISC_TF(r1.length == r2.length && match = (r1.length == r2.length &&
memcmp(r1.base, r2.base, r1.length) == 0); memcmp(r1.base, r2.base, r1.length) == 0);
printf("compare(%u): %s\n", dst_key_alg(key), printf("compare(%u): %s\n", dst_key_alg(key),
match ? "true" : "false"); match ? "true" : "false");
dst_key_free(&newkey); dst_key_free(&newkey);
+1 -1
View File
@@ -382,7 +382,7 @@ initctx1(isc_task_t *task, isc_event_t *event) {
gssctx = GSS_C_NO_CONTEXT; gssctx = GSS_C_NO_CONTEXT;
result = dns_tkey_buildgssquery(query, dns_fixedname_name(&servername), result = dns_tkey_buildgssquery(query, dns_fixedname_name(&servername),
dns_fixedname_name(&gssname), dns_fixedname_name(&gssname),
NULL, 36000, &gssctx, ISC_TRUE, NULL, 36000, &gssctx, true,
mctx, NULL); mctx, NULL);
CHECK("dns_tkey_buildgssquery", result); CHECK("dns_tkey_buildgssquery", result);
-67
View File
@@ -1,67 +0,0 @@
/*
* 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.
*/
/*! \file */
#include <config.h>
#include <stdio.h>
#include <stdlib.h>
#include <isc/keyboard.h>
#include <isc/print.h>
#include <isc/util.h>
static void
CHECK(const char *msg, isc_result_t result) {
if (result != ISC_R_SUCCESS) {
printf("FAILURE: %s: %s\n", msg, isc_result_totext(result));
exit(1);
}
}
int
main(int argc, char **argv) {
isc_keyboard_t kbd;
unsigned char c;
isc_result_t res;
unsigned int count;
UNUSED(argc);
UNUSED(argv);
printf("Type Q to exit.\n");
res = isc_keyboard_open(&kbd);
CHECK("isc_keyboard_open()", res);
c = 'x';
count = 0;
while (res == ISC_R_SUCCESS && c != 'Q') {
res = isc_keyboard_getchar(&kbd, &c);
printf(".");
fflush(stdout);
count++;
if (count % 64 == 0)
printf("\r\n");
}
printf("\r\n");
if (res != ISC_R_SUCCESS) {
printf("FAILURE: keyboard getchar failed: %s\r\n",
isc_result_totext(res));
goto errout;
}
errout:
res = isc_keyboard_close(&kbd, 3);
CHECK("isc_keyboard_close()", res);
return (0);
}
+3 -2
View File
@@ -13,18 +13,19 @@
#include <config.h> #include <config.h>
#include <stdio.h> #include <stdio.h>
#include <inttypes.h>
#include <isc/lfsr.h> #include <isc/lfsr.h>
#include <isc/print.h> #include <isc/print.h>
#include <isc/util.h> #include <isc/util.h>
isc_uint32_t state[1024 * 64]; uint32_t state[1024 * 64];
int int
main(int argc, char **argv) { main(int argc, char **argv) {
isc_lfsr_t lfsr1, lfsr2; isc_lfsr_t lfsr1, lfsr2;
int i; int i;
isc_uint32_t temp; uint32_t temp;
UNUSED(argc); UNUSED(argc);
UNUSED(argv); UNUSED(argv);

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