BIND 10 trac2142, updated. 5d2d668266686751c4a56470458c0c02970e2dfe [2142] First pass at database schema
BIND 10 source code commits
bind10-changes at lists.isc.org
Wed Oct 10 11:54:10 UTC 2012
The branch, trac2142 has been updated
via 5d2d668266686751c4a56470458c0c02970e2dfe (commit)
via bf260bbc80a813c30bb7499b8a085d7390d83e83 (commit)
via f8261d10f177e52b19af56343ddb5e7548f30195 (commit)
via 93e596c474ed1c637da7d6653eaa8c499b0b6a6d (commit)
via f037ebb23cb966f86d11c07bb0f4a80b6043c9b0 (commit)
via 41538b7ce9d6ab4131b572b79d84292884cf4a11 (commit)
via 78dfd7dcd6d76cb75d288a3887e8b099c12f3080 (commit)
via b1d4ff896a7781d98513fab8d171090ac3d6a1e4 (commit)
via 47c013b000db7235e1ab798eadebc3b42984b06e (commit)
via 3d68f767731a682d4a80e9ba74d953502c2ada7d (commit)
via f802291f6461f3fa7e13fcf3364bb39b4be42c06 (commit)
via fa51dffbe444e5d2ac6a768da001b60ad16d0341 (commit)
via 98692b1e0663b4d167670b7808f26b1bb718851c (commit)
via 1886c9f3083ce3e04d42b8a91e46838ee5a1e774 (commit)
via 37fd8a72b131d5de9a6fbe612d3dc3d19bafdf83 (commit)
via 1fb24f540ade83926d311316e77e1a6c8bef8432 (commit)
via c4c3946bad5bf1e9be0f375ac1029e1f95e94d94 (commit)
via 5c975417200358c916a62415caf51a1a73e0d470 (commit)
via 538a160ef48f7dbe927f75cafc335e470a82db33 (commit)
via e45115237b2c8c12f0c2fd3c62ae0aff01248cc9 (commit)
via a072ee8db55261a67dc7041c7c17d0536f8def0b (commit)
via 473e340929d0869bf71d972e1a1843dc81b0fbfa (commit)
via 94656c03d42d0339c79d10be8ccedaea6da55028 (commit)
via a6748eee324ebb4cf4ba99aa225df51d71458c81 (commit)
via 5acf0ff36e8503de33ce04fe16e279ec6ee871f1 (commit)
via 14680316801f9274e5b4d099a4dfbf63d7cb110b (commit)
via d25bb8d27cf235603cb8a1d789066b2aa993eccd (commit)
via f2b62e24805e97f66aeac4f9ab3db2d9778c9314 (commit)
via e0ce6d2f3010bfc5998e6c7da202258cbe28c6c6 (commit)
via d73842ed35d5aea29466e25a9a6b2dfb4e550e97 (commit)
via 7eaa1760f3ed6cd57cf1b8458516fa3d457371d7 (commit)
via b7bff77c9dfefe339a386afcaeeb79b4927cfda3 (commit)
via ff7d15330f2a74d983972efd1872d1af7d2cd958 (commit)
via fc7462103f1fb344bf91707a1e2de99534e237b9 (commit)
via eace2551ac4260065fbd7d900d157e77dccc6e26 (commit)
via 1ade0a0c0c8ead227aa7f8d374a1748de2535b15 (commit)
via e00795f47f7d88084973ff831278e4cf4004bfad (commit)
via 9047de5e8f973e12e536f7180738e6b515439448 (commit)
via ae8740e0bf3dc8daf25323d442ef5ba135817caa (commit)
via ed5f58850ca6c58778ec3241968ada3bbca67096 (commit)
via 26e55ce110123f7557732ecaeaaad4816cd0375b (commit)
via 397769f9a994bdf1a2716ee89d6746769c11c13d (commit)
via b9b899343170f79cd26929245180180c850d5594 (commit)
via 84d2f3799c493862a22e7b873352da9db766a19d (commit)
via a2bcf6e5b22df3c9bed473d342485548c60c8773 (commit)
via 408728e4512f08c8e50e3f627cc46eb6ad38a315 (commit)
via 2bed6220f561fa39358fb81fde8a2ee0a1b85c38 (commit)
via 1943079713265d5ad64762b107288b6e501c70cf (commit)
via 7a0a89d0cab063bb69e4ec4fede497f9d8d329ba (commit)
via f5811cdff640338babcf1ca0b4cfc7a06580a4f5 (commit)
via 723885f4ab0096dbea3a21f63badb18d79f28814 (commit)
via 76fa5523da1da9778a686b39dbba5759dcea34da (commit)
via 0ca39bfe35f856eb54ff77c50f5b2230ed20313b (commit)
via 52d245f139122e86c07a4336fbb2495bdb6499d9 (commit)
via 8bd4cd42e061d49d098cb1387b3614226a161f6d (commit)
via dd5bb15644a8e6d0df49d93ee8e982d2d0d463ea (commit)
via 09e793e3c71fbbc12f8f8461ceafbabc2edcbc9e (commit)
via 936498565a5249df01ad44a808bb447952240c90 (commit)
via c74022e2d7acf6b77979e9c8b646d5da95419ed3 (commit)
via 310150445a17a5043cb5e93ce5ecaddd0336b196 (commit)
via c4e44c1a57326915e7291e982e2271b6574f73fc (commit)
via 6f29861b92742da34be9ae76968e82222b5bfd7d (commit)
via da7375d619b7ba63b77c8430f8d67799d8f26026 (commit)
via 1ab6aafab6660d60a5f2e7cf7125d59d5807f2e5 (commit)
via ae20aca3d9324f9439baaf692f42db76ab15912f (commit)
via 0f0501530b755d42670e7e8d9a044027c20e1f27 (commit)
via eff1c6bcb840aa9a8736c6c29a1eeb68eef30279 (commit)
via 92daff7ee6bbd0a41b9a993a1d5d2b151984233a (commit)
via 003b2878529f02062656b84187edb800bc292c35 (commit)
via 362430efc09897c1e7d7bdf2bf7b4cffd9fd2e3b (commit)
via dfa822ebc063f5ae636e55e4f999bce3096483e1 (commit)
via 26cd9b7104c48ecce553cab9c8e7de6f57c8e88f (commit)
via 971e8bc5f615ebf009a4b1a60998151054ca34a5 (commit)
via dcde0c0b983dd0ce788d7273f0cf7e02b37a711d (commit)
via 46c77cb971eeb52802fba8091529c9947bfda05c (commit)
via af3d7616a9f65bf3effb25d2432d0955dcb5d03b (commit)
via 9b730d026d634dbefdc50eea9d63df77201e30f4 (commit)
via 6bd433b573a427c85cbbd7c75dd1bb08f672d678 (commit)
via 96da4b2e1aa8c82b1f33103a89d7bd8be8ca390b (commit)
via fa10a89c1e4b03da98f9926f31e1680cf5d4ef5d (commit)
via da0b581e22f7a10931767f4d535cfda1554cc525 (commit)
via 8e51d2165fb35be71aee1a0c381fc71f08a821b5 (commit)
via 718888317b9fb6b24c20d8d417ea540ff23257c5 (commit)
via 6e3d1a58e4ec1857fc0264e8070ce67f569b7e42 (commit)
via 076e5cff040e4da53df8dd60cee37a06e4e557c9 (commit)
via ac98e5dbf31b54eb74917d03e53ac071e8c8c92e (commit)
via 022f55634bf4865a315797abafedfbe43d54603b (commit)
via f759086adfb6c899be7a2201f063af49e88f60b7 (commit)
via 5c7990cd039e4350cf2823e8edc10b509d6d8ba7 (commit)
via 0b9f5f6d4afd45a3482ca0d4aec22f5d00df1865 (commit)
via 6978e7fbdfb9c036e1f0fedf04828d6edc731d9e (commit)
via 9b8b55c00ba7bba8e4f95336eb2bb34c0b151efb (commit)
via 3690baaf0660af752b00a370fadcd60859c50ca4 (commit)
via 704ca46ac3aa9c93c9964eb3495bacd4050f042e (commit)
via 055d0ff12778c3b37b2060900cfacf59dcec2767 (commit)
via 483011e9e126f02863fc10c69278f55f204b5f17 (commit)
via 1ed45f9349d76439f61d9ab88c0ce1ea84cc6711 (commit)
via 5a0aa214c3e6b52ef738ca574105bf0120ac844b (commit)
via b8f538b9fcf70394e5737269d4bed660721c245d (commit)
via 68621232d6840227c4309c1fd1ee9e1a8b26120f (commit)
via c9bae4745f58fc361ebeb0f91bb15b288e96e5cf (commit)
via beccbfe1acb5e6e309d5dee9cbc4461434091520 (commit)
via daf7bbcc05e24e2e6894ac2cf59fa738cfb199bc (commit)
via d1c7c9057bb24595f9dcefe226dc7f326f390486 (commit)
via a7a5b8a6e3605e3a3788f6920a45e9fa3c215be0 (commit)
via eda12494283d717f4fb095be4ff57608f4003502 (commit)
via a66bc5d487b4b095bb9e322e33ed31c55d8af339 (commit)
via c16a30cbaf082a05c0fbd5c929bf0be6f007503f (commit)
via e9498651c8bc59ba17f353f196c0675dd7b8e2ff (commit)
via abd88f16af1295f2ff67f5e9593e61d1539ef6e4 (commit)
via a3e7cc6cf85981ed5a8a5e63589dfe1767b01e64 (commit)
via 382204ee795971bf6daeebb95f6134bab10ca18d (commit)
via e25a0b2202650ef749340a1993b427bf99d962e5 (commit)
via 7cd33029c63a0cd0889dba94709cf6cadaea48ab (commit)
via c0128e80648ec83fb9f4e3cbf3bb7bba2ef0bbb5 (commit)
via b52c3d66c1462da3733725d2baf40a21b8f521d6 (commit)
via 10a4833ef74f0cf9aebc3861aa69cae6a25ce1cb (commit)
via 35d60f15a86733bb3bc9db77b3d8c7713d83d70d (commit)
via ff7d2f5f77fab130de8db0d59ce48a483a0a8b45 (commit)
via 99767bbe7b2a278ffa88086c24dcd6363d2ed0e5 (commit)
via 3559ddcbe67e91941139c8c74ed77bb9be501dc4 (commit)
via 53ea5695fbd2a596ffda7c9b7bf0dd503b101462 (commit)
via ec9e57a32cefe7db94c2b8b8bebc782b8e872fa9 (commit)
via 88b2af9980fb431eb97dc72cb39214d7e1700ab7 (commit)
from e5bf564f734555173b5cae04757bc3f870f3463a (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 5d2d668266686751c4a56470458c0c02970e2dfe
Author: Stephen Morris <stephen at isc.org>
Date: Wed Oct 10 12:53:24 2012 +0100
[2142] First pass at database schema
-----------------------------------------------------------------------
Summary of changes:
ChangeLog | 16 ++
INSTALL | 4 +
configure.ac | 2 +
doc/Doxyfile | 5 +-
src/bin/auth/Makefile.am | 1 +
src/bin/auth/auth_srv.cc | 28 +++
src/bin/auth/auth_srv.h | 35 ++++
src/bin/auth/benchmarks/Makefile.am | 1 +
src/bin/auth/command.cc | 4 +
src/bin/auth/datasrc_configurator.h | 3 +
src/bin/auth/tests/Makefile.am | 1 +
src/bin/auth/tests/auth_srv_unittest.cc | 31 ++-
src/bin/auth/tests/command_unittest.cc | 76 ++++---
.../auth/tests/datasrc_configurator_unittest.cc | 5 +
src/bin/auth/tests/query_unittest.cc | 17 +-
src/bin/bindctl/bindcmd.py | 131 ++++++++----
src/bin/bindctl/bindctl_main.py.in | 49 +++--
src/bin/bindctl/cmdparse.py | 36 ++--
src/bin/bindctl/tests/bindctl_test.py | 210 +++++++++++++-------
src/cppcheck-suppress.lst | 15 ++
src/lib/asiolink/io_address.h | 55 ++++-
src/lib/asiolink/tests/io_address_unittest.cc | 32 +++
src/lib/cache/tests/rrset_entry_unittest.cc | 3 -
src/lib/cc/data.cc | 8 +-
src/lib/config/tests/testdata/Makefile.am | 1 +
src/lib/config/tests/testdata/spec32.spec | 16 ++
.../tests/testdata/{spec24.spec => spec42.spec} | 5 +-
src/lib/datasrc/database.cc | 16 +-
src/lib/datasrc/memory/Makefile.am | 2 +
src/lib/datasrc/memory/zone_finder.cc | 142 +++++++------
src/lib/datasrc/memory/zone_finder.h | 2 +-
.../memory/zone_table_segment.cc} | 44 ++--
src/lib/datasrc/memory/zone_table_segment.h | 110 ++++++++++
.../memory/zone_table_segment_local.cc} | 47 +++--
src/lib/datasrc/memory/zone_table_segment_local.h | 66 ++++++
src/lib/datasrc/memory_datasrc.cc | 11 +-
src/lib/datasrc/sqlite3_accessor.cc | 36 ++--
src/lib/datasrc/tests/memory/Makefile.am | 2 +
.../tests/memory/zone_table_segment_unittest.cc | 83 ++++++++
src/lib/datasrc/tests/testdata/contexttest.zone | 3 +-
src/lib/datasrc/zone.h | 130 +++++++++---
src/lib/datasrc/zone_finder_context.cc | 17 +-
src/lib/dhcp/Makefile.am | 18 +-
src/lib/dhcp/README | 14 +-
src/lib/dhcp/addr_utilities.cc | 96 +++++++++
src/lib/dhcp/addr_utilities.h | 53 +++++
src/lib/dhcp/cfgmgr.cc | 78 ++++++++
src/lib/dhcp/cfgmgr.h | 126 ++++++++++++
src/lib/dhcp/dhcpdb_create.mysql | 56 ++++++
src/lib/dhcp/pool.cc | 87 ++++++++
src/lib/dhcp/pool.h | 155 +++++++++++++++
src/lib/dhcp/subnet.cc | 91 +++++++++
src/lib/dhcp/subnet.h | 161 +++++++++++++++
src/lib/dhcp/tests/Makefile.am | 21 +-
src/lib/dhcp/tests/addr_utilities_unittest.cc | 93 +++++++++
src/lib/dhcp/tests/cfgmgr_unittest.cc | 63 ++++++
src/lib/dhcp/tests/iface_mgr_unittest.cc | 2 +-
src/lib/dhcp/tests/pool_unittest.cc | 109 ++++++++++
src/lib/dhcp/tests/run_unittests.cc | 1 -
src/lib/dhcp/tests/subnet_unittest.cc | 112 +++++++++++
src/lib/dhcp/tests/triplet_unittest.cc | 104 ++++++++++
src/lib/dhcp/triplet.h | 110 ++++++++++
src/lib/dns/benchmarks/message_renderer_bench.cc | 2 +-
src/lib/dns/benchmarks/rdatarender_bench.cc | 5 +-
src/lib/dns/python/edns_python.cc | 3 +-
src/lib/dns/rdata/generic/afsdb_18.cc | 1 -
src/lib/dns/tests/rrparamregistry_unittest.cc | 5 +-
src/lib/log/compiler/message.cc | 10 +-
src/lib/log/tests/logger_example.cc | 1 -
src/lib/python/isc/config/ccsession.py | 8 +-
src/lib/python/isc/config/config_data.py | 99 +++++++--
src/lib/python/isc/config/tests/ccsession_test.py | 16 +-
.../python/isc/config/tests/config_data_test.py | 99 ++++++++-
src/lib/resolve/recursive_query.cc | 40 ++--
src/lib/resolve/tests/recursive_query_unittest.cc | 39 +---
src/lib/util/Makefile.am | 2 +-
src/lib/util/hash/sha1.cc | 4 +-
src/lib/util/tests/lru_list_unittest.cc | 6 +-
src/lib/util/threads/Makefile.am | 12 ++
src/lib/util/threads/lock.cc | 138 +++++++++++++
src/lib/util/threads/lock.h | 128 ++++++++++++
src/lib/util/threads/tests/Makefile.am | 36 ++++
src/lib/util/threads/tests/lock_unittest.cc | 116 +++++++++++
src/lib/util/{ => threads}/tests/run_unittests.cc | 2 +-
src/lib/util/threads/tests/thread_unittest.cc | 98 +++++++++
src/lib/util/threads/thread.cc | 172 ++++++++++++++++
src/lib/util/threads/thread.h | 112 +++++++++++
87 files changed, 3713 insertions(+), 492 deletions(-)
copy src/lib/config/tests/testdata/{spec24.spec => spec42.spec} (82%)
copy src/lib/{python/isc/datasrc/configurableclientlist_python.h => datasrc/memory/zone_table_segment.cc} (60%)
create mode 100644 src/lib/datasrc/memory/zone_table_segment.h
copy src/lib/{python/isc/datasrc/configurableclientlist_python.h => datasrc/memory/zone_table_segment_local.cc} (60%)
create mode 100644 src/lib/datasrc/memory/zone_table_segment_local.h
create mode 100644 src/lib/datasrc/tests/memory/zone_table_segment_unittest.cc
create mode 100644 src/lib/dhcp/addr_utilities.cc
create mode 100644 src/lib/dhcp/addr_utilities.h
create mode 100644 src/lib/dhcp/cfgmgr.cc
create mode 100644 src/lib/dhcp/cfgmgr.h
create mode 100644 src/lib/dhcp/dhcpdb_create.mysql
create mode 100644 src/lib/dhcp/pool.cc
create mode 100644 src/lib/dhcp/pool.h
create mode 100644 src/lib/dhcp/subnet.cc
create mode 100644 src/lib/dhcp/subnet.h
create mode 100644 src/lib/dhcp/tests/addr_utilities_unittest.cc
create mode 100644 src/lib/dhcp/tests/cfgmgr_unittest.cc
create mode 100644 src/lib/dhcp/tests/pool_unittest.cc
create mode 100644 src/lib/dhcp/tests/subnet_unittest.cc
create mode 100644 src/lib/dhcp/tests/triplet_unittest.cc
create mode 100644 src/lib/dhcp/triplet.h
create mode 100644 src/lib/util/threads/Makefile.am
create mode 100644 src/lib/util/threads/lock.cc
create mode 100644 src/lib/util/threads/lock.h
create mode 100644 src/lib/util/threads/tests/Makefile.am
create mode 100644 src/lib/util/threads/tests/lock_unittest.cc
copy src/lib/util/{ => threads}/tests/run_unittests.cc (93%)
create mode 100644 src/lib/util/threads/tests/thread_unittest.cc
create mode 100644 src/lib/util/threads/thread.cc
create mode 100644 src/lib/util/threads/thread.h
-----------------------------------------------------------------------
diff --git a/ChangeLog b/ChangeLog
index 9c5f9ba..bad54da 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,19 @@
+485. [bug] jelte
+ Several bugs have been fixed in bindctl; tab-completion now works
+ within configuration lists, the problem where sometimes the
+ completion added a part twice has been solved, and it no longer
+ suggests the confusing value 'argument' as a completion-hint for
+ configuration items. Additionally, bindctl no longer crashes upon
+ input like 'config remove Boss'.
+ (Trac #2254, git 9047de5e8f973e12e536f7180738e6b515439448)
+
+484. [func] tomek
+ A new library (libb10-dhcpsrv) has been created. At present, it
+ only holds the code for the DHCP Configuration Manager. Currently
+ this object only supports basic configuration storage for the DHCPv6
+ server, but that capability will be expanded.
+ (Trac #2238, git 6f29861b92742da34be9ae76968e82222b5bfd7d)
+
bind10-devel-20120927 released on September 27, 2012
483. [func] marcin
diff --git a/INSTALL b/INSTALL
index 839f120..944cb25 100644
--- a/INSTALL
+++ b/INSTALL
@@ -7,3 +7,7 @@ To then build from source:
For detailed installation directions, see the guide
at doc/guide/bind10-guide.txt or doc/guide/bind10-guide.html.
+
+You can find user-contributed OS-specific build/installation
+instructions on the BIND 10 wiki:
+http://bind10.isc.org/wiki/SystemSpecificNotes
diff --git a/configure.ac b/configure.ac
index b064480..c6a2f01 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1215,6 +1215,8 @@ AC_CONFIG_FILES([Makefile
src/lib/server_common/tests/Makefile
src/lib/util/Makefile
src/lib/util/io/Makefile
+ src/lib/util/threads/Makefile
+ src/lib/util/threads/tests/Makefile
src/lib/util/unittests/Makefile
src/lib/util/python/Makefile
src/lib/util/pyunittests/Makefile
diff --git a/doc/Doxyfile b/doc/Doxyfile
index 7e122e9..f6b9fa0 100644
--- a/doc/Doxyfile
+++ b/doc/Doxyfile
@@ -579,8 +579,9 @@ INPUT = ../src/lib/exceptions ../src/lib/cc \
../src/lib/log/compiler ../src/lib/asiolink/ ../src/lib/nsas \
../src/lib/testutils ../src/lib/cache ../src/lib/server_common/ \
../src/bin/sockcreator/ ../src/lib/util/ ../src/lib/util/io/ \
- ../src/lib/resolve ../src/lib/acl ../src/bin/dhcp6 ../src/lib/dhcp \
- ../src/bin/dhcp4 ../tests/tools/perfdhcp devel
+ ../src/lib/util/threads/ ../src/lib/resolve ../src/lib/acl \
+ ../src/bin/dhcp6 ../src/lib/dhcp ../src/bin/dhcp4 \
+ ../tests/tools/perfdhcp devel
# This tag can be used to specify the character encoding of the source files
# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
diff --git a/src/bin/auth/Makefile.am b/src/bin/auth/Makefile.am
index 3efa9d3..6128a4c 100644
--- a/src/bin/auth/Makefile.am
+++ b/src/bin/auth/Makefile.am
@@ -74,6 +74,7 @@ b10_auth_LDADD += $(top_builddir)/src/lib/log/libb10-log.la
b10_auth_LDADD += $(top_builddir)/src/lib/xfr/libb10-xfr.la
b10_auth_LDADD += $(top_builddir)/src/lib/server_common/libb10-server-common.la
b10_auth_LDADD += $(top_builddir)/src/lib/statistics/libb10-statistics.la
+b10_auth_LDADD += $(top_builddir)/src/lib/util/threads/libb10-threads.la
b10_auth_LDADD += $(SQLITE_LIBS)
# TODO: config.h.in is wrong because doesn't honor pkgdatadir
diff --git a/src/bin/auth/auth_srv.cc b/src/bin/auth/auth_srv.cc
index 82a98a4..b870ae2 100644
--- a/src/bin/auth/auth_srv.cc
+++ b/src/bin/auth/auth_srv.cc
@@ -26,6 +26,7 @@
#include <exceptions/exceptions.h>
#include <util/buffer.h>
+#include <util/threads/lock.h>
#include <dns/edns.h>
#include <dns/exceptions.h>
@@ -272,6 +273,10 @@ public:
boost::shared_ptr<ConfigurableClientList> getClientList(const RRClass&
rrclass)
{
+ // TODO: Debug-build only check
+ if (!mutex_.locked()) {
+ isc_throw(isc::Unexpected, "Not locked!");
+ }
const std::map<RRClass, boost::shared_ptr<ConfigurableClientList> >::
const_iterator it(client_lists_.find(rrclass));
if (it == client_lists_.end()) {
@@ -309,6 +314,8 @@ public:
isc::dns::Message& message,
bool done);
+ mutable util::thread::Mutex mutex_;
+
private:
bool xfrout_connected_;
AbstractXfroutClient& xfrout_client_;
@@ -636,6 +643,10 @@ AuthSrvImpl::processNormalQuery(const IOMessage& io_message, Message& message,
local_edns->setUDPSize(AuthSrvImpl::DEFAULT_LOCAL_UDPSIZE);
message.setEDNS(local_edns);
}
+ // Lock the client lists and keep them under the lock until the processing
+ // and rendering is done (this is the same mutex as from
+ // AuthSrv::getClientListMutex()).
+ isc::util::thread::Mutex::Locker locker(mutex_);
try {
const ConstQuestionPtr question = *message.beginQuestion();
@@ -667,6 +678,8 @@ AuthSrvImpl::processNormalQuery(const IOMessage& io_message, Message& message,
LOG_DEBUG(auth_logger, DBG_AUTH_MESSAGES, AUTH_SEND_NORMAL_RESPONSE)
.arg(renderer_.getLength()).arg(message);
return (true);
+ // The message can contain some data from the locked resource. But outside
+ // this method, we touch only the RCode of it, so it should be safe.
}
bool
@@ -920,6 +933,11 @@ AuthSrv::destroyDDNSForwarder() {
void
AuthSrv::setClientList(const RRClass& rrclass,
const boost::shared_ptr<ConfigurableClientList>& list) {
+ // TODO: Debug-build only check
+ if (!impl_->mutex_.locked()) {
+ isc_throw(isc::Unexpected, "Not locked");
+ }
+
if (list) {
impl_->client_lists_[rrclass] = list;
} else {
@@ -933,6 +951,11 @@ AuthSrv::getClientList(const RRClass& rrclass) {
vector<RRClass>
AuthSrv::getClientListClasses() const {
+ // TODO: Debug-build only check
+ if (!impl_->mutex_.locked()) {
+ isc_throw(isc::Unexpected, "Not locked");
+ }
+
vector<RRClass> result;
for (std::map<RRClass, boost::shared_ptr<ConfigurableClientList> >::
const_iterator it(impl_->client_lists_.begin());
@@ -942,6 +965,11 @@ AuthSrv::getClientListClasses() const {
return (result);
}
+util::thread::Mutex&
+AuthSrv::getClientListMutex() const {
+ return (impl_->mutex_);
+}
+
void
AuthSrv::setTCPRecvTimeout(size_t timeout) {
dnss_->setTCPRecvTimeout(timeout);
diff --git a/src/bin/auth/auth_srv.h b/src/bin/auth/auth_srv.h
index e2ffd71..ee7bd52 100644
--- a/src/bin/auth/auth_srv.h
+++ b/src/bin/auth/auth_srv.h
@@ -40,6 +40,9 @@ namespace util {
namespace io {
class BaseSocketSessionForwarder;
}
+namespace thread {
+class Mutex;
+}
}
namespace datasrc {
class ConfigurableClientList;
@@ -319,6 +322,38 @@ public:
/// has been set by setClientList.
std::vector<isc::dns::RRClass> getClientListClasses() const;
+ /// \brief Return a mutex for the client lists.
+ ///
+ /// Background loading of data uses threads. Therefore we need to protect
+ /// the client lists by a mutex, so they don't change (or get destroyed)
+ /// during query processing. Get (and lock) this mutex whenever you do
+ /// something with the lists and keep it locked until you finish. This
+ /// is correct:
+ /// \code
+ /// {
+ /// Mutex::Locker locker(auth->getClientListMutex());
+ /// boost::shared_ptr<isc::datasrc::ConfigurableClientList>
+ /// list(auth->getClientList(RRClass::IN()));
+ /// // Do some processing here
+ /// }
+ /// \endcode
+ ///
+ /// But this is not (it releases the mutex too soon):
+ /// \code
+ /// boost::shared_ptr<isc::datasrc::ConfigurableClientList> list;
+ /// {
+ /// Mutex::Locker locker(auth->getClientListMutex());
+ /// list = auth->getClientList(RRClass::IN()));
+ /// }
+ /// // Do some processing here
+ /// \endcode
+ ///
+ /// \note This method is const even if you are allowed to modify
+ /// (lock) the mutex. It's because locking of the mutex is not really
+ /// a modification of the server object and it is needed to protect the
+ /// lists even on read-only operations.
+ isc::util::thread::Mutex& getClientListMutex() const;
+
/// \brief Sets the timeout for incoming TCP connections
///
/// Incoming TCP connections that have not sent their data
diff --git a/src/bin/auth/benchmarks/Makefile.am b/src/bin/auth/benchmarks/Makefile.am
index 948e718..48e552a 100644
--- a/src/bin/auth/benchmarks/Makefile.am
+++ b/src/bin/auth/benchmarks/Makefile.am
@@ -34,5 +34,6 @@ query_bench_LDADD += $(top_builddir)/src/lib/asiolink/libb10-asiolink.la
query_bench_LDADD += $(top_builddir)/src/lib/server_common/libb10-server-common.la
query_bench_LDADD += $(top_builddir)/src/lib/asiodns/libb10-asiodns.la
query_bench_LDADD += $(top_builddir)/src/lib/statistics/libb10-statistics.la
+query_bench_LDADD += $(top_builddir)/src/lib/util/threads/libb10-threads.la
query_bench_LDADD += $(SQLITE_LIBS)
diff --git a/src/bin/auth/command.cc b/src/bin/auth/command.cc
index 43b2422..448a31b 100644
--- a/src/bin/auth/command.cc
+++ b/src/bin/auth/command.cc
@@ -21,6 +21,7 @@
#include <config/ccsession.h>
#include <exceptions/exceptions.h>
#include <dns/rrclass.h>
+#include <util/threads/lock.h>
#include <string>
@@ -189,6 +190,9 @@ public:
}
Name origin(origin_elem->stringValue());
+ // We're going to work with the client lists. They may be used
+ // from a different thread too, protect them.
+ isc::util::thread::Mutex::Locker locker(server.getClientListMutex());
const boost::shared_ptr<isc::datasrc::ConfigurableClientList>
list(server.getClientList(zone_class));
diff --git a/src/bin/auth/datasrc_configurator.h b/src/bin/auth/datasrc_configurator.h
index f305a0d..6b2f582 100644
--- a/src/bin/auth/datasrc_configurator.h
+++ b/src/bin/auth/datasrc_configurator.h
@@ -20,6 +20,7 @@
#include <datasrc/client_list.h>
#include <config/ccsession.h>
#include <cc/data.h>
+#include <util/threads/lock.h>
#include <set>
@@ -119,6 +120,8 @@ public:
isc_throw(isc::InvalidOperation,
"Can't reconfigure while not initialized by init()");
}
+ // Lock the client lists, we're going to manipulate them.
+ isc::util::thread::Mutex::Locker locker(server_->getClientListMutex());
typedef std::map<std::string, isc::data::ConstElementPtr> Map;
typedef std::pair<isc::dns::RRClass, ListPtr> RollbackPair;
typedef std::pair<isc::dns::RRClass, isc::data::ConstElementPtr>
diff --git a/src/bin/auth/tests/Makefile.am b/src/bin/auth/tests/Makefile.am
index 75e4a27..7c01a6b 100644
--- a/src/bin/auth/tests/Makefile.am
+++ b/src/bin/auth/tests/Makefile.am
@@ -73,6 +73,7 @@ run_unittests_LDADD += $(top_builddir)/src/lib/nsas/libb10-nsas.la
run_unittests_LDADD += $(top_builddir)/src/lib/util/unittests/libutil_unittests.la
run_unittests_LDADD += $(top_builddir)/src/lib/statistics/libb10-statistics.la
run_unittests_LDADD += $(top_builddir)/src/lib/config/tests/libfake_session.la
+run_unittests_LDADD += $(top_builddir)/src/lib/util/threads/libb10-threads.la
run_unittests_LDADD += $(GTEST_LDADD)
run_unittests_LDADD += $(SQLITE_LIBS)
diff --git a/src/bin/auth/tests/auth_srv_unittest.cc b/src/bin/auth/tests/auth_srv_unittest.cc
index e7b4ca7..3197e7e 100644
--- a/src/bin/auth/tests/auth_srv_unittest.cc
+++ b/src/bin/auth/tests/auth_srv_unittest.cc
@@ -39,6 +39,7 @@
#include <auth/datasrc_configurator.h>
#include <util/unittests/mock_socketsession.h>
+#include <util/threads/lock.h>
#include <dns/tests/unittest_util.h>
#include <testutils/dnsmessage_test.h>
#include <testutils/srv_test.h>
@@ -1286,7 +1287,7 @@ public:
if (fake_rrset_ && fake_rrset_->getName() == name &&
fake_rrset_->getType() == type)
{
- return (ZoneFinderContextPtr(new ZoneFinder::Context(
+ return (ZoneFinderContextPtr(new ZoneFinder::GenericContext(
*this, options,
ResultContext(SUCCESS,
fake_rrset_))));
@@ -1425,10 +1426,13 @@ TEST_F(AuthSrvTest,
{
// Set real inmem client to proxy
updateInMemory(&server, "example.", CONFIG_INMEMORY_EXAMPLE);
- boost::shared_ptr<isc::datasrc::ConfigurableClientList>
- list(new FakeList(server.getClientList(RRClass::IN()), THROW_NEVER,
- false));
- server.setClientList(RRClass::IN(), list);
+ {
+ isc::util::thread::Mutex::Locker locker(server.getClientListMutex());
+ boost::shared_ptr<isc::datasrc::ConfigurableClientList>
+ list(new FakeList(server.getClientList(RRClass::IN()), THROW_NEVER,
+ false));
+ server.setClientList(RRClass::IN(), list);
+ }
createDataFromFile("nsec3query_nodnssec_fromWire.wire");
server.processMessage(*io_message, *parse_message, *response_obuffer,
@@ -1451,6 +1455,7 @@ setupThrow(AuthSrv* server, ThrowWhen throw_when, bool isc_exception,
{
updateInMemory(server, "example.", CONFIG_INMEMORY_EXAMPLE);
+ isc::util::thread::Mutex::Locker locker(server->getClientListMutex());
boost::shared_ptr<isc::datasrc::ConfigurableClientList>
list(new FakeList(server->getClientList(RRClass::IN()), throw_when,
isc_exception, rrset));
@@ -1763,6 +1768,10 @@ TEST_F(AuthSrvTest, DDNSForwardCreateDestroy) {
// Check the client list accessors
TEST_F(AuthSrvTest, clientList) {
+ // We need to lock the mutex to make the (get|set)ClientList happy.
+ // There's a debug-build only check in them to make sure everything
+ // locks them and we call them directly here.
+ isc::util::thread::Mutex::Locker locker(server.getClientListMutex());
// The lists don't exist. Therefore, the list of RRClasses is empty.
// We also have no IN list.
EXPECT_TRUE(server.getClientListClasses().empty());
@@ -1793,4 +1802,16 @@ TEST_F(AuthSrvTest, clientList) {
EXPECT_EQ(list, server.getClientList(RRClass::IN()));
}
+// We just test the mutex can be locked (exactly once).
+TEST_F(AuthSrvTest, mutex) {
+ isc::util::thread::Mutex::Locker l1(server.getClientListMutex());
+ // TODO: Once we have non-debug build, this one will not work, since
+ // we currently use the fact that we can't lock twice from the same
+ // thread. In the non-debug mode, this would deadlock.
+ // Skip then.
+ EXPECT_THROW({
+ isc::util::thread::Mutex::Locker l2(server.getClientListMutex());
+ }, isc::InvalidOperation);
+}
+
}
diff --git a/src/bin/auth/tests/command_unittest.cc b/src/bin/auth/tests/command_unittest.cc
index a22725e..e57de93 100644
--- a/src/bin/auth/tests/command_unittest.cc
+++ b/src/bin/auth/tests/command_unittest.cc
@@ -174,6 +174,7 @@ TEST_F(AuthCommandTest, shutdownIncorrectPID) {
// zones, and checks the zones are correctly loaded.
void
zoneChecks(AuthSrv& server) {
+ isc::util::thread::Mutex::Locker locker(server.getClientListMutex());
EXPECT_EQ(ZoneFinder::SUCCESS, server.getClientList(RRClass::IN())->
find(Name("ns.test1.example")).finder_->
find(Name("ns.test1.example"), RRType::A())->code);
@@ -214,6 +215,7 @@ configureZones(AuthSrv& server) {
void
newZoneChecks(AuthSrv& server) {
+ isc::util::thread::Mutex::Locker locker(server.getClientListMutex());
EXPECT_EQ(ZoneFinder::SUCCESS, server.getClientList(RRClass::IN())->
find(Name("ns.test1.example")).finder_->
find(Name("ns.test1.example"), RRType::A())->code);
@@ -271,30 +273,33 @@ TEST_F(AuthCommandTest,
"}]}"));
DataSourceConfigurator::testReconfigure(&server_, config);
- // Check that the A record at www.example.org does not exist
- EXPECT_EQ(ZoneFinder::NXDOMAIN, server_.getClientList(RRClass::IN())->
- find(Name("example.org")).finder_->
- find(Name("www.example.org"), RRType::A())->code);
-
- // Add the record to the underlying sqlite database, by loading
- // it as a separate datasource, and updating it
- ConstElementPtr sql_cfg = Element::fromJSON("{ \"type\": \"sqlite3\","
- "\"database_file\": \""
- + test_db + "\"}");
- DataSourceClientContainer sql_ds("sqlite3", sql_cfg);
- ZoneUpdaterPtr sql_updater =
- sql_ds.getInstance().getUpdater(Name("example.org"), false);
- RRsetPtr rrset(new RRset(Name("www.example.org."), RRClass::IN(),
- RRType::A(), RRTTL(60)));
- rrset->addRdata(rdata::createRdata(rrset->getType(),
- rrset->getClass(),
- "192.0.2.1"));
- sql_updater->addRRset(*rrset);
- sql_updater->commit();
-
- EXPECT_EQ(ZoneFinder::NXDOMAIN, server_.getClientList(RRClass::IN())->
- find(Name("example.org")).finder_->
- find(Name("www.example.org"), RRType::A())->code);
+ {
+ isc::util::thread::Mutex::Locker locker(server_.getClientListMutex());
+ // Check that the A record at www.example.org does not exist
+ EXPECT_EQ(ZoneFinder::NXDOMAIN, server_.getClientList(RRClass::IN())->
+ find(Name("example.org")).finder_->
+ find(Name("www.example.org"), RRType::A())->code);
+
+ // Add the record to the underlying sqlite database, by loading
+ // it as a separate datasource, and updating it
+ ConstElementPtr sql_cfg = Element::fromJSON("{ \"type\": \"sqlite3\","
+ "\"database_file\": \""
+ + test_db + "\"}");
+ DataSourceClientContainer sql_ds("sqlite3", sql_cfg);
+ ZoneUpdaterPtr sql_updater =
+ sql_ds.getInstance().getUpdater(Name("example.org"), false);
+ RRsetPtr rrset(new RRset(Name("www.example.org."), RRClass::IN(),
+ RRType::A(), RRTTL(60)));
+ rrset->addRdata(rdata::createRdata(rrset->getType(),
+ rrset->getClass(),
+ "192.0.2.1"));
+ sql_updater->addRRset(*rrset);
+ sql_updater->commit();
+
+ EXPECT_EQ(ZoneFinder::NXDOMAIN, server_.getClientList(RRClass::IN())->
+ find(Name("example.org")).finder_->
+ find(Name("www.example.org"), RRType::A())->code);
+ }
// Now send the command to reload it
result_ = execAuthServerCommand(server_, "loadzone",
@@ -302,20 +307,26 @@ TEST_F(AuthCommandTest,
"{\"origin\": \"example.org\"}"));
checkAnswer(0, "Successful load");
- // And now it should be present too.
- EXPECT_EQ(ZoneFinder::SUCCESS, server_.getClientList(RRClass::IN())->
- find(Name("example.org")).finder_->
- find(Name("www.example.org"), RRType::A())->code);
+ {
+ isc::util::thread::Mutex::Locker locker(server_.getClientListMutex());
+ // And now it should be present too.
+ EXPECT_EQ(ZoneFinder::SUCCESS, server_.getClientList(RRClass::IN())->
+ find(Name("example.org")).finder_->
+ find(Name("www.example.org"), RRType::A())->code);
+ }
// Some error cases. First, the zone has no configuration. (note .com here)
result_ = execAuthServerCommand(server_, "loadzone",
Element::fromJSON("{\"origin\": \"example.com\"}"));
checkAnswer(1, "example.com");
- // The previous zone is not hurt in any way
- EXPECT_EQ(ZoneFinder::SUCCESS, server_.getClientList(RRClass::IN())->
- find(Name("example.org")).finder_->
- find(Name("example.org"), RRType::SOA())->code);
+ {
+ isc::util::thread::Mutex::Locker locker(server_.getClientListMutex());
+ // The previous zone is not hurt in any way
+ EXPECT_EQ(ZoneFinder::SUCCESS, server_.getClientList(RRClass::IN())->
+ find(Name("example.org")).finder_->
+ find(Name("example.org"), RRType::SOA())->code);
+ }
const ConstElementPtr config2(Element::fromJSON("{"
"\"IN\": [{"
@@ -331,6 +342,7 @@ TEST_F(AuthCommandTest,
Element::fromJSON("{\"origin\": \"example.com\"}"));
checkAnswer(1, "Unreadable");
+ isc::util::thread::Mutex::Locker locker(server_.getClientListMutex());
// The previous zone is not hurt in any way
EXPECT_EQ(ZoneFinder::SUCCESS, server_.getClientList(RRClass::IN())->
find(Name("example.org")).finder_->
diff --git a/src/bin/auth/tests/datasrc_configurator_unittest.cc b/src/bin/auth/tests/datasrc_configurator_unittest.cc
index 78e3688..254b238 100644
--- a/src/bin/auth/tests/datasrc_configurator_unittest.cc
+++ b/src/bin/auth/tests/datasrc_configurator_unittest.cc
@@ -16,6 +16,7 @@
#include <config/tests/fake_session.h>
#include <config/ccsession.h>
+#include <util/threads/lock.h>
#include <gtest/gtest.h>
#include <memory>
@@ -81,6 +82,9 @@ public:
}
return (result);
}
+ isc::util::thread::Mutex& getClientListMutex() const {
+ return (mutex_);
+ }
protected:
DatasrcConfiguratorTest() :
session(ElementPtr(new ListElement), ElementPtr(new ListElement),
@@ -137,6 +141,7 @@ protected:
const string specfile;
std::map<RRClass, ListPtr> lists_;
string log_;
+ mutable isc::util::thread::Mutex mutex_;
};
// Check the initialization (and cleanup)
diff --git a/src/bin/auth/tests/query_unittest.cc b/src/bin/auth/tests/query_unittest.cc
index 603bf5c..84b7f8a 100644
--- a/src/bin/auth/tests/query_unittest.cc
+++ b/src/bin/auth/tests/query_unittest.cc
@@ -442,10 +442,9 @@ public:
ConstRRsetPtr rrset)
{
nsec_name_ = nsec_name;
- nsec_context_.reset(new Context(*this,
- FIND_DEFAULT, // a fake value
- ResultContext(code, rrset,
- RESULT_NSEC_SIGNED)));
+ nsec_context_.reset(
+ new GenericContext(*this, FIND_DEFAULT, // a fake value
+ ResultContext(code, rrset, RESULT_NSEC_SIGNED)));
}
// Once called, the findNSEC3 will return the provided result for the next
@@ -487,8 +486,8 @@ protected:
{
ConstRRsetPtr rp = stripRRsigs(rrset, options);
return (ZoneFinderContextPtr(
- new Context(*this, options,
- ResultContext(code, rp, flags))));
+ new GenericContext(*this, options,
+ ResultContext(code, rp, flags))));
}
private:
@@ -604,9 +603,9 @@ MockZoneFinder::findAll(const Name& name, std::vector<ConstRRsetPtr>& target,
target.push_back(stripRRsigs(found_rrset->second, options));
}
return (ZoneFinderContextPtr(
- new Context(*this, options,
- ResultContext(SUCCESS, RRsetPtr()),
- target)));
+ new GenericContext(*this, options,
+ ResultContext(SUCCESS, RRsetPtr()),
+ target)));
}
}
diff --git a/src/bin/bindctl/bindcmd.py b/src/bin/bindctl/bindcmd.py
index f1a622e..b4e71bf 100644
--- a/src/bin/bindctl/bindcmd.py
+++ b/src/bin/bindctl/bindcmd.py
@@ -22,7 +22,7 @@ import sys
from cmd import Cmd
from bindctl.exception import *
from bindctl.moduleinfo import *
-from bindctl.cmdparse import BindCmdParse
+from bindctl.cmdparse import BindCmdParser
from bindctl import command_sets
from xml.dom import minidom
import isc
@@ -48,20 +48,21 @@ except ImportError:
# if we have readline support, use that, otherwise use normal stdio
try:
import readline
- # This is a fix for the problem described in
- # http://bind10.isc.org/ticket/1345
- # If '-' is seen as a word-boundary, the final completion-step
- # (as handled by the cmd module, and hence outside our reach) can
- # mistakenly add data twice, resulting in wrong completion results
- # The solution is to remove it.
- delims = readline.get_completer_delims()
- delims = delims.replace('-', '')
- readline.set_completer_delims(delims)
+ # Only consider spaces as word boundaries; identifiers can contain
+ # '/' and '[]', and configuration item names can in theory use any
+ # printable character. See the discussion in tickets #1345 and
+ # #2254 for more information.
+ readline.set_completer_delims(' ')
my_readline = readline.get_line_buffer
except ImportError:
my_readline = sys.stdin.readline
+# Used for tab-completion of 'identifiers' (i.e. config values)
+# If a command parameter has this name, the tab completion hints
+# are derived from config data
+CFGITEM_IDENTIFIER_PARAM = 'identifier'
+
CSV_FILE_NAME = 'default_user.csv'
CONFIG_MODULE_NAME = 'config'
CONST_BINDCTL_HELP = """
@@ -463,41 +464,101 @@ class BindCmdInterpreter(Cmd):
Cmd.onecmd(self, line)
- def remove_prefix(self, list, prefix):
- """Removes the prefix already entered, and all elements from the
- list that don't match it"""
- if prefix.startswith('/'):
- prefix = prefix[1:]
-
- new_list = []
- for val in list:
- if val.startswith(prefix):
- new_val = val[len(prefix):]
- if new_val.startswith("/"):
- new_val = new_val[1:]
- new_list.append(new_val)
- return new_list
+ def _get_identifier_startswith(self, id_text):
+ """Return the tab-completion hints for identifiers starting with
+ id_text.
+
+ Parameters:
+ id_text (string): the currently entered identifier part, which
+ is to be completed.
+ """
+ # Strip starting "/" from id_text
+ if id_text.startswith('/'):
+ id_text = id_text[1:]
+ # Get all items from the given module (up to the first /)
+ list = self.config_data.get_config_item_list(
+ id_text.rpartition("/")[0], recurse=True)
+ # filter out all possibilities that don't match currently entered
+ # text part
+ hints = [val for val in list if val.startswith(id_text)]
+ return hints
+
+ def _cmd_has_identifier_param(self, cmd):
+ """
+ Returns True if the given (parsed) command is known and has a
+ parameter which points to a config data identifier
+
+ Parameters:
+ cmd (cmdparse.BindCmdParser): command context, including given params
+
+ """
+ if cmd.module not in self.modules:
+ return False
+ command = self.modules[cmd.module].get_command_with_name(cmd.command)
+ return command.has_param_with_name(CFGITEM_IDENTIFIER_PARAM)
def complete(self, text, state):
- if 0 == state:
+ """
+ Returns tab-completion hints. See the python documentation of the
+ readline and Cmd modules for more information.
+
+ The first time this is called (within one 'completer' action), it
+ has state 0, and a list of possible completions is made. This list
+ is stored; complete() will then be called with increasing values of
+ state, until it returns None. For each call it returns the state'th
+ element of the hints it collected in the first call.
+
+ The hints list contents depend on which part of the full command
+ line; if no module is given yet, it will list all modules. If a
+ module is given, but no command, it will complete with module
+ commands. If both have been given, it will create the hints based on
+ the command parameters.
+
+ If module and command have already been specified, and the command
+ has a parameter 'identifier', the configuration data is used to
+ create the hints list.
+
+ Parameters:
+ text (string): The text entered so far in the 'current' part of
+ the command (module, command, parameters)
+ state (int): state used in the readline tab-completion logic;
+ 0 on first call, increasing by one until there are
+ no (more) hints to return.
+
+ Returns the string value of the hints list with index 'state',
+ or None if no (more) hints are available.
+ """
+ if state == 0:
self._update_all_modules_info()
text = text.strip()
hints = []
cur_line = my_readline()
try:
- cmd = BindCmdParse(cur_line)
+ cmd = BindCmdParser(cur_line)
if not cmd.params and text:
hints = self._get_command_startswith(cmd.module, text)
+ elif self._cmd_has_identifier_param(cmd):
+ # If the command has an argument that is a configuration
+ # identifier (currently, this is only a subset of
+ # the config commands), then don't tab-complete with
+ # hints derived from command parameters, but from
+ # possible configuration identifiers.
+ #
+ # This solves the issue reported in #2254, where
+ # there were hints such as 'argument' and 'identifier'.
+ #
+ # Since they are replaced, the tab-completion no longer
+ # adds 'help' as an option (but it still works)
+ #
+ # Also, currently, tab-completion does not work
+ # together with 'config go' (it does not take 'current
+ # position' into account). But config go currently has
+ # problems by itself, unrelated to completion.
+ hints = self._get_identifier_startswith(text)
else:
hints = self._get_param_startswith(cmd.module, cmd.command,
text)
- if cmd.module == CONFIG_MODULE_NAME:
- # grm text has been stripped of slashes...
- my_text = self.location + "/" + cur_line.rpartition(" ")[2]
- list = self.config_data.get_config_item_list(my_text.rpartition("/")[0], True)
- hints.extend([val for val in list if val.startswith(my_text[1:])])
- # remove the common prefix from the hints so we don't get it twice
- hints = self.remove_prefix(hints, my_text.rpartition("/")[0])
+
except CmdModuleNameFormatError:
if not text:
hints = self.get_module_names()
@@ -562,7 +623,7 @@ class BindCmdInterpreter(Cmd):
def _parse_cmd(self, line):
try:
- cmd = BindCmdParse(line)
+ cmd = BindCmdParser(line)
self._validate_cmd(cmd)
self._handle_cmd(cmd)
except (IOError, http.client.HTTPException) as err:
@@ -794,7 +855,7 @@ class BindCmdInterpreter(Cmd):
else:
print("Warning: ignoring unknown directive: " + line)
else:
- cmd = BindCmdParse(line)
+ cmd = BindCmdParser(line)
self._validate_cmd(cmd)
self._handle_cmd(cmd)
except (isc.config.ModuleCCSessionError,
diff --git a/src/bin/bindctl/bindctl_main.py.in b/src/bin/bindctl/bindctl_main.py.in
index 1685355..546ecc0 100755
--- a/src/bin/bindctl/bindctl_main.py.in
+++ b/src/bin/bindctl/bindctl_main.py.in
@@ -42,16 +42,19 @@ def prepare_config_commands(tool):
cmd = CommandInfo(name = "show", desc = "Show configuration.")
param = ParamInfo(name = "argument", type = "string", optional=True, desc = "If you specify the argument 'all' (before the identifier), recursively show all child elements for the given identifier.")
cmd.add_param(param)
- param = ParamInfo(name = "identifier", type = "string", optional=True, desc = DEFAULT_IDENTIFIER_DESC)
+ param = ParamInfo(name=CFGITEM_IDENTIFIER_PARAM, type="string",
+ optional=True, desc=DEFAULT_IDENTIFIER_DESC)
cmd.add_param(param)
module.add_command(cmd)
- cmd = CommandInfo(name = "show_json", desc = "Show full configuration in JSON format.")
- param = ParamInfo(name = "identifier", type = "string", optional=True, desc = DEFAULT_IDENTIFIER_DESC)
+ cmd = CommandInfo(name="show_json",
+ desc="Show full configuration in JSON format.")
+ param = ParamInfo(name=CFGITEM_IDENTIFIER_PARAM, type="string",
+ optional=True, desc=DEFAULT_IDENTIFIER_DESC)
cmd.add_param(param)
module.add_command(cmd)
- cmd = CommandInfo(name = "add", desc =
+ cmd = CommandInfo(name="add", desc=
"Add an entry to configuration list or a named set. "
"When adding to a list, the command has one optional argument, "
"a value to add to the list. The value must be in correct JSON "
@@ -60,45 +63,53 @@ def prepare_config_commands(tool):
"parameter value, similar to when adding to a list. "
"In either case, when no value is given, an entry will be "
"constructed with default values.")
- param = ParamInfo(name = "identifier", type = "string", optional=True, desc = DEFAULT_IDENTIFIER_DESC)
+ param = ParamInfo(name=CFGITEM_IDENTIFIER_PARAM, type="string",
+ optional=True, desc=DEFAULT_IDENTIFIER_DESC)
cmd.add_param(param)
- param = ParamInfo(name = "value_or_name", type = "string", optional=True, desc = "Specifies a value to add to the list, or the name when adding to a named set. It must be in correct JSON format and complete.")
+ param = ParamInfo(name="value_or_name", type="string", optional=True,
+ desc="Specifies a value to add to the list, or the name when adding to a named set. It must be in correct JSON format and complete.")
cmd.add_param(param)
module.add_command(cmd)
- param = ParamInfo(name = "value_for_set", type = "string", optional=True, desc = "Specifies an optional value to add to the named map. It must be in correct JSON format and complete.")
+ param = ParamInfo(name="value_for_set", type="string", optional=True,
+ desc="Specifies an optional value to add to the named map. It must be in correct JSON format and complete.")
cmd.add_param(param)
module.add_command(cmd)
- cmd = CommandInfo(name = "remove", desc = "Remove entry from configuration list or named set.")
- param = ParamInfo(name = "identifier", type = "string", optional=True, desc = DEFAULT_IDENTIFIER_DESC)
+ cmd = CommandInfo(name="remove", desc="Remove entry from configuration list or named set.")
+ param = ParamInfo(name=CFGITEM_IDENTIFIER_PARAM, type="string",
+ optional=True, desc=DEFAULT_IDENTIFIER_DESC)
cmd.add_param(param)
param = ParamInfo(name = "value", type = "string", optional=True, desc = "When identifier is a list, specifies a value to remove from the list. It must be in correct JSON format and complete. When it is a named set, specifies the name to remove.")
cmd.add_param(param)
module.add_command(cmd)
- cmd = CommandInfo(name = "set", desc = "Set a configuration value.")
- param = ParamInfo(name = "identifier", type = "string", optional=True, desc = DEFAULT_IDENTIFIER_DESC)
+ cmd = CommandInfo(name="set", desc="Set a configuration value.")
+ param = ParamInfo(name=CFGITEM_IDENTIFIER_PARAM, type="string",
+ optional=True, desc=DEFAULT_IDENTIFIER_DESC)
cmd.add_param(param)
- param = ParamInfo(name = "value", type = "string", optional=False, desc = "Specifies a value to set. It must be in correct JSON format and complete.")
+ param = ParamInfo(name="value", type="string", optional=False,
+ desc="Specifies a value to set. It must be in correct JSON format and complete.")
cmd.add_param(param)
module.add_command(cmd)
- cmd = CommandInfo(name = "unset", desc = "Unset a configuration value (i.e. revert to the default, if any).")
- param = ParamInfo(name = "identifier", type = "string", optional=False, desc = DEFAULT_IDENTIFIER_DESC)
+ cmd = CommandInfo(name="unset", desc="Unset a configuration value (i.e. revert to the default, if any).")
+ param = ParamInfo(name=CFGITEM_IDENTIFIER_PARAM, type="string",
+ optional=False, desc=DEFAULT_IDENTIFIER_DESC)
cmd.add_param(param)
module.add_command(cmd)
- cmd = CommandInfo(name = "diff", desc = "Show all local changes that have not been committed.")
+ cmd = CommandInfo(name="diff", desc="Show all local changes that have not been committed.")
module.add_command(cmd)
- cmd = CommandInfo(name = "revert", desc = "Revert all local changes.")
+ cmd = CommandInfo(name="revert", desc="Revert all local changes.")
module.add_command(cmd)
- cmd = CommandInfo(name = "commit", desc = "Commit all local changes.")
+ cmd = CommandInfo(name="commit", desc="Commit all local changes.")
module.add_command(cmd)
- cmd = CommandInfo(name = "go", desc = "Go to a specific configuration part.")
- param = ParamInfo(name = "identifier", type="string", optional=False, desc = DEFAULT_IDENTIFIER_DESC)
+ cmd = CommandInfo(name="go", desc="Go to a specific configuration part.")
+ param = ParamInfo(name=CFGITEM_IDENTIFIER_PARAM, type="string",
+ optional=False, desc=DEFAULT_IDENTIFIER_DESC)
cmd.add_param(param)
module.add_command(cmd)
diff --git a/src/bin/bindctl/cmdparse.py b/src/bin/bindctl/cmdparse.py
index c624cba..30909a3 100644
--- a/src/bin/bindctl/cmdparse.py
+++ b/src/bin/bindctl/cmdparse.py
@@ -25,7 +25,7 @@ except ImportError:
param_name_str = "^\s*(?P<param_name>[\w]+)\s*=\s*"
-# The value string can be a sequence without space or comma
+# The value string can be a sequence without space or comma
# characters, or a string surroundedby quotation marks(such marks
# can be part of string in an escaped form)
#param_value_str = "(?P<param_value>[\"\'].+?(?<!\\\)[\"\']|[^\'\"][^, ]+)"
@@ -34,8 +34,8 @@ param_value_with_quota_str = "[\"\'](?P<param_value>.+?)(?<!\\\)[\"\']"
next_params_str = "(?P<blank>\s*)(?P<comma>,?)(?P<next_params>.*)$"
-PARAM_WITH_QUOTA_PATTERN = re.compile(param_name_str +
- param_value_with_quota_str +
+PARAM_WITH_QUOTA_PATTERN = re.compile(param_name_str +
+ param_value_with_quota_str +
next_params_str)
PARAM_PATTERN = re.compile(param_name_str + param_value_str + next_params_str)
# Used for module and command name
@@ -83,52 +83,52 @@ def _remove_list_and_map_whitespace(text):
if map_count == 0:
result.append(_remove_unquoted_whitespace(text[cur_start_map_pos:pos + 1]))
start_pos = pos + 1
-
+
pos = pos + 1
if start_pos <= len(text):
result.append(text[start_pos:len(text)])
return "".join(result)
-
-
-class BindCmdParse:
+
+
+class BindCmdParser:
""" This class will parse the command line user input into three parts:
module name, command, parameters
- the first two parts are strings and parameter is one hash,
+ the first two parts are strings and parameter is one hash,
parameters part is optional
-
- Example: zone reload, zone_name=example.com
+
+ Example: zone reload, zone_name=example.com
module == zone
command == reload
params == [zone_name = 'example.com']
"""
-
+
def __init__(self, cmd):
self.params = OrderedDict()
self.module = ''
self.command = ''
self._parse_cmd(cmd)
- def _parse_cmd(self, text_str):
+ def _parse_cmd(self, text_str):
'''Parse command line. '''
# Get module name
groups = NAME_PATTERN.match(text_str)
if not groups:
raise CmdModuleNameFormatError
-
+
self.module = groups.group('name')
cmd_str = groups.group('others')
if cmd_str:
if not groups.group('blank'):
raise CmdModuleNameFormatError
- else:
+ else:
raise CmdMissCommandNameFormatError(self.module)
-
+
# Get command name
groups = NAME_PATTERN.match(cmd_str)
if (not groups):
raise CmdCommandNameFormatError(self.module)
-
+
self.command = groups.group('name')
param_str = groups.group('others')
if param_str:
@@ -143,7 +143,7 @@ class BindCmdParse:
def _parse_params(self, param_text):
"""convert a=b,c=d into one hash """
param_text = _remove_list_and_map_whitespace(param_text)
-
+
# Check parameter name "help"
param = NAME_PATTERN.match(param_text)
if param and param.group('name') == "help":
@@ -153,7 +153,7 @@ class BindCmdParse:
while True:
if not param_text.strip():
break
-
+
groups = PARAM_PATTERN.match(param_text) or \
PARAM_WITH_QUOTA_PATTERN.match(param_text)
if not groups:
diff --git a/src/bin/bindctl/tests/bindctl_test.py b/src/bin/bindctl/tests/bindctl_test.py
index bcfb6c5..f598472 100644
--- a/src/bin/bindctl/tests/bindctl_test.py
+++ b/src/bin/bindctl/tests/bindctl_test.py
@@ -40,14 +40,14 @@ except ImportError:
class TestCmdLex(unittest.TestCase):
def my_assert_raise(self, exception_type, cmd_line):
- self.assertRaises(exception_type, cmdparse.BindCmdParse, cmd_line)
+ self.assertRaises(exception_type, cmdparse.BindCmdParser, cmd_line)
def testCommandWithoutParameter(self):
- cmd = cmdparse.BindCmdParse("zone add")
- assert cmd.module == "zone"
- assert cmd.command == "add"
- self.assertEqual(len(cmd.params), 0)
+ cmd_parser = cmdparse.BindCmdParser("zone add")
+ assert cmd_parser.module == "zone"
+ assert cmd_parser.command == "add"
+ self.assertEqual(len(cmd_parser.params), 0)
def testCommandWithParameters(self):
@@ -56,45 +56,51 @@ class TestCmdLex(unittest.TestCase):
"zone add zone_name = 'cnnic.cn\", file ='cnnic.cn.file' master=1.1.1.1, " }
for cmd_line in lines:
- cmd = cmdparse.BindCmdParse(cmd_line)
- assert cmd.module == "zone"
- assert cmd.command == "add"
- assert cmd.params["zone_name"] == "cnnic.cn"
- assert cmd.params["file"] == "cnnic.cn.file"
- assert cmd.params["master"] == '1.1.1.1'
+ cmd_parser = cmdparse.BindCmdParser(cmd_line)
+ assert cmd_parser.module == "zone"
+ assert cmd_parser.command == "add"
+ assert cmd_parser.params["zone_name"] == "cnnic.cn"
+ assert cmd_parser.params["file"] == "cnnic.cn.file"
+ assert cmd_parser.params["master"] == '1.1.1.1'
def testCommandWithParamters_2(self):
'''Test whether the parameters in key=value can be parsed properly.'''
- cmd = cmdparse.BindCmdParse('zone cmd name = 1:34::2')
- self.assertEqual(cmd.params['name'], '1:34::2')
-
- cmd = cmdparse.BindCmdParse('zone cmd name = 1\"\'34**&2 value=44\"\'\"')
- self.assertEqual(cmd.params['name'], '1\"\'34**&2')
- self.assertEqual(cmd.params['value'], '44\"\'\"')
-
- cmd = cmdparse.BindCmdParse('zone cmd name = 1\"\'34**&2 ,value= 44\"\'\"')
- self.assertEqual(cmd.params['name'], '1\"\'34**&2')
- self.assertEqual(cmd.params['value'], '44\"\'\"')
-
- cmd = cmdparse.BindCmdParse('zone cmd name = 1\'34**&2value=44\"\'\" value = \"==============\'')
- self.assertEqual(cmd.params['name'], '1\'34**&2value=44\"\'\"')
- self.assertEqual(cmd.params['value'], '==============')
-
- cmd = cmdparse.BindCmdParse('zone cmd name = \"1234, 567890 \" value ==&*/')
- self.assertEqual(cmd.params['name'], '1234, 567890 ')
- self.assertEqual(cmd.params['value'], '=&*/')
+ cmd_parser = cmdparse.BindCmdParser('zone cmd name = 1:34::2')
+ self.assertEqual(cmd_parser.params['name'], '1:34::2')
+
+ cmd_parser = cmdparse.BindCmdParser('zone cmd name = 1\"\'34**&2'
+ ' value=44\"\'\"')
+ self.assertEqual(cmd_parser.params['name'], '1\"\'34**&2')
+ self.assertEqual(cmd_parser.params['value'], '44\"\'\"')
+
+ cmd_parser = cmdparse.BindCmdParser('zone cmd name = 1\"\'34**&2'
+ ',value= 44\"\'\"')
+ self.assertEqual(cmd_parser.params['name'], '1\"\'34**&2')
+ self.assertEqual(cmd_parser.params['value'], '44\"\'\"')
+
+ cmd_parser = cmdparse.BindCmdParser('zone cmd name = 1\'34**&2'
+ 'value=44\"\'\" value = '
+ '\"==============\'')
+ self.assertEqual(cmd_parser.params['name'], '1\'34**&2value=44\"\'\"')
+ self.assertEqual(cmd_parser.params['value'], '==============')
+
+ cmd_parser = cmdparse.BindCmdParser('zone cmd name = \"1234, '
+ '567890 \" value ==&*/')
+ self.assertEqual(cmd_parser.params['name'], '1234, 567890 ')
+ self.assertEqual(cmd_parser.params['value'], '=&*/')
def testCommandWithListParam(self):
- cmd = cmdparse.BindCmdParse("zone set zone_name='cnnic.cn', master='1.1.1.1, 2.2.2.2'")
- assert cmd.params["master"] == '1.1.1.1, 2.2.2.2'
+ cmd_parser = cmdparse.BindCmdParser("zone set zone_name='cnnic.cn', "
+ "master='1.1.1.1, 2.2.2.2'")
+ assert cmd_parser.params["master"] == '1.1.1.1, 2.2.2.2'
def testCommandWithHelpParam(self):
- cmd = cmdparse.BindCmdParse("zone add help")
- assert cmd.params["help"] == "help"
+ cmd_parser = cmdparse.BindCmdParser("zone add help")
+ assert cmd_parser.params["help"] == "help"
- cmd = cmdparse.BindCmdParse("zone add help *&)&)*&&$#$^%")
- assert cmd.params["help"] == "help"
- self.assertEqual(len(cmd.params), 1)
+ cmd_parser = cmdparse.BindCmdParser("zone add help *&)&)*&&$#$^%")
+ assert cmd_parser.params["help"] == "help"
+ self.assertEqual(len(cmd_parser.params), 1)
def testCmdModuleNameFormatError(self):
@@ -130,15 +136,20 @@ class TestCmdSyntax(unittest.TestCase):
int_spec = { 'item_type' : 'integer',
'item_optional' : False,
'item_default' : 10}
- zone_file_param = ParamInfo(name = "zone_file", param_spec = string_spec)
+ zone_file_param = ParamInfo(name = "zone_file",
+ param_spec = string_spec)
zone_name = ParamInfo(name = 'zone_name', param_spec = string_spec)
load_cmd = CommandInfo(name = "load")
load_cmd.add_param(zone_file_param)
load_cmd.add_param(zone_name)
- param_master = ParamInfo(name = "master", optional = True, param_spec = string_spec)
- param_master = ParamInfo(name = "port", optional = True, param_spec = int_spec)
- param_allow_update = ParamInfo(name = "allow_update", optional = True, param_spec = string_spec)
+ param_master = ParamInfo(name = "master", optional = True,
+ param_spec = string_spec)
+ param_master = ParamInfo(name = "port", optional = True,
+ param_spec = int_spec)
+ param_allow_update = ParamInfo(name = "allow_update",
+ optional = True,
+ param_spec = string_spec)
set_cmd = CommandInfo(name = "set")
set_cmd.add_param(param_master)
set_cmd.add_param(param_allow_update)
@@ -160,13 +171,14 @@ class TestCmdSyntax(unittest.TestCase):
def no_assert_raise(self, cmd_line):
- cmd = cmdparse.BindCmdParse(cmd_line)
- self.bindcmd._validate_cmd(cmd)
+ cmd_parser = cmdparse.BindCmdParser(cmd_line)
+ self.bindcmd._validate_cmd(cmd_parser)
def my_assert_raise(self, exception_type, cmd_line):
- cmd = cmdparse.BindCmdParse(cmd_line)
- self.assertRaises(exception_type, self.bindcmd._validate_cmd, cmd)
+ cmd_parser = cmdparse.BindCmdParser(cmd_line)
+ self.assertRaises(exception_type, self.bindcmd._validate_cmd,
+ cmd_parser)
def testValidateSuccess(self):
@@ -177,7 +189,8 @@ class TestCmdSyntax(unittest.TestCase):
self.no_assert_raise("zone help help='dd' ")
self.no_assert_raise("zone set allow_update='1.1.1.1' zone_name='cn'")
self.no_assert_raise("zone set zone_name='cn'")
- self.my_assert_raise(isc.cc.data.DataTypeError, "zone set zone_name ='cn', port='cn'")
+ self.my_assert_raise(isc.cc.data.DataTypeError,
+ "zone set zone_name ='cn', port='cn'")
self.no_assert_raise("zone reload_all")
def testCmdUnknownModuleSyntaxError(self):
@@ -188,15 +201,22 @@ class TestCmdSyntax(unittest.TestCase):
self.my_assert_raise(CmdUnknownCmdSyntaxError, "zone dd")
def testCmdMissParamSyntaxError(self):
- self.my_assert_raise(CmdMissParamSyntaxError, "zone load zone_file='cn'")
- self.my_assert_raise(CmdMissParamSyntaxError, "zone load zone_name='cn'")
- self.my_assert_raise(CmdMissParamSyntaxError, "zone set allow_update='1.1.1.1'")
- self.my_assert_raise(CmdMissParamSyntaxError, "zone set ")
+ self.my_assert_raise(CmdMissParamSyntaxError,
+ "zone load zone_file='cn'")
+ self.my_assert_raise(CmdMissParamSyntaxError,
+ "zone load zone_name='cn'")
+ self.my_assert_raise(CmdMissParamSyntaxError,
+ "zone set allow_update='1.1.1.1'")
+ self.my_assert_raise(CmdMissParamSyntaxError,
+ "zone set ")
def testCmdUnknownParamSyntaxError(self):
- self.my_assert_raise(CmdUnknownParamSyntaxError, "zone load zone_d='cn'")
- self.my_assert_raise(CmdUnknownParamSyntaxError, "zone reload_all zone_name = 'cn'")
- self.my_assert_raise(CmdUnknownParamSyntaxError, "zone help a b c")
+ self.my_assert_raise(CmdUnknownParamSyntaxError,
+ "zone load zone_d='cn'")
+ self.my_assert_raise(CmdUnknownParamSyntaxError,
+ "zone reload_all zone_name = 'cn'")
+ self.my_assert_raise(CmdUnknownParamSyntaxError,
+ "zone help a b c")
class TestModuleInfo(unittest.TestCase):
@@ -233,7 +253,8 @@ class TestNameSequence(unittest.TestCase):
self.tool.add_module_info(ModuleInfo(name = random_str))
def setUp(self):
- self.random_names = ['1erdfeDDWsd', '3fe', '2009erd', 'Fe231', 'tere142', 'rei8WD']
+ self.random_names = ['1erdfeDDWsd', '3fe', '2009erd',
+ 'Fe231', 'tere142', 'rei8WD']
self._create_bindcmd()
def testSequence(self):
@@ -321,7 +342,8 @@ class TestConfigCommands(unittest.TestCase):
def precmd(line):
self.tool.precmd(line)
self.tool._update_all_modules_info = update_all_modules_info
- # If line is equals to 'EOF', _update_all_modules_info() shouldn't be called
+ # If line is equals to 'EOF', _update_all_modules_info()
+ # shouldn't be called
precmd('EOF')
self.assertRaises(socket.error, precmd, 'continue')
@@ -360,34 +382,41 @@ class TestConfigCommands(unittest.TestCase):
self.assertEqual((1, MultiConfigData.DEFAULT),
self.tool.config_data.get_value("/foo/an_int"))
- cmd = cmdparse.BindCmdParse("config set identifier=\"foo/an_int\" value=\"5\"")
- self.tool.apply_config_cmd(cmd)
+ cmd_parser = cmdparse.BindCmdParser('config set identifier='
+ '"foo/an_int" value="5"')
+ self.tool.apply_config_cmd(cmd_parser)
self.assertEqual((5, MultiConfigData.LOCAL),
self.tool.config_data.get_value("/foo/an_int"))
- cmd = cmdparse.BindCmdParse("config unset identifier=\"foo/an_int\"")
- self.tool.apply_config_cmd(cmd)
+ cmd_parser = cmdparse.BindCmdParser('config unset identifier='
+ '"foo/an_int"')
+ self.tool.apply_config_cmd(cmd_parser)
self.assertEqual((1, MultiConfigData.DEFAULT),
self.tool.config_data.get_value("/foo/an_int"))
# this should raise a NotFoundError
- cmd = cmdparse.BindCmdParse("config set identifier=\"foo/bar\" value=\"[]\"")
- self.assertRaises(isc.cc.data.DataNotFoundError, self.tool.apply_config_cmd, cmd)
+ cmd_parser = cmdparse.BindCmdParser('config set identifier='
+ '"foo/bar" value="[]"')
+ self.assertRaises(isc.cc.data.DataNotFoundError,
+ self.tool.apply_config_cmd, cmd_parser)
- cmd = cmdparse.BindCmdParse("config unset identifier=\"foo/bar\"")
+ cmd_parser = cmdparse.BindCmdParser('config unset identifier='
+ '"foo/bar"')
self.assertRaises(isc.cc.data.DataNotFoundError,
- self.tool.apply_config_cmd, cmd)
+ self.tool.apply_config_cmd, cmd_parser)
# this should raise a TypeError
- cmd = cmdparse.BindCmdParse("config set identifier=\"foo/an_int\" value=\"[]\"")
- self.assertRaises(isc.cc.data.DataTypeError, self.tool.apply_config_cmd, cmd)
+ cmd_parser = cmdparse.BindCmdParser('config set identifier='
+ '"foo/an_int" value="[]"')
+ self.assertRaises(isc.cc.data.DataTypeError,
+ self.tool.apply_config_cmd, cmd_parser)
# this is a very specific one for use with a set of list tests
# to try out the flexibility of the parser (only in the next test)
def clt(self, full_cmd_string, item_value):
- cmd = cmdparse.BindCmdParse(full_cmd_string)
- self.tool.apply_config_cmd(cmd)
+ cmd_parser = cmdparse.BindCmdParser(full_cmd_string)
+ self.tool.apply_config_cmd(cmd_parser)
self.assertEqual(([item_value], MultiConfigData.LOCAL),
self.tool.config_data.get_value("/foo/a_list"))
@@ -410,15 +439,56 @@ class TestConfigCommands(unittest.TestCase):
self.clt("config set identifier = \"foo/a_list\" value=[ \"k\" ]", "k")
# this should raise a TypeError
- cmd = cmdparse.BindCmdParse("config set identifier=\"foo/a_list\" value=\"a\"")
- self.assertRaises(isc.cc.data.DataTypeError, self.tool.apply_config_cmd, cmd)
+ cmd_parser = cmdparse.BindCmdParser('config set identifier='
+ '"foo/a_list" value="a"')
+ self.assertRaises(isc.cc.data.DataTypeError,
+ self.tool.apply_config_cmd, cmd_parser)
- cmd = cmdparse.BindCmdParse("config set identifier=\"foo/a_list\" value=[1]")
- self.assertRaises(isc.cc.data.DataTypeError, self.tool.apply_config_cmd, cmd)
+ cmd_parser = cmdparse.BindCmdParser('config set identifier='
+ '"foo/a_list" value=[1]')
+ self.assertRaises(isc.cc.data.DataTypeError,
+ self.tool.apply_config_cmd, cmd_parser)
def tearDown(self):
sys.stdout = self.stdout_backup
+ def test_cmd_has_identifier_param(self):
+ module = ModuleInfo(name="test_module")
+
+ cmd = CommandInfo(name="command_with_identifier")
+ param = ParamInfo(name=bindcmd.CFGITEM_IDENTIFIER_PARAM)
+ cmd.add_param(param)
+ module.add_command(cmd)
+
+ cmd = CommandInfo(name="command_without_identifier")
+ param = ParamInfo(name="some_argument")
+ cmd.add_param(param)
+ module.add_command(cmd)
+
+ self.tool.add_module_info(module)
+
+ cmd_parser = cmdparse.BindCmdParser('test_module '
+ 'command_with_identifier')
+ self.assertTrue(self.tool._cmd_has_identifier_param(cmd_parser))
+
+ cmd_parser = cmdparse.BindCmdParser('test_module '
+ 'command_without_identifier')
+ self.assertFalse(self.tool._cmd_has_identifier_param(cmd_parser))
+
+ cmd_parser = cmdparse.BindCmdParser('badmodule '
+ 'command_without_identifier')
+ self.assertFalse(self.tool._cmd_has_identifier_param(cmd_parser))
+
+ def test_get_identifier_startswith(self):
+ hints = self.tool._get_identifier_startswith("/")
+ self.assertEqual(['foo/an_int', 'foo/a_list'], hints)
+
+ hints = self.tool._get_identifier_startswith("/foo/an")
+ self.assertEqual(['foo/an_int'], hints)
+
+ hints = self.tool._get_identifier_startswith("/bar")
+ self.assertEqual([], hints)
+
class FakeBindCmdInterpreter(bindcmd.BindCmdInterpreter):
def __init__(self):
pass
diff --git a/src/cppcheck-suppress.lst b/src/cppcheck-suppress.lst
index ff4a79a..9dc8d99 100644
--- a/src/cppcheck-suppress.lst
+++ b/src/cppcheck-suppress.lst
@@ -11,3 +11,18 @@ missingInclude
//
// // cppcheck-suppress duplicateExpression
// EXPECT_FALSE(small_name < small_name);
+
+// With cppcheck 1.56, there are a number of false positives, which
+// All of these should be checked and hopefully removed after upgrading
+// cppcheck past 1.56
+
+// eraseDereference: This is a known false positive, which has been
+// fixed in the current development version of cppcheck
+eraseDereference
+
+// Unused functions: there suddenly are a lot of unused function errors
+// We could address those by adding for instance early declarations or
+// (unnecessary) header files, but they were all somewhat false positives
+// When we upgrade past 1.56, we should re-check this, and perhaps enable
+// unused-functions again.
+unusedFunction
diff --git a/src/lib/asiolink/io_address.h b/src/lib/asiolink/io_address.h
index c40e5b9..a3bb61a 100644
--- a/src/lib/asiolink/io_address.h
+++ b/src/lib/asiolink/io_address.h
@@ -131,7 +131,7 @@ public:
return equals(other);
}
- // \brief Compare addresses for inequality
+ /// \brief Compare addresses for inequality
///
/// \param other Address to compare against.
///
@@ -140,7 +140,58 @@ public:
return (!equals(other));
}
- // \brief Compare addresses for inequality
+ /// \brief Checks if one address is smaller than the other
+ ///
+ /// \param other Address to compare against.
+ ///
+ /// \return true if this address is smaller than the other address.
+ ///
+ /// It is useful for comparing which address is bigger.
+ /// Operations within one protocol family are obvious.
+ /// Comparisons between v4 and v6 will allways return v4
+ /// being smaller. This follows boost::asio::ip implementation
+ bool lessThan(const IOAddress& other) const {
+ if (this->getFamily() == other.getFamily()) {
+ if (this->getFamily() == AF_INET6) {
+ return (this->asio_address_.to_v6() < other.asio_address_.to_v6());
+ } else {
+ return (this->asio_address_.to_v4() < other.asio_address_.to_v4());
+ }
+ }
+ return (this->getFamily() < other.getFamily());
+ }
+
+ /// \brief Checks if one address is smaller or equal than the other
+ ///
+ /// \param other Address to compare against.
+ ///
+ /// \return true if this address is smaller than the other address.
+ bool smallerEqual(const IOAddress& other) const {
+ if (equals(other)) {
+ return (true);
+ }
+ return (lessThan(other));
+ }
+
+ /// \brief Checks if one address is smaller than the other
+ ///
+ /// \param other Address to compare against.
+ ///
+ /// See \ref smaller_than method for details.
+ bool operator<(const IOAddress& other) const {
+ return (lessThan(other));
+ }
+
+ /// \brief Checks if one address is smaller or equal than the other
+ ///
+ /// \param other Address to compare against.
+ ///
+ /// See \ref smaller_equal method for details.
+ bool operator<=(const IOAddress& other) const {
+ return (smallerEqual(other));
+ }
+
+ /// \brief Compare addresses for inequality
///
/// \param other Address to compare against.
///
diff --git a/src/lib/asiolink/tests/io_address_unittest.cc b/src/lib/asiolink/tests/io_address_unittest.cc
index 4322283..a1a9076 100644
--- a/src/lib/asiolink/tests/io_address_unittest.cc
+++ b/src/lib/asiolink/tests/io_address_unittest.cc
@@ -99,3 +99,35 @@ TEST(IOAddressTest, uint32) {
EXPECT_EQ(addr3.toText(), "192.0.2.5");
}
+
+TEST(IOAddressTest, lessThanEqual) {
+ IOAddress addr1("192.0.2.5");
+ IOAddress addr2("192.0.2.6");
+ IOAddress addr3("0.0.0.0");
+
+ IOAddress addr4("::");
+ IOAddress addr5("2001:db8::1");
+ IOAddress addr6("2001:db8::1:0");
+ IOAddress addr7("2001:db8::1:0"); // the same as 6
+
+ // v4 comparisons
+ EXPECT_TRUE(addr1 < addr2);
+ EXPECT_FALSE(addr2 < addr1);
+ EXPECT_FALSE(addr2 <= addr1);
+ EXPECT_TRUE(addr3 < addr1);
+ EXPECT_TRUE(addr3 < addr2);
+ EXPECT_TRUE(addr3 <= addr2);
+
+ // v6 comparisons
+ EXPECT_TRUE(addr4 < addr5);
+ EXPECT_TRUE(addr5 < addr6);
+ EXPECT_FALSE(addr6 < addr5);
+ EXPECT_FALSE(addr6 <= addr5);
+
+ // v4 to v6 - v4 should always be smaller
+ EXPECT_TRUE(addr1 < addr4);
+ EXPECT_TRUE(addr3 < addr4);
+ EXPECT_TRUE(addr2 < addr5);
+
+ EXPECT_TRUE(addr6 <= addr7);
+}
diff --git a/src/lib/cache/tests/rrset_entry_unittest.cc b/src/lib/cache/tests/rrset_entry_unittest.cc
index c7c3c6e..a6ac27e 100644
--- a/src/lib/cache/tests/rrset_entry_unittest.cc
+++ b/src/lib/cache/tests/rrset_entry_unittest.cc
@@ -50,9 +50,6 @@ class DerivedRRsetEntry: public RRsetEntry {
public:
DerivedRRsetEntry(const isc::dns::RRset& rrset, const RRsetTrustLevel& level) : RRsetEntry(rrset, level) {};
- void updateTTLForTest() {
-
- }
};
#define TEST_TTL 100
diff --git a/src/lib/cc/data.cc b/src/lib/cc/data.cc
index 6ec243a..47b1eb1 100644
--- a/src/lib/cc/data.cc
+++ b/src/lib/cc/data.cc
@@ -413,7 +413,7 @@ from_stringstream_number(std::istream &in, int &pos) {
isc_throw(JSONError, std::string("Number overflow: ") + number);
}
}
-
+
if (is_double) {
return (Element::create(d));
} else {
@@ -501,7 +501,7 @@ from_stringstream_map(std::istream &in, const std::string& file, int& line,
ConstElementPtr value = Element::fromJSON(in, file, line, pos);
map->set(key, value);
-
+
skip_to(in, file, line, pos, ",}", WHITESPACE);
c = in.get();
pos++;
@@ -942,7 +942,7 @@ removeIdentical(ConstElementPtr a, ConstElementPtr b) {
if (!b) {
return (result);
}
-
+
if (a->getType() != Element::map || b->getType() != Element::map) {
isc_throw(TypeError, "Non-map Elements passed to removeIdentical");
}
@@ -965,7 +965,7 @@ merge(ElementPtr element, ConstElementPtr other) {
other->getType() != Element::map) {
isc_throw(TypeError, "merge arguments not MapElements");
}
-
+
const std::map<std::string, ConstElementPtr>& m = other->mapValue();
for (std::map<std::string, ConstElementPtr>::const_iterator it = m.begin();
it != m.end() ; ++it) {
diff --git a/src/lib/config/tests/testdata/Makefile.am b/src/lib/config/tests/testdata/Makefile.am
index fce74d0..9b383d6 100644
--- a/src/lib/config/tests/testdata/Makefile.am
+++ b/src/lib/config/tests/testdata/Makefile.am
@@ -70,3 +70,4 @@ EXTRA_DIST += spec38.spec
EXTRA_DIST += spec39.spec
EXTRA_DIST += spec40.spec
EXTRA_DIST += spec41.spec
+EXTRA_DIST += spec42.spec
diff --git a/src/lib/config/tests/testdata/spec32.spec b/src/lib/config/tests/testdata/spec32.spec
index 854d967..2baf1c1 100644
--- a/src/lib/config/tests/testdata/spec32.spec
+++ b/src/lib/config/tests/testdata/spec32.spec
@@ -49,6 +49,22 @@
"item_optional": true
}
}
+ },
+ { "item_name": "named_set_item4",
+ "item_type": "named_set",
+ "item_optional": true,
+ "item_default": {},
+ "named_set_item_spec": {
+ "item_name": "named_set_element",
+ "item_type": "named_set",
+ "item_optional": false,
+ "item_default": { "a": 1, "b": 2 },
+ "named_set_item_spec":
+ { "item_name": "named_set_element",
+ "item_type": "integer",
+ "item_optional": true
+ }
+ }
}
]
}
diff --git a/src/lib/config/tests/testdata/spec42.spec b/src/lib/config/tests/testdata/spec42.spec
new file mode 100644
index 0000000..d822465
--- /dev/null
+++ b/src/lib/config/tests/testdata/spec42.spec
@@ -0,0 +1,17 @@
+{
+ "module_spec": {
+ "module_name": "Spec42",
+ "config_data": [
+ { "item_name": "list_item",
+ "item_type": "list",
+ "item_optional": true,
+ "list_item_spec": {
+ "item_name": "list_element",
+ "item_type": "string",
+ "item_optional": false,
+ "item_default": ""
+ }
+ }
+ ]
+ }
+}
diff --git a/src/lib/datasrc/database.cc b/src/lib/datasrc/database.cc
index ede7aa3..fbada44 100644
--- a/src/lib/datasrc/database.cc
+++ b/src/lib/datasrc/database.cc
@@ -386,10 +386,11 @@ DatabaseClient::Finder::findAll(const isc::dns::Name& name,
std::vector<isc::dns::ConstRRsetPtr>& target,
const FindOptions options)
{
- return (ZoneFinderContextPtr(new Context(*this, options,
- findInternal(name, RRType::ANY(),
- &target, options),
- target)));
+ return (ZoneFinderContextPtr(new GenericContext(
+ *this, options,
+ findInternal(name, RRType::ANY(),
+ &target, options),
+ target)));
}
ZoneFinderContextPtr
@@ -400,9 +401,10 @@ DatabaseClient::Finder::find(const isc::dns::Name& name,
if (type == RRType::ANY()) {
isc_throw(isc::Unexpected, "Use findAll to answer ANY");
}
- return (ZoneFinderContextPtr(new Context(*this, options,
- findInternal(name, type, NULL,
- options))));
+ return (ZoneFinderContextPtr(new GenericContext(
+ *this, options,
+ findInternal(name, type, NULL,
+ options))));
}
DatabaseClient::Finder::DelegationSearchResult
diff --git a/src/lib/datasrc/memory/Makefile.am b/src/lib/datasrc/memory/Makefile.am
index 3bdec0d..743caa2 100644
--- a/src/lib/datasrc/memory/Makefile.am
+++ b/src/lib/datasrc/memory/Makefile.am
@@ -20,6 +20,8 @@ libdatasrc_memory_la_SOURCES += memory_client.h memory_client.cc
libdatasrc_memory_la_SOURCES += logger.h logger.cc
libdatasrc_memory_la_SOURCES += zone_table.h zone_table.cc
libdatasrc_memory_la_SOURCES += zone_finder.h zone_finder.cc
+libdatasrc_memory_la_SOURCES += zone_table_segment.h zone_table_segment.cc
+libdatasrc_memory_la_SOURCES += zone_table_segment_local.h zone_table_segment_local.cc
nodist_libdatasrc_memory_la_SOURCES = memory_messages.h memory_messages.cc
EXTRA_DIST = rdata_serialization_priv.cc
diff --git a/src/lib/datasrc/memory/zone_finder.cc b/src/lib/datasrc/memory/zone_finder.cc
index 9403c4f..86dd874 100644
--- a/src/lib/datasrc/memory/zone_finder.cc
+++ b/src/lib/datasrc/memory/zone_finder.cc
@@ -33,6 +33,8 @@
#include <algorithm>
#include <vector>
+#include <utility>
+
using namespace isc::dns;
using namespace isc::datasrc::memory;
using namespace isc::datasrc;
@@ -73,6 +75,17 @@ public:
using internal::ZoneFinderResultContext;
namespace {
+/// Conceptual RRset in the form of a pair of zone node and RdataSet.
+///
+/// In this implementation, the owner name of an RRset is derived from the
+/// corresponding zone node, and the rest of the attributes come from
+/// an RdataSet. This shortcut type can be used when we want to refer to
+/// the conceptual RRset without knowing these details.
+///
+/// This is a read-only version of the pair (and at the moment we don't need
+/// a mutable version).
+typedef std::pair<const ZoneNode*, const RdataSet*> ConstNodeRRset;
+
/// Creates a TreeNodeRRsetPtr for the given RdataSet at the given Node, for
/// the given RRClass
///
@@ -117,7 +130,7 @@ struct FindState {
FindState(bool glue_ok) :
zonecut_node_(NULL),
dname_node_(NULL),
- rrset_(NULL),
+ rdataset_(NULL),
glue_ok_(glue_ok)
{}
@@ -129,7 +142,7 @@ struct FindState {
const ZoneNode* dname_node_;
// Delegation RRset (NS or DNAME), if found.
- const RdataSet* rrset_;
+ const RdataSet* rdataset_;
// Whether to continue search below a delegation point.
// Set at construction time.
@@ -149,7 +162,7 @@ bool cutCallback(const ZoneNode& node, FindState* state) {
if (found_dname != NULL) {
LOG_DEBUG(logger, DBG_TRACE_DETAILED, DATASRC_MEM_DNAME_ENCOUNTERED);
state->dname_node_ = &node;
- state->rrset_ = found_dname;
+ state->rdataset_ = found_dname;
return (true);
}
@@ -171,7 +184,7 @@ bool cutCallback(const ZoneNode& node, FindState* state) {
// It cannot happen for us (at least for now), so we don't do
// that check.
state->zonecut_node_ = &node;
- state->rrset_ = found_ns;
+ state->rdataset_ = found_ns;
// Unless glue is allowed the search stops here, so we return
// false; otherwise return true to continue the search.
@@ -225,8 +238,8 @@ ZoneFinderResultContext
createFindResult(const RRClass& rrclass,
const ZoneData& zone_data,
ZoneFinder::Result code,
- const RdataSet* rdset,
const ZoneNode* node,
+ const RdataSet* rdataset,
ZoneFinder::FindOptions options,
bool wild = false,
const Name* qname = NULL)
@@ -247,10 +260,10 @@ createFindResult(const RRClass& rrclass,
}
}
- return (ZoneFinderResultContext(code, createTreeNodeRRset(node, rdset,
+ return (ZoneFinderResultContext(code, createTreeNodeRRset(node, rdataset,
rrclass, options,
rename),
- flags, zone_data, node, rdset));
+ flags, zone_data, node, rdataset));
}
// A helper function for NSEC-signed zones. It searches the zone for
@@ -272,16 +285,15 @@ createFindResult(const RRClass& rrclass,
// method doesn't bother to find NSEC, and simply returns NULL. So, by
// definition of "NSEC-signed", when it really tries to find an NSEC it
// should succeed; there should be one at least at the zone origin.
-const RdataSet*
+ConstNodeRRset
getClosestNSEC(const ZoneData& zone_data,
ZoneChain& node_path,
- const ZoneNode** nsec_node,
ZoneFinder::FindOptions options)
{
if (!zone_data.isSigned() ||
(options & ZoneFinder::FIND_DNSSEC) == 0 ||
zone_data.isNSEC3Signed()) {
- return (NULL);
+ return (ConstNodeRRset(NULL, NULL));
}
const ZoneNode* prev_node;
@@ -291,8 +303,7 @@ getClosestNSEC(const ZoneData& zone_data,
const RdataSet* found =
RdataSet::find(prev_node->getData(), RRType::NSEC());
if (found != NULL) {
- *nsec_node = prev_node;
- return (found);
+ return (ConstNodeRRset(prev_node, found));
}
}
}
@@ -301,7 +312,7 @@ getClosestNSEC(const ZoneData& zone_data,
assert(false);
// Even though there is an assert here, strict compilers
// will still need some return value.
- return (NULL);
+ return (ConstNodeRRset(NULL, NULL));
}
// A helper function for the NXRRSET case in find(). If the zone is
@@ -338,16 +349,16 @@ public:
FindNodeResult(ZoneFinder::Result code_param,
const ZoneNode* node_param,
- const RdataSet* rrset_param,
+ const RdataSet* rdataset_param,
unsigned int flags_param = 0) :
code(code_param),
node(node_param),
- rrset(rrset_param),
+ rdataset(rdataset_param),
flags(flags_param)
{}
const ZoneFinder::Result code;
const ZoneNode* node;
- const RdataSet* rrset;
+ const RdataSet* rdataset;
const unsigned int flags;
};
@@ -426,7 +437,7 @@ FindNodeResult findNode(const ZoneData& zone_data,
const unsigned int zonecut_flag =
(state.zonecut_node_ != NULL) ? FindNodeResult::FIND_ZONECUT : 0;
if (result == ZoneTree::EXACTMATCH) {
- return (FindNodeResult(ZoneFinder::SUCCESS, node, state.rrset_,
+ return (FindNodeResult(ZoneFinder::SUCCESS, node, state.rdataset_,
zonecut_flag));
} else if (result == ZoneTree::PARTIALMATCH) {
assert(node != NULL);
@@ -434,26 +445,23 @@ FindNodeResult findNode(const ZoneData& zone_data,
LOG_DEBUG(logger, DBG_TRACE_DATA, DATASRC_MEM_DNAME_FOUND).
arg(state.dname_node_->getName());
return (FindNodeResult(ZoneFinder::DNAME, state.dname_node_,
- state.rrset_));
+ state.rdataset_));
}
if (state.zonecut_node_ != NULL) { // DELEGATION due to NS
LOG_DEBUG(logger, DBG_TRACE_DATA, DATASRC_MEM_DELEG_FOUND).
arg(state.zonecut_node_->getName());
return (FindNodeResult(ZoneFinder::DELEGATION,
state.zonecut_node_,
- state.rrset_));
+ state.rdataset_));
}
if (node_path.getLastComparisonResult().getRelation() ==
NameComparisonResult::SUPERDOMAIN) { // empty node, so NXRRSET
LOG_DEBUG(logger, DBG_TRACE_DATA,
DATASRC_MEM_SUPER_STOP).arg(name_labels);
- const ZoneNode* nsec_node;
- const RdataSet* nsec_rds = getClosestNSEC(zone_data,
- node_path,
- &nsec_node,
- options);
- return (FindNodeResult(ZoneFinder::NXRRSET, nsec_node,
- nsec_rds));
+ ConstNodeRRset nsec_rrset = getClosestNSEC(zone_data, node_path,
+ options);
+ return (FindNodeResult(ZoneFinder::NXRRSET, nsec_rrset.first,
+ nsec_rrset.second));
}
// Nothing really matched.
@@ -468,13 +476,11 @@ FindNodeResult findNode(const ZoneData& zone_data,
// should cancel wildcard. Treat it as NXDOMAIN.
LOG_DEBUG(logger, DBG_TRACE_DATA,
DATASRC_MEM_WILDCARD_CANCEL).arg(name_labels);
- const ZoneNode* nsec_node;
- const RdataSet* nsec_rds = getClosestNSEC(zone_data,
- node_path,
- &nsec_node,
- options);
- return (FindNodeResult(ZoneFinder::NXDOMAIN, nsec_node,
- nsec_rds));
+ ConstNodeRRset nsec_rrset = getClosestNSEC(zone_data,
+ node_path,
+ options);
+ return (FindNodeResult(ZoneFinder::NXDOMAIN, nsec_rrset.first,
+ nsec_rrset.second));
}
uint8_t ls_buf[LabelSequence::MAX_SERIALIZED_LENGTH];
@@ -495,16 +501,16 @@ FindNodeResult findNode(const ZoneData& zone_data,
// Otherwise, why would the domain_flag::WILD be there if
// there was no wildcard under it?
assert(result == ZoneTree::EXACTMATCH);
- return (FindNodeResult(ZoneFinder::SUCCESS, node, state.rrset_,
+ return (FindNodeResult(ZoneFinder::SUCCESS, node, state.rdataset_,
FindNodeResult::FIND_WILDCARD | zonecut_flag));
}
LOG_DEBUG(logger, DBG_TRACE_DATA, DATASRC_MEM_NOT_FOUND).
arg(name_labels);
- const ZoneNode* nsec_node;
- const RdataSet* nsec_rds = getClosestNSEC(zone_data, node_path,
- &nsec_node, options);
- return (FindNodeResult(ZoneFinder::NXDOMAIN, nsec_node, nsec_rds));
+ ConstNodeRRset nsec_rrset = getClosestNSEC(zone_data, node_path,
+ options);
+ return (FindNodeResult(ZoneFinder::NXDOMAIN, nsec_rrset.first,
+ nsec_rrset.second));
} else {
// If the name is neither an exact or partial match, it is
// out of bailiwick, which is considered an error, unless the caller
@@ -528,17 +534,26 @@ FindNodeResult findNode(const ZoneData& zone_data,
/// context.
class InMemoryZoneFinder::Context : public ZoneFinder::Context {
public:
- Context(ZoneFinder& finder, ZoneFinder::FindOptions options,
+ Context(InMemoryZoneFinder& finder, ZoneFinder::FindOptions options,
const RRClass& rrclass, const ZoneFinderResultContext& result) :
- ZoneFinder::Context(finder, options,
- ResultContext(result.code, result.rrset,
- result.flags)),
+ ZoneFinder::Context(options, ResultContext(result.code, result.rrset,
+ result.flags)),
+ finder_(finder), // NOTE: when entire #2283 is done we won't need this
rrclass_(rrclass), zone_data_(result.zone_data),
found_node_(result.found_node),
found_rdset_(result.found_rdset)
{}
protected:
+ // When all tickets in #2283 are done this can simply return NULL.
+ virtual ZoneFinder* getFinder() { return (&finder_); }
+
+ // We don't use the default protected methods that rely on this method,
+ // so we can simply return NULL.
+ virtual const std::vector<isc::dns::ConstRRsetPtr>* getAllRRsets() const {
+ return (NULL);
+ }
+
virtual void getAdditionalImpl(const std::vector<RRType>& requested_types,
std::vector<ConstRRsetPtr>& result)
{
@@ -620,6 +635,7 @@ private:
}
private:
+ InMemoryZoneFinder& finder_;
const RRClass rrclass_;
const ZoneData* const zone_data_;
const ZoneNode* const found_node_;
@@ -689,8 +705,8 @@ InMemoryZoneFinder::find(const isc::dns::Name& name,
const FindOptions options)
{
return (ZoneFinderContextPtr(new Context(*this, options, rrclass_,
- find_internal(name, type,
- NULL, options))));
+ findInternal(name, type,
+ NULL, options))));
}
boost::shared_ptr<ZoneFinder::Context>
@@ -699,17 +715,17 @@ InMemoryZoneFinder::findAll(const isc::dns::Name& name,
const FindOptions options)
{
return (ZoneFinderContextPtr(new Context(*this, options, rrclass_,
- find_internal(name,
- RRType::ANY(),
- &target,
- options))));
+ findInternal(name,
+ RRType::ANY(),
+ &target,
+ options))));
}
ZoneFinderResultContext
-InMemoryZoneFinder::find_internal(const isc::dns::Name& name,
- const isc::dns::RRType& type,
- std::vector<ConstRRsetPtr>* target,
- const FindOptions options)
+InMemoryZoneFinder::findInternal(const isc::dns::Name& name,
+ const isc::dns::RRType& type,
+ std::vector<ConstRRsetPtr>* target,
+ const FindOptions options)
{
// Get the node. All other cases than an exact match are handled
// in findNode(). We simply construct a result structure and return.
@@ -718,7 +734,7 @@ InMemoryZoneFinder::find_internal(const isc::dns::Name& name,
findNode(zone_data_, LabelSequence(name), node_path, options);
if (node_result.code != SUCCESS) {
return (createFindResult(rrclass_, zone_data_, node_result.code,
- node_result.rrset, node_result.node,
+ node_result.node, node_result.rdataset,
options));
}
@@ -734,11 +750,11 @@ InMemoryZoneFinder::find_internal(const isc::dns::Name& name,
if (node->isEmpty()) {
LOG_DEBUG(logger, DBG_TRACE_DATA, DATASRC_MEM_DOMAIN_EMPTY).
arg(name);
- const ZoneNode* nsec_node;
- const RdataSet* nsec_rds = getClosestNSEC(zone_data_, node_path,
- &nsec_node, options);
+ ConstNodeRRset nsec_rrset = getClosestNSEC(zone_data_, node_path,
+ options);
return (createFindResult(rrclass_, zone_data_, NXRRSET,
- nsec_rds, nsec_node, options, wild));
+ nsec_rrset.first, nsec_rrset.second,
+ options, wild));
}
const RdataSet* found;
@@ -757,7 +773,7 @@ InMemoryZoneFinder::find_internal(const isc::dns::Name& name,
LOG_DEBUG(logger, DBG_TRACE_DATA,
DATASRC_MEM_EXACT_DELEGATION).arg(name);
return (createFindResult(rrclass_, zone_data_, DELEGATION,
- found, node, options, wild, &name));
+ node, found, options, wild, &name));
}
}
@@ -772,7 +788,7 @@ InMemoryZoneFinder::find_internal(const isc::dns::Name& name,
}
LOG_DEBUG(logger, DBG_TRACE_DATA, DATASRC_MEM_ANY_SUCCESS).
arg(name);
- return (createFindResult(rrclass_, zone_data_, SUCCESS, NULL, node,
+ return (createFindResult(rrclass_, zone_data_, SUCCESS, node, NULL,
options, wild, &name));
}
@@ -781,7 +797,7 @@ InMemoryZoneFinder::find_internal(const isc::dns::Name& name,
// Good, it is here
LOG_DEBUG(logger, DBG_TRACE_DATA, DATASRC_MEM_SUCCESS).arg(name).
arg(type);
- return (createFindResult(rrclass_, zone_data_, SUCCESS, found, node,
+ return (createFindResult(rrclass_, zone_data_, SUCCESS, node, found,
options, wild, &name));
} else {
// Next, try CNAME.
@@ -789,14 +805,14 @@ InMemoryZoneFinder::find_internal(const isc::dns::Name& name,
if (found != NULL) {
LOG_DEBUG(logger, DBG_TRACE_DATA, DATASRC_MEM_CNAME).arg(name);
- return (createFindResult(rrclass_, zone_data_, CNAME, found, node,
+ return (createFindResult(rrclass_, zone_data_, CNAME, node, found,
options, wild, &name));
}
}
// No exact match or CNAME. Get NSEC if necessary and return NXRRSET.
- return (createFindResult(rrclass_, zone_data_, NXRRSET,
+ return (createFindResult(rrclass_, zone_data_, NXRRSET, node,
getNSECForNXRRSET(zone_data_, options, node),
- node, options, wild, &name));
+ options, wild, &name));
}
isc::datasrc::ZoneFinder::FindNSEC3Result
diff --git a/src/lib/datasrc/memory/zone_finder.h b/src/lib/datasrc/memory/zone_finder.h
index 85e21c3..c95b5bc 100644
--- a/src/lib/datasrc/memory/zone_finder.h
+++ b/src/lib/datasrc/memory/zone_finder.h
@@ -92,7 +92,7 @@ private:
class Context;
/// Actual implementation for both find() and findAll()
- internal::ZoneFinderResultContext find_internal(
+ internal::ZoneFinderResultContext findInternal(
const isc::dns::Name& name,
const isc::dns::RRType& type,
std::vector<isc::dns::ConstRRsetPtr>* target,
diff --git a/src/lib/datasrc/memory/zone_table_segment.cc b/src/lib/datasrc/memory/zone_table_segment.cc
new file mode 100644
index 0000000..7a80e3c
--- /dev/null
+++ b/src/lib/datasrc/memory/zone_table_segment.cc
@@ -0,0 +1,38 @@
+// Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <datasrc/memory/zone_table_segment.h>
+#include <datasrc/memory/zone_table_segment_local.h>
+
+namespace isc {
+namespace datasrc {
+namespace memory {
+
+ZoneTableSegment*
+ZoneTableSegment::create(const isc::data::Element&) {
+ /// FIXME: For now, we always return ZoneTableSegmentLocal. This
+ /// should be updated eventually to parse the passed Element
+ /// argument and construct a corresponding ZoneTableSegment
+ /// implementation.
+ return (new ZoneTableSegmentLocal);
+}
+
+void
+ZoneTableSegment::destroy(ZoneTableSegment *segment) {
+ delete segment;
+}
+
+} // namespace memory
+} // namespace datasrc
+} // namespace isc
diff --git a/src/lib/datasrc/memory/zone_table_segment.h b/src/lib/datasrc/memory/zone_table_segment.h
new file mode 100644
index 0000000..7fd1310
--- /dev/null
+++ b/src/lib/datasrc/memory/zone_table_segment.h
@@ -0,0 +1,110 @@
+// Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#ifndef __ZONE_TABLE_SEGMENT_H__
+#define __ZONE_TABLE_SEGMENT_H__
+
+#include <datasrc/memory/zone_table.h>
+#include <cc/data.h>
+#include <util/memory_segment.h>
+
+#include <boost/interprocess/offset_ptr.hpp>
+
+#include <stdlib.h>
+
+namespace isc {
+namespace datasrc {
+namespace memory {
+
+/// \brief Memory-management independent entry point that contains a
+/// pointer to a zone table in memory.
+///
+/// An instance of this type lives inside a ZoneTableSegment
+/// implementation. It contains an offset pointer to the zone table (a
+/// map from domain names to zone locators) in memory.
+struct ZoneTableHeader {
+public:
+ /// \brief Returns a pointer to the underlying zone table.
+ ZoneTable* getTable() {
+ return (table.get());
+ }
+
+ /// \brief const version of \c getTable().
+ const ZoneTable* getTable() const {
+ return (table.get());
+ }
+
+private:
+ boost::interprocess::offset_ptr<ZoneTable> table;
+};
+
+/// \brief Manages a ZoneTableHeader, an entry point into a table of
+/// zones
+///
+/// This class specifies an interface for derived implementations which
+/// return a pointer to an object of type ZoneTableHeader, an entry
+/// point into a table of zones regardless of the underlying memory
+/// management implementation. Derived classes would implement the
+/// interface for specific memory-implementation behavior.
+class ZoneTableSegment {
+protected:
+ /// \brief Protected constructor
+ ///
+ /// An instance implementing this interface is expected to be
+ /// created by the factory method (\c create()), so this constructor
+ /// is protected.
+ ZoneTableSegment()
+ {}
+public:
+ /// \brief Destructor
+ virtual ~ZoneTableSegment() {}
+
+ /// \brief Return the ZoneTableHeader for the zone table segment.
+ virtual ZoneTableHeader& getHeader() = 0;
+
+ /// \brief const version of \c getHeader().
+ virtual const ZoneTableHeader& getHeader() const = 0;
+
+ /// \brief Return the MemorySegment for the zone table segment.
+ virtual isc::util::MemorySegment& getMemorySegment() = 0;
+
+ /// \brief Create an instance depending on the memory segment model
+ ///
+ /// This is a factory method to create a derived ZoneTableSegment
+ /// object based on the \c config passed. The method returns a
+ /// dynamically-allocated object. The caller is responsible for
+ /// destroying it with \c ZoneTableSegment::destroy().
+ ///
+ /// FIXME: For now, we always return ZoneTableSegmentLocal
+ /// regardless of the passed \c config.
+ ///
+ /// \param config The configuration based on which a derived object
+ /// is returned.
+ /// \return Returns a ZoneTableSegment object
+ static ZoneTableSegment* create(const isc::data::Element& config);
+
+ /// \brief Destroy a ZoneTableSegment
+ ///
+ /// This method destroys the passed ZoneTableSegment. It must be
+ /// passed a segment previously created by \c ZoneTableSegment::create().
+ ///
+ /// \param segment The segment to destroy.
+ static void destroy(ZoneTableSegment* segment);
+};
+
+} // namespace memory
+} // namespace datasrc
+} // namespace isc
+
+#endif // __ZONE_TABLE_SEGMENT_H__
diff --git a/src/lib/datasrc/memory/zone_table_segment_local.cc b/src/lib/datasrc/memory/zone_table_segment_local.cc
new file mode 100644
index 0000000..589c9af
--- /dev/null
+++ b/src/lib/datasrc/memory/zone_table_segment_local.cc
@@ -0,0 +1,43 @@
+// Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <datasrc/memory/zone_table_segment_local.h>
+
+using namespace isc::util;
+
+namespace isc {
+namespace datasrc {
+namespace memory {
+
+// After more methods' definitions are added here, it would be a good
+// idea to move getHeader() and getMemorySegment() definitions to the
+// header file.
+ZoneTableHeader&
+ZoneTableSegmentLocal::getHeader() {
+ return (header_);
+}
+
+const ZoneTableHeader&
+ZoneTableSegmentLocal::getHeader() const {
+ return (header_);
+}
+
+MemorySegment&
+ZoneTableSegmentLocal::getMemorySegment() {
+ return (mem_sgmt_);
+}
+
+} // namespace memory
+} // namespace datasrc
+} // namespace isc
diff --git a/src/lib/datasrc/memory/zone_table_segment_local.h b/src/lib/datasrc/memory/zone_table_segment_local.h
new file mode 100644
index 0000000..de776a9
--- /dev/null
+++ b/src/lib/datasrc/memory/zone_table_segment_local.h
@@ -0,0 +1,66 @@
+// Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#ifndef __ZONE_TABLE_SEGMENT_LOCAL_H__
+#define __ZONE_TABLE_SEGMENT_LOCAL_H__
+
+#include <datasrc/memory/zone_table_segment.h>
+#include <util/memory_segment_local.h>
+
+namespace isc {
+namespace datasrc {
+namespace memory {
+
+/// \brief Local implementation of ZoneTableSegment class
+///
+/// This class specifies a concrete implementation for a
+/// MemorySegmentLocal based ZoneTableSegment. Please see the
+/// ZoneTableSegment class documentation for usage.
+class ZoneTableSegmentLocal : public ZoneTableSegment {
+ // This is so that ZoneTableSegmentLocal can be instantiated from
+ // ZoneTableSegment::create().
+ friend class ZoneTableSegment;
+protected:
+ /// \brief Protected constructor
+ ///
+ /// Instances are expected to be created by the factory method
+ /// (\c ZoneTableSegment::create()), so this constructor is
+ /// protected.
+ ZoneTableSegmentLocal()
+ {}
+public:
+ /// \brief Destructor
+ virtual ~ZoneTableSegmentLocal() {}
+
+ /// \brief Return the ZoneTableHeader for the local zone table
+ /// segment implementation.
+ virtual ZoneTableHeader& getHeader();
+
+ /// \brief const version of \c getHeader().
+ virtual const ZoneTableHeader& getHeader() const;
+
+ /// \brief Return the MemorySegment for the local zone table segment
+ /// implementation (a MemorySegmentLocal instance).
+ virtual isc::util::MemorySegment& getMemorySegment();
+
+private:
+ ZoneTableHeader header_;
+ isc::util::MemorySegmentLocal mem_sgmt_;
+};
+
+} // namespace memory
+} // namespace datasrc
+} // namespace isc
+
+#endif // __ZONE_TABLE_SEGMENT_LOCAL_H__
diff --git a/src/lib/datasrc/memory_datasrc.cc b/src/lib/datasrc/memory_datasrc.cc
index e38a487..53cf077 100644
--- a/src/lib/datasrc/memory_datasrc.cc
+++ b/src/lib/datasrc/memory_datasrc.cc
@@ -792,13 +792,19 @@ public:
/// context.
Context(ZoneFinder& finder, ZoneFinder::FindOptions options,
const RBNodeResultContext& result) :
- ZoneFinder::Context(finder, options,
+ ZoneFinder::Context(options,
ResultContext(result.code, result.rrset,
result.flags)),
- rrset_(result.rrset), found_node_(result.found_node)
+ finder_(finder), rrset_(result.rrset), found_node_(result.found_node)
{}
protected:
+ virtual ZoneFinder* getFinder() { return (&finder_); }
+
+ virtual const std::vector<isc::dns::ConstRRsetPtr>* getAllRRsets() const {
+ return (NULL);
+ }
+
virtual void getAdditionalImpl(const vector<RRType>& requested_types,
vector<ConstRRsetPtr>& result)
{
@@ -866,6 +872,7 @@ private:
}
}
+ ZoneFinder& finder_;
const ConstRBNodeRRsetPtr rrset_;
const DomainNode* const found_node_;
};
diff --git a/src/lib/datasrc/sqlite3_accessor.cc b/src/lib/datasrc/sqlite3_accessor.cc
index 24d7b3f..672121e 100644
--- a/src/lib/datasrc/sqlite3_accessor.cc
+++ b/src/lib/datasrc/sqlite3_accessor.cc
@@ -20,6 +20,8 @@
#include <exceptions/exceptions.h>
+#include <dns/name.h>
+
#include <datasrc/sqlite3_accessor.h>
#include <datasrc/logger.h>
#include <datasrc/data_source.h>
@@ -84,8 +86,13 @@ const char* const text_statements[NUM_STATEMENTS] = {
"SELECT id FROM zones WHERE name=?1 AND rdclass = ?2", // ZONE
"SELECT rdtype, ttl, sigtype, rdata FROM records " // ANY
"WHERE zone_id=?1 AND name=?2",
- "SELECT rdtype, ttl, sigtype, rdata " // ANY_SUB
- "FROM records WHERE zone_id=?1 AND name LIKE (\"%.\" || ?2)",
+
+ // ANY_SUB:
+ // This query returns records in the specified zone for the domain
+ // matching the passed name, and its sub-domains.
+ "SELECT rdtype, ttl, sigtype, rdata "
+ "FROM records WHERE zone_id=?1 AND rname LIKE ?2",
+
"BEGIN", // BEGIN
"COMMIT", // COMMIT
"ROLLBACK", // ROLLBACK
@@ -660,17 +667,27 @@ public:
statement_(NULL),
name_(name)
{
- // Choose the statement text depending on the query type
- const char* statement(NULL);
+ // Choose the statement text depending on the query type, and
+ // prepare a statement to get data from it.
switch (qtype) {
case QT_ANY:
- statement = text_statements[ANY];
+ statement_ = prepare(accessor->dbparameters_->db_,
+ text_statements[ANY]);
+ bindZoneId(id);
+ bindName(name_);
break;
case QT_SUBDOMAINS:
- statement = text_statements[ANY_SUB];
+ statement_ = prepare(accessor->dbparameters_->db_,
+ text_statements[ANY_SUB]);
+ bindZoneId(id);
+ // Done once, this should not be very inefficient.
+ bindName(isc::dns::Name(name_).reverse().toText() + "%");
break;
case QT_NSEC3:
- statement = text_statements[NSEC3];
+ statement_ = prepare(accessor->dbparameters_->db_,
+ text_statements[NSEC3]);
+ bindZoneId(id);
+ bindName(name_);
break;
default:
// Can Not Happen - there isn't any other type of query
@@ -680,11 +697,6 @@ public:
"Invalid qtype passed - unreachable code branch "
"reached");
}
-
- // We create the statement now and then just keep getting data from it
- statement_ = prepare(accessor->dbparameters_->db_, statement);
- bindZoneId(id);
- bindName(name_);
}
bool getNext(std::string (&data)[COLUMN_COUNT]) {
diff --git a/src/lib/datasrc/tests/memory/Makefile.am b/src/lib/datasrc/tests/memory/Makefile.am
index 00d5594..37e9043 100644
--- a/src/lib/datasrc/tests/memory/Makefile.am
+++ b/src/lib/datasrc/tests/memory/Makefile.am
@@ -32,12 +32,14 @@ run_unittests_SOURCES += ../../tests/faked_nsec3.h ../../tests/faked_nsec3.cc
run_unittests_SOURCES += memory_segment_test.h
run_unittests_SOURCES += segment_object_holder_unittest.cc
run_unittests_SOURCES += memory_client_unittest.cc
+run_unittests_SOURCES += zone_table_segment_unittest.cc
run_unittests_CPPFLAGS = $(AM_CPPFLAGS) $(GTEST_INCLUDES)
run_unittests_LDFLAGS = $(AM_LDFLAGS) $(GTEST_LDFLAGS)
run_unittests_LDADD = $(top_builddir)/src/lib/datasrc/libb10-datasrc.la
run_unittests_LDADD += $(top_builddir)/src/lib/dns/libb10-dns++.la
+run_unittests_LDADD += $(top_builddir)/src/lib/cc/libb10-cc.la
run_unittests_LDADD += $(top_builddir)/src/lib/util/unittests/libutil_unittests.la
run_unittests_LDADD += $(top_builddir)/src/lib/util/libb10-util.la
run_unittests_LDADD += $(top_builddir)/src/lib/testutils/libb10-testutils.la
diff --git a/src/lib/datasrc/tests/memory/zone_table_segment_unittest.cc b/src/lib/datasrc/tests/memory/zone_table_segment_unittest.cc
new file mode 100644
index 0000000..6bdd737
--- /dev/null
+++ b/src/lib/datasrc/tests/memory/zone_table_segment_unittest.cc
@@ -0,0 +1,83 @@
+// Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <datasrc/memory/zone_table_segment.h>
+#include <gtest/gtest.h>
+
+using namespace isc::datasrc::memory;
+using namespace isc::data;
+using namespace isc::util;
+using namespace std;
+
+namespace {
+
+class ZoneTableSegmentTest : public ::testing::Test {
+protected:
+ ZoneTableSegmentTest() :
+ config_(Element::fromJSON("{}")),
+ segment_(ZoneTableSegment::create((*config_.get())))
+ {}
+
+ ~ZoneTableSegmentTest() {
+ if (segment_ != NULL) {
+ ZoneTableSegment::destroy(segment_);
+ }
+ }
+
+ void TearDown() {
+ // Catch any future leaks here.
+ const MemorySegment& mem_sgmt = segment_->getMemorySegment();
+ EXPECT_TRUE(mem_sgmt.allMemoryDeallocated());
+
+ ZoneTableSegment::destroy(segment_);
+ segment_ = NULL;
+ }
+
+ const ElementPtr config_;
+ ZoneTableSegment* segment_;
+};
+
+
+TEST_F(ZoneTableSegmentTest, create) {
+ // By default, a local zone table segment is created.
+ EXPECT_NE(static_cast<void*>(NULL), segment_);
+}
+
+// Helper function to check const and non-const methods.
+template <typename TS, typename TH, typename TT>
+void
+testGetHeader(ZoneTableSegment* segment) {
+ TH& header = static_cast<TS*>(segment)->getHeader();
+
+ // The zone table is unset.
+ TT* table = header.getTable();
+ EXPECT_EQ(static_cast<void*>(NULL), table);
+}
+
+TEST_F(ZoneTableSegmentTest, getHeader) {
+ // non-const version.
+ testGetHeader<ZoneTableSegment, ZoneTableHeader, ZoneTable>(segment_);
+
+ // const version.
+ testGetHeader<const ZoneTableSegment, const ZoneTableHeader,
+ const ZoneTable>(segment_);
+}
+
+TEST_F(ZoneTableSegmentTest, getMemorySegment) {
+ // This doesn't do anything fun except test the API.
+ MemorySegment& mem_sgmt = segment_->getMemorySegment();
+ EXPECT_TRUE(mem_sgmt.allMemoryDeallocated());
+}
+
+} // anonymous namespace
diff --git a/src/lib/datasrc/tests/testdata/contexttest.zone b/src/lib/datasrc/tests/testdata/contexttest.zone
index a39649d..0c1393c 100644
--- a/src/lib/datasrc/tests/testdata/contexttest.zone
+++ b/src/lib/datasrc/tests/testdata/contexttest.zone
@@ -1,9 +1,10 @@
;; test zone file used for ZoneFinderContext tests.
;; RRSIGs are (obviouslly) faked ones for testing.
-example.org. 3600 IN SOA ns1.example.org. bugs.x.w.example.org. 71 3600 300 3600000 3600
+example.org. 3600 IN SOA ns1.example.org. bugs.x.w.example.org. 74 3600 300 3600000 3600
example.org. 3600 IN NS ns1.example.org.
example.org. 3600 IN NS ns2.example.org.
+example.org. 3600 IN RRSIG NS 7 3 3600 20150420235959 20051021000000 40430 example.org. FAKEFAKEFAKE
example.org. 3600 IN MX 1 mx1.example.org.
example.org. 3600 IN MX 2 mx2.example.org.
example.org. 3600 IN MX 3 mx.a.example.org.
diff --git a/src/lib/datasrc/zone.h b/src/lib/datasrc/zone.h
index 2330412..36a1cff 100644
--- a/src/lib/datasrc/zone.h
+++ b/src/lib/datasrc/zone.h
@@ -168,48 +168,25 @@ public:
/// can define a derived class of the base Context and override the
/// specific virtual method.
///
+ /// This base class defines these common protected methods along with
+ /// some helper pure virtual methods that would be necessary for the
+ /// common methods. If a derived class wants to use the common version
+ /// of the protected method, it needs to provide expected result through
+ /// their implementation of the pure virtual methods.
+ ///
/// This class object is generally expected to be associated with the
/// ZoneFinder that originally performed the \c find() call, and expects
/// the finder is valid throughout the lifetime of this object. It's
/// caller's responsibility to ensure that assumption.
class Context {
public:
- /// \brief The constructor for the normal find call.
- ///
- /// This constructor is expected to be called from the \c find()
- /// method when it constructs the return value.
+ /// \brief The constructor.
///
- /// \param finder The ZoneFinder on which find() is called.
/// \param options The find options specified for the find() call.
/// \param result The result of the find() call.
- Context(ZoneFinder& finder, FindOptions options,
- const ResultContext& result) :
- code(result.code), rrset(result.rrset),
- finder_(finder), flags_(result.flags), options_(options)
- {}
-
- /// \brief The constructor for the normal findAll call.
- ///
- /// This constructor is expected to be called from the \c findAll()
- /// method when it constructs the return value.
- ///
- /// It copies the vector that is to be returned to the caller of
- /// \c findAll() for possible subsequent use. Note that it cannot
- /// simply hold a reference to the vector because the caller may
- /// alter it after the \c findAll() call.
- ///
- /// \param finder The ZoneFinder on which findAll() is called.
- /// \param options The find options specified for the findAll() call.
- /// \param result The result of the findAll() call (whose rrset is
- /// expected to be NULL).
- /// \param all_set Reference to the vector given by the caller of
- /// \c findAll(), storing the RRsets to be returned.
- Context(ZoneFinder& finder, FindOptions options,
- const ResultContext& result,
- const std::vector<isc::dns::ConstRRsetPtr> &all_set) :
+ Context(FindOptions options, const ResultContext& result) :
code(result.code), rrset(result.rrset),
- finder_(finder), flags_(result.flags), options_(options),
- all_set_(all_set)
+ flags_(result.flags), options_(options)
{}
/// \brief The destructor.
@@ -292,21 +269,108 @@ public:
}
protected:
+ /// \brief Return the \c ZoneFinder that created this \c Context.
+ ///
+ /// A derived class implementation can return NULL if it defines
+ /// other protected methods that require a non NULL result from
+ /// this method. Otherwise it must return a valid, non NULL pointer
+ /// to the \c ZoneFinder object.
+ ///
+ /// When returning non NULL, the ownership of the pointed object
+ /// was not transferred to the caller; it cannot be assumed to be
+ /// valid after the originating \c Context object is destroyed.
+ /// Also, the caller must not try to delete the returned object.
+ virtual ZoneFinder* getFinder() = 0;
+
+ /// \brief Return a vector of RRsets corresponding to findAll() result.
+ ///
+ /// This method returns a set of RRsets that correspond to the
+ /// returned RRsets to a prior \c findAll() call.
+ ///
+ /// A derived class implementation can return NULL if it defines
+ /// other protected methods that require a non NULL result from
+ /// this method. Otherwise it must return a valid, non NULL pointer
+ /// to a vector that correspond to the expected set of RRsets.
+ ///
+ /// When returning non NULL, the ownership of the pointed object
+ /// was not transferred to the caller; it cannot be assumed to be
+ /// valid after the originating \c Context object is destroyed.
+ /// Also, the caller must not try to delete the returned object.
+ virtual const std::vector<isc::dns::ConstRRsetPtr>*
+ getAllRRsets() const = 0;
+
/// \brief Actual implementation of getAdditional().
///
/// This base class defines a default implementation that can be
/// used for any type of data sources. A data source implementation
/// can override it.
+ ///
+ /// The default version of this implementation requires both
+ /// \c getFinder() and \c getAllRRsets() return valid results.
virtual void getAdditionalImpl(
const std::vector<isc::dns::RRType>& requested_types,
std::vector<isc::dns::ConstRRsetPtr>& result);
private:
- ZoneFinder& finder_;
const FindResultFlags flags_;
protected:
const FindOptions options_;
+ };
+
+ /// \brief Generic ZoneFinder context that works for all implementations.
+ ///
+ /// This is a concrete derived class of \c ZoneFinder::Context that
+ /// only use the generic (default) versions of the protected methods
+ /// and therefore work for any data source implementation.
+ ///
+ /// A data source implementation can use this class to create a
+ /// \c Context object as a return value of \c find() or \c findAll()
+ /// method if it doesn't have to optimize specific protected methods.
+ class GenericContext : public Context {
+ public:
+ /// \brief The constructor for the normal find call.
+ ///
+ /// This constructor is expected to be called from the \c find()
+ /// method when it constructs the return value.
+ ///
+ /// \param finder The ZoneFinder on which find() is called.
+ /// \param options See the \c Context class.
+ /// \param result See the \c Context class.
+ GenericContext(ZoneFinder& finder, FindOptions options,
+ const ResultContext& result) :
+ Context(options, result), finder_(finder)
+ {}
+
+ /// \brief The constructor for the normal findAll call.
+ ///
+ /// This constructor is expected to be called from the \c findAll()
+ /// method when it constructs the return value.
+ ///
+ /// It copies the vector that is to be returned to the caller of
+ /// \c findAll() for possible subsequent use. Note that it cannot
+ /// simply hold a reference to the vector because the caller may
+ /// alter it after the \c findAll() call.
+ ///
+ /// \param finder The ZoneFinder on which findAll() is called.
+ /// \param options See the \c Context class.
+ /// \param result See the \c Context class.
+ /// \param all_set Reference to the vector given by the caller of
+ /// \c findAll(), storing the RRsets to be returned.
+ GenericContext(ZoneFinder& finder, FindOptions options,
+ const ResultContext& result,
+ const std::vector<isc::dns::ConstRRsetPtr>& all_set) :
+ Context(options, result), finder_(finder), all_set_(all_set)
+ {}
+
+ protected:
+ virtual ZoneFinder* getFinder() { return (&finder_); }
+ virtual const std::vector<isc::dns::ConstRRsetPtr>*
+ getAllRRsets() const {
+ return (&all_set_);
+ }
+
private:
+ ZoneFinder& finder_;
std::vector<isc::dns::ConstRRsetPtr> all_set_;
};
diff --git a/src/lib/datasrc/zone_finder_context.cc b/src/lib/datasrc/zone_finder_context.cc
index 7913d71..482eb65 100644
--- a/src/lib/datasrc/zone_finder_context.cc
+++ b/src/lib/datasrc/zone_finder_context.cc
@@ -12,6 +12,8 @@
// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
// PERFORMANCE OF THIS SOFTWARE.
+#include <exceptions/exceptions.h>
+
#include <dns/rdata.h>
#include <dns/rrset.h>
#include <dns/rrtype.h>
@@ -87,13 +89,22 @@ ZoneFinder::Context::getAdditionalImpl(const vector<RRType>& requested_types,
{
// If rrset is non NULL, it should have been SUCCESS/DELEGATION; otherwise
// we should have responded to type ANY query.
+ ZoneFinder* finder = getFinder();
+ if (finder == NULL) {
+ // This is a bug of the derived class implementation.
+ isc_throw(isc::Unexpected, "NULL ZoneFinder in finder Context");
+ }
if (rrset) {
- getAdditionalForRRset(finder_, *rrset, requested_types, result,
+ getAdditionalForRRset(*finder, *rrset, requested_types, result,
options_);
return;
}
- BOOST_FOREACH(ConstRRsetPtr rrset_in_set, all_set_) {
- getAdditionalForRRset(finder_, *rrset_in_set, requested_types, result,
+ const vector<ConstRRsetPtr>* all_sets = getAllRRsets();
+ if (all_sets == NULL) { // bug of the derived class implementation.
+ isc_throw(isc::Unexpected, "All RRsets is NULL in finder Context");
+ }
+ BOOST_FOREACH(ConstRRsetPtr rrset_in_set, *getAllRRsets()) {
+ getAdditionalForRRset(*finder, *rrset_in_set, requested_types, result,
options_);
}
}
diff --git a/src/lib/dhcp/Makefile.am b/src/lib/dhcp/Makefile.am
index fbd4eb5..f9beaa7 100644
--- a/src/lib/dhcp/Makefile.am
+++ b/src/lib/dhcp/Makefile.am
@@ -13,7 +13,7 @@ AM_CXXFLAGS += $(WARNING_NO_MISSING_FIELD_INITIALIZERS_CFLAG)
CLEANFILES = *.gcno *.gcda
-lib_LTLIBRARIES = libb10-dhcp++.la
+lib_LTLIBRARIES = libb10-dhcp++.la libb10-dhcpsrv.la
libb10_dhcp___la_SOURCES =
libb10_dhcp___la_SOURCES += libdhcp++.cc libdhcp++.h
libb10_dhcp___la_SOURCES += iface_mgr.cc iface_mgr.h
@@ -29,8 +29,18 @@ libb10_dhcp___la_SOURCES += dhcp6.h dhcp4.h
libb10_dhcp___la_SOURCES += pkt6.cc pkt6.h
libb10_dhcp___la_SOURCES += pkt4.cc pkt4.h
+libb10_dhcpsrv_la_SOURCES = cfgmgr.cc cfgmgr.h
+libb10_dhcpsrv_la_SOURCES += pool.cc pool.h
+libb10_dhcpsrv_la_SOURCES += subnet.cc subnet.h
+libb10_dhcpsrv_la_SOURCES += triplet.h
+libb10_dhcpsrv_la_SOURCES += addr_utilities.cc addr_utilities.h
+libb10_dhcpsrv_la_CXXFLAGS = $(AM_CXXFLAGS)
+libb10_dhcpsrv_la_CPPFLAGS = $(AM_CPPFLAGS) $(LOG4CPLUS_INCLUDES)
+libb10_dhcpsrv_la_LIBADD = $(top_builddir)/src/lib/asiolink/libb10-asiolink.la
+libb10_dhcpsrv_la_LIBADD += $(top_builddir)/src/lib/util/libb10-util.la
+libb10_dhcpsrv_la_LDFLAGS = -no-undefined -version-info 2:0:0
+
EXTRA_DIST = README
-#EXTRA_DIST += log_messages.mes
libb10_dhcp___la_CXXFLAGS = $(AM_CXXFLAGS)
libb10_dhcp___la_CPPFLAGS = $(AM_CPPFLAGS) $(LOG4CPLUS_INCLUDES)
@@ -43,3 +53,7 @@ if USE_CLANGPP
# Boost headers when compiling with clang.
libb10_dhcp___la_CXXFLAGS += -Wno-unused-parameter
endif
+
+EXTRA_DIST += dhcpdb_create.mysql
+dist_pkgdata_DATA = dhcpdb_create.mysql
+
diff --git a/src/lib/dhcp/README b/src/lib/dhcp/README
index 6bd6384..c5e70f2 100644
--- a/src/lib/dhcp/README
+++ b/src/lib/dhcp/README
@@ -1,11 +1,9 @@
-This directory holds implementation for libdhcp++.
+This directory holds implementation for DHCP libraries:
+libdhcp++ - this is a generic purpose DHCP library. Please be careful
+what is put here. It is going to be shared by various servers (the "regular"
+one and the embedded as well), clients, relays and performance tools.
-Basic Ideas
-===========
+libdhcpsrv - Server specific code goes in here. It will be used by
+dhcp4 and dhcp6 server.
-
-Notes
-=====
-This work just begun. Don't expect to see much useful code here.
-We are working on it.
diff --git a/src/lib/dhcp/addr_utilities.cc b/src/lib/dhcp/addr_utilities.cc
new file mode 100644
index 0000000..ad72833
--- /dev/null
+++ b/src/lib/dhcp/addr_utilities.cc
@@ -0,0 +1,96 @@
+// Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <string.h>
+#include <dhcp/addr_utilities.h>
+
+using namespace isc::asiolink;
+
+namespace isc {
+namespace dhcp {
+
+isc::asiolink::IOAddress firstAddrInPrefix(const isc::asiolink::IOAddress& prefix,
+ uint8_t len) {
+
+ const static uint8_t bitMask[]= { 0, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff };
+ uint8_t packed[V6ADDRESS_LEN];
+
+ // First we copy the whole address as 16 bytes.
+ memcpy(packed, prefix.getAddress().to_v6().to_bytes().data(), 16);
+
+ // If the length is divisible by 8, it is simple. We just zero out the host
+ // part. Otherwise we need to handle the byte that has to be partially
+ // zeroed.
+ if (len % 8 != 0) {
+
+ // Get the appropriate mask. It has relevant bits (those that should
+ // stay) set and irrelevant (those that should be wiped) cleared.
+ uint8_t mask = bitMask[len % 8];
+
+ // Let's leave only whatever the mask says should not be cleared.
+ packed[len / 8] = packed[len / 8] & mask;
+
+ // Since we have just dealt with this byte, let's move the prefix length
+ // to the beginning of the next byte (len is expressed in bits).
+ len = (len / 8 + 1) * 8;
+ }
+
+ // Clear out the remaining bits.
+ for (int i = len / 8; i < sizeof(packed); ++i) {
+ packed[i] = 0x0;
+ }
+
+ // Finally, let's wrap this into nice and easy IOAddress object.
+ return (isc::asiolink::IOAddress::from_bytes(AF_INET6, packed));
+}
+
+isc::asiolink::IOAddress lastAddrInPrefix(const isc::asiolink::IOAddress& prefix,
+ uint8_t len) {
+
+ const static uint8_t bitMask[]= { 0, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff };
+ uint8_t packed[V6ADDRESS_LEN];
+
+ // First we copy the whole address as 16 bytes.
+ memcpy(packed, prefix.getAddress().to_v6().to_bytes().data(), 16);
+
+ // if the length is divisible by 8, it is simple. We just fill the host part
+ // with ones. Otherwise we need to handle the byte that has to be partially
+ // zeroed.
+ if (len % 8 != 0) {
+ // Get the appropriate mask. It has relevant bits (those that should
+ // stay) set and irrelevant (those that should be set to 1) cleared.
+ uint8_t mask = bitMask[len % 8];
+
+ // Let's set those irrelevant bits with 1. It would be perhaps
+ // easier to not use negation here and invert bitMask content. However,
+ // with this approach, we can use the same mask in first and last
+ // address calculations.
+ packed[len / 8] = packed[len / 8] | ~mask;
+
+ // Since we have just dealt with this byte, let's move the prefix length
+ // to the beginning of the next byte (len is expressed in bits).
+ len = (len / 8 + 1) * 8;
+ }
+
+ // Finally set remaining bits to 1.
+ for (int i = len / 8; i < sizeof(packed); ++i) {
+ packed[i] = 0xff;
+ }
+
+ // Finally, let's wrap this into nice and easy IOAddress object.
+ return (isc::asiolink::IOAddress::from_bytes(AF_INET6, packed));
+}
+
+};
+};
diff --git a/src/lib/dhcp/addr_utilities.h b/src/lib/dhcp/addr_utilities.h
new file mode 100644
index 0000000..15532d0
--- /dev/null
+++ b/src/lib/dhcp/addr_utilities.h
@@ -0,0 +1,53 @@
+// Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <asiolink/io_address.h>
+
+namespace isc {
+namespace dhcp {
+
+/// This code is based on similar code from the Dibbler project. I, Tomasz Mrugalski,
+/// as a sole creator of that code hereby release it under BSD license for the benefit
+/// of the BIND10 project.
+
+/// @brief returns a first address in a given prefix
+///
+/// Example: For 2001:db8:1::deaf:beef and length /120 the function will return
+/// 2001:db8:1::dead:be00. See also @ref lastAddrInPrefix.
+///
+/// @todo It currently works for v6 only and will throw if v4 address is passed.
+///
+/// @param prefix and address that belongs to a prefix
+/// @param len prefix length
+///
+/// @return first address from a prefix
+isc::asiolink::IOAddress firstAddrInPrefix(const isc::asiolink::IOAddress& prefix,
+ uint8_t len);
+
+/// @brief returns a last address in a given prefix
+///
+/// Example: For 2001:db8:1::deaf:beef and length /112 the function will return
+/// 2001:db8:1::dead:ffff. See also @ref firstAddrInPrefix.
+///
+/// @todo It currently works for v6 only and will throw if v4 address is passed.
+///
+/// @param prefix and address that belongs to a prefix
+/// @param len prefix length
+///
+/// @return first address from a prefix
+isc::asiolink::IOAddress lastAddrInPrefix(const isc::asiolink::IOAddress& prefix,
+ uint8_t len);
+
+};
+};
diff --git a/src/lib/dhcp/cfgmgr.cc b/src/lib/dhcp/cfgmgr.cc
new file mode 100644
index 0000000..15e3ad9
--- /dev/null
+++ b/src/lib/dhcp/cfgmgr.cc
@@ -0,0 +1,78 @@
+// Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <asiolink/io_address.h>
+#include <dhcp/cfgmgr.h>
+
+using namespace isc::asiolink;
+using namespace isc::util;
+
+namespace isc {
+namespace dhcp {
+
+
+
+
+CfgMgr&
+CfgMgr::instance() {
+ static CfgMgr cfg_mgr;
+ return (cfg_mgr);
+}
+
+Subnet6Ptr
+CfgMgr::getSubnet6(const isc::asiolink::IOAddress& hint) {
+
+ // If there's only one subnet configured, let's just use it
+ // The idea is to keep small deployments easy. In a small network - one
+ // router that also runs DHCPv6 server. Users specifies a single pool and
+ // expects it to just work. Without this, the server would complain that it
+ // doesn't have IP address on its interfaces that matches that
+ // configuration. Such requirement makes sense in IPv4, but not in IPv6.
+ // The server does not need to have a global address (using just link-local
+ // is ok for DHCPv6 server) from the pool it serves.
+ if (subnets6_.size() == 1) {
+ return (subnets6_[0]);
+ }
+
+ // If there is more than one, we need to choose the proper one
+ for (Subnet6Collection::iterator subnet = subnets6_.begin();
+ subnet != subnets6_.end(); ++subnet) {
+ if ((*subnet)->inRange(hint)) {
+ return (*subnet);
+ }
+ }
+
+ // sorry, we don't support that subnet
+ return (Subnet6Ptr());
+}
+
+Subnet6Ptr CfgMgr::getSubnet6(OptionPtr /*interfaceId*/) {
+ /// @todo: Implement get subnet6 by interface-id (for relayed traffic)
+ isc_throw(NotImplemented, "Relayed DHCPv6 traffic is not supported yet.");
+}
+
+void CfgMgr::addSubnet6(const Subnet6Ptr& subnet) {
+ /// @todo: Check that this new subnet does not cross boundaries of any
+ /// other already defined subnet.
+ subnets6_.push_back(subnet);
+}
+
+CfgMgr::CfgMgr() {
+}
+
+CfgMgr::~CfgMgr() {
+}
+
+}; // end of isc::dhcp namespace
+}; // end of isc namespace
diff --git a/src/lib/dhcp/cfgmgr.h b/src/lib/dhcp/cfgmgr.h
new file mode 100644
index 0000000..5b73f2b
--- /dev/null
+++ b/src/lib/dhcp/cfgmgr.h
@@ -0,0 +1,126 @@
+// Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#ifndef CFGMGR_H
+#define CFGMGR_H
+
+#include <string>
+#include <map>
+#include <vector>
+#include <boost/shared_ptr.hpp>
+#include <boost/noncopyable.hpp>
+#include <asiolink/io_address.h>
+#include <util/buffer.h>
+#include <dhcp/option.h>
+#include <dhcp/pool.h>
+#include <dhcp/subnet.h>
+
+namespace isc {
+namespace dhcp {
+
+
+/// @brief Configuration Manager
+///
+/// This singleton class holds the whole configuration for DHCPv4 and DHCPv6
+/// servers. It currently holds information about zero or more subnets6.
+/// Each subnet may contain zero or more pools. Pool4 and Pool6 is the most
+/// basic "chunk" of configuration. It contains a range of assigneable
+/// addresses.
+///
+/// Below is a sketch of configuration inheritance (not implemented yet).
+/// Let's investigate the following configuration:
+///
+/// preferred-lifetime 500;
+/// valid-lifetime 1000;
+/// subnet6 2001:db8:1::/48 {
+/// pool6 2001::db8:1::1 - 2001::db8:1::ff;
+/// };
+/// subnet6 2001:db8:2::/48 {
+/// valid-lifetime 2000;
+/// pool6 2001::db8:2::1 - 2001::db8:2::ff;
+/// };
+/// Parameters defined in a global scope are applicable to everything until
+/// they are overwritten in a smaller scope, in this case subnet6.
+/// In the example above, the first subnet6 has preferred lifetime of 500s
+/// and a valid lifetime of 1000s. The second subnet has preferred lifetime
+/// of 500s, but valid lifetime of 2000s.
+///
+/// Parameter inheritance is likely to be implemented in configuration handling
+/// routines, so there is no storage capability in a global scope for
+/// subnet-specific parameters.
+///
+/// @todo: Implement Subnet4 support (ticket #2237)
+/// @todo: Implement option definition support
+/// @todo: Implement parameter inheritance
+class CfgMgr : public boost::noncopyable {
+public:
+
+ /// @brief returns a single instance of Configuration Manager
+ ///
+ /// CfgMgr is a singleton and this method is the only way of
+ /// accessing it.
+ static CfgMgr& instance();
+
+ /// @brief get subnet by address
+ ///
+ /// Finds a matching subnet, based on an address. This can be used
+ /// in two cases: when trying to find an appropriate lease based on
+ /// a) relay link address (that must be the address that is on link)
+ /// b) our global address on the interface the message was received on
+ /// (for directly connected clients)
+ ///
+ /// @param hint an address that belongs to a searched subnet
+ Subnet6Ptr getSubnet6(const isc::asiolink::IOAddress& hint);
+
+ /// @brief get subnet by interface-id
+ ///
+ /// Another possibility to find a subnet is based on interface-id.
+ ///
+ /// @param interface_id content of interface-id option returned by a relay
+ /// @todo This method is not currently supported.
+ Subnet6Ptr getSubnet6(OptionPtr interface_id);
+
+ /// @brief adds a subnet6
+ void addSubnet6(const Subnet6Ptr& subnet);
+
+ /// @todo: Add subnet6 removal routines. Currently it is not possible
+ /// to remove subnets. The only case where subnet6 removal would be
+ /// needed is a dynamic server reconfiguration - a use case that is not
+ /// planned to be supported any time soon.
+protected:
+
+ /// @brief Protected constructor.
+ ///
+ /// This constructor is protected for 2 reasons. First, it forbids any
+ /// instantiations of this class (CfgMgr is a singleton). Second, it
+ /// allows derived class to instantiate it. That is useful for testing
+ /// purposes.
+ CfgMgr();
+
+ /// @brief virtual desctructor
+ virtual ~CfgMgr();
+
+ /// @brief a container for Subnet6
+ ///
+ /// That is a simple vector of pointers. It does not make much sense to
+ /// optimize access time (e.g. using a map), because typical search
+ /// pattern will use calling inRange() method on each subnet until
+ /// a match is found.
+ Subnet6Collection subnets6_;
+};
+
+} // namespace isc::dhcp
+} // namespace isc
+
+#endif
diff --git a/src/lib/dhcp/dhcpdb_create.mysql b/src/lib/dhcp/dhcpdb_create.mysql
new file mode 100644
index 0000000..4ee40ae
--- /dev/null
+++ b/src/lib/dhcp/dhcpdb_create.mysql
@@ -0,0 +1,56 @@
+# Copyright (C) 2012 Internet Systems Consortium.
+#
+# Permission to use, copy, modify, and distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SYSTEMS CONSORTIUM
+# DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
+# INTERNET SYSTEMS CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT,
+# INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
+# FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+# NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+# WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+CREATE TABLE lease4 (
+ address INT UNSIGNED UNIQUE NOT NULL, # IPv4 address
+ hwaddr VARCHAR(20), # Hardware address
+ client_id VARCHAR(128), # Client ID
+ valid_lft INT, # Valid lifetime (seconds)
+ recycle_time INT DEFAULT 0, # Recycle time (seconds)
+ cllt TIMESTAMP, # Client last comm time
+ pool_id INT, # Pool identification
+ options TEXT # List of options
+ ) ENGINE = INNODB;
+
+# Holds the IPv6 leases
+CREATE TABLE lease6 (
+ address BINARY(16) UNIQUE NOT NULL, # IPv6 address
+ hwaddr VARCHAR(20), # Hardware address
+ client_id VARCHAR(128), # Client ID
+ fixed BOOL DEFAULT FALSE, # Is this lease fixed?
+ valid_lft INT, # Valid lifetime (seconds)
+ recycle_time INT DEFAULT 0, # Recycle time (seconds)
+ cllt TIMESTAMP, # Client last comm time
+ pool_id INT, # Pool identification
+ iaid INT UNSIGNED, # IA ID
+ prefix_len TINYINT UNSIGNED, # For IA_PD only
+ options TEXT # Textual form of options
+ ) ENGINE = INNODB;
+
+# The host table
+CREATE TABLE host (
+ hostname VARCHAR(255) UNIQUE, # Name of the host
+ address4 INT UNSIGNED DEFAULT NULL, # IPv4 address
+ address6 BINARY(16) DEFAULT NULL, # IPv6 address
+ options TEXT # Textual form of the options
+ ) ENGINE = INNODB;
+
+# Finally, the version of the schema. We start at 0.0 during development.
+# This table is only modified during schema upgrades.
+CREATE TABLE schema_version (
+ major INT NOT NULL, # Major version number
+ minor INT NOT NULL # Minor version number
+ );
+INSERT INTO schema_version VALUES (0, 0);
diff --git a/src/lib/dhcp/pool.cc b/src/lib/dhcp/pool.cc
new file mode 100644
index 0000000..da8a2e3
--- /dev/null
+++ b/src/lib/dhcp/pool.cc
@@ -0,0 +1,87 @@
+// Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <asiolink/io_address.h>
+#include <dhcp/addr_utilities.h>
+#include <dhcp/pool.h>
+
+using namespace isc::asiolink;
+
+namespace isc {
+namespace dhcp {
+
+Pool::Pool(const isc::asiolink::IOAddress& first,
+ const isc::asiolink::IOAddress& last)
+ :id_(getNextID()), first_(first), last_(last) {
+}
+
+bool Pool::inRange(const isc::asiolink::IOAddress& addr) const {
+ return (first_.smallerEqual(addr) && addr.smallerEqual(last_));
+}
+
+Pool6::Pool6(Pool6Type type, const isc::asiolink::IOAddress& first,
+ const isc::asiolink::IOAddress& last)
+ :Pool(first, last), type_(type), prefix_len_(0) {
+
+ // check if specified address boundaries are sane
+ if (first.getFamily() != AF_INET6 || last.getFamily() != AF_INET6) {
+ isc_throw(BadValue, "Invalid Pool6 address boundaries: not IPv6");
+ }
+
+ if (last < first) {
+ isc_throw(BadValue, "Upper boundary is smaller than lower boundary.");
+ // This check is a bit strict. If we decide that it is too strict,
+ // we need to comment it and uncomment lines below.
+ // On one hand, letting the user specify 2001::f - 2001::1 is nice, but
+ // on the other hand, 2001::1 may be a typo and the user really meant
+ // 2001::1:0 (or 1 followed by some hex digit), so a at least a warning
+ // would be useful.
+
+ // first_ = last;
+ // last_ = first;
+ }
+
+
+ // TYPE_PD is not supported by this constructor. first-last style
+ // parameters are for IA and TA only. There is another dedicated
+ // constructor for that (it uses prefix/length)
+ if ((type != TYPE_IA) && (type != TYPE_TA)) {
+ isc_throw(BadValue, "Invalid Pool6 type specified");
+ }
+}
+
+Pool6::Pool6(Pool6Type type, const isc::asiolink::IOAddress& prefix,
+ uint8_t prefix_len)
+ :Pool(prefix, IOAddress("::")),
+ type_(type), prefix_len_(prefix_len) {
+
+ // check if the prefix is sane
+ if (prefix.getFamily() != AF_INET6) {
+ isc_throw(BadValue, "Invalid Pool6 address boundaries: not IPv6");
+ }
+
+ // check if the prefix length is sane
+ if (prefix_len == 0 || prefix_len > 128) {
+ isc_throw(BadValue, "Invalid prefix length");
+ }
+
+ /// @todo: We should probably implement checks against weird addresses
+ /// here, like ::, starting with fe80, starting with ff etc. .
+
+ // Let's now calculate the last address in defined pool
+ last_ = lastAddrInPrefix(prefix, prefix_len);
+}
+
+}; // end of isc::dhcp namespace
+}; // end of isc namespace
diff --git a/src/lib/dhcp/pool.h b/src/lib/dhcp/pool.h
new file mode 100644
index 0000000..8f6fd86
--- /dev/null
+++ b/src/lib/dhcp/pool.h
@@ -0,0 +1,155 @@
+// Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#ifndef POOL_H
+#define POOL_H
+
+#include <vector>
+#include <asiolink/io_address.h>
+#include <boost/shared_ptr.hpp>
+
+namespace isc {
+namespace dhcp {
+
+/// @brief base class for Pool4 and Pool6
+///
+/// Stores information about pool of IPv4 or IPv6 addresses.
+/// That is a basic component of a configuration.
+class Pool {
+
+public:
+
+ /// @brief returns Pool-id
+ ///
+ /// @return pool-id value
+ /// Pool-id is an unique value that can be used to identify a pool.
+ uint32_t getId() const {
+ return (id_);
+ }
+
+ /// @brief Returns the first address in a pool.
+ ///
+ /// @return first address in a pool
+ const isc::asiolink::IOAddress& getFirstAddress() const {
+ return (first_);
+ }
+
+ /// @brief Returns the last address in a pool.
+ /// @return last address in a pool
+ const isc::asiolink::IOAddress& getLastAddress() const {
+ return (last_);
+ }
+
+ /// @brief Checks if a given address is in the range.
+ ///
+ /// @return true, if the address is in pool
+ bool inRange(const isc::asiolink::IOAddress& addr) const;
+
+protected:
+
+ /// @brief protected constructor
+ ///
+ /// This constructor is protected to prevent anyone from instantiating
+ /// Pool class directly. Instances of Pool4 and Pool6 should be created
+ /// instead.
+ Pool(const isc::asiolink::IOAddress& first,
+ const isc::asiolink::IOAddress& last);
+
+ /// @brief returns the next unique Pool-ID
+ ///
+ /// @return the next unique Pool-ID
+ static uint32_t getNextID() {
+ static uint32_t id = 0;
+ return (id++);
+ }
+
+ /// @brief pool-id
+ ///
+ /// This ID is used to identify this specific pool.
+ uint32_t id_;
+
+ /// @brief The first address in a pool
+ isc::asiolink::IOAddress first_;
+
+ /// @brief The last address in a pool
+ isc::asiolink::IOAddress last_;
+
+ /// @brief Comments field
+ ///
+ /// @todo: This field is currently not used.
+ std::string comments_;
+};
+
+/// @brief Pool information for IPv6 addresses and prefixes
+///
+/// It holds information about pool6, i.e. a range of IPv6 address space that
+/// is configured for DHCP allocation.
+class Pool6 : public Pool {
+public:
+
+ /// @brief specifies Pool type
+ ///
+ /// Currently there are 3 pool types defined in DHCPv6:
+ /// - Non-temporary addresses (conveyed in IA_NA)
+ /// - Temporary addresses (conveyed in IA_TA)
+ /// - Delegated Prefixes (conveyed in IA_PD)
+ /// There is a new one being worked on (IA_PA, see draft-ietf-dhc-host-gen-id), but
+ /// support for it is not planned for now.
+ typedef enum {
+ TYPE_IA,
+ TYPE_TA,
+ TYPE_PD
+ } Pool6Type;
+
+ /// @brief the constructor for Pool6 "min-max" style definition
+ ///
+ /// @param first the first address in a pool
+ /// @param last the last address in a pool
+ Pool6(Pool6Type type, const isc::asiolink::IOAddress& first,
+ const isc::asiolink::IOAddress& last);
+
+ /// @brief the constructor for Pool6 "prefix/len" style definition
+ ///
+ /// @param prefix specifies prefix of the pool
+ /// @param prefix_len specifies length of the prefix of the pool
+ Pool6(Pool6Type type, const isc::asiolink::IOAddress& prefix,
+ uint8_t prefix_len);
+
+ /// @brief returns pool type
+ ///
+ /// @return pool type
+ Pool6Type getType() const {
+ return (type_);
+ }
+
+private:
+ /// @brief defines a pool type
+ Pool6Type type_;
+
+ /// @brief prefix length
+ /// used by TYPE_PD only (zeroed for other types)
+ uint8_t prefix_len_;
+};
+
+/// @brief a pointer an IPv6 Pool
+typedef boost::shared_ptr<Pool6> Pool6Ptr;
+
+/// @brief a container for IPv6 Pools
+typedef std::vector<Pool6Ptr> Pool6Collection;
+
+} // end of isc::dhcp namespace
+} // end of isc namespace
+
+
+#endif // POOL_H
diff --git a/src/lib/dhcp/subnet.cc b/src/lib/dhcp/subnet.cc
new file mode 100644
index 0000000..a999295
--- /dev/null
+++ b/src/lib/dhcp/subnet.cc
@@ -0,0 +1,91 @@
+// Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <dhcp/addr_utilities.h>
+#include <asiolink/io_address.h>
+#include <dhcp/subnet.h>
+#include <dhcp/pool.h>
+
+using namespace isc::asiolink;
+
+namespace isc {
+namespace dhcp {
+
+Subnet::Subnet(const isc::asiolink::IOAddress& prefix, uint8_t len,
+ const Triplet<uint32_t>& t1,
+ const Triplet<uint32_t>& t2,
+ const Triplet<uint32_t>& valid_lifetime)
+ :id_(getNextID()), prefix_(prefix), prefix_len_(len), t1_(t1),
+ t2_(t2), valid_(valid_lifetime) {
+ if ( (prefix.getFamily() == AF_INET6 && len > 128) ||
+ (prefix.getFamily() == AF_INET && len > 32) ) {
+ isc_throw(BadValue, "Invalid prefix length specified for subnet: " << len);
+ }
+}
+
+bool Subnet::inRange(const isc::asiolink::IOAddress& addr) const {
+ IOAddress first = firstAddrInPrefix(prefix_, prefix_len_);
+ IOAddress last = lastAddrInPrefix(prefix_, prefix_len_);
+
+ return ((first <= addr) && (addr <= last));
+}
+
+Subnet6::Subnet6(const isc::asiolink::IOAddress& prefix, uint8_t length,
+ const Triplet<uint32_t>& t1,
+ const Triplet<uint32_t>& t2,
+ const Triplet<uint32_t>& preferred_lifetime,
+ const Triplet<uint32_t>& valid_lifetime)
+ :Subnet(prefix, length, t1, t2, valid_lifetime),
+ preferred_(preferred_lifetime){
+ if (prefix.getFamily() != AF_INET6) {
+ isc_throw(BadValue, "Non IPv6 prefix " << prefix.toText()
+ << " specified in subnet6");
+ }
+}
+
+void Subnet6::addPool6(const Pool6Ptr& pool) {
+ IOAddress first_addr = pool->getFirstAddress();
+ IOAddress last_addr = pool->getLastAddress();
+
+ if (!inRange(first_addr) || !inRange(last_addr)) {
+ isc_throw(BadValue, "Pool6 (" << first_addr.toText() << "-" << last_addr.toText()
+ << " does not belong in this (" << prefix_ << "/" << prefix_len_
+ << ") subnet6");
+ }
+
+ /// @todo: Check that pools do not overlap
+
+ pools_.push_back(pool);
+}
+
+Pool6Ptr Subnet6::getPool6(const isc::asiolink::IOAddress& hint /* = IOAddress("::")*/ ) {
+ Pool6Ptr candidate;
+ for (Pool6Collection::iterator pool = pools_.begin(); pool != pools_.end(); ++pool) {
+
+ // if we won't find anything better, then let's just use the first pool
+ if (!candidate) {
+ candidate = *pool;
+ }
+
+ // if the client provided a pool and there's a pool that hint is valid in,
+ // then let's use that pool
+ if ((*pool)->inRange(hint)) {
+ return (*pool);
+ }
+ }
+ return (candidate);
+}
+
+} // end of isc::dhcp namespace
+} // end of isc namespace
diff --git a/src/lib/dhcp/subnet.h b/src/lib/dhcp/subnet.h
new file mode 100644
index 0000000..aa59010
--- /dev/null
+++ b/src/lib/dhcp/subnet.h
@@ -0,0 +1,161 @@
+// Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#ifndef SUBNET_H
+#define SUBNET_H
+
+#include <boost/shared_ptr.hpp>
+#include <asiolink/io_address.h>
+#include <dhcp/pool.h>
+#include <dhcp/triplet.h>
+
+namespace isc {
+namespace dhcp {
+
+/// @brief a base class for Subnet4 and Subnet6
+///
+/// This class presents a common base for IPv4 and IPv6 subnets.
+/// In a physical sense, a subnet defines a single network link with all devices
+/// attached to it. In most cases all devices attached to a single link can
+/// share the same parameters. Therefore Subnet holds several values that are
+/// typically shared by all hosts: renew timer (T1), rebind timer (T2) and
+/// leased addresses lifetime (valid-lifetime).
+///
+/// @todo: Implement support for options here
+class Subnet {
+public:
+ /// @brief checks if specified address is in range
+ bool inRange(const isc::asiolink::IOAddress& addr) const;
+
+ /// @brief return valid-lifetime for addresses in that prefix
+ Triplet<uint32_t> getValid() const {
+ return (valid_);
+ }
+
+ /// @brief returns T1 (renew timer), expressed in seconds
+ Triplet<uint32_t> getT1() const {
+ return (t1_);
+ }
+
+ /// @brief returns T2 (rebind timer), expressed in seconds
+ Triplet<uint32_t> getT2() const {
+ return (t2_);
+ }
+
+protected:
+ /// @brief protected constructor
+ //
+ /// By making the constructor protected, we make sure that noone will
+ /// ever instantiate that class. Pool4 and Pool6 should be used instead.
+ Subnet(const isc::asiolink::IOAddress& prefix, uint8_t len,
+ const Triplet<uint32_t>& t1,
+ const Triplet<uint32_t>& t2,
+ const Triplet<uint32_t>& valid_lifetime);
+
+ /// @brief returns the next unique Subnet-ID
+ ///
+ /// @return the next unique Subnet-ID
+ static uint32_t getNextID() {
+ static uint32_t id = 0;
+ return (id++);
+ }
+
+ /// @brief subnet-id
+ ///
+ /// Subnet-id is a unique value that can be used to find or identify
+ /// a Subnet4 or Subnet6.
+ uint32_t id_;
+
+ /// @brief a prefix of the subnet
+ isc::asiolink::IOAddress prefix_;
+
+ /// @brief a prefix length of the subnet
+ uint8_t prefix_len_;
+
+ /// @brief a tripet (min/default/max) holding allowed renew timer values
+ Triplet<uint32_t> t1_;
+
+ /// @brief a tripet (min/default/max) holding allowed rebind timer values
+ Triplet<uint32_t> t2_;
+
+ /// @brief a tripet (min/default/max) holding allowed valid lifetime values
+ Triplet<uint32_t> valid_;
+};
+
+/// @brief A configuration holder for IPv6 subnet.
+///
+/// This class represents an IPv6 subnet.
+class Subnet6 : public Subnet {
+public:
+
+ /// @brief Constructor with all parameters
+ ///
+ /// @param prefix Subnet6 prefix
+ /// @param length prefix length
+ /// @param t1 renewal timer (in seconds)
+ /// @param t2 rebind timer (in seconds)
+ /// @param preferred_lifetime preferred lifetime of leases (in seconds)
+ /// @param valid_lifetime preferred lifetime of leases (in seconds)
+ Subnet6(const isc::asiolink::IOAddress& prefix, uint8_t length,
+ const Triplet<uint32_t>& t1,
+ const Triplet<uint32_t>& t2,
+ const Triplet<uint32_t>& preferred_lifetime,
+ const Triplet<uint32_t>& valid_lifetime);
+
+ /// @brief Returns preverred lifetime (in seconds)
+ ///
+ /// @return a triplet with preferred lifetime
+ Triplet<uint32_t> getPreferred() const {
+ return (preferred_);
+ }
+
+ /// @brief Returns a pool that specified address belongs to
+ ///
+ /// @param hint address that the returned pool should cover (optional)
+ /// @return Pointer to found pool6 (or NULL)
+ Pool6Ptr getPool6(const isc::asiolink::IOAddress& hint =
+ isc::asiolink::IOAddress("::"));
+
+ /// @brief Adds a new pool.
+ /// @param pool pool to be added
+ void addPool6(const Pool6Ptr& pool);
+
+ /// @brief returns all pools
+ ///
+ /// The reference is only valid as long as the object that
+ /// returned it.
+ ///
+ /// @return a collection of all pools
+ const Pool6Collection& getPools() const {
+ return pools_;
+ }
+
+protected:
+ /// @brief collection of pools in that list
+ Pool6Collection pools_;
+
+ /// @brief a triplet with preferred lifetime (in seconds)
+ Triplet<uint32_t> preferred_;
+};
+
+/// @brief A pointer to a Subnet6 object
+typedef boost::shared_ptr<Subnet6> Subnet6Ptr;
+
+/// @brief A collection of Subnet6 objects
+typedef std::vector<Subnet6Ptr> Subnet6Collection;
+
+} // end of isc::dhcp namespace
+} // end of isc namespace
+
+#endif // SUBNET_T
diff --git a/src/lib/dhcp/tests/Makefile.am b/src/lib/dhcp/tests/Makefile.am
index 9e00ab0..9fd3492 100644
--- a/src/lib/dhcp/tests/Makefile.am
+++ b/src/lib/dhcp/tests/Makefile.am
@@ -24,7 +24,7 @@ TESTS_ENVIRONMENT = \
TESTS =
if HAVE_GTEST
-TESTS += libdhcp++_unittests
+TESTS += libdhcp++_unittests libdhcpsrv_unittests
libdhcp___unittests_SOURCES = run_unittests.cc
libdhcp___unittests_SOURCES += libdhcp++_unittest.cc
libdhcp___unittests_SOURCES += iface_mgr_unittest.cc
@@ -38,20 +38,37 @@ libdhcp___unittests_SOURCES += pkt4_unittest.cc
libdhcp___unittests_CPPFLAGS = $(AM_CPPFLAGS) $(GTEST_INCLUDES) $(LOG4CPLUS_INCLUDES)
libdhcp___unittests_LDFLAGS = $(AM_LDFLAGS) $(GTEST_LDFLAGS)
-
libdhcp___unittests_CXXFLAGS = $(AM_CXXFLAGS)
+libdhcpsrv_unittests_SOURCES = run_unittests.cc
+libdhcpsrv_unittests_SOURCES += cfgmgr_unittest.cc triplet_unittest.cc
+libdhcpsrv_unittests_SOURCES += pool_unittest.cc subnet_unittest.cc
+libdhcpsrv_unittests_SOURCES += addr_utilities_unittest.cc
+
+libdhcpsrv_unittests_CPPFLAGS = $(AM_CPPFLAGS) $(GTEST_INCLUDES) $(LOG4CPLUS_INCLUDES)
+libdhcpsrv_unittests_LDFLAGS = $(AM_LDFLAGS) $(GTEST_LDFLAGS)
+libdhcpsrv_unittests_CXXFLAGS = $(AM_CXXFLAGS)
+libdhcpsrv_unittests_LDADD = $(GTEST_LDADD)
+libdhcpsrv_unittests_LDADD += $(top_builddir)/src/lib/exceptions/libb10-exceptions.la
+libdhcpsrv_unittests_LDADD += $(top_builddir)/src/lib/asiolink/libb10-asiolink.la
+libdhcpsrv_unittests_LDADD += $(top_builddir)/src/lib/dhcp/libb10-dhcpsrv.la
+libdhcpsrv_unittests_LDADD += $(top_builddir)/src/lib/log/libb10-log.la
+
+
if USE_CLANGPP
# This is to workaround unused variables tcout and tcerr in
# log4cplus's streams.h and unused parameters from some of the
# Boost headers.
libdhcp___unittests_CXXFLAGS += -Wno-unused-variable -Wno-unused-parameter
+libdhcpsrv_unittests_CXXFLAGS += -Wno-unused-variable -Wno-unused-parameter
endif
+
libdhcp___unittests_LDADD = $(top_builddir)/src/lib/dhcp/libb10-dhcp++.la
libdhcp___unittests_LDADD += $(top_builddir)/src/lib/log/libb10-log.la
libdhcp___unittests_LDADD += $(top_builddir)/src/lib/util/libb10-util.la
libdhcp___unittests_LDADD += $(top_builddir)/src/lib/asiolink/libb10-asiolink.la
libdhcp___unittests_LDADD += $(top_builddir)/src/lib/exceptions/libb10-exceptions.la
+libdhcp___unittests_LDADD += $(top_builddir)/src/lib/log/libb10-log.la
libdhcp___unittests_LDADD += $(GTEST_LDADD)
endif
diff --git a/src/lib/dhcp/tests/addr_utilities_unittest.cc b/src/lib/dhcp/tests/addr_utilities_unittest.cc
new file mode 100644
index 0000000..8382827
--- /dev/null
+++ b/src/lib/dhcp/tests/addr_utilities_unittest.cc
@@ -0,0 +1,93 @@
+
+// Copyright (C) 2010 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <config.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include <gtest/gtest.h>
+#include <vector>
+
+#include <dhcp/addr_utilities.h>
+
+using namespace std;
+using namespace isc::dhcp;
+using namespace isc::asiolink;
+
+TEST(Pool6Test, lastAddrInPrefix) {
+ IOAddress addr1("2001:db8:1:1234:5678:abcd:1234:beef");
+
+ // Prefixes rounded to nibbles are easy...
+ EXPECT_EQ("2001:db8:1:1234:5678:abcd:1234:ffff",
+ lastAddrInPrefix(addr1, 112).toText());
+ EXPECT_EQ("2001:db8:1:1234:5678:abcd:123f:ffff",
+ lastAddrInPrefix(addr1, 108).toText());
+ EXPECT_EQ("2001:db8:1:1234:5678:abcd:12ff:ffff",
+ lastAddrInPrefix(addr1, 104).toText());
+ EXPECT_EQ("2001:db8:1:1234:ffff:ffff:ffff:ffff",
+ lastAddrInPrefix(addr1, 64).toText());
+
+ IOAddress addr2("2001::");
+
+ // These are tricker, though, as they are done in 1 bit increments
+
+ // the last address in 2001::/127 pool should be 2001::1
+ EXPECT_EQ("2001::1", lastAddrInPrefix(addr2, 127).toText());
+
+ EXPECT_EQ("2001::3", lastAddrInPrefix(addr2, 126).toText());
+ EXPECT_EQ("2001::7", lastAddrInPrefix(addr2, 125).toText());
+ EXPECT_EQ("2001::f", lastAddrInPrefix(addr2, 124).toText());
+ EXPECT_EQ("2001::1f", lastAddrInPrefix(addr2, 123).toText());
+ EXPECT_EQ("2001::3f", lastAddrInPrefix(addr2, 122).toText());
+ EXPECT_EQ("2001::7f", lastAddrInPrefix(addr2, 121).toText());
+ EXPECT_EQ("2001::ff", lastAddrInPrefix(addr2, 120).toText());
+
+ // Let's check extreme cases
+ IOAddress anyAddr("::");
+ EXPECT_EQ("7fff:ffff:ffff:ffff:ffff:ffff:ffff:ffff",
+ lastAddrInPrefix(anyAddr, 1).toText());
+ EXPECT_EQ("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff",
+ lastAddrInPrefix(anyAddr, 0).toText());
+ EXPECT_EQ("::", lastAddrInPrefix(anyAddr, 128).toText());
+}
+
+TEST(Pool6Test, firstAddrInPrefix) {
+ IOAddress addr1("2001:db8:1:1234:5678:1234:abcd:beef");
+
+ // Prefixes rounded to nibbles are easy...
+ EXPECT_EQ("2001:db8:1:1234:5678:1234::",
+ firstAddrInPrefix(addr1, 96).toText());
+ EXPECT_EQ("2001:db8:1:1234:5678:1230::",
+ firstAddrInPrefix(addr1, 92).toText());
+ EXPECT_EQ("2001:db8:1:1234:5678:1200::",
+ firstAddrInPrefix(addr1, 88).toText());
+ EXPECT_EQ("2001:db8:1:1234::",
+ firstAddrInPrefix(addr1, 64).toText());
+
+ IOAddress addr2("2001::ffff");
+
+ // These are tricker, though, as they are done in 1 bit increments
+
+ // the first address in 2001::/127 pool should be 2001::1
+ EXPECT_EQ("2001::fffe", firstAddrInPrefix(addr2, 127).toText());
+
+ EXPECT_EQ("2001::fffc", firstAddrInPrefix(addr2, 126).toText());
+ EXPECT_EQ("2001::fff8", firstAddrInPrefix(addr2, 125).toText());
+ EXPECT_EQ("2001::fff0", firstAddrInPrefix(addr2, 124).toText());
+ EXPECT_EQ("2001::ffe0", firstAddrInPrefix(addr2, 123).toText());
+ EXPECT_EQ("2001::ffc0", firstAddrInPrefix(addr2, 122).toText());
+ EXPECT_EQ("2001::ff80", firstAddrInPrefix(addr2, 121).toText());
+ EXPECT_EQ("2001::ff00", firstAddrInPrefix(addr2, 120).toText());
+}
diff --git a/src/lib/dhcp/tests/cfgmgr_unittest.cc b/src/lib/dhcp/tests/cfgmgr_unittest.cc
new file mode 100644
index 0000000..a11acbf
--- /dev/null
+++ b/src/lib/dhcp/tests/cfgmgr_unittest.cc
@@ -0,0 +1,63 @@
+// Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <config.h>
+#include <iostream>
+#include <sstream>
+#include <arpa/inet.h>
+#include <gtest/gtest.h>
+#include <dhcp/cfgmgr.h>
+#include <exceptions/exceptions.h>
+
+using namespace std;
+using namespace isc::asiolink;
+using namespace isc::dhcp;
+using namespace isc::util;
+using namespace isc;
+
+// don't import the entire boost namespace. It will unexpectedly hide uint8_t
+// for some systems.
+using boost::scoped_ptr;
+
+namespace {
+
+// This test verifies if the configuration manager is able to hold and return
+// valid leases
+TEST(CfgMgrTest, subnet6) {
+ CfgMgr& cfg_mgr = CfgMgr::instance();
+
+ ASSERT_TRUE(&cfg_mgr != 0);
+
+ Subnet6Ptr subnet1(new Subnet6(IOAddress("2000::"), 48, 1, 2, 3, 4));
+ Subnet6Ptr subnet2(new Subnet6(IOAddress("3000::"), 48, 1, 2, 3, 4));
+ Subnet6Ptr subnet3(new Subnet6(IOAddress("4000::"), 48, 1, 2, 3, 4));
+
+ // there shouldn't be any subnet configured at this stage
+ EXPECT_EQ( Subnet6Ptr(), cfg_mgr.getSubnet6(IOAddress("2000::1")));
+
+ cfg_mgr.addSubnet6(subnet1);
+
+ // Now we have only one subnet, any request will be served from it
+ EXPECT_EQ(subnet1, cfg_mgr.getSubnet6(IOAddress("2001:db8::1")));
+
+ cfg_mgr.addSubnet6(subnet2);
+ cfg_mgr.addSubnet6(subnet3);
+
+ EXPECT_EQ(subnet3, cfg_mgr.getSubnet6(IOAddress("4000::123")));
+ EXPECT_EQ(subnet2, cfg_mgr.getSubnet6(IOAddress("3000::dead:beef")));
+ EXPECT_EQ(Subnet6Ptr(), cfg_mgr.getSubnet6(IOAddress("5000::1")));
+
+}
+
+} // end of anonymous namespace
diff --git a/src/lib/dhcp/tests/iface_mgr_unittest.cc b/src/lib/dhcp/tests/iface_mgr_unittest.cc
index 2c7b86b..462910b 100644
--- a/src/lib/dhcp/tests/iface_mgr_unittest.cc
+++ b/src/lib/dhcp/tests/iface_mgr_unittest.cc
@@ -1096,7 +1096,7 @@ void parse_ifconfig(const std::string& textFile, IfaceMgr::IfaceCollection& ifac
addr = addr.substr(0, addr.find_first_of(" "));
IOAddress a(addr);
iface->addAddress(a);
- } else if(line.find("Metric")) {
+ } else if(line.find("Metric") != string::npos) {
// flags
if (line.find("UP") != string::npos) {
iface->flag_up_ = true;
diff --git a/src/lib/dhcp/tests/pool_unittest.cc b/src/lib/dhcp/tests/pool_unittest.cc
new file mode 100644
index 0000000..61d4c4a
--- /dev/null
+++ b/src/lib/dhcp/tests/pool_unittest.cc
@@ -0,0 +1,109 @@
+// Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <config.h>
+#include <iostream>
+#include <vector>
+#include <sstream>
+#include <gtest/gtest.h>
+#include <dhcp/pool.h>
+#include <asiolink/io_address.h>
+
+using boost::scoped_ptr;
+using namespace isc;
+using namespace isc::dhcp;
+using namespace isc::asiolink;
+
+namespace {
+
+TEST(Pool6Test, constructor_first_last) {
+
+ // let's construct 2001:db8:1:: - 2001:db8:1::ffff:ffff:ffff:ffff pool
+ Pool6 pool1(Pool6::TYPE_IA, IOAddress("2001:db8:1::"),
+ IOAddress("2001:db8:1::ffff:ffff:ffff:ffff"));
+
+ EXPECT_EQ(Pool6::TYPE_IA, pool1.getType());
+ EXPECT_EQ(IOAddress("2001:db8:1::"), pool1.getFirstAddress());
+ EXPECT_EQ(IOAddress("2001:db8:1::ffff:ffff:ffff:ffff"),
+ pool1.getLastAddress());
+
+ // This is Pool6, IPv4 addresses do not belong here
+ EXPECT_THROW(Pool6(Pool6::TYPE_IA, IOAddress("2001:db8::1"),
+ IOAddress("192.168.0.5")), BadValue);
+ EXPECT_THROW(Pool6(Pool6::TYPE_IA, IOAddress("192.168.0.2"),
+ IOAddress("2001:db8::1")), BadValue);
+
+ // Should throw. Range should be 2001:db8::1 - 2001:db8::2, not
+ // the other way around.
+ EXPECT_THROW(Pool6(Pool6::TYPE_IA, IOAddress("2001:db8::2"),
+ IOAddress("2001:db8::1")), BadValue);
+}
+
+TEST(Pool6Test, constructor_prefix_len) {
+
+ // let's construct 2001:db8:1::/96 pool
+ Pool6 pool1(Pool6::TYPE_IA, IOAddress("2001:db8:1::"), 96);
+
+ EXPECT_EQ(Pool6::TYPE_IA, pool1.getType());
+ EXPECT_EQ("2001:db8:1::", pool1.getFirstAddress().toText());
+ EXPECT_EQ("2001:db8:1::ffff:ffff", pool1.getLastAddress().toText());
+
+ // No such thing as /130 prefix
+ EXPECT_THROW(Pool6(Pool6::TYPE_IA, IOAddress("2001:db8::"), 130),
+ BadValue);
+
+ // /0 prefix does not make sense
+ EXPECT_THROW(Pool6(Pool6::TYPE_IA, IOAddress("2001:db8::"), 0),
+ BadValue);
+
+ // This is Pool6, IPv4 addresses do not belong here
+ EXPECT_THROW(Pool6(Pool6::TYPE_IA, IOAddress("192.168.0.2"), 96),
+ BadValue);
+}
+
+TEST(Pool6Test, in_range) {
+ Pool6 pool1(Pool6::TYPE_IA, IOAddress("2001:db8:1::1"),
+ IOAddress("2001:db8:1::f"));
+
+ EXPECT_FALSE(pool1.inRange(IOAddress("2001:db8:1::")));
+ EXPECT_TRUE(pool1.inRange(IOAddress("2001:db8:1::1")));
+ EXPECT_TRUE(pool1.inRange(IOAddress("2001:db8:1::7")));
+ EXPECT_TRUE(pool1.inRange(IOAddress("2001:db8:1::f")));
+ EXPECT_FALSE(pool1.inRange(IOAddress("2001:db8:1::10")));
+ EXPECT_FALSE(pool1.inRange(IOAddress("::")));
+}
+
+// This test creates 100 pools and verifies that their IDs are unique.
+TEST(Pool6Test, unique_id) {
+
+ const int num_pools = 100;
+ std::vector<Pool6Ptr> pools;
+
+ for (int i = 0; i < num_pools; ++i) {
+ pools.push_back(Pool6Ptr(new Pool6(Pool6::TYPE_IA, IOAddress("2001:db8:1::"),
+ IOAddress("2001:db8:1::ffff:ffff:ffff:ffff"))));
+ }
+
+ for (int i = 0; i < num_pools; ++i) {
+ for (int j = i + 1; j < num_pools; ++j) {
+ if (pools[i]->getId() == pools[j]->getId()) {
+ FAIL() << "Pool-ids must be unique";
+ }
+ }
+ }
+
+}
+
+}; // end of anonymous namespace
+
diff --git a/src/lib/dhcp/tests/run_unittests.cc b/src/lib/dhcp/tests/run_unittests.cc
index db27f76..0126645 100644
--- a/src/lib/dhcp/tests/run_unittests.cc
+++ b/src/lib/dhcp/tests/run_unittests.cc
@@ -13,7 +13,6 @@
// PERFORMANCE OF THIS SOFTWARE.
#include <gtest/gtest.h>
-
#include <log/logger_support.h>
int
diff --git a/src/lib/dhcp/tests/subnet_unittest.cc b/src/lib/dhcp/tests/subnet_unittest.cc
new file mode 100644
index 0000000..6afebb8
--- /dev/null
+++ b/src/lib/dhcp/tests/subnet_unittest.cc
@@ -0,0 +1,112 @@
+// Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+
+#include <config.h>
+#include <dhcp/subnet.h>
+#include <exceptions/exceptions.h>
+#include <boost/scoped_ptr.hpp>
+#include <gtest/gtest.h>
+#include <asiolink/io_address.h>
+
+// don't import the entire boost namespace. It will unexpectedly hide uint8_t
+// for some systems.
+using boost::scoped_ptr;
+using namespace isc;
+using namespace isc::dhcp;
+using namespace isc::asiolink;
+
+namespace {
+
+TEST(Subnet6Test, constructor) {
+
+ EXPECT_NO_THROW(Subnet6 subnet1(IOAddress("2001:db8:1::"), 64,
+ 1, 2, 3, 4));
+
+ EXPECT_THROW(Subnet6 subnet2(IOAddress("2001:db8:1::"), 129, 1, 2, 3, 4),
+ BadValue); // invalid prefix length
+ EXPECT_THROW(Subnet6 subnet3(IOAddress("192.168.0.0"), 32, 1, 2, 3, 4),
+ BadValue); // IPv4 addresses are not allowed in Subnet6
+}
+
+TEST(Subnet6Test, in_range) {
+ Subnet6 subnet(IOAddress("2001:db8:1::"), 64, 1000, 2000, 3000, 4000);
+
+ EXPECT_EQ(1000, subnet.getT1());
+ EXPECT_EQ(2000, subnet.getT2());
+ EXPECT_EQ(3000, subnet.getPreferred());
+ EXPECT_EQ(4000, subnet.getValid());
+
+
+ EXPECT_FALSE(subnet.inRange(IOAddress("2001:db8:0:ffff:ffff:ffff:ffff:ffff")));
+ EXPECT_TRUE(subnet.inRange(IOAddress("2001:db8:1::0")));
+ EXPECT_TRUE(subnet.inRange(IOAddress("2001:db8:1::1")));
+ EXPECT_TRUE(subnet.inRange(IOAddress("2001:db8:1::ffff:ffff:ffff:ffff")));
+ EXPECT_FALSE(subnet.inRange(IOAddress("2001:db8:1:1::")));
+ EXPECT_FALSE(subnet.inRange(IOAddress("::")));
+}
+
+TEST(Subnet6Test, Pool6InSubnet6) {
+
+ Subnet6Ptr subnet(new Subnet6(IOAddress("2001:db8:1::"), 56, 1, 2, 3, 4));
+
+ Pool6Ptr pool1(new Pool6(Pool6::TYPE_IA, IOAddress("2001:db8:1:1::"), 64));
+ Pool6Ptr pool2(new Pool6(Pool6::TYPE_IA, IOAddress("2001:db8:1:2::"), 64));
+ Pool6Ptr pool3(new Pool6(Pool6::TYPE_IA, IOAddress("2001:db8:1:3::"), 64));
+
+ subnet->addPool6(pool1);
+
+ // If there's only one pool, get that pool
+ Pool6Ptr mypool = subnet->getPool6();
+ EXPECT_EQ(mypool, pool1);
+
+
+ subnet->addPool6(pool2);
+ subnet->addPool6(pool3);
+
+ // If there are more than one pool and we didn't provide hint, we
+ // should get the first pool
+ mypool = subnet->getPool6();
+
+ EXPECT_EQ(mypool, pool1);
+
+ // If we provide a hint, we should get a pool that this hint belongs to
+ mypool = subnet->getPool6(IOAddress("2001:db8:1:3::dead:beef"));
+
+ EXPECT_EQ(mypool, pool3);
+
+}
+
+TEST(Subnet6Test, Subnet6_Pool6_checks) {
+
+ Subnet6Ptr subnet(new Subnet6(IOAddress("2001:db8:1::"), 56, 1, 2, 3, 4));
+
+ // this one is in subnet
+ Pool6Ptr pool1(new Pool6(Pool6::TYPE_IA, IOAddress("2001:db8:1:1::"), 64));
+ subnet->addPool6(pool1);
+
+ // this one is larger than the subnet!
+ Pool6Ptr pool2(new Pool6(Pool6::TYPE_IA, IOAddress("2001:db8::"), 48));
+
+ EXPECT_THROW(subnet->addPool6(pool2), BadValue);
+
+
+ // this one is totally out of blue
+ Pool6Ptr pool3(new Pool6(Pool6::TYPE_IA, IOAddress("3000::"), 16));
+ EXPECT_THROW(subnet->addPool6(pool3), BadValue);
+
+}
+
+
+};
diff --git a/src/lib/dhcp/tests/triplet_unittest.cc b/src/lib/dhcp/tests/triplet_unittest.cc
new file mode 100644
index 0000000..727eb8a
--- /dev/null
+++ b/src/lib/dhcp/tests/triplet_unittest.cc
@@ -0,0 +1,104 @@
+// Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <config.h>
+#include <stdint.h>
+#include <gtest/gtest.h>
+#include <dhcp/triplet.h>
+#include <exceptions/exceptions.h>
+
+using namespace isc::dhcp;
+using namespace isc;
+
+namespace {
+
+// constructor validation
+TEST(TripletTest, constructor) {
+
+ const uint32_t min = 10;
+ const uint32_t value = 20;
+ const uint32_t max = 30;
+
+ Triplet<uint32_t> x(min, value, max);
+
+ EXPECT_EQ(min, x.getMin());
+ EXPECT_EQ(value, x.get());
+ EXPECT_EQ(max, x.getMax());
+
+ // requested values below min should return allowed min value
+ EXPECT_EQ(min, x.get(min - 5));
+
+ EXPECT_EQ(min, x.get(min));
+
+ // requesting a value from within the range (min < x < max) should
+ // return the requested value
+ EXPECT_EQ(17, x.get(17));
+
+ EXPECT_EQ(max, x.get(max));
+
+ EXPECT_EQ(max, x.get(max + 5));
+
+ // this will be boring. It is expected to return 42 no matter what
+ Triplet<uint32_t> y(42);
+
+ EXPECT_EQ(42, y.getMin()); // min, default and max are equal to 42
+ EXPECT_EQ(42, y.get()); // it returns ...
+ EXPECT_EQ(42, y.getMax()); // the exact value...
+
+ // requested values below or above are ignore
+ EXPECT_EQ(42, y.get(5)); // all...
+ EXPECT_EQ(42, y.get(42)); // the...
+ EXPECT_EQ(42, y.get(80)); // time!
+}
+
+// Triplets must be easy to use.
+// Simple to/from int conversions must be done on the fly.
+TEST(TripletTest, operator) {
+
+ uint32_t x = 47;
+
+ Triplet<uint32_t> foo(1,2,3);
+ Triplet<uint32_t> bar(4,5,6);
+
+ foo = bar;
+
+ EXPECT_EQ(4, foo.getMin());
+ EXPECT_EQ(5, foo.get());
+ EXPECT_EQ(6, foo.getMax());
+
+ // assignment operator: uint32_t => triplet
+ Triplet<uint32_t> y(0);
+ y = x;
+
+ EXPECT_EQ(x, y.get());
+
+ // let's try the other way around: triplet => uint32_t
+ uint32_t z = 0;
+ z = y;
+
+ EXPECT_EQ(x, z);
+}
+
+// check if specified values are sane
+TEST(TripletTest, sanity_check) {
+
+ // min is larger than default
+ EXPECT_THROW(Triplet<uint32_t>(6,5,5), BadValue);
+
+ // max is smaller than default
+ EXPECT_THROW(Triplet<uint32_t>(5,5,4), BadValue);
+
+}
+
+}; // end of anonymous namespace
diff --git a/src/lib/dhcp/triplet.h b/src/lib/dhcp/triplet.h
new file mode 100644
index 0000000..d45f003
--- /dev/null
+++ b/src/lib/dhcp/triplet.h
@@ -0,0 +1,110 @@
+// Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <exceptions/exceptions.h>
+
+namespace isc {
+namespace dhcp {
+
+/// @brief this template specifies a parameter value
+///
+/// This template class is used to store configuration parameters, like lifetime or T1.
+/// It defines 3 parameters: min, default, and max value. There are 2 constructors:
+/// - simple (just one value that sets all parameters)
+/// - extended (that sets default value and two thresholds)
+/// It will be used with integer types. It provides necessary operators, so
+/// it can be assigned to a plain integer or integer assigned to a Triplet.
+/// See TripletTest.operator test for details on an easy Triplet usage.
+template <class T>
+class Triplet {
+public:
+
+ /// @brief base type to Triple conversion
+ ///
+ /// Typically: uint32_t to Triplet assignment. It is very convenient
+ /// to be able to simply write Triplet<uint32_t> x = 7;
+ Triplet<T> operator=(T other) {
+ min_ = other;
+ default_ = other;
+ max_ = other;
+ return *this;
+ }
+
+ /// @brief triplet to base type conversion
+ ///
+ /// Typically: Triplet to uint32_t assignment. It is very convenient
+ /// to be able to simply write uint32_t z = x; (where x is a Triplet)
+ operator T() const {
+ return (default_);
+ }
+
+ /// @brief sets a fixed value
+ ///
+ /// This constructor assigns a fixed (i.e. no range, just a single value)
+ /// value.
+ Triplet(T value)
+ :min_(value), default_(value), max_(value) {
+ }
+
+ /// @brief sets the default value and thresholds
+ ///
+ /// @throw BadValue if min <= def <= max rule is violated
+ Triplet(T min, T def, T max)
+ :min_(min), default_(def), max_(max) {
+ if ( (min_ > def) || (def > max_) ) {
+ isc_throw(BadValue, "Invalid triplet values.");
+ }
+ }
+
+ /// @brief returns a minimum allowed value
+ T getMin() const { return min_;}
+
+ /// @brief returns the default value
+ T get() const { return default_;}
+
+ /// @brief returns value with a hint
+ ///
+ /// DHCP protocol treats any values sent by a client as hints.
+ /// This is a method that implements that. We can assign any value
+ /// from configured range that client asks.
+ T get(T hint) const {
+ if (hint <= min_) {
+ return (min_);
+ }
+
+ if (hint >= max_) {
+ return (max_);
+ }
+
+ return (hint);
+ }
+
+ /// @brief returns a maximum allowed value
+ T getMax() const { return max_; }
+
+protected:
+
+ /// @brief the minimum value
+ T min_;
+
+ /// @brief the default value
+ T default_;
+
+ /// @brief the maximum value
+ T max_;
+};
+
+
+} // namespace isc::dhcp
+} // namespace isc
diff --git a/src/lib/dns/benchmarks/message_renderer_bench.cc b/src/lib/dns/benchmarks/message_renderer_bench.cc
index 6376498..abf3192 100644
--- a/src/lib/dns/benchmarks/message_renderer_bench.cc
+++ b/src/lib/dns/benchmarks/message_renderer_bench.cc
@@ -39,7 +39,7 @@ public:
renderer_(NULL),
names_(names)
{}
- MessageRendererBenchMark() {
+ ~MessageRendererBenchMark() {
delete renderer_;
}
unsigned int run() {
diff --git a/src/lib/dns/benchmarks/rdatarender_bench.cc b/src/lib/dns/benchmarks/rdatarender_bench.cc
index 38ee2ac..65576ee 100644
--- a/src/lib/dns/benchmarks/rdatarender_bench.cc
+++ b/src/lib/dns/benchmarks/rdatarender_bench.cc
@@ -42,9 +42,10 @@ template <typename T>
class RdataRenderBenchMark {
public:
RdataRenderBenchMark(const vector<T>& dataset) :
- dataset_(dataset)
+ dataset_(dataset),
+ renderer_(NULL)
{}
- RdataRenderBenchMark() {
+ ~RdataRenderBenchMark() {
delete renderer_;
}
unsigned int run() {
diff --git a/src/lib/dns/python/edns_python.cc b/src/lib/dns/python/edns_python.cc
index 8f0f1a4..e9d54c1 100644
--- a/src/lib/dns/python/edns_python.cc
+++ b/src/lib/dns/python/edns_python.cc
@@ -269,7 +269,6 @@ EDNS_createFromRR(const s_EDNS* null_self, PyObject* args) {
const PyObject* rrtype;
const PyObject* rrttl;
const PyObject* rdata;
- s_EDNS* edns_obj = NULL;
assert(null_self == NULL);
@@ -277,7 +276,7 @@ EDNS_createFromRR(const s_EDNS* null_self, PyObject* args) {
&rrclass_type, &rrclass, &rrtype_type, &rrtype,
&rrttl_type, &rrttl, &rdata_type, &rdata)) {
uint8_t extended_rcode;
- edns_obj = PyObject_New(s_EDNS, &edns_type);
+ s_EDNS* edns_obj = PyObject_New(s_EDNS, &edns_type);
if (edns_obj == NULL) {
return (NULL);
}
diff --git a/src/lib/dns/rdata/generic/afsdb_18.cc b/src/lib/dns/rdata/generic/afsdb_18.cc
index 6afc4de..ec76ee0 100644
--- a/src/lib/dns/rdata/generic/afsdb_18.cc
+++ b/src/lib/dns/rdata/generic/afsdb_18.cc
@@ -57,7 +57,6 @@ AFSDB::AFSDB(const std::string& afsdb_str) :
try {
const uint32_t subtype = tokenToNum<int32_t, 16>(getToken(iss));
const Name servername(getToken(iss));
- string server;
if (!iss.eof()) {
isc_throw(InvalidRdataText, "Unexpected input for AFSDB"
diff --git a/src/lib/dns/tests/rrparamregistry_unittest.cc b/src/lib/dns/tests/rrparamregistry_unittest.cc
index d2bec5c..c155b53 100644
--- a/src/lib/dns/tests/rrparamregistry_unittest.cc
+++ b/src/lib/dns/tests/rrparamregistry_unittest.cc
@@ -37,6 +37,7 @@ protected:
{
ostringstream oss1;
oss1 << test_class_code;
+ // cppcheck-suppress useInitializationList
test_class_unknown_str = "CLASS" + oss1.str();
ostringstream oss2;
@@ -60,7 +61,7 @@ protected:
// we assume class/type numbers are officially unassigned. If not we'll
// need to update the test cases.
- static const uint16_t test_class_code = 65533;
+ static const uint16_t test_class_code = 65533;
static const uint16_t test_type_code = 65534;
static const string test_class_str;
static const string test_type_str;
@@ -77,7 +78,7 @@ TEST_F(RRParamRegistryTest, addRemove) {
// the first removal attempt should succeed
EXPECT_TRUE(RRParamRegistry::getRegistry().removeType(test_type_code));
- // then toText() should treat it as an "unknown"
+ // then toText() should treat it as an "unknown"
EXPECT_EQ(test_type_unknown_str, RRType(test_type_code).toText());
// attempt of removing non-existent mapping should result in 'false'
EXPECT_FALSE(RRParamRegistry::getRegistry().removeType(test_type_code));
diff --git a/src/lib/log/compiler/message.cc b/src/lib/log/compiler/message.cc
index 86c5f20..ef62b2f 100644
--- a/src/lib/log/compiler/message.cc
+++ b/src/lib/log/compiler/message.cc
@@ -109,11 +109,13 @@ currentTime() {
// Get a text representation of the current time.
time_t curtime;
time(&curtime);
- char* buffer = ctime(&curtime);
+ struct tm* timeinfo;
+ timeinfo = localtime(&curtime);
- // Convert to string and strip out the trailing newline
- string current_time = buffer;
- return (isc::util::str::trim(current_time));
+ char buffer[80];
+ strftime(buffer, 80, "%a %b %d %Y %H:%M", timeinfo);
+
+ return (std::string(buffer));
}
diff --git a/src/lib/log/tests/logger_example.cc b/src/lib/log/tests/logger_example.cc
index 6f95e5d..08c9084 100644
--- a/src/lib/log/tests/logger_example.cc
+++ b/src/lib/log/tests/logger_example.cc
@@ -118,7 +118,6 @@ int main(int argc, char** argv) {
LoggerSpecification cur_spec(ROOT_NAME);// Current specification
OutputOption cur_opt; // Current output option
vector<LoggerSpecification> loggers; // Set of logger specifications
- vector<OutputOption> options; // Output options for logger
std::string severity; // Severity set for logger
// Initialize logging system - set the root logger name.
diff --git a/src/lib/python/isc/config/ccsession.py b/src/lib/python/isc/config/ccsession.py
index a95316d..8464a01 100644
--- a/src/lib/python/isc/config/ccsession.py
+++ b/src/lib/python/isc/config/ccsession.py
@@ -575,7 +575,7 @@ class UIModuleCCSession(MultiConfigData):
# for type any, we determine the 'type' by what value is set
# (which would be either list or dict)
cur_value, _ = self.get_value(identifier)
- type_any = module_spec['item_type'] == 'any'
+ type_any = isc.config.config_data.spec_part_is_any(module_spec)
# the specified element must be a list or a named_set
if 'list_item_spec' in module_spec or\
@@ -603,7 +603,7 @@ class UIModuleCCSession(MultiConfigData):
self._add_value_to_named_set(identifier, item_name,
item_value)
else:
- raise isc.cc.data.DataNotFoundError(str(identifier) + " is not a list or a named set")
+ raise isc.cc.data.DataTypeError(str(identifier) + " is not a list or a named set")
def _remove_value_from_list(self, identifier, value):
if value is None:
@@ -653,7 +653,7 @@ class UIModuleCCSession(MultiConfigData):
# for type any, we determine the 'type' by what value is set
# (which would be either list or dict)
cur_value, _ = self.get_value(identifier)
- type_any = module_spec['item_type'] == 'any'
+ type_any = isc.config.config_data.spec_part_is_any(module_spec)
# there's two forms of 'remove from list'; the remove-value-from-list
# form, and the 'remove-by-index' form. We can recognize the second
@@ -668,7 +668,7 @@ class UIModuleCCSession(MultiConfigData):
(type_any and type(cur_value) == dict):
self._remove_value_from_named_set(identifier, value_str)
else:
- raise isc.cc.data.DataNotFoundError(str(identifier) + " is not a list or a named_set")
+ raise isc.cc.data.DataTypeError(str(identifier) + " is not a list or a named_set")
diff --git a/src/lib/python/isc/config/config_data.py b/src/lib/python/isc/config/config_data.py
index 413d052..ae61e2a 100644
--- a/src/lib/python/isc/config/config_data.py
+++ b/src/lib/python/isc/config/config_data.py
@@ -45,6 +45,13 @@ def spec_part_is_named_set(spec_part):
named_set specification, and False otherwise."""
return (type(spec_part) == dict and 'named_set_item_spec' in spec_part)
+def spec_part_is_any(spec_part):
+ """Returns true if the given spec_part specifies an element of type
+ any, and False otherwise.
+ """
+ return (type(spec_part) == dict and 'item_type' in spec_part and
+ spec_part['item_type'] == "any")
+
def check_type(spec_part, value):
"""Does nothing if the value is of the correct type given the
specification part relevant for the value. Raises an
@@ -237,7 +244,8 @@ def spec_name_list(spec, prefix="", recurse=False):
elif 'named_set_item_spec' in spec:
# we added a '/' above, but in this one case we don't want it
result.append(prefix[:-1])
- else:
+ # ignore any
+ elif not spec_part_is_any(spec):
for name in spec:
result.append(prefix + name + "/")
if recurse:
@@ -392,14 +400,25 @@ class MultiConfigData:
identifier, or None if not found. The first part of the
identifier (up to the first /) is interpreted as the module
name. Returns None if not found, or if identifier is not a
- string."""
+ string.
+ If an index is given for a List-type element, it returns
+ the specification of the list elements, not of the list itself
+ """
if type(identifier) != str or identifier == "":
return None
if identifier[0] == '/':
identifier = identifier[1:]
module, sep, id = identifier.partition("/")
+ if id != "":
+ id, indices = isc.cc.data.split_identifier_list_indices(id)
+ else:
+ indices = None
try:
- return find_spec_part(self._specifications[module].get_config_spec(), id)
+ spec_part = find_spec_part(self._specifications[module].get_config_spec(), id)
+ if indices is not None and spec_part_is_list(spec_part):
+ return spec_part['list_item_spec']
+ else:
+ return spec_part
except isc.cc.data.DataNotFoundError as dnfe:
return None
except KeyError as ke:
@@ -780,19 +799,75 @@ class MultiConfigData:
indices and named_set names to the completion list. If
the given item_name is for a list or named_set, it'll
return a list of those (appended to item_name), otherwise
- the list will only contain the item_name itself."""
+ the list will only contain the item_name itself.
+
+ If the item is a named set, and it's contents are maps
+ or named_sets as well, a / is appended to the result
+ strings.
+
+ If the item is a list, this method is then called recursively
+ for each list entry.
+
+ This behaviour is slightly arbitrary, and currently reflects
+ the most probable way the resulting data should look like;
+ for lists, bindctl would always expect their contents to
+ be added as well. For named_sets, however, we do not
+ do recursion, since the resulting list may be too long.
+ This will probably change in a revision of the way this
+ data is handled; ideally, the result should always recurse,
+ but only up to a limited depth, and the resulting list
+ should probably be paginated clientside.
+
+ Parameters:
+ item_name (string): the (full) identifier for the list or
+ named_set to enumerate.
+
+ Returns a list of strings with item names
+
+ Examples:
+ _get_list_items("Module/some_item")
+ where item is not a list of a named_set, or where
+ said list or named set is empty, returns
+ ["Module/some_item"]
+ _get_list_items("Module/named_set")
+ where the named_set contains items with names 'a'
+ and 'b', returns
+ [ "Module/named_set/a", "Module/named_set/b" ]
+ _get_list_items("Module/named_set_of_maps")
+ where the named_set contains items with names 'a'
+ and 'b', and those items are maps themselves
+ (or other named_sets), returns
+ [ "Module/named_set/a/", "Module/named_set/b/" ]
+ _get_list_items("Module/list")
+ where the list contains 2 elements, returns
+ [ "Module/list[0]", "Module/list[1]" ]
+ """
spec_part = self.find_spec_part(item_name)
- if 'item_type' in spec_part and \
- spec_part['item_type'] == 'named_set':
- subslash = ""
- if spec_part['named_set_item_spec']['item_type'] == 'map' or\
- spec_part['named_set_item_spec']['item_type'] == 'named_set':
- subslash = "/"
- values, status = self.get_value(item_name)
- if len(values) > 0:
+ if spec_part_is_named_set(spec_part):
+ values, _ = self.get_value(item_name)
+ if values is not None and len(values) > 0:
+ subslash = ""
+ if spec_part['named_set_item_spec']['item_type'] == 'map' or\
+ spec_part['named_set_item_spec']['item_type'] == 'named_set':
+ subslash = "/"
+ # Don't recurse for named_sets (so as not to return too
+ # much data), but do add a / so the client so that
+ # the user can immediately tab-complete further if needed.
return [ item_name + "/" + v + subslash for v in values.keys() ]
else:
return [ item_name ]
+ elif spec_part_is_list(spec_part):
+ values, _ = self.get_value(item_name)
+ if values is not None and len(values) > 0:
+ result = []
+ for i in range(len(values)):
+ name = item_name + '[%d]' % i
+ # Recurse for list entries, so that its sub-contents
+ # are also added to the result
+ result.extend(self._get_list_items(name))
+ return result
+ else:
+ return [ item_name ]
else:
return [ item_name ]
diff --git a/src/lib/python/isc/config/tests/ccsession_test.py b/src/lib/python/isc/config/tests/ccsession_test.py
index 0101d50..ad364ac 100644
--- a/src/lib/python/isc/config/tests/ccsession_test.py
+++ b/src/lib/python/isc/config/tests/ccsession_test.py
@@ -993,10 +993,15 @@ class TestUIModuleCCSession(unittest.TestCase):
self.assertRaises(isc.cc.data.DataNotFoundError, uccs.add_value, 1, "a")
self.assertRaises(isc.cc.data.DataNotFoundError, uccs.add_value, "no_such_item", "a")
- self.assertRaises(isc.cc.data.DataNotFoundError, uccs.add_value, "Spec2/item1", "a")
self.assertRaises(isc.cc.data.DataNotFoundError, uccs.remove_value, 1, "a")
self.assertRaises(isc.cc.data.DataNotFoundError, uccs.remove_value, "no_such_item", "a")
- self.assertRaises(isc.cc.data.DataNotFoundError, uccs.remove_value, "Spec2/item1", "a")
+ # add and remove should raise DataNotFoundError when used with items
+ # that are not a list or named_set (more importantly, they should
+ # not raise TypeError)
+ self.assertRaises(isc.cc.data.DataTypeError, uccs.add_value, "Spec2/item1", "a")
+ self.assertRaises(isc.cc.data.DataTypeError, uccs.remove_value, "Spec2/item1", "a")
+ self.assertRaises(isc.cc.data.DataTypeError, uccs.add_value, "Spec2", "")
+ self.assertRaises(isc.cc.data.DataTypeError, uccs.remove_value, "Spec2", "")
self.assertEqual({}, uccs._local_changes)
uccs.add_value("Spec2/item5", "foo")
@@ -1020,6 +1025,7 @@ class TestUIModuleCCSession(unittest.TestCase):
self.assertRaises(isc.cc.data.DataTypeError,
uccs.remove_value, "Spec2/item5", None)
+
# Check that the difference between no default and default = null
# is recognized
def test_default_null(self):
@@ -1042,9 +1048,9 @@ class TestUIModuleCCSession(unittest.TestCase):
items_as_str = [ '1234', 'foo', 'true', 'false' ]
def test_fails():
- self.assertRaises(isc.cc.data.DataNotFoundError, uccs.add_value, "Spec40/item1", "foo")
- self.assertRaises(isc.cc.data.DataNotFoundError, uccs.add_value, "Spec40/item1", "foo", "bar")
- self.assertRaises(isc.cc.data.DataNotFoundError, uccs.remove_value, "Spec40/item1", "foo")
+ self.assertRaises(isc.cc.data.DataTypeError, uccs.add_value, "Spec40/item1", "foo")
+ self.assertRaises(isc.cc.data.DataTypeError, uccs.add_value, "Spec40/item1", "foo", "bar")
+ self.assertRaises(isc.cc.data.DataTypeError, uccs.remove_value, "Spec40/item1", "foo")
self.assertRaises(isc.cc.data.DataTypeError, uccs.remove_value, "Spec40/item1[0]", None)
# A few helper functions to perform a number of tests
diff --git a/src/lib/python/isc/config/tests/config_data_test.py b/src/lib/python/isc/config/tests/config_data_test.py
index 86fbc11..45feb35 100644
--- a/src/lib/python/isc/config/tests/config_data_test.py
+++ b/src/lib/python/isc/config/tests/config_data_test.py
@@ -252,6 +252,18 @@ class TestConfigData(unittest.TestCase):
self.assertRaises(ConfigDataError, spec_name_list, 1)
self.assertRaises(ConfigDataError, spec_name_list, [ 'a' ])
+ # Test one with type any as well
+ module_spec = isc.config.module_spec_from_file(self.data_path + os.sep + "spec40.spec")
+ spec_part = module_spec.get_config_spec()
+ name_list = spec_name_list(module_spec.get_config_spec())
+ self.assertEqual(['item1', 'item2', 'item3'], name_list)
+
+ # item3 itself is 'empty'
+ spec_part = find_spec_part(spec_part, 'item3')
+ name_list = spec_name_list(spec_part)
+ self.assertEqual([], name_list)
+
+
def test_init(self):
self.assertRaises(ConfigDataError, ConfigData, "asdf")
@@ -377,12 +389,37 @@ class TestMultiConfigData(unittest.TestCase):
self.assertEqual(None, spec_part)
spec_part = self.mcd.find_spec_part("/Spec2/item1")
self.assertEqual(None, spec_part)
- module_spec = isc.config.module_spec_from_file(self.data_path + os.sep + "spec2.spec")
+ module_spec = isc.config.module_spec_from_file(self.data_path +
+ os.sep + "spec2.spec")
self.mcd.set_specification(module_spec)
spec_part = self.mcd.find_spec_part("Spec2/item1")
- self.assertEqual({'item_name': 'item1', 'item_type': 'integer', 'item_optional': False, 'item_default': 1, }, spec_part)
+ self.assertEqual({'item_name': 'item1', 'item_type': 'integer',
+ 'item_optional': False, 'item_default': 1, },
+ spec_part)
+
+ # For lists, either the spec of the list itself, or the
+ # spec for the list contents should be returned (the
+ # latter when an index is given in the identifier)
+ spec_part = self.mcd.find_spec_part("Spec2/item5")
+ self.assertEqual({'item_default': ['a', 'b'],
+ 'item_name': 'item5',
+ 'item_optional': False,
+ 'item_type': 'list',
+ 'list_item_spec': {'item_default': '',
+ 'item_name': 'list_element',
+ 'item_optional': False,
+ 'item_type': 'string'}},
+ spec_part)
+ spec_part = self.mcd.find_spec_part("Spec2/item5[0]")
+ self.assertEqual({'item_default': '',
+ 'item_name': 'list_element',
+ 'item_optional': False,
+ 'item_type': 'string'},
+ spec_part)
+
def test_find_spec_part_nested(self):
+ # Check that find_spec_part works for nested lists
module_spec = isc.config.module_spec_from_file(self.data_path + os.sep + "spec30.spec")
self.mcd.set_specification(module_spec)
spec_part = self.mcd.find_spec_part("/lists/first_list_items[0]/second_list_items[1]/final_element")
@@ -391,6 +428,7 @@ class TestMultiConfigData(unittest.TestCase):
self.assertEqual(None, spec_part)
def test_find_spec_part_nested2(self):
+ # Check that find_spec_part works for nested lists and maps
module_spec = isc.config.module_spec_from_file(self.data_path + os.sep + "spec31.spec")
self.mcd.set_specification(module_spec)
spec_part = self.mcd.find_spec_part("/lists/first_list_items[0]/second_list_items[1]/map_element/list1[1]/list2[2]")
@@ -638,7 +676,7 @@ class TestMultiConfigData(unittest.TestCase):
self.assertEqual(expected, maps)
# A slash at the end should not produce different output with
- # indices too
+ # indices either
expected2 = [{'default': True,
'type': 'integer',
'name': 'Spec22/value5[1]',
@@ -720,6 +758,8 @@ class TestMultiConfigData(unittest.TestCase):
self.assertRaises(isc.cc.data.DataNotFoundError, self.mcd.unset, "Spec2/doesnotexist")
def test_get_config_item_list(self):
+ # Test get_config_item_list(), which returns a list of the config
+ # items in a specification.
config_items = self.mcd.get_config_item_list()
self.assertEqual([], config_items)
module_spec = isc.config.module_spec_from_file(self.data_path + os.sep + "spec2.spec")
@@ -729,15 +769,42 @@ class TestMultiConfigData(unittest.TestCase):
config_items = self.mcd.get_config_item_list(None, False)
self.assertEqual(['Spec2'], config_items)
config_items = self.mcd.get_config_item_list(None, True)
- self.assertEqual(['Spec2/item1', 'Spec2/item2', 'Spec2/item3', 'Spec2/item4', 'Spec2/item5', 'Spec2/item6/value1', 'Spec2/item6/value2'], config_items)
+ self.assertEqual(['Spec2/item1', 'Spec2/item2', 'Spec2/item3',
+ 'Spec2/item4', 'Spec2/item5', 'Spec2/item6/value1',
+ 'Spec2/item6/value2'], config_items)
config_items = self.mcd.get_config_item_list("Spec2", True)
- self.assertEqual(['Spec2/item1', 'Spec2/item2', 'Spec2/item3', 'Spec2/item4', 'Spec2/item5', 'Spec2/item6/value1', 'Spec2/item6/value2'], config_items)
+ self.assertEqual(['Spec2/item1', 'Spec2/item2', 'Spec2/item3',
+ 'Spec2/item4', 'Spec2/item5[0]', 'Spec2/item5[1]',
+ 'Spec2/item6/value1', 'Spec2/item6/value2'],
+ config_items)
config_items = self.mcd.get_config_item_list("Spec2")
- self.assertEqual(['Spec2/item1', 'Spec2/item2', 'Spec2/item3', 'Spec2/item4', 'Spec2/item5', 'Spec2/item6'], config_items)
+ self.assertEqual(['Spec2/item1', 'Spec2/item2', 'Spec2/item3',
+ 'Spec2/item4', 'Spec2/item5[0]', 'Spec2/item5[1]',
+ 'Spec2/item6'], config_items)
config_items = self.mcd.get_config_item_list("/Spec2")
- self.assertEqual(['Spec2/item1', 'Spec2/item2', 'Spec2/item3', 'Spec2/item4', 'Spec2/item5', 'Spec2/item6'], config_items)
+ self.assertEqual(['Spec2/item1', 'Spec2/item2', 'Spec2/item3',
+ 'Spec2/item4', 'Spec2/item5[0]', 'Spec2/item5[1]',
+ 'Spec2/item6'], config_items)
+ config_items = self.mcd.get_config_item_list("Spec2", True)
+ self.assertEqual(['Spec2/item1', 'Spec2/item2', 'Spec2/item3',
+ 'Spec2/item4', 'Spec2/item5[0]', 'Spec2/item5[1]',
+ 'Spec2/item6/value1', 'Spec2/item6/value2'],
+ config_items)
+
+ # When lists are empty, it should only show the name
+ self.mcd.set_value('Spec2/item5', [])
config_items = self.mcd.get_config_item_list("Spec2", True)
- self.assertEqual(['Spec2/item1', 'Spec2/item2', 'Spec2/item3', 'Spec2/item4', 'Spec2/item5', 'Spec2/item6/value1', 'Spec2/item6/value2'], config_items)
+ self.assertEqual(['Spec2/item1', 'Spec2/item2', 'Spec2/item3',
+ 'Spec2/item4', 'Spec2/item5', 'Spec2/item6/value1',
+ 'Spec2/item6/value2'], config_items)
+
+ # Also if the list is None (optional value and no default)
+ module_spec = isc.config.module_spec_from_file(self.data_path
+ + os.sep
+ + "spec42.spec")
+ self.mcd.set_specification(module_spec)
+ config_items = self.mcd.get_config_item_list("Spec42", True)
+ self.assertEqual(['Spec42/list_item'], config_items)
def test_is_named_set(self):
module_spec = isc.config.module_spec_from_file(self.data_path + os.sep + "spec32.spec")
@@ -756,7 +823,8 @@ class TestMultiConfigData(unittest.TestCase):
self.assertEqual(['Spec32'], config_items)
config_items = self.mcd.get_config_item_list(None, True)
self.assertEqual(['Spec32/named_set_item', 'Spec32/named_set_item2',
- 'Spec32/named_set_item3'], config_items)
+ 'Spec32/named_set_item3', 'Spec32/named_set_item4'],
+ config_items)
self.mcd.set_value('Spec32/named_set_item', { "aaaa": 4, "aabb": 5,
"bbbb": 6})
config_items = self.mcd.get_config_item_list("/Spec32/named_set_item",
@@ -766,6 +834,19 @@ class TestMultiConfigData(unittest.TestCase):
'Spec32/named_set_item/bbbb',
], config_items)
+ self.mcd.set_value('Spec32/named_set_item', {})
+ config_items = self.mcd.get_config_item_list("/Spec32/named_set_item",
+ True)
+ self.assertEqual(['Spec32/named_set_item'], config_items)
+
+ self.mcd.set_value('Spec32/named_set_item4', { "a": { "aa": 4 } } )
+ config_items = self.mcd.get_config_item_list("/Spec32/named_set_item4",
+ True)
+ self.assertEqual(['Spec32/named_set_item4/a/'], config_items)
+ config_items = self.mcd.get_config_item_list("/Spec32/named_set_item4/a",
+ True)
+ self.assertEqual(['Spec32/named_set_item4/a/aa'], config_items)
+
def test_set_named_set_nonlocal(self):
# Test whether a default named set is copied to local if a subitem
# is changed, and that other items in the set do not get lost
diff --git a/src/lib/resolve/recursive_query.cc b/src/lib/resolve/recursive_query.cc
index 8d03c1c..c5b280f 100644
--- a/src/lib/resolve/recursive_query.cc
+++ b/src/lib/resolve/recursive_query.cc
@@ -176,7 +176,7 @@ class RunningQuery : public IOFetch::Callback {
class ResolverNSASCallback : public isc::nsas::AddressRequestCallback {
public:
ResolverNSASCallback(RunningQuery* rq) : rq_(rq) {}
-
+
void success(const isc::nsas::NameserverAddress& address) {
// Success callback, send query to found namesever
LOG_DEBUG(isc::resolve::logger, RESLIB_DBG_CB, RESLIB_RUNQ_SUCCESS)
@@ -184,7 +184,7 @@ public:
rq_->nsasCallbackCalled();
rq_->sendTo(address);
}
-
+
void unreachable() {
// Nameservers unreachable: drop query or send servfail?
LOG_DEBUG(isc::resolve::logger, RESLIB_DBG_CB, RESLIB_RUNQ_FAIL);
@@ -261,7 +261,7 @@ private:
bool done_;
// If we have a client timeout, we call back with a failure message,
- // but we do not stop yet. We use this variable to make sure we
+ // but we do not stop yet. We use this variable to make sure we
// don't call back a second time later
bool callback_called_;
@@ -270,7 +270,7 @@ private:
// Reference to our cache
isc::cache::ResolverCache& cache_;
-
+
// the 'current' zone we are in (i.e.) we start out at the root,
// and for each delegation this gets updated with the zone the
// delegation points to.
@@ -278,7 +278,7 @@ private:
// of the call we use it in take a string, we need update those
// too).
std::string cur_zone_;
-
+
// This is the handler we pass on to the NSAS; it is called when
// the NSAS has an address for us to query
boost::shared_ptr<ResolverNSASCallback> nsas_callback_;
@@ -295,7 +295,7 @@ private:
// The moment in time we sent a query to the nameserver above.
struct timeval current_ns_qsent_time;
-
+
// RunningQuery deletes itself when it is done. In order for us
// to do this safely, we must make sure that there are no events
// that might call back to it. There are two types of events in
@@ -365,7 +365,7 @@ private:
io_.get_io_service().post(query);
}
}
-
+
// 'general' send, ask the NSAS to give us an address.
void send(IOFetch::Protocol protocol = IOFetch::UDP, bool edns = true) {
protocol_ = protocol; // Store protocol being used for this
@@ -397,7 +397,7 @@ private:
nsas_.lookup(cur_zone_, question_.getClass(), nsas_callback_);
}
}
-
+
// Called by our NSAS callback handler so we know we do not have
// an outstanding NSAS call anymore.
void nsasCallbackCalled() {
@@ -422,13 +422,13 @@ private:
// here (classify() will set it when it walks through
// the cname chain to verify it).
Name cname_target(question_.getName());
-
+
isc::resolve::ResponseClassifier::Category category =
isc::resolve::ResponseClassifier::classify(
question_, incoming, cname_target, cname_count_);
bool found_ns = false;
-
+
switch (category) {
case isc::resolve::ResponseClassifier::ANSWER:
case isc::resolve::ResponseClassifier::ANSWERCNAME:
@@ -569,7 +569,7 @@ private:
// SERVFAIL if we get FORMERR instead
}
goto SERVFAIL;
-
+
default:
SERVFAIL:
// Some error in received packet it. Report it and return SERVFAIL
@@ -718,7 +718,7 @@ public:
++outstanding_events_;
lookup_timer.async_wait(boost::bind(&RunningQuery::lookupTimeout, this));
}
-
+
// Setup the timer to send an answer (client_timeout)
if (client_timeout >= 0) {
client_timer.expires_from_now(
@@ -726,7 +726,7 @@ public:
++outstanding_events_;
client_timer.async_wait(boost::bind(&RunningQuery::clientTimeout, this));
}
-
+
doLookup();
}
@@ -741,7 +741,7 @@ public:
--outstanding_events_;
stop();
}
-
+
// called if we have a client timeout; if our callback has
// not been called, call it now. But do not stop.
void clientTimeout() {
@@ -810,7 +810,7 @@ public:
// XXX is this the place for TCP retry?
assert(outstanding_events_ > 0);
--outstanding_events_;
-
+
if (!done_ && result != IOFetch::TIME_OUT) {
// we got an answer
@@ -890,7 +890,7 @@ public:
stop();
}
}
-
+
// Clear the answer parts of answer_message, and set the rcode
// to servfail
void makeSERVFAIL() {
@@ -1096,7 +1096,7 @@ RecursiveQuery::resolve(const QuestionPtr& question,
// Message found, return that
LOG_DEBUG(isc::resolve::logger, RESLIB_DBG_CACHE, RESLIB_RECQ_CACHE_FIND)
.arg(questionText(*question)).arg(1);
-
+
// TODO: err, should cache set rcode as well?
answer_message->setRcode(Rcode::NOERROR());
callback->success(answer_message);
@@ -1146,11 +1146,11 @@ RecursiveQuery::resolve(const Question& question,
// TODO: general 'prepareinitialanswer'
answer_message->setOpcode(isc::dns::Opcode::QUERY());
answer_message->addQuestion(question);
-
+
// First try to see if we have something cached in the messagecache
LOG_DEBUG(isc::resolve::logger, RESLIB_DBG_TRACE, RESLIB_RESOLVE)
.arg(questionText(question)).arg(2);
-
+
if (cache_.lookup(question.getName(), question.getType(),
question.getClass(), *answer_message) &&
answer_message->getRRCount(Message::SECTION_ANSWER) > 0) {
@@ -1181,7 +1181,7 @@ RecursiveQuery::resolve(const Question& question,
// delete itself when it is done
LOG_DEBUG(isc::resolve::logger, RESLIB_DBG_TRACE, RESLIB_RECQ_CACHE_NO_FIND)
.arg(questionText(question)).arg(2);
- new RunningQuery(io, question, answer_message,
+ new RunningQuery(io, question, answer_message,
test_server_, buffer, crs, query_timeout_,
client_timeout_, lookup_timeout_, retries_,
nsas_, cache_, rtt_recorder_);
diff --git a/src/lib/resolve/tests/recursive_query_unittest.cc b/src/lib/resolve/tests/recursive_query_unittest.cc
index 02721f1..4513458 100644
--- a/src/lib/resolve/tests/recursive_query_unittest.cc
+++ b/src/lib/resolve/tests/recursive_query_unittest.cc
@@ -218,7 +218,7 @@ protected:
}
// Receive a UDP packet from a mock server; used for testing
- // recursive lookup. The caller must place a RecursiveQuery
+ // recursive lookup. The caller must place a RecursiveQuery
// on the IO Service queue before running this routine.
void recvUDP(const int family, void* buffer, size_t& size) {
ScopedAddrInfo sai(resolveAddress(family, IPPROTO_UDP, true));
@@ -267,7 +267,7 @@ protected:
if (ret < 0) {
isc_throw(IOError, "recvfrom failed: " << strerror(errno));
}
-
+
// Pass the message size back via the size parameter
size = ret;
}
@@ -693,37 +693,6 @@ createTestSocket() {
return (sock.release());
}
-int
-setSocketTimeout(int sock, size_t tv_sec, size_t tv_usec) {
- const struct timeval timeo = { tv_sec, tv_usec };
- int recv_options = 0;
- if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &timeo, sizeof(timeo))) {
- if (errno == ENOPROTOOPT) { // see RecursiveQueryTest::recvUDP()
- recv_options = MSG_DONTWAIT;
- } else {
- isc_throw(IOError, "set RCVTIMEO failed: " << strerror(errno));
- }
- }
- return (recv_options);
-}
-
-// try to read from the socket max time
-// *num is incremented for every succesfull read
-// returns true if it can read max times, false otherwise
-bool tryRead(int sock, int recv_options, size_t max, int* num) {
- size_t i = 0;
- do {
- char inbuff[512];
- if (recv(sock, inbuff, sizeof(inbuff), recv_options) < 0) {
- return false;
- } else {
- ++i;
- ++*num;
- }
- } while (i < max);
- return true;
-}
-
// Mock resolver callback for testing forward query.
class MockResolverCallback : public isc::resolve::ResolverInterface::Callback {
public:
@@ -904,7 +873,7 @@ TEST_F(RecursiveQueryTest, lowtimeouts) {
TEST_F(RecursiveQueryTest, DISABLED_recursiveSendOk) {
setDNSService(true, false);
bool done;
-
+
MockServerStop server(io_service_, &done);
vector<pair<string, uint16_t> > empty_vector;
RecursiveQuery rq(*dns_service_, *nsas_, cache_, empty_vector,
@@ -930,7 +899,7 @@ TEST_F(RecursiveQueryTest, DISABLED_recursiveSendOk) {
TEST_F(RecursiveQueryTest, DISABLED_recursiveSendNXDOMAIN) {
setDNSService(true, false);
bool done;
-
+
MockServerStop server(io_service_, &done);
vector<pair<string, uint16_t> > empty_vector;
RecursiveQuery rq(*dns_service_, *nsas_, cache_, empty_vector,
diff --git a/src/lib/util/Makefile.am b/src/lib/util/Makefile.am
index c56e4b8..fe1b327 100644
--- a/src/lib/util/Makefile.am
+++ b/src/lib/util/Makefile.am
@@ -1,4 +1,4 @@
-SUBDIRS = . io unittests tests pyunittests python
+SUBDIRS = . io unittests tests pyunittests python threads
AM_CPPFLAGS = -I$(top_srcdir)/src/lib -I$(top_builddir)/src/lib
AM_CPPFLAGS += -I$(top_srcdir)/src/lib/util -I$(top_builddir)/src/lib/util
diff --git a/src/lib/util/hash/sha1.cc b/src/lib/util/hash/sha1.cc
index 091e293..1fdadfd 100644
--- a/src/lib/util/hash/sha1.cc
+++ b/src/lib/util/hash/sha1.cc
@@ -48,7 +48,7 @@
* merchantability of this software or the suitability of this
* software for any particular purpose. It is provided "as is"
* without express or implied warranty of any kind.
- *
+ *
*/
#include <util/hash/sha1.h>
@@ -79,7 +79,7 @@ SHA_Parity(const uint32_t x, const uint32_t y, const uint32_t z) {
return ((x) ^ (y) ^ (z));
}
-static inline int
+static inline int
SHA1CircularShift(uint8_t bits, uint32_t word) {
return ((word << bits) | (word >> (32 - bits)));
}
diff --git a/src/lib/util/tests/lru_list_unittest.cc b/src/lib/util/tests/lru_list_unittest.cc
index bfb3b4d..c0201ea 100644
--- a/src/lib/util/tests/lru_list_unittest.cc
+++ b/src/lib/util/tests/lru_list_unittest.cc
@@ -168,7 +168,7 @@ protected:
entry7_(new TestEntry("eta", 1))
{}
- virtual ~LruListTest()
+ virtual ~LruListTest()
{}
boost::shared_ptr<TestEntry> entry1_;
@@ -355,7 +355,7 @@ TEST_F(LruListTest, Dropped) {
lru.add(entry5_);
EXPECT_NE(0, (entry2_->getCode() & 0x8000));
- // Delete an entry and check that the handler does not run.
+ // Delete an entry and check that the handler does not run.
EXPECT_EQ(0, (entry3_->getCode() & 0x8000));
lru.remove(entry3_);
EXPECT_EQ(0, (entry3_->getCode() & 0x8000));
@@ -386,7 +386,7 @@ TEST_F(LruListTest, Clear) {
EXPECT_NE(0, (entry1_->getCode() & 0x8000));
EXPECT_NE(0, (entry2_->getCode() & 0x8000));
EXPECT_NE(0, (entry3_->getCode() & 0x8000));
-
+
EXPECT_EQ(0, lru.size());
}
diff --git a/src/lib/util/threads/Makefile.am b/src/lib/util/threads/Makefile.am
new file mode 100644
index 0000000..7b9fb8f
--- /dev/null
+++ b/src/lib/util/threads/Makefile.am
@@ -0,0 +1,12 @@
+SUBDIRS = . tests
+AM_CXXFLAGS = $(B10_CXXFLAGS)
+
+AM_CPPFLAGS = -I$(top_srcdir)/src/lib -I$(top_builddir)/src/lib
+AM_CPPFLAGS += $(BOOST_INCLUDES) $(MULTITHREADING_FLAG)
+
+lib_LTLIBRARIES = libb10-threads.la
+libb10_threads_la_SOURCES = lock.h lock.cc
+libb10_threads_la_SOURCES += thread.h thread.cc
+libb10_threads_la_LIBADD = $(top_builddir)/src/lib/exceptions/libb10-exceptions.la
+
+CLEANFILES = *.gcno *.gcda
diff --git a/src/lib/util/threads/lock.cc b/src/lib/util/threads/lock.cc
new file mode 100644
index 0000000..6a165aa
--- /dev/null
+++ b/src/lib/util/threads/lock.cc
@@ -0,0 +1,138 @@
+// Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "lock.h"
+
+#include <exceptions/exceptions.h>
+
+#include <cstring>
+#include <memory>
+#include <cerrno>
+#include <cassert>
+
+#include <pthread.h>
+
+using std::auto_ptr;
+
+namespace isc {
+namespace util {
+namespace thread {
+
+class Mutex::Impl {
+public:
+ Impl() :
+ locked_count(0)
+ {}
+ pthread_mutex_t mutex;
+ // Only in debug mode
+ size_t locked_count;
+};
+
+namespace {
+
+struct Deinitializer {
+ Deinitializer(pthread_mutexattr_t& attributes):
+ attributes_(attributes)
+ {}
+ ~Deinitializer() {
+ const int result = pthread_mutexattr_destroy(&attributes_);
+ // This should never happen. According to the man page,
+ // if there's error, it's our fault.
+ assert(result == 0);
+ }
+ pthread_mutexattr_t& attributes_;
+};
+
+}
+
+Mutex::Mutex() :
+ impl_(NULL)
+{
+ pthread_mutexattr_t attributes;
+ int result = pthread_mutexattr_init(&attributes);
+ switch (result) {
+ case 0: // All 0K
+ break;
+ case ENOMEM:
+ throw std::bad_alloc();
+ default:
+ isc_throw(isc::InvalidOperation, std::strerror(result));
+ }
+ Deinitializer deinitializer(attributes);
+ // TODO: Distinguish if debug mode is enabled in compilation.
+ // If so, it should be PTHREAD_MUTEX_NORMAL or NULL
+ result = pthread_mutexattr_settype(&attributes, PTHREAD_MUTEX_ERRORCHECK);
+ if (result != 0) {
+ isc_throw(isc::InvalidOperation, std::strerror(result));
+ }
+ auto_ptr<Impl> impl(new Impl);
+ result = pthread_mutex_init(&impl->mutex, &attributes);
+ switch (result) {
+ case 0: // All 0K
+ impl_ = impl.release();
+ break;
+ case ENOMEM:
+ case EAGAIN:
+ throw std::bad_alloc();
+ default:
+ isc_throw(isc::InvalidOperation, std::strerror(result));
+ }
+}
+
+Mutex::~Mutex() {
+ if (impl_ != NULL) {
+ const int result = pthread_mutex_destroy(&impl_->mutex);
+ const bool locked = impl_->locked_count != 0;
+ delete impl_;
+ // We don't want to throw from the destructor. Also, if this ever
+ // fails, something is really screwed up a lot.
+ assert(result == 0);
+
+ // We should not try to destroy a locked mutex, bad threaded monsters
+ // could get loose if we ever do and it is also forbidden by pthreads.
+
+ // This should not be possible to happen, since the
+ // pthread_mutex_destroy should check for it already. But it seems
+ // there are systems that don't check it.
+ assert(!locked);
+ }
+}
+
+void
+Mutex::lock() {
+ assert(impl_ != NULL);
+ const int result = pthread_mutex_lock(&impl_->mutex);
+ if (result != 0) {
+ isc_throw(isc::InvalidOperation, std::strerror(result));
+ }
+ ++impl_->locked_count; // Only in debug mode
+}
+
+void
+Mutex::unlock() {
+ assert(impl_ != NULL);
+ --impl_->locked_count; // Only in debug mode
+ const int result = pthread_mutex_unlock(&impl_->mutex);
+ assert(result == 0); // This should never be possible
+}
+
+// TODO: Disable in non-debug build
+bool
+Mutex::locked() const {
+ return (impl_->locked_count != 0);
+}
+
+}
+}
+}
diff --git a/src/lib/util/threads/lock.h b/src/lib/util/threads/lock.h
new file mode 100644
index 0000000..fef537b
--- /dev/null
+++ b/src/lib/util/threads/lock.h
@@ -0,0 +1,128 @@
+// Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#ifndef B10_THREAD_LOCK_H
+#define B10_THREAD_LOCK_H
+
+#include <boost/noncopyable.hpp>
+
+#include <cstdlib> // for NULL.
+
+namespace isc {
+namespace util {
+namespace thread {
+
+/// \brief Mutex with very simple interface
+///
+/// Since mutexes are very system dependant, we create our own wrapper around
+/// whatever is available on the system and hide it.
+///
+/// To use this mutex, create it and then lock and unlock it by creating the
+/// Mutex::Locker object.
+///
+/// Also, as mutex is a low-level system object, an error might happen at any
+/// operation with it. We convert many errors to the isc::InvalidOperation,
+/// since the errors usually happen only when used in a wrong way. Any methods
+/// or constructors in this class can throw. Allocation errors are converted
+/// to std::bad_alloc (for example when OS-dependant limit of mutexes is
+/// exceeded). Some errors which usually mean a programmer error abort the
+/// program, since there could be no safe way to recover from them.
+///
+/// The current interface is somewhat minimalistic. If we ever need more, we
+/// can add it later.
+class Mutex : public boost::noncopyable {
+public:
+ /// \brief Constructor.
+ ///
+ /// Creates a mutex. It is a non-recursive mutex (can be locked just once,
+ /// if the same threads tries to lock it again, Bad Things Happen).
+ ///
+ /// Depending on compilation parameters and OS, the mutex may or may not
+ /// do some error and sanity checking. However, such checking is meant
+ /// only to aid development, not rely on it as a feature.
+ ///
+ /// \throw std::bad_alloc In case allocation of something (memory, the
+ /// OS mutex) fails.
+ /// \throw isc::InvalidOperation Other unspecified errors around the mutex.
+ /// This should be rare.
+ Mutex();
+
+ /// \brief Destructor.
+ ///
+ /// Destroys the mutex. It is not allowed to destroy a mutex which is
+ /// currently locked. This means a Locker created with this Mutex must
+ /// never live longer than the Mutex itself.
+ ~Mutex();
+
+ /// \brief This holds a lock on a Mutex.
+ ///
+ /// To lock a mutex, create a locker. It'll get unlocked when the locker
+ /// is destroyed.
+ ///
+ /// If you create the locker on the stack or using some other "garbage
+ /// collecting" mechanism (auto_ptr, for example), it ensures exception
+ /// safety with regards to the mutex - it'll get released on the exit
+ /// of function no matter by what means.
+ class Locker : public boost::noncopyable {
+ public:
+ /// \brief Constructor.
+ ///
+ /// Locks the mutex. May block for extended period of time.
+ ///
+ /// \throw isc::InvalidOperation when OS reports error. This usually
+ /// means an attempt to use the mutex in a wrong way (locking
+ /// a mutex second time from the same thread, for example).
+ Locker(Mutex& mutex) :
+ mutex_(NULL)
+ {
+ // Set the mutex_ after we acquire the lock. This is because of
+ // exception safety. If lock() throws, it didn't work, so we must
+ // not unlock when we are destroyed. In such case, mutex_ is
+ // NULL and checked in the destructor.
+ mutex.lock();
+ mutex_ = &mutex;
+ }
+
+ /// \brief Destructor.
+ ///
+ /// Unlocks the mutex.
+ ~Locker() {
+ if (mutex_ != NULL) {
+ mutex_->unlock();
+ }
+ }
+ private:
+ Mutex* mutex_;
+ };
+ /// \brief If the mutex is currently locked
+ ///
+ /// This is debug aiding method only. And it might be unavailable in
+ /// non-debug build (because keeping the state might be needlesly
+ /// slow).
+ ///
+ /// \todo Disable in non-debug build
+ bool locked() const;
+private:
+ class Impl;
+ Impl* impl_;
+ void lock();
+ void unlock();
+};
+
+
+}
+}
+}
+
+#endif
diff --git a/src/lib/util/threads/tests/Makefile.am b/src/lib/util/threads/tests/Makefile.am
new file mode 100644
index 0000000..2d9d4f9
--- /dev/null
+++ b/src/lib/util/threads/tests/Makefile.am
@@ -0,0 +1,36 @@
+SUBDIRS = .
+
+AM_CPPFLAGS = -I$(top_builddir)/src/lib -I$(top_srcdir)/src/lib
+AM_CPPFLAGS += $(BOOST_INCLUDES) $(MULTITHREADING_FLAG)
+# XXX: we'll pollute the top builddir for creating a temporary test file
+# # used to bind a UNIX domain socket so we can minimize the risk of exceeding
+# # the limit of file name path size.
+AM_CPPFLAGS += -DTEST_DATA_TOPBUILDDIR=\"$(abs_top_builddir)\"
+AM_CXXFLAGS = $(B10_CXXFLAGS)
+
+if USE_STATIC_LINK
+AM_LDFLAGS = -static
+endif
+
+CLEANFILES = *.gcno *.gcda
+
+TESTS_ENVIRONMENT = \
+ $(LIBTOOL) --mode=execute $(VALGRIND_COMMAND)
+
+TESTS =
+if HAVE_GTEST
+TESTS += run_unittests
+run_unittests_SOURCES = run_unittests.cc
+run_unittests_SOURCES += thread_unittest.cc
+run_unittests_SOURCES += lock_unittest.cc
+
+run_unittests_CPPFLAGS = $(AM_CPPFLAGS) $(GTEST_INCLUDES)
+run_unittests_LDFLAGS = $(AM_LDFLAGS) $(GTEST_LDFLAGS) $(PTHREAD_LDFLAGS)
+
+run_unittests_LDADD = $(top_builddir)/src/lib/util/threads/libb10-threads.la
+run_unittests_LDADD += \
+ $(top_builddir)/src/lib/util/unittests/libutil_unittests.la
+run_unittests_LDADD += $(GTEST_LDADD)
+endif
+
+noinst_PROGRAMS = $(TESTS)
diff --git a/src/lib/util/threads/tests/lock_unittest.cc b/src/lib/util/threads/tests/lock_unittest.cc
new file mode 100644
index 0000000..0b4d3ce
--- /dev/null
+++ b/src/lib/util/threads/tests/lock_unittest.cc
@@ -0,0 +1,116 @@
+// Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <util/threads/lock.h>
+#include <util/threads/thread.h>
+
+#include <gtest/gtest.h>
+
+#include <boost/bind.hpp>
+#include <unistd.h>
+#include <signal.h>
+
+using namespace isc::util::thread;
+
+namespace {
+
+// If we try to lock the debug mutex multiple times, it should throw.
+TEST(MutexTest, lockMultiple) {
+ // TODO: Once we support non-debug mutexes, disable the test if we compile
+ // with them.
+ Mutex mutex;
+ EXPECT_FALSE(mutex.locked()); // Debug-only build
+ Mutex::Locker l1(mutex);
+ EXPECT_TRUE(mutex.locked()); // Debug-only build
+ EXPECT_THROW({
+ Mutex::Locker l2(mutex); // Attempt to lock again.
+ }, isc::InvalidOperation);
+ EXPECT_TRUE(mutex.locked()); // Debug-only build
+}
+
+// Destroying a locked mutex is a bad idea as well
+#ifdef EXPECT_DEATH
+TEST(MutexTest, destroyLocked) {
+ EXPECT_DEATH({
+ Mutex* mutex = new Mutex;
+ new Mutex::Locker(*mutex);
+ delete mutex;
+ // This'll leak the locker, but inside the slave process, it should
+ // not be an issue.
+ }, "");
+}
+#endif
+
+// In this test, we try to check if a mutex really locks. We could try that
+// with a deadlock, but that's not practical (the test would not end).
+//
+// Instead, we try do to some operation on the same data from multiple threads
+// that's likely to break if not locked. Also, the test must run for a while
+// to have an opportunity to manifest.
+//
+// Currently we try incrementing a double variable. That one is large enough
+// and complex enough so it should not be possible for the CPU to do it as an
+// atomic operation, at least on common architectures.
+const size_t iterations = 100000;
+
+void
+performIncrement(volatile double* canary, volatile bool* ready_me,
+ volatile bool* ready_other, Mutex* mutex)
+{
+ // Loosely (busy) wait for the other thread so both will start
+ // approximately at the same time.
+ *ready_me = true;
+ while (!*ready_other) {}
+
+ for (size_t i = 0; i < iterations; ++i) {
+ Mutex::Locker lock(*mutex);
+ *canary += 1;
+ }
+}
+
+void
+no_handler(int) {}
+
+TEST(MutexTest, swarm) {
+ // Create a timeout in case something got stuck here
+ struct sigaction ignored, original;
+ memset(&ignored, 0, sizeof ignored);
+ ignored.sa_handler = no_handler;
+ if (sigaction(SIGALRM, &ignored, &original)) {
+ FAIL() << "Couldn't set alarm";
+ }
+ alarm(10);
+ // This type has a low chance of being atomic itself, further raising
+ // the chance of problems appearing.
+ double canary = 0;
+ Mutex mutex;
+ // Run two parallel threads
+ bool ready1 = false;
+ bool ready2 = false;
+ Thread t1(boost::bind(&performIncrement, &canary, &ready1, &ready2,
+ &mutex));
+ Thread t2(boost::bind(&performIncrement, &canary, &ready2, &ready1,
+ &mutex));
+ t1.wait();
+ t2.wait();
+ // Check it the sum is the expected value.
+ EXPECT_EQ(iterations * 2, canary) << "Threads are badly synchronized";
+ // Cancel the alarm and return the original handler
+ alarm(0);
+ if (sigaction(SIGALRM, &original, NULL)) {
+ FAIL() << "Couldn't restore alarm";
+ }
+}
+
+}
diff --git a/src/lib/util/threads/tests/run_unittests.cc b/src/lib/util/threads/tests/run_unittests.cc
new file mode 100644
index 0000000..6f71ad6
--- /dev/null
+++ b/src/lib/util/threads/tests/run_unittests.cc
@@ -0,0 +1,25 @@
+// Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <gtest/gtest.h>
+#include <util/unittests/run_all.h>
+#include <stdlib.h>
+
+int
+main(int argc, char* argv[]) {
+ ::testing::InitGoogleTest(&argc, argv);
+
+ setenv("B10_LOCKFILE_DIR_FROM_BUILD", TEST_DATA_TOPBUILDDIR, 1);
+ return (isc::util::unittests::run_all());
+}
diff --git a/src/lib/util/threads/tests/thread_unittest.cc b/src/lib/util/threads/tests/thread_unittest.cc
new file mode 100644
index 0000000..5afdf3f
--- /dev/null
+++ b/src/lib/util/threads/tests/thread_unittest.cc
@@ -0,0 +1,98 @@
+// Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <util/threads/thread.h>
+
+#include <boost/bind.hpp>
+
+#include <gtest/gtest.h>
+
+// This file tests the Thread class. It's hard to test an actual thread is
+// started, but we at least check the function is run and exceptions are
+// propagated as they should.
+//
+// We run some tests mutiple times to see if there happen to be a race
+// condition (then it would have better chance showing up).
+//
+// The detached tests are not run as many times to prevent many threads being
+// started in parallel (the other tests wait for the previous one to terminate
+// before starting new one).
+
+using namespace isc::util::thread;
+
+namespace {
+const size_t iterations = 200;
+const size_t detached_iterations = 25;
+
+void
+doSomething(int*) { }
+
+// We just test that we can forget about the thread and nothing
+// bad will happen on our side.
+TEST(ThreadTest, detached) {
+ int x;
+ for (size_t i = 0; i < detached_iterations; ++i) {
+ Thread thread(boost::bind(&doSomething, &x));
+ }
+}
+
+void
+markRun(bool* mark) {
+ EXPECT_FALSE(*mark);
+ *mark = true;
+}
+
+// Wait for a thread to end first. The variable must be set at the time.
+TEST(ThreadTest, wait) {
+ for (size_t i = 0; i < iterations; ++i) {
+ bool mark = false;
+ Thread thread(boost::bind(markRun, &mark));
+ thread.wait();
+ ASSERT_TRUE(mark) << "Not finished yet in " << i << "th iteration";
+ // Can't wait second time
+ ASSERT_THROW(thread.wait(), isc::InvalidOperation);
+ }
+}
+
+void
+throwSomething() {
+ throw 42; // Throw something really unusual, to see everything is caught.
+}
+
+void
+throwException() {
+ throw std::exception();
+}
+
+// Exception in the thread we forget about should not do anything to us
+TEST(ThreadTest, detachedException) {
+ for (size_t i = 0; i < detached_iterations; ++i) {
+ Thread thread(throwSomething);
+ }
+ for (size_t i = 0; i < detached_iterations; ++i) {
+ Thread thread(throwException);
+ }
+}
+
+// An uncaught exception in the thread should propagate through wait
+TEST(ThreadTest, exception) {
+ for (size_t i = 0; i < iterations; ++i) {
+ Thread thread(throwSomething);
+ Thread thread2(throwException);
+ ASSERT_THROW(thread.wait(), Thread::UncaughtException);
+ ASSERT_THROW(thread2.wait(), Thread::UncaughtException);
+ }
+}
+
+}
diff --git a/src/lib/util/threads/thread.cc b/src/lib/util/threads/thread.cc
new file mode 100644
index 0000000..c1c9cdf
--- /dev/null
+++ b/src/lib/util/threads/thread.cc
@@ -0,0 +1,172 @@
+// Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "thread.h"
+#include "lock.h"
+
+#include <memory>
+#include <string>
+#include <cstring>
+#include <cerrno>
+
+#include <pthread.h>
+
+#include <boost/scoped_ptr.hpp>
+
+using std::string;
+using std::exception;
+using std::auto_ptr;
+using boost::scoped_ptr;
+
+namespace isc {
+namespace util {
+namespace thread {
+
+// The implementation of the Thread class.
+//
+// This internal state is not deleted until the thread terminates and is either
+// waited for or detached. We could do this with shared_ptr (or, shared_ptr and
+// weak_ptr), but we plan on compiling boost without thread support, so it
+// might not be safe. Therefore we use an explicit mutex. It is being locked
+// only 2-3 times in the lifetime of the thread, which should be negligible
+// overhead anyway.
+class Thread::Impl {
+public:
+ Impl(const boost::function<void ()>& main) :
+ // Two things to happen before destruction - thread needs to terminate
+ // and the creating thread needs to release it.
+ waiting_(2),
+ main_(main),
+ exception_(false)
+ {}
+ // Another of the waiting events is done. If there are no more, delete
+ // impl.
+ static void done(Impl* impl) {
+ bool should_delete(false);
+ { // We need to make sure the mutex is unlocked before it is deleted
+ Mutex::Locker locker(impl->mutex_);
+ if (--impl->waiting_ == 0) {
+ should_delete = true;
+ }
+ }
+ if (should_delete) {
+ delete impl;
+ }
+ }
+ // Run the thread. The type of parameter is because the pthread API.
+ static void* run(void* impl_raw) {
+ Impl* impl = static_cast<Impl*>(impl_raw);
+ try {
+ impl->main_();
+ } catch (const exception& e) {
+ impl->exception_ = true;
+ impl->exception_text_ = e.what();
+ } catch (...) {
+ impl->exception_ = true;
+ impl->exception_text_ = "Uknown exception";
+ }
+ done(impl);
+ return (NULL);
+ }
+ // How many events are waiting? One is for the thread to finish, one
+ // for the destructor of Thread or wait. Once both happen, this is
+ // no longer needed.
+ size_t waiting_;
+ // The main function of the thread.
+ boost::function<void ()> main_;
+ // Was there an exception?
+ bool exception_;
+ string exception_text_;
+ // The mutex protects the waiting_ member, which ensures there are
+ // no race conditions and collisions when terminating. The other members
+ // should be safe, because:
+ // * tid_ is read only.
+ // * exception_ and exception_text_ is accessed outside of the thread
+ // only after join, by that time the thread must have terminated.
+ // * main_ is used in a read-only way here. If there are any shared
+ // resources used inside, it is up to the main_ itself to take care.
+ Mutex mutex_;
+ // Which thread are we talking about anyway?
+ pthread_t tid_;
+};
+
+Thread::Thread(const boost::function<void ()>& main) :
+ impl_(NULL)
+{
+ auto_ptr<Impl> impl(new Impl(main));
+ const int result = pthread_create(&impl->tid_, NULL, &Impl::run,
+ impl.get());
+ // Any error here?
+ switch (result) {
+ case 0: // All 0K
+ impl_ = impl.release();
+ break;
+ case EAGAIN:
+ throw std::bad_alloc();
+ default: // Other errors. They should not happen.
+ isc_throw(isc::InvalidOperation, std::strerror(result));
+ }
+}
+
+Thread::~Thread() {
+ if (impl_ != NULL) {
+ // In case we didn't call wait yet
+ const int result = pthread_detach(impl_->tid_);
+ Impl::done(impl_);
+ impl_ = NULL;
+ // If the detach ever fails, something is screwed rather badly.
+ assert(result == 0);
+ }
+}
+
+void
+Thread::wait() {
+ if (impl_ == NULL) {
+ isc_throw(isc::InvalidOperation,
+ "Wait called and no thread to wait for");
+ }
+
+ const int result = pthread_join(impl_->tid_, NULL);
+ if (result != 0) {
+ isc_throw(isc::InvalidOperation, std::strerror(result));
+ }
+
+ // Was there an exception in the thread?
+ scoped_ptr<UncaughtException> ex;
+ // Something here could in theory throw. But we already terminated the thread, so
+ // we need to make sure we are in consistent state even in such situation (like
+ // releasing the mutex and impl_).
+ try {
+ if (impl_->exception_) {
+ ex.reset(new UncaughtException(__FILE__, __LINE__,
+ impl_->exception_text_.c_str()));
+ }
+ } catch (...) {
+ Impl::done(impl_);
+ impl_ = NULL;
+ // We have eaten the UncaughtException by now, but there's another
+ // exception instead, so we have at least something.
+ throw;
+ }
+
+ Impl::done(impl_);
+ impl_ = NULL;
+ if (ex.get() != NULL) {
+ throw UncaughtException(*ex);
+ }
+}
+
+}
+}
+}
diff --git a/src/lib/util/threads/thread.h b/src/lib/util/threads/thread.h
new file mode 100644
index 0000000..9c6d20a
--- /dev/null
+++ b/src/lib/util/threads/thread.h
@@ -0,0 +1,112 @@
+// Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#ifndef B10_THREAD_H
+#define B10_THREAD_H
+
+#include <exceptions/exceptions.h>
+
+#include <boost/noncopyable.hpp>
+#include <boost/function.hpp>
+
+namespace isc {
+namespace util {
+/// \brief Wrappers for thread related functionality
+///
+/// We provide our own wrappers, currently around pthreads. We tried using
+/// the boost thread support, but it gave us some trouble, so we implemented
+/// in-house ones.
+namespace thread {
+
+/// \brief A separate thread.
+///
+/// A thread of execution. When created, starts running in the background.
+/// You can wait for it then or just forget it ever existed and leave it
+/// live peacefully.
+///
+/// The interface is minimalistic for now. We may need to extend it later.
+///
+/// \note While the objects of this class represent another thread, they
+/// are not thread-safe. You're not supposed to call wait() on the same
+/// object from multiple threads or so. They are reentrant (you can
+/// wait for different threads from different threads).
+class Thread : public boost::noncopyable {
+public:
+ /// \brief There's an uncaught exception in a thread.
+ ///
+ /// When a thread terminates because it the main function of the thread
+ /// throws, this one is re-thrown out of wait() and contains the what
+ /// of the original exception.
+ class UncaughtException : public isc::Exception {
+ public:
+ UncaughtException(const char* file, size_t line, const char* what) :
+ Exception(file, line, what)
+ {}
+ };
+
+ /// \brief Create and start a thread.
+ ///
+ /// Create a new thread and run body inside it.
+ ///
+ /// If you need to pass parameters to body, or return some result, you
+ /// may just want to use boost::bind or alike to store them within the
+ /// body functor.
+ ///
+ /// \note The main functor will be copied internally. You need to consider
+ /// this when returning the result.
+ ///
+ /// The body should terminate by exiting the function. If it throws, it
+ /// is considered an error. You should generally catch any exceptions form
+ /// within there and handle them somehow.
+ ///
+ /// \param main The code to run inside the thread.
+ ///
+ /// \throw std::bad_alloc if allocation of the new thread or other
+ /// resources fails.
+ /// \throw isc::InvalidOperation for other errors (should not happen).
+ Thread(const boost::function<void()>& main);
+
+ /// \brief Destructor.
+ ///
+ /// It is completely legitimate to destroy the thread without calling
+ /// wait() before. In such case, the thread will just live on until it
+ /// terminates. However, if the thread dies due to exception, for example,
+ /// it's up to you to detect that, no error is reported from this class.
+ ///
+ /// \throw isc::InvalidOperation in the rare case of OS reporting a
+ /// problem. This should not happen unless you messed up with the raw
+ /// thread by the low-level API.
+ ~Thread();
+
+ /// \brief Wait for the thread to terminate.
+ ///
+ /// Waits until the thread terminates. Must be called at most once.
+ ///
+ /// \throw isc::InvalidOperation if the OS API returns error. This usually
+ /// mean a programmer error (like two threads trying to wait on each
+ /// other).
+ /// \throw isc::InvalidOperation calling wait a second time.
+ /// \throw UncaughtException if the thread terminated by throwing an
+ /// exception instead of just returning from the function.
+ void wait();
+private:
+ class Impl;
+ Impl* impl_;
+};
+
+}
+}
+}
+
+#endif
More information about the bind10-changes
mailing list