BIND 10 master, updated. 4ba8271b4050f3133dd6ca53721c0ce32ec715a3 [master] corrected distcheck issues from trac3186
BIND 10 source code commits
bind10-changes at lists.isc.org
Wed Oct 23 21:09:00 UTC 2013
The branch, master has been updated
via 4ba8271b4050f3133dd6ca53721c0ce32ec715a3 (commit)
via f36aab92c85498f8511fbbe19fad5e3f787aef68 (commit)
via 2c28d84f3657c10e6520c413705f532c0b42b1c8 (commit)
via 4707a2dbce19333a1c6cb1bc9020ef2051eca1fe (commit)
via a1b91fbe2702b3fb60ac639f3ce7286c525c739a (commit)
via e76a6be3b3ffbc619ddb36b56e2a30d998ac9c36 (commit)
via a27c2a6a18ec14e5c79eae56beb238044ecb87d2 (commit)
via bd647c2a9820ecd3fc62852c42797265eca26ab1 (commit)
via 11ec18030d858c037a862cc806a0329d3271d53a (commit)
via c95421cd2f4719b166700bac51361254483787ef (commit)
via 6291862d54c72d64178fe3c5f5b489120e297e12 (commit)
via 14918661a10e2f9c3367f668261656db1ee4bfed (commit)
via f0edd52c244689cd370853d520bc6e97d23a3bb2 (commit)
from 99db31bc3494aece5861df6c64b821564cbb9348 (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 4ba8271b4050f3133dd6ca53721c0ce32ec715a3
Author: Thomas Markwalder <tmark at isc.org>
Date: Wed Oct 23 17:06:46 2013 -0400
[master] corrected distcheck issues from trac3186
After merging, distcheck revealed a few minor issues with logging
files and unit test data files. These were corrected.
commit f36aab92c85498f8511fbbe19fad5e3f787aef68
Merge: 99db31b 2c28d84
Author: Thomas Markwalder <tmark at isc.org>
Date: Wed Oct 23 14:15:46 2013 -0400
[master] Merge branch 'trac3186' DHCP hook library user_chk
Adds the hooks subdirectory to bind10/dir for storing hooks shared
libraries, and the first such library for DHCP, user_chk.
-----------------------------------------------------------------------
Summary of changes:
configure.ac | 5 +
src/Makefile.am | 2 +
src/hooks/Makefile.am | 1 +
src/hooks/dhcp/Makefile.am | 1 +
src/hooks/dhcp/user_chk/Makefile.am | 65 +++++
src/hooks/dhcp/user_chk/load_unload.cc | 113 +++++++++
src/hooks/dhcp/user_chk/subnet_select_co.cc | 237 +++++++++++++++++++
src/hooks/dhcp/user_chk/tests/Makefile.am | 76 ++++++
.../dhcp/user_chk}/tests/run_unittests.cc | 2 +-
.../user_chk/tests/test_data_files_config.h.in} | 9 +-
src/hooks/dhcp/user_chk/tests/test_users_1.txt | 2 +
src/hooks/dhcp/user_chk/tests/test_users_err.txt | 2 +
.../dhcp/user_chk/tests/user_file_unittests.cc | 158 +++++++++++++
.../dhcp/user_chk/tests/user_registry_unittests.cc | 216 +++++++++++++++++
src/hooks/dhcp/user_chk/tests/user_unittests.cc | 96 ++++++++
src/hooks/dhcp/user_chk/tests/userid_unittests.cc | 139 +++++++++++
src/hooks/dhcp/user_chk/user.cc | 210 +++++++++++++++++
src/hooks/dhcp/user_chk/user.h | 249 ++++++++++++++++++++
.../dhcp/user_chk/user_chk_log.cc} | 7 +-
.../dhcp/user_chk/user_chk_log.h} | 24 +-
src/hooks/dhcp/user_chk/user_chk_messages.mes | 43 ++++
src/hooks/dhcp/user_chk/user_data_source.h | 75 ++++++
src/hooks/dhcp/user_chk/user_file.cc | 159 +++++++++++++
src/hooks/dhcp/user_chk/user_file.h | 135 +++++++++++
src/hooks/dhcp/user_chk/user_registry.cc | 122 ++++++++++
src/hooks/dhcp/user_chk/user_registry.h | 128 ++++++++++
.../dhcp/user_chk/version.cc} | 14 +-
27 files changed, 2262 insertions(+), 28 deletions(-)
create mode 100644 src/hooks/Makefile.am
create mode 100644 src/hooks/dhcp/Makefile.am
create mode 100644 src/hooks/dhcp/user_chk/Makefile.am
create mode 100644 src/hooks/dhcp/user_chk/load_unload.cc
create mode 100644 src/hooks/dhcp/user_chk/subnet_select_co.cc
create mode 100644 src/hooks/dhcp/user_chk/tests/Makefile.am
copy src/{lib/dhcp_ddns => hooks/dhcp/user_chk}/tests/run_unittests.cc (93%)
copy src/{bin/resolver/common.cc => hooks/dhcp/user_chk/tests/test_data_files_config.h.in} (77%)
create mode 100644 src/hooks/dhcp/user_chk/tests/test_users_1.txt
create mode 100644 src/hooks/dhcp/user_chk/tests/test_users_err.txt
create mode 100644 src/hooks/dhcp/user_chk/tests/user_file_unittests.cc
create mode 100644 src/hooks/dhcp/user_chk/tests/user_registry_unittests.cc
create mode 100644 src/hooks/dhcp/user_chk/tests/user_unittests.cc
create mode 100644 src/hooks/dhcp/user_chk/tests/userid_unittests.cc
create mode 100644 src/hooks/dhcp/user_chk/user.cc
create mode 100644 src/hooks/dhcp/user_chk/user.h
copy src/{bin/resolver/common.cc => hooks/dhcp/user_chk/user_chk_log.cc} (78%)
copy src/{lib/dhcp_ddns/dhcp_ddns_log.h => hooks/dhcp/user_chk/user_chk_log.h} (68%)
create mode 100644 src/hooks/dhcp/user_chk/user_chk_messages.mes
create mode 100644 src/hooks/dhcp/user_chk/user_data_source.h
create mode 100644 src/hooks/dhcp/user_chk/user_file.cc
create mode 100644 src/hooks/dhcp/user_chk/user_file.h
create mode 100644 src/hooks/dhcp/user_chk/user_registry.cc
create mode 100644 src/hooks/dhcp/user_chk/user_registry.h
copy src/{bin/dhcp6/tests/test_data_files_config.h.in => hooks/dhcp/user_chk/version.cc} (77%)
-----------------------------------------------------------------------
diff --git a/configure.ac b/configure.ac
index 7786ab5..4bed0c6 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1288,6 +1288,10 @@ AC_CONFIG_FILES([Makefile
src/bin/usermgr/Makefile
src/bin/usermgr/tests/Makefile
src/bin/tests/Makefile
+ src/hooks/Makefile
+ src/hooks/dhcp/Makefile
+ src/hooks/dhcp/user_chk/Makefile
+ src/hooks/dhcp/user_chk/tests/Makefile
src/lib/Makefile
src/lib/asiolink/Makefile
src/lib/asiolink/tests/Makefile
@@ -1468,6 +1472,7 @@ AC_OUTPUT([doc/version.ent
src/bin/d2/spec_config.h.pre
src/bin/d2/tests/test_data_files_config.h
src/bin/tests/process_rename_test.py
+ src/hooks/dhcp/user_chk/tests/test_data_files_config.h
src/lib/config/tests/data_def_unittests_config.h
src/lib/dhcpsrv/tests/test_libraries.h
src/lib/python/isc/config/tests/config_test
diff --git a/src/Makefile.am b/src/Makefile.am
index 395553c..0e0109a 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -1,4 +1,6 @@
SUBDIRS = lib bin
+# @todo hooks lib could be a configurable switch
+SUBDIRS += hooks
EXTRA_DIST = \
cppcheck-suppress.lst \
diff --git a/src/hooks/Makefile.am b/src/hooks/Makefile.am
new file mode 100644
index 0000000..815beed
--- /dev/null
+++ b/src/hooks/Makefile.am
@@ -0,0 +1 @@
+SUBDIRS = dhcp
diff --git a/src/hooks/dhcp/Makefile.am b/src/hooks/dhcp/Makefile.am
new file mode 100644
index 0000000..6785617
--- /dev/null
+++ b/src/hooks/dhcp/Makefile.am
@@ -0,0 +1 @@
+SUBDIRS = user_chk
diff --git a/src/hooks/dhcp/user_chk/Makefile.am b/src/hooks/dhcp/user_chk/Makefile.am
new file mode 100644
index 0000000..874719b
--- /dev/null
+++ b/src/hooks/dhcp/user_chk/Makefile.am
@@ -0,0 +1,65 @@
+SUBDIRS = . tests
+
+AM_CPPFLAGS = -I$(top_builddir)/src/lib -I$(top_srcdir)/src/lib
+AM_CPPFLAGS += $(BOOST_INCLUDES)
+AM_CXXFLAGS = $(B10_CXXFLAGS)
+
+# Some versions of GCC warn about some versions of Boost regarding
+# missing initializer for members in its posix_time.
+# https://svn.boost.org/trac/boost/ticket/3477
+# But older GCC compilers don't have the flag.
+AM_CXXFLAGS += $(WARNING_NO_MISSING_FIELD_INITIALIZERS_CFLAG)
+
+# Until logging in dynamically loaded libraries is fixed,
+# Define rule to build logging source files from message file
+# user_chk_messages.h user_chk_messages.cc: s-messages
+
+# Until logging in dynamically loaded libraries is fixed, exclude these.
+# s-messages: user_chk_messages.mes
+# $(top_builddir)/src/lib/log/compiler/message $(top_srcdir)/src/hooks/dhcp/user_chk/user_chk_messages.mes
+# touch $@
+
+# Tell automake that the message files are built as part of the build process
+# (so that they are built before the main library is built).
+# BUILT_SOURCES = user_chk_messages.h user_chk_messages.cc
+BUILT_SOURCES =
+
+# Ensure that the message file is included in the distribution
+EXTRA_DIST =
+
+# Get rid of generated message files on a clean
+#CLEANFILES = *.gcno *.gcda user_chk_messages.h user_chk_messages.cc s-messages
+CLEANFILES = *.gcno *.gcda
+
+lib_LTLIBRARIES = libdhcp_user_chk.la
+libdhcp_user_chk_la_SOURCES =
+libdhcp_user_chk_la_SOURCES += load_unload.cc
+libdhcp_user_chk_la_SOURCES += subnet_select_co.cc
+libdhcp_user_chk_la_SOURCES += user.cc user.h
+# Until logging in dynamically loaded libraries is fixed, exclude these.
+#libdhcp_user_chk_la_SOURCES += user_chk_log.cc user_chk_log.h
+libdhcp_user_chk_la_SOURCES += user_data_source.h
+libdhcp_user_chk_la_SOURCES += user_file.cc user_file.h
+libdhcp_user_chk_la_SOURCES += user_registry.cc user_registry.h
+libdhcp_user_chk_la_SOURCES += version.cc
+
+# Until logging in dynamically loaded libraries is fixed, exclude these.
+#nodist_libdhcp_user_chk_la_SOURCES = user_chk_messages.cc user_chk_messages.h
+
+libdhcp_user_chk_la_CXXFLAGS = $(AM_CXXFLAGS)
+libdhcp_user_chk_la_CPPFLAGS = $(AM_CPPFLAGS) $(LOG4CPLUS_INCLUDES)
+libdhcp_user_chk_la_LDFLAGS = $(AM_LDFLAGS)
+libdhcp_user_chk_la_LDFLAGS += -avoid-version -export-dynamic -module
+libdhcp_user_chk_la_LIBADD =
+libdhcp_user_chk_la_LIBADD += $(top_builddir)/src/lib/hooks/libb10-hooks.la
+libdhcp_user_chk_la_LIBADD += $(top_builddir)/src/lib/log/libb10-log.la
+libdhcp_user_chk_la_LIBADD += $(top_builddir)/src/lib/exceptions/libb10-exceptions.la
+libdhcp_user_chk_la_LIBADD += $(top_builddir)/src/lib/util/libb10-util.la
+libdhcp_user_chk_la_LIBADD += $(top_builddir)/src/lib/util/threads/libb10-threads.la
+
+
+if USE_CLANGPP
+# Disable unused parameter warning caused by some of the
+# Boost headers when compiling with clang.
+libdhcp_user_chk_la_CXXFLAGS += -Wno-unused-parameter
+endif
diff --git a/src/hooks/dhcp/user_chk/load_unload.cc b/src/hooks/dhcp/user_chk/load_unload.cc
new file mode 100644
index 0000000..79afb82
--- /dev/null
+++ b/src/hooks/dhcp/user_chk/load_unload.cc
@@ -0,0 +1,113 @@
+// Copyright (C) 2013 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.
+
+/// @file This file defines the load and unload hooks library functions.
+
+#include <hooks/hooks.h>
+#include <user_registry.h>
+#include <user_file.h>
+
+#include <iostream>
+#include <fstream>
+#include <errno.h>
+
+using namespace isc::hooks;
+
+/// @brief Pointer to the registry instance.
+UserRegistryPtr user_registry;
+
+/// @brief Output filestream for recording user check outcomes.
+std::fstream user_chk_output;
+
+/// @brief User registry input file name.
+/// @todo Hard-coded for now, this should be configurable.
+const char* registry_fname = "/tmp/user_chk_registry.txt";
+
+/// @brief User check outcome file name.
+/// @todo Hard-coded for now, this should be configurable.
+const char* user_chk_output_fname = "/tmp/user_chk_outcome.txt";
+
+// Functions accessed by the hooks framework use C linkage to avoid the name
+// mangling that accompanies use of the C++ compiler as well as to avoid
+// issues related to namespaces.
+extern "C" {
+
+/// @brief Called by the Hooks library manager when the library is loaded.
+///
+/// Instantiates the UserRegistry and opens the outcome file. Failure in
+/// either results in a failed return code.
+///
+/// @param unused library handle parameter required by Hooks API.
+///
+/// @return Returns 0 upon success, non-zero upon failure.
+int load(LibraryHandle&) {
+ // non-zero indicates an error.
+ int ret_val = 0;
+ try {
+ // Instantiate the registry.
+ user_registry.reset(new UserRegistry());
+
+ // Create the data source.
+ UserDataSourcePtr user_file(new UserFile(registry_fname));
+
+ // Set the registry's data source
+ user_registry->setSource(user_file);
+
+ // Do an initial load of the registry.
+ user_registry->refresh();
+
+ // Open up the output file for user_chk results.
+ user_chk_output.open(user_chk_output_fname,
+ std::fstream::out | std::fstream::app);
+
+ if (!user_chk_output) {
+ // Grab the system error message.
+ const char* errmsg = strerror(errno);
+ isc_throw(isc::Unexpected, "Cannot open output file: "
+ << user_chk_output_fname
+ << " reason: " << errmsg);
+ }
+ }
+ catch (const std::exception& ex) {
+ // Log the error and return failure.
+ std::cout << "DHCP UserCheckHook could not be loaded: "
+ << ex.what() << std::endl;
+ ret_val = 1;
+ }
+
+ return (ret_val);
+}
+
+/// @brief Called by the Hooks library manager when the library is unloaded.
+///
+/// Destroys the UserRegistry and closes the outcome file.
+///
+/// @return Always returns 0.
+int unload() {
+ try {
+ user_registry.reset();
+ if (user_chk_output.is_open()) {
+ user_chk_output.close();
+ }
+ } catch (const std::exception& ex) {
+ // On the off chance something goes awry, catch it and log it.
+ // @todo Not sure if we should return a non-zero result or not.
+ std::cout << "DHCP UserCheckHook could not be unloaded: "
+ << ex.what() << std::endl;
+ }
+
+ return (0);
+}
+
+}
diff --git a/src/hooks/dhcp/user_chk/subnet_select_co.cc b/src/hooks/dhcp/user_chk/subnet_select_co.cc
new file mode 100644
index 0000000..31fbd6f
--- /dev/null
+++ b/src/hooks/dhcp/user_chk/subnet_select_co.cc
@@ -0,0 +1,237 @@
+// Copyright (C) 2013 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.
+
+/// @file Defines the subnet4_select and subnet6_select callout functions.
+
+#include <hooks/hooks.h>
+#include <dhcp/pkt4.h>
+#include <dhcp/dhcp6.h>
+#include <dhcp/pkt6.h>
+#include <dhcpsrv/subnet.h>
+#include <user_registry.h>
+
+#include <fstream>
+#include <string>
+
+using namespace isc::dhcp;
+using namespace isc::hooks;
+using namespace std;
+
+extern UserRegistryPtr user_registry;
+extern std::fstream user_chk_output;
+extern const char* registry_fname;
+extern const char* user_chk_output_fname;
+
+// Functions accessed by the hooks framework use C linkage to avoid the name
+// mangling that accompanies use of the C++ compiler as well as to avoid
+// issues related to namespaces.
+extern "C" {
+
+/// @brief Adds an entry to the end of the user check outcome file.
+///
+/// Each user entry is written in an ini-like format, with one name-value pair
+/// per line as follows:
+///
+/// id_type=<id type>
+/// client=<id str>
+/// subnet=<subnet str>
+/// registered=<is registered>"
+///
+/// where:
+/// <id type> text label of the id type: "HW_ADDR" or "DUID"
+/// <id str> user's id formatted as either isc::dhcp::Hwaddr.toText() or
+/// isc::dhcp::DUID.toText()
+/// <subnet str> selected subnet formatted as isc::dhcp::Subnet4::toText() or
+/// isc::dhcp::Subnet6::toText() as appropriate.
+/// <is registered> "yes" or "no"
+///
+/// Sample IPv4 entry would like this:
+///
+/// @code
+/// id_type=DUID
+/// client=00:01:00:01:19:ef:e6:3b:00:0c:01:02:03:04
+/// subnet=2001:db8:2::/64
+/// registered=yes
+/// id_type=duid
+/// @endcode
+///
+/// Sample IPv4 entry would like this:
+///
+/// @code
+/// id_type=DUID
+/// id_type=HW_ADDR
+/// client=hwtype=1 00:0c:01:02:03:05
+/// subnet=152.77.5.0/24
+/// registered=no
+/// @endcode
+///
+/// @param id_type_str text label identify the id type
+/// @param id_val_str text representation of the user id
+/// @param subnet_str text representation of the selected subnet
+/// @param registered boolean indicating if the user is registered or not
+void generate_output_record(const std::string& id_type_str,
+ const std::string& id_val_str,
+ const std::string& subnet_str,
+ const bool& registered)
+{
+ user_chk_output << "id_type=" << id_type_str << std::endl
+ << "client=" << id_val_str << std::endl
+ << "subnet=" << subnet_str << std::endl
+ << "registered=" << (registered ? "yes" : "no")
+ << std::endl;
+
+ // @todo Flush is here to ensure output is immediate for demo purposes.
+ // Performance would generally dictate not using it.
+ flush(user_chk_output);
+}
+
+/// @brief This callout is called at the "subnet4_select" hook.
+///
+/// This function searches the UserRegistry for the client indicated by the
+/// inbound IPv4 DHCP packet. If the client is found in the registry output
+/// the generate outcome record and return.
+///
+/// If the client is not found in the registry replace the selected subnet
+/// with the restricted access subnet, then generate the outcome record and
+/// return. By convention, it is assumed that last subnet in the list of
+/// available subnets is the restricted access subnet.
+///
+/// @param handle CalloutHandle which provides access to context.
+///
+/// @return 0 upon success, non-zero otherwise.
+int subnet4_select(CalloutHandle& handle) {
+ if (!user_registry) {
+ std::cout << "DHCP UserCheckHook : subnet4_select UserRegistry is null"
+ << std::endl;
+ return (1);
+ }
+
+ try {
+ // Get subnet collection. If it's empty just bail nothing to do.
+ const isc::dhcp::Subnet4Collection *subnets = NULL;
+ handle.getArgument("subnet4collection", subnets);
+ if (subnets->size() == 0) {
+ return 0;
+ }
+
+ // Refresh the registry.
+ user_registry->refresh();
+
+ // Get the HWAddress as the user identifier.
+ Pkt4Ptr query;
+ handle.getArgument("query4", query);
+ HWAddrPtr hwaddr = query->getHWAddr();
+
+ // Look for the user.
+ UserPtr registered_user = user_registry->findUser(*hwaddr);
+ if (registered_user) {
+ // User is in the registry, so leave the pre-selected subnet alone.
+ Subnet4Ptr subnet;
+ handle.getArgument("subnet4", subnet);
+ // Add the outcome entry to the output file.
+ generate_output_record(UserId::HW_ADDRESS_STR, hwaddr->toText(),
+ subnet->toText(), true);
+ } else {
+ // User is not in the registry, so assign them to the last subnet
+ // in the collection. By convention we are assuming this is the
+ // restricted subnet.
+ Subnet4Ptr subnet = subnets->back();
+ handle.setArgument("subnet4", subnet);
+ // Add the outcome entry to the output file.
+ generate_output_record(UserId::HW_ADDRESS_STR, hwaddr->toText(),
+ subnet->toText(), false);
+ }
+ } catch (const std::exception& ex) {
+ std::cout << "DHCP UserCheckHook : subnet6_select unexpected error: "
+ << ex.what() << std::endl;
+ return (1);
+ }
+
+ return (0);
+}
+
+/// @brief This callout is called at the "subnet6_select" hook.
+///
+/// This function searches the UserRegistry for the client indicated by the
+/// inbound IPv6 DHCP packet. If the client is found in the registry generate
+/// the outcome record and return.
+///
+/// If the client is not found in the registry replace the selected subnet
+/// with the restricted access subnet, then generate the outcome record and
+/// return. By convention, it is assumed that last subnet in the list of
+/// available subnets is the restricted access subnet.
+///
+/// @param handle CalloutHandle which provides access to context.
+///
+/// @return 0 upon success, non-zero otherwise.
+int subnet6_select(CalloutHandle& handle) {
+ if (!user_registry) {
+ std::cout << "DHCP UserCheckHook : subnet6_select UserRegistry is null"
+ << std::endl;
+ return (1);
+ }
+
+ try {
+ // Get subnet collection. If it's empty just bail nothing to do.
+ const isc::dhcp::Subnet6Collection *subnets = NULL;
+ handle.getArgument("subnet6collection", subnets);
+ if (subnets->size() == 0) {
+ return 0;
+ }
+
+ // Refresh the registry.
+ user_registry->refresh();
+
+ // Get the HWAddress as the user identifier.
+ Pkt6Ptr query;
+ handle.getArgument("query6", query);
+
+ DuidPtr duid;
+ OptionPtr opt_duid = query->getOption(D6O_CLIENTID);
+ if (!opt_duid) {
+ std::cout << "DHCP6 query is missing DUID" << std::endl;
+ return (1);
+ }
+
+ duid = DuidPtr(new DUID(opt_duid->getData()));
+
+ // Look for the user.
+ UserPtr registered_user = user_registry->findUser(*duid);
+ if (registered_user) {
+ // User is in the registry, so leave the pre-selected subnet alone.
+ Subnet6Ptr subnet;
+ handle.getArgument("subnet6", subnet);
+ // Add the outcome entry to the output file.
+ generate_output_record(UserId::DUID_STR, duid->toText(),
+ subnet->toText(), true);
+ } else {
+ // User is not in the registry, so assign them to the last subnet
+ // in the collection. By convention we are assuming this is the
+ // restricted subnet.
+ Subnet6Ptr subnet = subnets->back();
+ handle.setArgument("subnet6", subnet);
+ // Add the outcome entry to the output file.
+ generate_output_record(UserId::DUID_STR, duid->toText(),
+ subnet->toText(), false);
+ }
+ } catch (const std::exception& ex) {
+ std::cout << "DHCP UserCheckHook : subnet6_select unexpected error: "
+ << ex.what() << std::endl;
+ return (1);
+ }
+
+ return (0);
+}
+
+}
diff --git a/src/hooks/dhcp/user_chk/tests/Makefile.am b/src/hooks/dhcp/user_chk/tests/Makefile.am
new file mode 100644
index 0000000..7406c9d
--- /dev/null
+++ b/src/hooks/dhcp/user_chk/tests/Makefile.am
@@ -0,0 +1,76 @@
+SUBDIRS = .
+
+AM_CPPFLAGS = -I$(top_builddir)/src/lib -I$(top_srcdir)/src/lib
+AM_CPPFLAGS += -I$(top_builddir)/src/hooks/dhcp/user_chk -I$(top_srcdir)/src/hooks/dhcp/user_chk
+AM_CPPFLAGS += $(BOOST_INCLUDES) $(BOTAN_INCLUDES)
+AM_CPPFLAGS += -DTEST_DATA_BUILDDIR=\"$(abs_top_builddir)/src/hooks/dhcp/user_chk/tests\"
+AM_CPPFLAGS += -DINSTALL_PROG=\"$(abs_top_srcdir)/install-sh\"
+
+AM_CXXFLAGS = $(B10_CXXFLAGS)
+
+# Some versions of GCC warn about some versions of Boost regarding
+# missing initializer for members in its posix_time.
+# https://svn.boost.org/trac/boost/ticket/3477
+# But older GCC compilers don't have the flag.
+AM_CXXFLAGS += $(WARNING_NO_MISSING_FIELD_INITIALIZERS_CFLAG)
+
+USER_CHK_LIB = $(top_builddir)/src/hooks/dhcp/user_chk/libdhcp_user_chk.la
+
+if USE_STATIC_LINK
+AM_LDFLAGS = -static
+endif
+
+# Unit test data files need to get installed.
+EXTRA_DIST = test_users_1.txt test_users_err.txt
+
+CLEANFILES = *.gcno *.gcda
+
+TESTS_ENVIRONMENT = \
+ $(LIBTOOL) --mode=execute $(VALGRIND_COMMAND)
+
+TESTS =
+if HAVE_GTEST
+TESTS += libdhcp_user_chk_unittests
+
+libdhcp_user_chk_unittests_SOURCES =
+libdhcp_user_chk_unittests_SOURCES += ../load_unload.cc
+libdhcp_user_chk_unittests_SOURCES += ../subnet_select_co.cc
+libdhcp_user_chk_unittests_SOURCES += ../version.cc
+libdhcp_user_chk_unittests_SOURCES += ../user.cc ../user.h
+# Until logging in dynamically loaded libraries is fixed, exclude these.
+#libdhcp_user_chk_unittests_SOURCES += ../user_chk_log.cc ../user_chk_log.h
+#libdhcp_user_chk_unittests_SOURCES += ../user_chk_messages.cc ../user_chk_messages.h
+libdhcp_user_chk_unittests_SOURCES += ../user_data_source.h
+libdhcp_user_chk_unittests_SOURCES += ../user_file.cc ../user_file.h
+libdhcp_user_chk_unittests_SOURCES += ../user_registry.cc ../user_registry.h
+libdhcp_user_chk_unittests_SOURCES += run_unittests.cc
+libdhcp_user_chk_unittests_SOURCES += userid_unittests.cc
+libdhcp_user_chk_unittests_SOURCES += user_unittests.cc
+libdhcp_user_chk_unittests_SOURCES += user_registry_unittests.cc
+libdhcp_user_chk_unittests_SOURCES += user_file_unittests.cc
+
+libdhcp_user_chk_unittests_CPPFLAGS = $(AM_CPPFLAGS) $(GTEST_INCLUDES) $(LOG4CPLUS_INCLUDES)
+
+libdhcp_user_chk_unittests_LDFLAGS = $(AM_LDFLAGS) $(GTEST_LDFLAGS)
+
+libdhcp_user_chk_unittests_CXXFLAGS = $(AM_CXXFLAGS)
+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_user_chk_unittests_CXXFLAGS += -Wno-unused-parameter
+endif
+
+libdhcp_user_chk_unittests_LDADD = $(top_builddir)/src/lib/log/libb10-log.la
+libdhcp_user_chk_unittests_LDADD += $(top_builddir)/src/lib/util/libb10-util.la
+libdhcp_user_chk_unittests_LDADD += $(top_builddir)/src/lib/hooks/libb10-hooks.la
+libdhcp_user_chk_unittests_LDADD += $(top_builddir)/src/lib/dhcp/libb10-dhcp++.la
+libdhcp_user_chk_unittests_LDADD += $(top_builddir)/src/lib/exceptions/libb10-exceptions.la
+libdhcp_user_chk_unittests_LDADD += $(top_builddir)/src/lib/cc/libb10-cc.la
+libdhcp_user_chk_unittests_LDADD += ${BOTAN_LIBS} ${BOTAN_RPATH}
+libdhcp_user_chk_unittests_LDADD += $(GTEST_LDADD)
+endif
+noinst_PROGRAMS = $(TESTS)
+
+libdhcp_user_chk_unittestsdir = $(abs_top_builddir)/src/hooks/dhcp/user_chk/tests
+libdhcp_user_chk_unittests_DATA = test_users_1.txt test_users_err.txt
diff --git a/src/hooks/dhcp/user_chk/tests/run_unittests.cc b/src/hooks/dhcp/user_chk/tests/run_unittests.cc
new file mode 100644
index 0000000..185f888
--- /dev/null
+++ b/src/hooks/dhcp/user_chk/tests/run_unittests.cc
@@ -0,0 +1,27 @@
+// Copyright (C) 2013 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 <log/logger_support.h>
+
+#include <gtest/gtest.h>
+
+int
+main(int argc, char* argv[]) {
+ ::testing::InitGoogleTest(&argc, argv);
+ isc::log::initLogger();
+
+ int result = RUN_ALL_TESTS();
+
+ return (result);
+}
diff --git a/src/hooks/dhcp/user_chk/tests/test_data_files_config.h.in b/src/hooks/dhcp/user_chk/tests/test_data_files_config.h.in
new file mode 100644
index 0000000..9abdbc6
--- /dev/null
+++ b/src/hooks/dhcp/user_chk/tests/test_data_files_config.h.in
@@ -0,0 +1,16 @@
+// Copyright (C) 2013 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.
+//
+/// @brief Path to local dir so tests can locate test data files
+#define USER_CHK_TEST_DIR "@abs_top_srcdir@/src/hooks/dhcp/user_chk/tests"
diff --git a/src/hooks/dhcp/user_chk/tests/test_users_1.txt b/src/hooks/dhcp/user_chk/tests/test_users_1.txt
new file mode 100644
index 0000000..5fa718f
--- /dev/null
+++ b/src/hooks/dhcp/user_chk/tests/test_users_1.txt
@@ -0,0 +1,2 @@
+{ "type" : "HW_ADDR", "id" : "01AC00F03344", "opt1" : "true" }
+{ "type" : "DUID", "id" : "225060de0a0b", "opt1" : "true" }
diff --git a/src/hooks/dhcp/user_chk/tests/test_users_err.txt b/src/hooks/dhcp/user_chk/tests/test_users_err.txt
new file mode 100644
index 0000000..3204006
--- /dev/null
+++ b/src/hooks/dhcp/user_chk/tests/test_users_err.txt
@@ -0,0 +1,2 @@
+{ "type" : "DUID", "id" : "777777777777", "opt1" : "true" }
+{ "type" : "BOGUS", "id" : "01AC00F03344", "opt1" : "true" }
diff --git a/src/hooks/dhcp/user_chk/tests/user_file_unittests.cc b/src/hooks/dhcp/user_chk/tests/user_file_unittests.cc
new file mode 100644
index 0000000..9507fab
--- /dev/null
+++ b/src/hooks/dhcp/user_chk/tests/user_file_unittests.cc
@@ -0,0 +1,158 @@
+// Copyright (C) 2013 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>
+#include <test_data_files_config.h>
+#include <user_file.h>
+
+#include <boost/function.hpp>
+#include <boost/bind.hpp>
+#include <boost/shared_ptr.hpp>
+#include <gtest/gtest.h>
+
+using namespace std;
+
+namespace {
+
+/// @brief Convenience method for reliably building test file path names.
+///
+/// Function prefixes the given file name with a path to unit tests directory
+/// so we can reliably find test data files.
+///
+/// @param name base file name of the test file
+std::string testFilePath(const std::string& name) {
+ return (std::string(USER_CHK_TEST_DIR) + "/" + name);
+}
+
+/// @brief Tests the UserFile constructor.
+TEST(UserFile, construction) {
+ // Verify that a UserFile with no file name is rejected.
+ ASSERT_THROW(UserFile(""), UserFileError);
+
+ // Verify that a UserFile with a non-blank file name is accepted.
+ ASSERT_NO_THROW(UserFile("someName"));
+}
+
+/// @brief Tests opening and closing UserFile
+TEST(UserFile, openFile) {
+ UserFilePtr user_file;
+
+ // Construct a user file that refers to a non existant file.
+ ASSERT_NO_THROW(user_file.reset(new UserFile("NoSuchFile")));
+ EXPECT_FALSE(user_file->isOpen());
+
+ // Verify a non-existant file fails to open
+ ASSERT_THROW(user_file->open(), UserFileError);
+ EXPECT_FALSE(user_file->isOpen());
+
+ // Construct a user file that should exist.
+ ASSERT_NO_THROW(user_file.reset(new UserFile
+ (testFilePath("test_users_1.txt"))));
+ // File should not be open.
+ EXPECT_FALSE(user_file->isOpen());
+
+ // Verify that we can open it.
+ ASSERT_NO_THROW(user_file->open());
+ EXPECT_TRUE(user_file->isOpen());
+
+ // Verify that we cannot open an already open file.
+ ASSERT_THROW(user_file->open(), UserFileError);
+
+ // Verifyt we can close it.
+ ASSERT_NO_THROW(user_file->close());
+ EXPECT_FALSE(user_file->isOpen());
+
+ // Verify that we can reopen it.
+ ASSERT_NO_THROW(user_file->open());
+ EXPECT_TRUE(user_file->isOpen());
+}
+
+
+/// @brief Tests makeUser with invalid user strings
+TEST(UserFile, makeUser) {
+ const char* invalid_strs[]= {
+ // Missinge type element.
+ "{ \"id\" : \"01AC00F03344\" }",
+ // Invalid id type string value.
+ "{ \"type\" : \"BOGUS\", \"id\" : \"01AC00F03344\"}",
+ // Non-string id type
+ "{ \"type\" : 1, \"id\" : \"01AC00F03344\"}",
+ // Missing id element.
+ "{ \"type\" : \"HW_ADDR\" }",
+ // Odd number of digits in id value.
+ "{ \"type\" : \"HW_ADDR\", \"id\" : \"1AC00F03344\"}",
+ // Invalid characters in id value.
+ "{ \"type\" : \"HW_ADDR\", \"id\" : \"THIS IS BAD!\"}",
+ // Empty id value.
+ "{ \"type\" : \"HW_ADDR\", \"id\" : \"\"}",
+ // Non-string id.
+ "{ \"type\" : \"HW_ADDR\", \"id\" : 01AC00F03344 }",
+ // Option with non-string value
+ "{ \"type\" : \"HW_ADDR\", \"id\" : \"01AC00F03344\", \"opt\" : 4 }",
+ NULL
+ };
+
+ // Create a UseFile to work with.
+ UserFilePtr user_file;
+ ASSERT_NO_THROW(user_file.reset(new UserFile("noFile")));
+
+ // Iterate over the list of invalid user strings and verify
+ // each one fails.
+ const char** tmp = invalid_strs;;
+ while (*tmp) {
+ EXPECT_THROW(user_file->makeUser(*tmp), UserFileError)
+ << "Invalid str not caught: ["
+ << *tmp << "]" << std::endl;
+ ++tmp;
+ }
+}
+
+/// @brief Test reading from UserFile
+TEST(UserFile, readFile) {
+ UserFilePtr user_file;
+
+ // Construct and then open a known file.
+ ASSERT_NO_THROW(user_file.reset(new UserFile
+ (testFilePath("test_users_1.txt"))));
+ ASSERT_NO_THROW(user_file->open());
+ EXPECT_TRUE(user_file->isOpen());
+
+ // File should contain two valid users. Read and verify each.
+ UserPtr user;
+ int i = 0;
+ do {
+ ASSERT_NO_THROW(user = user_file->readNextUser());
+ switch (i++) {
+ case 0:
+ EXPECT_EQ(UserId::HW_ADDRESS, user->getUserId().getType());
+ EXPECT_EQ("01ac00f03344", user->getUserId().toText());
+ EXPECT_EQ("true", user->getProperty("opt1"));
+ break;
+ case 1:
+ EXPECT_EQ(UserId::DUID, user->getUserId().getType());
+ EXPECT_EQ("225060de0a0b", user->getUserId().toText());
+ EXPECT_EQ("true", user->getProperty("opt1"));
+ break;
+ default:
+ // Third time around, we are at EOF User should be null.
+ ASSERT_FALSE(user);
+ break;
+ }
+ } while (user);
+
+
+ ASSERT_NO_THROW(user_file->close());
+}
+
+} // end of anonymous namespace
diff --git a/src/hooks/dhcp/user_chk/tests/user_registry_unittests.cc b/src/hooks/dhcp/user_chk/tests/user_registry_unittests.cc
new file mode 100644
index 0000000..1f250c8
--- /dev/null
+++ b/src/hooks/dhcp/user_chk/tests/user_registry_unittests.cc
@@ -0,0 +1,216 @@
+// Copyright (C) 2013 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/hwaddr.h>
+#include <exceptions/exceptions.h>
+#include <user_registry.h>
+#include <user_file.h>
+#include <test_data_files_config.h>
+
+#include <boost/function.hpp>
+#include <boost/bind.hpp>
+#include <boost/shared_ptr.hpp>
+#include <gtest/gtest.h>
+
+using namespace std;
+
+namespace {
+
+/// @brief Convenience method for reliably building test file path names.
+///
+/// Function prefixes the given file name with a path to unit tests directory
+/// so we can reliably find test data files.
+///
+/// @param name base file name of the test file
+std::string testFilePath(const std::string& name) {
+ return (std::string(USER_CHK_TEST_DIR) + "/" + name);
+}
+
+/// @brief Tests UserRegistry construction.
+TEST(UserRegistry, constructor) {
+ // Currently there is only the default constructor which does not throw.
+ UserRegistryPtr reg;
+ ASSERT_NO_THROW(reg.reset(new UserRegistry()));
+}
+
+/// @brief Tests mechanics of adding, finding, removing Users.
+TEST(UserRegistry, userBasics) {
+ // Create an empty registry.
+ UserRegistryPtr reg;
+ ASSERT_NO_THROW(reg.reset(new UserRegistry()));
+
+ // Verify that a blank user cannot be added.
+ UserPtr user;
+ ASSERT_THROW(reg->addUser(user), UserRegistryError);
+
+ // Make a new id and user.
+ UserIdPtr id;
+ ASSERT_NO_THROW(id.reset(new UserId(UserId::HW_ADDRESS, "01010101")));
+ ASSERT_NO_THROW(user.reset(new User(*id)));
+
+ // Verify that we can add a user.
+ ASSERT_NO_THROW(reg->addUser(user));
+
+ // Verify that the user can be found.
+ UserPtr found_user;
+ ASSERT_NO_THROW(found_user = reg->findUser(*id));
+ EXPECT_TRUE(found_user);
+ EXPECT_EQ(found_user->getUserId(), *id);
+
+ // Verify that searching for a non-existant user returns empty user pointer.
+ UserIdPtr id2;
+ ASSERT_NO_THROW(id2.reset(new UserId(UserId::HW_ADDRESS, "02020202")));
+ ASSERT_NO_THROW(found_user = reg->findUser(*id2));
+ EXPECT_FALSE(found_user);
+
+ // Verify that the user can be deleted.
+ ASSERT_NO_THROW(reg->removeUser(*id));
+ ASSERT_NO_THROW(found_user = reg->findUser(*id));
+ EXPECT_FALSE(found_user);
+}
+
+/// @brief Tests finding users by isc::dhcp::HWaddr instance.
+TEST(UserRegistry, findByHWAddr) {
+ // Create the registry.
+ UserRegistryPtr reg;
+ ASSERT_NO_THROW(reg.reset(new UserRegistry()));
+
+ // Make a new user and add it.
+ UserPtr user;
+ ASSERT_NO_THROW(user.reset(new User(UserId::HW_ADDRESS, "01010101")));
+ ASSERT_NO_THROW(reg->addUser(user));
+
+ // Make a HWAddr instance using the same id value.
+ isc::dhcp::HWAddr hwaddr(user->getUserId().getId(), isc::dhcp::HTYPE_ETHER);
+
+ // Verify user can be found by HWAddr.
+ UserPtr found_user;
+ ASSERT_NO_THROW(found_user = reg->findUser(hwaddr));
+ EXPECT_TRUE(found_user);
+ EXPECT_EQ(found_user->getUserId(), user->getUserId());
+}
+
+/// @brief Tests finding users by isc::dhcp::DUID instance.
+TEST(UserRegistry, findByDUID) {
+ // Create the registry.
+ UserRegistryPtr reg;
+ ASSERT_NO_THROW(reg.reset(new UserRegistry()));
+
+ // Make a new user and add it.
+ UserPtr user;
+ ASSERT_NO_THROW(user.reset(new User(UserId::DUID, "01010101")));
+ ASSERT_NO_THROW(reg->addUser(user));
+
+ // Make a DUID instance using the same id value.
+ isc::dhcp::DUID duid(user->getUserId().getId());
+
+ // Verify user can be found by DUID.
+ UserPtr found_user;
+ ASSERT_NO_THROW(found_user = reg->findUser(duid));
+ EXPECT_TRUE(found_user);
+ EXPECT_EQ(found_user->getUserId(), user->getUserId());
+}
+
+/// @brief Tests mixing users of different types.
+TEST(UserRegistry, oneOfEach) {
+ // Create the registry.
+ UserRegistryPtr reg;
+ ASSERT_NO_THROW(reg.reset(new UserRegistry()));
+
+ // Make user ids.
+ UserIdPtr idh, idd;
+ ASSERT_NO_THROW(idh.reset(new UserId(UserId::HW_ADDRESS, "01010101")));
+ ASSERT_NO_THROW(idd.reset(new UserId(UserId::DUID, "03030303")));
+
+ // Make and add HW_ADDRESS user.
+ UserPtr user;
+ user.reset(new User(*idh));
+ ASSERT_NO_THROW(reg->addUser(user));
+
+ // Make and add DUID user.
+ user.reset(new User(*idd));
+ ASSERT_NO_THROW(reg->addUser(user));
+
+ // Verify we can find both.
+ UserPtr found_user;
+ ASSERT_NO_THROW(found_user = reg->findUser(*idh));
+ ASSERT_NO_THROW(found_user = reg->findUser(*idd));
+}
+
+/// @brief Tests loading the registry from a file.
+TEST(UserRegistry, refreshFromFile) {
+ // Create the registry.
+ UserRegistryPtr reg;
+ ASSERT_NO_THROW(reg.reset(new UserRegistry()));
+
+ UserDataSourcePtr user_file;
+
+ // Verify that data source cannot be set to null source.
+ ASSERT_THROW(reg->setSource(user_file), UserRegistryError);
+
+ // Create the data source.
+ ASSERT_NO_THROW(user_file.reset(new UserFile
+ (testFilePath("test_users_1.txt"))));
+
+ // Set the registry's data source and refresh the registry.
+ ASSERT_NO_THROW(reg->setSource(user_file));
+ ASSERT_NO_THROW(reg->refresh());
+
+ // Verify we can find all the expected users.
+ UserIdPtr id;
+ ASSERT_NO_THROW(id.reset(new UserId(UserId::HW_ADDRESS, "01ac00f03344")));
+ EXPECT_TRUE(reg->findUser(*id));
+
+ ASSERT_NO_THROW(id.reset(new UserId(UserId::DUID, "225060de0a0b")));
+ EXPECT_TRUE(reg->findUser(*id));
+}
+
+/// @brief Tests preservation of registry upon refresh failure.
+TEST(UserRegistry, refreshFail) {
+ // Create the registry.
+ UserRegistryPtr reg;
+ ASSERT_NO_THROW(reg.reset(new UserRegistry()));
+
+ // Create the data source.
+ UserDataSourcePtr user_file;
+ ASSERT_NO_THROW(user_file.reset(new UserFile
+ (testFilePath("test_users_1.txt"))));
+
+ // Set the registry's data source and refresh the registry.
+ ASSERT_NO_THROW(reg->setSource(user_file));
+ ASSERT_NO_THROW(reg->refresh());
+
+ // Make user ids of expected users.
+ UserIdPtr id1, id2;
+ ASSERT_NO_THROW(id1.reset(new UserId(UserId::HW_ADDRESS, "01ac00f03344")));
+ ASSERT_NO_THROW(id2.reset(new UserId(UserId::DUID, "225060de0a0b")));
+
+ // Verify we can find all the expected users.
+ EXPECT_TRUE(reg->findUser(*id1));
+ EXPECT_TRUE(reg->findUser(*id2));
+
+ // Replace original data source with a new one containing an invalid entry.
+ ASSERT_NO_THROW(user_file.reset(new UserFile
+ (testFilePath("test_users_err.txt"))));
+ ASSERT_NO_THROW(reg->setSource(user_file));
+
+ // Refresh should throw due to invalid data.
+ EXPECT_THROW(reg->refresh(), UserRegistryError);
+
+ // Verify we can still find all the original users.
+ EXPECT_TRUE(reg->findUser(*id1));
+ EXPECT_TRUE(reg->findUser(*id2));
+}
+
+} // end of anonymous namespace
diff --git a/src/hooks/dhcp/user_chk/tests/user_unittests.cc b/src/hooks/dhcp/user_chk/tests/user_unittests.cc
new file mode 100644
index 0000000..7049711
--- /dev/null
+++ b/src/hooks/dhcp/user_chk/tests/user_unittests.cc
@@ -0,0 +1,96 @@
+// Copyright (C) 2013 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>
+#include <user.h>
+
+#include <boost/function.hpp>
+#include <boost/bind.hpp>
+#include <boost/shared_ptr.hpp>
+#include <gtest/gtest.h>
+
+using namespace std;
+
+namespace {
+
+/// @brief Tests User construction variants.
+/// Note, since all constructors accept or rely on UserId, invalid id
+/// variants are tested under UserId not here.
+TEST(UserTest, construction) {
+ std::string test_address("01FF02AC030B0709");
+
+ // Create a user id.
+ UserIdPtr id;
+ ASSERT_NO_THROW(id.reset(new UserId(UserId::HW_ADDRESS, test_address)));
+
+ // Verify construction from a UserId.
+ UserPtr user;
+ ASSERT_NO_THROW(user.reset(new User(*id)));
+
+ // Verify construction from an id type and an address vector.
+ ASSERT_NO_THROW(user.reset(new User(UserId::HW_ADDRESS, id->getId())));
+ ASSERT_NO_THROW(user.reset(new User(UserId::DUID, id->getId())));
+
+ // Verify construction from an id type and an address string.
+ ASSERT_NO_THROW(user.reset(new User(UserId::HW_ADDRESS, test_address)));
+ ASSERT_NO_THROW(user.reset(new User(UserId::DUID, test_address)));
+}
+
+/// @brief Tests property map fundamentals.
+TEST(UserTest, properties) {
+ // Create a user.
+ UserPtr user;
+ ASSERT_NO_THROW(user.reset(new User(UserId::DUID, "01020304050607")));
+
+ // Verify that we can add and retrieve a property.
+ std::string value = "";
+ EXPECT_NO_THROW(user->setProperty("one","1"));
+ EXPECT_NO_THROW(value = user->getProperty("one"));
+ EXPECT_EQ("1", value);
+
+ // Verify that we can update and then retrieve the property.
+ EXPECT_NO_THROW(user->setProperty("one","1.0"));
+ EXPECT_NO_THROW(value = user->getProperty("one"));
+ EXPECT_EQ("1.0", value);
+
+ // Verify that we can remove and then NOT find the property.
+ EXPECT_NO_THROW(user->delProperty("one"));
+ EXPECT_NO_THROW(value = user->getProperty("one"));
+ EXPECT_TRUE(value.empty());
+
+ // Verify that a blank property name is NOT permitted.
+ EXPECT_THROW(user->setProperty("", "blah"), isc::BadValue);
+
+ // Verify that a blank property value IS permitted.
+ EXPECT_NO_THROW(user->setProperty("one", ""));
+ EXPECT_NO_THROW(value = user->getProperty("one"));
+ EXPECT_TRUE(value.empty());
+
+ PropertyMap map;
+ map["one"]="1.0";
+ map["two"]="2.0";
+
+ ASSERT_NO_THROW(user->setProperties(map));
+
+ EXPECT_NO_THROW(value = user->getProperty("one"));
+ EXPECT_EQ("1.0", value);
+
+ EXPECT_NO_THROW(value = user->getProperty("two"));
+ EXPECT_EQ("2.0", value);
+
+ const PropertyMap& map2 = user->getProperties();
+ EXPECT_EQ(map2, map);
+}
+
+} // end of anonymous namespace
diff --git a/src/hooks/dhcp/user_chk/tests/userid_unittests.cc b/src/hooks/dhcp/user_chk/tests/userid_unittests.cc
new file mode 100644
index 0000000..817e011
--- /dev/null
+++ b/src/hooks/dhcp/user_chk/tests/userid_unittests.cc
@@ -0,0 +1,139 @@
+// Copyright (C) 2013 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>
+#include <user.h>
+
+#include <boost/function.hpp>
+#include <boost/bind.hpp>
+#include <boost/shared_ptr.hpp>
+#include <gtest/gtest.h>
+
+using namespace std;
+
+namespace {
+
+/// @brief Test invalid constructors.
+TEST(UserIdTest, invalidConstructors) {
+ // Verify that constructor does not allow empty id vector.
+ std::vector<uint8_t> empty_bytes;
+ ASSERT_THROW(UserId(UserId::HW_ADDRESS, empty_bytes), isc::BadValue);
+ ASSERT_THROW(UserId(UserId::DUID, empty_bytes), isc::BadValue);
+
+ // Verify that constructor does not allow empty id string.
+ ASSERT_THROW(UserId(UserId::HW_ADDRESS, ""), isc::BadValue);
+ ASSERT_THROW(UserId(UserId::DUID, ""), isc::BadValue);
+}
+
+/// @brief Test making and using HW_ADDRESS type UserIds
+TEST(UserIdTest, hwAddress_type) {
+ // Verify text label look up for HW_ADDRESS enum.
+ EXPECT_EQ(std::string(UserId::HW_ADDRESS_STR),
+ UserId::lookupTypeStr(UserId::HW_ADDRESS));
+
+ // Verify enum look up for HW_ADDRESS text label.
+ EXPECT_EQ(UserId::HW_ADDRESS,
+ UserId::lookupType(UserId::HW_ADDRESS_STR));
+
+ // Build a test address vector.
+ uint8_t tmp[] = { 0x01, 0xFF, 0x02, 0xAC, 0x03, 0x0B, 0x07, 0x08 };
+ std::vector<uint8_t> bytes(tmp, tmp + (sizeof(tmp)/sizeof(uint8_t)));
+
+ // Verify construction from an HW_ADDRESS id type and address vector.
+ UserIdPtr id;
+ ASSERT_NO_THROW(id.reset(new UserId(UserId::HW_ADDRESS, bytes)));
+ // Verify that the id can be fetched.
+ EXPECT_EQ(id->getType(), UserId::HW_ADDRESS);
+ EXPECT_EQ(bytes, id->getId());
+
+ // Check relational oeprators when a == b.
+ UserIdPtr id2;
+ ASSERT_NO_THROW(id2.reset(new UserId(UserId::HW_ADDRESS, id->toText())));
+ EXPECT_TRUE(*id == *id2);
+ EXPECT_FALSE(*id != *id2);
+ EXPECT_FALSE(*id < *id2);
+
+ // Check relational oeprators when a < b.
+ ASSERT_NO_THROW(id2.reset(new UserId(UserId::HW_ADDRESS,
+ "01FF02AC030B0709")));
+ EXPECT_FALSE(*id == *id2);
+ EXPECT_TRUE(*id != *id2);
+ EXPECT_TRUE(*id < *id2);
+
+ // Check relational oeprators when a > b.
+ ASSERT_NO_THROW(id2.reset(new UserId(UserId::HW_ADDRESS,
+ "01FF02AC030B0707")));
+ EXPECT_FALSE(*id == *id2);
+ EXPECT_TRUE(*id != *id2);
+ EXPECT_FALSE(*id < *id2);
+}
+
+/// @brief Test making and using DUID type UserIds
+TEST(UserIdTest, duid_type) {
+ // Verify text label look up for DUID enum.
+ EXPECT_EQ(std::string(UserId::DUID_STR),
+ UserId::lookupTypeStr(UserId::DUID));
+
+ // Verify enum look up for DUID text label.
+ EXPECT_EQ(UserId::DUID,
+ UserId::lookupType(UserId::DUID_STR));
+
+ // Build a test DUID vector.
+ uint8_t tmp[] = { 0x01, 0xFF, 0x02, 0xAC, 0x03, 0x0B, 0x07, 0x08 };
+ std::vector<uint8_t> bytes(tmp, tmp + (sizeof(tmp)/sizeof(uint8_t)));
+
+ // Verify construction from an DUID id type and address vector.
+ UserIdPtr id;
+ ASSERT_NO_THROW(id.reset(new UserId(UserId::DUID, bytes)));
+ // Verify that the id can be fetched.
+ EXPECT_EQ(id->getType(), UserId::DUID);
+ EXPECT_EQ(bytes, id->getId());
+
+ // Check relational oeprators when a == b.
+ UserIdPtr id2;
+ ASSERT_NO_THROW(id2.reset(new UserId(UserId::DUID, id->toText())));
+ EXPECT_TRUE(*id == *id2);
+ EXPECT_FALSE(*id != *id2);
+ EXPECT_FALSE(*id < *id2);
+
+ // Check relational oeprators when a < b.
+ ASSERT_NO_THROW(id2.reset(new UserId(UserId::DUID, "01FF02AC030B0709")));
+ EXPECT_FALSE(*id == *id2);
+ EXPECT_TRUE(*id != *id2);
+ EXPECT_TRUE(*id < *id2);
+
+ // Check relational oeprators when a > b.
+ ASSERT_NO_THROW(id2.reset(new UserId(UserId::DUID, "01FF02AC030B0707")));
+ EXPECT_FALSE(*id == *id2);
+ EXPECT_TRUE(*id != *id2);
+ EXPECT_FALSE(*id < *id2);
+}
+
+/// @brief Tests that UserIds of different types compare correctly.
+TEST(UserIdTest, mixed_type_compare) {
+ UserIdPtr hw, duid;
+ // Create UserIds with different types, but same id data.
+ ASSERT_NO_THROW(hw.reset(new UserId(UserId::HW_ADDRESS,
+ "01FF02AC030B0709")));
+ ASSERT_NO_THROW(duid.reset(new UserId(UserId::DUID,
+ "01FF02AC030B0709")));
+
+ // Verify that UserIdType influences logical comparators.
+ EXPECT_FALSE(*hw == *duid);
+ EXPECT_TRUE(*hw != *duid);
+ EXPECT_TRUE(*hw < *duid);
+}
+
+
+} // end of anonymous namespace
diff --git a/src/hooks/dhcp/user_chk/user.cc b/src/hooks/dhcp/user_chk/user.cc
new file mode 100644
index 0000000..c7c18fa
--- /dev/null
+++ b/src/hooks/dhcp/user_chk/user.cc
@@ -0,0 +1,210 @@
+// Copyright (C) 2013 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/hwaddr.h>
+#include <dhcp/duid.h>
+#include <exceptions/exceptions.h>
+#include <util/encode/hex.h>
+
+#include <user.h>
+
+#include <iomanip>
+#include <sstream>
+
+//********************************* UserId ******************************
+
+const char* UserId::HW_ADDRESS_STR = "HW_ADDR";
+const char* UserId::DUID_STR = "DUID";
+
+UserId::UserId(UserIdType id_type, const std::vector<uint8_t>& id)
+ : id_type_(id_type), id_(id) {
+ if (id.size() == 0) {
+ isc_throw(isc::BadValue, "UserId id may not be blank");
+ }
+}
+
+UserId::UserId(UserIdType id_type, const std::string & id_str) :
+ id_type_(id_type) {
+ if (id_str.empty()) {
+ isc_throw(isc::BadValue, "UserId id string may not be blank");
+ }
+
+ // Convert the id string to vector.
+ // Input is expected to be 2-digits per bytes, no delimiters.
+ std::vector<uint8_t> addr_bytes;
+ isc::util::encode::decodeHex(id_str, addr_bytes);
+
+ // Attempt to instantiate the appropriate id class to leverage validation.
+ switch (id_type) {
+ case HW_ADDRESS: {
+ isc::dhcp::HWAddr hwaddr(addr_bytes, isc::dhcp::HTYPE_ETHER);
+ break;
+ }
+ case DUID: {
+ isc::dhcp::DUID duid(addr_bytes);
+ break;
+ }
+ default:
+ isc_throw (isc::BadValue, "Invalid id_type: " << id_type);
+ break;
+ }
+
+ // It's a valid id.
+ id_ = addr_bytes;
+}
+
+UserId::~UserId() {
+}
+
+const std::vector<uint8_t>&
+UserId::getId() const {
+ return (id_);
+}
+
+UserId::UserIdType
+UserId::getType() const {
+ return (id_type_);
+}
+
+std::string
+UserId::toText(char delim_char) const {
+ std::stringstream tmp;
+ tmp << std::hex;
+ bool delim = false;
+ for (std::vector<uint8_t>::const_iterator it = id_.begin();
+ it != id_.end(); ++it) {
+ if (delim_char && delim) {
+ tmp << delim_char;
+ }
+
+ tmp << std::setw(2) << std::setfill('0')
+ << static_cast<unsigned int>(*it);
+ delim = true;
+ }
+
+ return (tmp.str());
+}
+
+bool
+UserId::operator ==(const UserId & other) const {
+ return ((this->id_type_ == other.id_type_) && (this->id_ == other.id_));
+}
+
+bool
+UserId::operator !=(const UserId & other) const {
+ return (!(*this == other));
+}
+
+bool
+UserId::operator <(const UserId & other) const {
+ return ((this->id_type_ < other.id_type_) ||
+ ((this->id_type_ == other.id_type_) && (this->id_ < other.id_)));
+}
+
+std::string
+UserId::lookupTypeStr(UserIdType type) {
+ const char* tmp = NULL;
+ switch (type) {
+ case HW_ADDRESS:
+ tmp = HW_ADDRESS_STR;
+ break;
+ case DUID:
+ tmp = DUID_STR;
+ break;
+ default:
+ isc_throw(isc::BadValue, "Invalid UserIdType:" << type);
+ break;
+ }
+
+ return (std::string(tmp));
+}
+
+UserId::UserIdType
+UserId::lookupType(const std::string& type_str) {
+ if (type_str.compare(HW_ADDRESS_STR) == 0) {
+ return (HW_ADDRESS);
+ } else if (type_str.compare(DUID_STR) == 0) {
+ return (DUID);
+ }
+
+ isc_throw(isc::BadValue, "Invalid UserIdType string:" << type_str);
+}
+
+std::ostream&
+operator<<(std::ostream& os, const UserId& user_id) {
+ std::string tmp = UserId::lookupTypeStr(user_id.getType());
+ os << tmp << "=" << user_id.toText();
+ return (os);
+}
+
+//********************************* User ******************************
+
+User::User(const UserId& user_id) : user_id_(user_id) {
+}
+
+User::User(UserId::UserIdType id_type, const std::vector<uint8_t>& id)
+ : user_id_(id_type, id) {
+}
+
+User::User(UserId::UserIdType id_type, const std::string& id_str)
+ : user_id_(id_type, id_str) {
+}
+
+User::~User() {
+}
+
+const PropertyMap&
+User::getProperties() const {
+ return (properties_);
+}
+
+void
+User::setProperties(const PropertyMap& properties) {
+ properties_ = properties;
+}
+
+void User::setProperty(const std::string& name, const std::string& value) {
+ if (name.empty()) {
+ isc_throw (isc::BadValue, "User property name cannot be blank");
+ }
+
+ // Note that if the property exists its value will be updated.
+ properties_[name]=value;
+}
+
+std::string
+User::getProperty(const std::string& name) const {
+ PropertyMap::const_iterator it = properties_.find(name);
+ if (it != properties_.end()) {
+ return ((*it).second);
+ }
+
+ // By returning an empty string rather than throwing, we allow the
+ // flexibility of defaulting to blank if not specified. Let the caller
+ // decide if that is valid or not.
+ return ("");
+}
+
+void
+User::delProperty(const std::string & name) {
+ PropertyMap::iterator it = properties_.find(name);
+ if (it != properties_.end()) {
+ properties_.erase(it);
+ }
+}
+
+const UserId&
+User::getUserId() const {
+ return (user_id_);
+}
diff --git a/src/hooks/dhcp/user_chk/user.h b/src/hooks/dhcp/user_chk/user.h
new file mode 100644
index 0000000..20167b6
--- /dev/null
+++ b/src/hooks/dhcp/user_chk/user.h
@@ -0,0 +1,249 @@
+// Copyright (C) 2013 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 USER_H
+#define USER_H
+
+#include <boost/shared_ptr.hpp>
+
+#include <map>
+#include <stdint.h>
+#include <vector>
+
+/// @file user.h This file defines classes: UserId and User.
+/// @brief These classes are used to describe and recognize DHCP lease
+/// clients.
+
+/// @brief Encapsulates a unique identifier for a DHCP client.
+/// This class provides a generic wrapper around the information used to
+/// uniquely identify the requester in a DHCP request packet. It provides
+/// the necessary operators such that it can be used as a key within STL
+/// containers such as maps. It supports both IPv4 and IPv6 clients.
+class UserId {
+public:
+ /// @brief Defines the supported types of user ids.
+ // Use explicit values to ensure consistent numeric ordering for key
+ // comparisons.
+ enum UserIdType {
+ /// @brief Hardware addresses (MAC) are used for IPv4 clients.
+ HW_ADDRESS = 0,
+ /// @brief DUIDs are used for IPv6 clients.
+ DUID = 1
+ };
+
+ /// @brief Defines the text label hardware address id type.
+ static const char* HW_ADDRESS_STR;
+ /// @brief Define the text label DUID id type.
+ static const char* DUID_STR;
+
+ /// @brief Constructor
+ ///
+ /// Constructs a UserId from an id type and id vector.
+ ///
+ /// @param id_type The type of user id contained in vector
+ /// @param id a vector of unsigned bytes containing the id
+ ///
+ /// @throw isc::BadValue if the vector is empty.
+ UserId(UserIdType id_type, const std::vector<uint8_t>& id);
+
+ /// @brief Constructor
+ ///
+ /// Constructs a UserId from an id type and id string.
+ ///
+ /// @param id_type The type of user id contained in string.
+ /// The string is expected to contain an even number of hex digits
+ /// without delimiters.
+ ///
+ /// @param id a vector of unsigned bytes containing the id
+ ///
+ /// @throw isc::BadValue if the string is empty, contains non
+ /// valid hex digits, or an odd number of hex digits.
+ UserId(UserIdType id_type, const std::string& id_str);
+
+ /// @brief Destructor.
+ ~UserId();
+
+ /// @brief Returns a const reference to the actual id value
+ const std::vector<uint8_t>& getId() const;
+
+ /// @brief Returns the user id type
+ UserIdType getType() const;
+
+ /// @brief Returns textual representation of the id
+ ///
+ /// Outputs a string of hex digits representing the id with an
+ /// optional delimiter between digit pairs (i.e. bytes).
+ ///
+ /// Without a delimiter:
+ /// "0c220F"
+ ///
+ /// with colon as a delimiter:
+ /// "0c:22:0F"
+ ///
+ /// @param delim_char The delimiter to place in between
+ /// "bytes". It defaults to none.
+ /// (e.g. 00010203ff)
+ std::string toText(char delim_char=0x0) const;
+
+ /// @brief Compares two UserIds for equality
+ bool operator ==(const UserId & other) const;
+
+ /// @brief Compares two UserIds for inequality
+ bool operator !=(const UserId & other) const;
+
+ /// @brief Performs less than comparison of two UserIds
+ bool operator <(const UserId & other) const;
+
+ /// @brief Returns the text label for a given id type
+ ///
+ /// @param type The id type value for which the label is desired
+ ///
+ /// @throw isc::BadValue if type is not valid.
+ static std::string lookupTypeStr(UserIdType type);
+
+ /// @brief Returns the id type for a given text label
+ ///
+ /// @param type_str The text label for which the id value is desired
+ ///
+ /// @throw isc::BadValue if type_str is not a valid text label.
+ static UserIdType lookupType(const std::string& type_str);
+
+private:
+ /// @brief The type of id value
+ UserIdType id_type_;
+
+ /// @brief The id value
+ std::vector<uint8_t> id_;
+
+};
+
+/// @brief Outputs the UserId contents in a string to the given stream.
+///
+/// The output string has the form "<type>=<id>" where:
+///
+/// <type> is the text label returned by UserId::lookupTypeStr()
+/// <id> is the output of UserId::toText() without a delimiter.
+///
+/// Examples:
+/// HW_ADDR=0c0e0a01ff06
+/// DUID=0001000119efe63b000c01020306
+///
+/// @param os output stream to which to write
+/// @param user_id source object to output
+std::ostream&
+operator<<(std::ostream& os, const UserId& user_id);
+
+/// @brief Defines a smart pointer to UserId
+typedef boost::shared_ptr<UserId> UserIdPtr;
+
+/// @brief Defines a map of string values keyed by string labels.
+typedef std::map<std::string, std::string> PropertyMap;
+
+/// @brief Represents a unique DHCP user
+/// This class is used to represent a specific DHCP user who is identified by a
+/// unique id and who possesses a set of properties.
+class User {
+public:
+ /// @brief Constructor
+ ///
+ /// Constructs a new User from a given id with an empty set of properties.
+ ///
+ /// @param user_id Id to assign to the user
+ ///
+ /// @throw isc::BadValue if user id is blank.
+ User(const UserId & user_id);
+
+ /// @brief Constructor
+ ///
+ /// Constructs a new User from a given id type and vector containing the
+ /// id data with an empty set of properties.
+ ///
+ /// @param user_id Type of id contained in the id vector
+ /// @param id Vector of data representing the user's id
+ ///
+ /// @throw isc::BadValue if user id vector is empty.
+ User(UserId::UserIdType id_type, const std::vector<uint8_t>& id);
+
+ /// @brief Constructor
+ ///
+ /// Constructs a new User from a given id type and string containing the
+ /// id data with an empty set of properties.
+ ///
+ /// @param user_id Type of id contained in the id vector
+ /// @param id string of hex digits representing the user's id
+ ///
+ /// @throw isc::BadValue if user id string is empty or invalid
+ User(UserId::UserIdType id_type, const std::string& id_str);
+
+ /// @brief Destructor
+ ~User();
+
+ /// @brief Returns a reference to the map of properties.
+ ///
+ /// Note that this reference can go out of scope and should not be
+ /// relied upon other than for momentary use.
+ const PropertyMap& getProperties() const;
+
+ /// @brief Sets the user's properties from a given property map
+ ///
+ /// Replaces the contents of the user's property map with the given
+ /// property map.
+ ///
+ /// @param properties property map to assign to the user
+ void setProperties(const PropertyMap& properties);
+
+ /// @brief Sets a given property to the given value
+ ///
+ /// Adds or updates the given property to the given value.
+ ///
+ /// @param name string by which the property is identified (keyed)
+ /// @param value string data to associate with the property
+ ///
+ /// @throw isc::BadValue if name is blank.
+ void setProperty(const std::string& name, const std::string& value);
+
+ /// @brief Fetches the string value for a given property name.
+ ///
+ /// @param name property name to fetch
+ ///
+ /// @return Returns the string value for the given name or an empty string
+ /// if the property is not found in the property map.
+ std::string getProperty(const std::string& name) const;
+
+ /// @brief Removes the given property from the property map.
+ ///
+ /// Removes the given property from the map if found. If not, no harm no
+ /// foul.
+ ///
+ /// @param name property name to remove
+ void delProperty(const std::string& name);
+
+ /// @brief Returns the user's id.
+ ///
+ /// Note that this reference can go out of scope and should not be
+ /// relied upon other than for momentary use.
+ const UserId& getUserId() const;
+
+private:
+ /// @brief The user's id.
+ UserId user_id_;
+
+ /// @brief The user's property map.
+ PropertyMap properties_;
+};
+
+/// @brief Defines a smart pointer to a User.
+typedef boost::shared_ptr<User> UserPtr;
+
+#endif
diff --git a/src/hooks/dhcp/user_chk/user_chk_log.cc b/src/hooks/dhcp/user_chk/user_chk_log.cc
new file mode 100644
index 0000000..f104efb
--- /dev/null
+++ b/src/hooks/dhcp/user_chk/user_chk_log.cc
@@ -0,0 +1,18 @@
+// Copyright (C) 2013 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.
+
+/// Defines the logger used by the user check hooks library.
+#include <user_chk_log.h>
+
+isc::log::Logger user_chk_logger("user_chk");
diff --git a/src/hooks/dhcp/user_chk/user_chk_log.h b/src/hooks/dhcp/user_chk/user_chk_log.h
new file mode 100644
index 0000000..43fb364
--- /dev/null
+++ b/src/hooks/dhcp/user_chk/user_chk_log.h
@@ -0,0 +1,29 @@
+// Copyright (C) 2013 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 USER_CHK_LOG_H
+#define USER_CHK_LOG_H
+
+#include <log/message_initializer.h>
+#include <log/macros.h>
+#include <user_chk_messages.h>
+
+/// @brief User Check Logger
+///
+/// Define the logger used to log messages. We could define it in multiple
+/// modules, but defining in a single module and linking to it saves time and
+/// space.
+extern isc::log::Logger user_chk_logger;
+
+#endif // USER_CHK_LOG_H
diff --git a/src/hooks/dhcp/user_chk/user_chk_messages.mes b/src/hooks/dhcp/user_chk/user_chk_messages.mes
new file mode 100644
index 0000000..23e3023
--- /dev/null
+++ b/src/hooks/dhcp/user_chk/user_chk_messages.mes
@@ -0,0 +1,43 @@
+# Copyright (C) 2013 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.
+
+% USER_CHK_HOOK_LOAD_ERROR DHCP UserCheckHook could not be loaded: %1
+This is an error message issued when the DHCP UserCheckHook could not be loaded.
+The exact cause should be explained in the log message. User subnet selection
+will revert to default processing.
+
+% USER_CHK_HOOK_UNLOAD_ERROR DHCP UserCheckHook an error occurred unloading the library: %1
+This is an error message issued when an error occurs while unloading the
+UserCheckHook library. This is unlikely to occur and normal operations of the
+library will likely resume when it is next loaded.
+
+% USER_CHK_SUBNET4_SELECT_ERROR DHCP UserCheckHook an unexpected error occured in subnet4_select callout: %1
+This is an error message issued when the DHCP UserCheckHook subnet4_select hook
+encounters an unexpected error. The message should contain a more detailed
+explanation.
+
+% USER_CHK_SUBNET4_SELECT_REGISTRY_NULL DHCP UserCheckHook UserRegistry has not been created.
+This is an error message issued when the DHCP UserCheckHook subnet4_select hook
+has been invoked but the UserRegistry has not been created. This is a
+programmatic error and should not occur.
+
+% USER_CHK_SUBNET6_SELECT_ERROR DHCP UserCheckHook an unexpected error occured in subnet6_select callout: %1
+This is an error message issued when the DHCP UserCheckHook subnet6_select hook
+encounters an unexpected error. The message should contain a more detailed
+explanation.
+
+% USER_CHK_SUBNET6_SELECT_REGISTRY_NULL DHCP UserCheckHook UserRegistry has not been created.
+This is an error message issued when the DHCP UserCheckHook subnet6_select hook
+has been invoked but the UserRegistry has not been created. This is a
+programmatic error and should not occur.
diff --git a/src/hooks/dhcp/user_chk/user_data_source.h b/src/hooks/dhcp/user_chk/user_data_source.h
new file mode 100644
index 0000000..a1842cf
--- /dev/null
+++ b/src/hooks/dhcp/user_chk/user_data_source.h
@@ -0,0 +1,75 @@
+// Copyright (C) 2013 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 _USER_DATA_SOURCE_H
+#define _USER_DATA_SOURCE_H
+
+/// @file user_data_source.h Defines the base class, UserDataSource.
+#include <exceptions/exceptions.h>
+#include <user.h>
+
+/// @brief Thrown if UserDataSource encounters an error
+class UserDataSourceError : public isc::Exception {
+public:
+ UserDataSourceError(const char* file, size_t line,
+ const char* what) :
+ isc::Exception(file, line, what) { };
+};
+
+/// @brief Defines an interface for reading user data into a registry.
+/// This is an abstract class which defines the interface for reading Users
+/// from an IO source such as a file.
+class UserDataSource {
+public:
+ /// @brief Constructor.
+ UserDataSource() {};
+
+ /// @brief Virtual Destructor.
+ virtual ~UserDataSource() {};
+
+ /// @brief Opens the data source.
+ ///
+ /// Prepares the data source for reading. Upon successful completion the
+ /// data source is ready to read from the beginning of its content.
+ ///
+ /// @throw UserDataSourceError if the source fails to open.
+ virtual void open() = 0;
+
+ /// @brief Fetches the next user from the data source.
+ ///
+ /// Reads the next User from the data source and returns it. If no more
+ /// data is available it should return an empty (null) user.
+ ///
+ /// @throw UserDataSourceError if an error occurs.
+ virtual UserPtr readNextUser() = 0;
+
+ /// @brief Closes that data source.
+ ///
+ /// Closes the data source.
+ ///
+ /// This method must not throw exceptions.
+ virtual void close() = 0;
+
+ /// @brief Returns true if the data source is open.
+ ///
+ /// This method should return true once the data source has been
+ /// successfully opened and until it has been closed.
+ ///
+ /// It is assumed to be exception safe.
+ virtual bool isOpen() const = 0;
+};
+
+/// @brief Defines a smart pointer to a UserDataSource.
+typedef boost::shared_ptr<UserDataSource> UserDataSourcePtr;
+
+#endif
diff --git a/src/hooks/dhcp/user_chk/user_file.cc b/src/hooks/dhcp/user_chk/user_file.cc
new file mode 100644
index 0000000..4181dc4
--- /dev/null
+++ b/src/hooks/dhcp/user_chk/user_file.cc
@@ -0,0 +1,159 @@
+// Copyright (C) 2013 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 <cc/data.h>
+#include <user.h>
+#include <user_file.h>
+
+#include <boost/foreach.hpp>
+#include <errno.h>
+#include <iostream>
+
+UserFile::UserFile(const std::string& fname) : fname_(fname), file_() {
+ if (fname_.empty()) {
+ isc_throw(UserFileError, "file name cannot be blank");
+ }
+}
+
+UserFile::~UserFile(){
+ close();
+};
+
+void
+UserFile::open() {
+ if (isOpen()) {
+ isc_throw (UserFileError, "file is already open");
+ }
+
+ file_.open(fname_.c_str(), std::ifstream::in);
+ int sav_error = errno;
+ if (!file_.is_open()) {
+ isc_throw(UserFileError, "cannot open file:" << fname_
+ << " reason: " << strerror(sav_error));
+ }
+}
+
+UserPtr
+UserFile::readNextUser() {
+ if (!isOpen()) {
+ isc_throw (UserFileError, "cannot read, file is not open");
+ }
+
+ if (file_.good()) {
+ char buf[USER_ENTRY_MAX_LEN];
+
+ // Get the next line.
+ file_.getline(buf, sizeof(buf));
+
+ // We got something, try to make a user out of it.
+ if (file_.gcount() > 0) {
+ return(makeUser(buf));
+ }
+ }
+
+ // Returns an empty user on EOF.
+ return (UserPtr());
+}
+
+UserPtr
+UserFile::makeUser(const std::string& user_string) {
+ // This method leverages the existing JSON parsing provided by isc::data
+ // library. Should this prove to be a performance issue, it may be that
+ // lighter weight solution would be appropriate.
+
+ // Turn the string of JSON text into an Element set.
+ isc::data::ElementPtr elements;
+ try {
+ elements = isc::data::Element::fromJSON(user_string);
+ } catch (isc::data::JSONError& ex) {
+ isc_throw(UserFileError,
+ "UserFile entry is malformed JSON: " << ex.what());
+ }
+
+ // Get a map of the Elements, keyed by element name.
+ isc::data::ConstElementPtr element;
+ PropertyMap properties;
+ std::string id_type_str;
+ std::string id_str;
+
+ // Iterate over the elements, saving of "type" and "id" to their
+ // respective locals. Anything else is assumed to be an option so
+ // add it to the local property map.
+ std::pair<std::string, isc::data::ConstElementPtr> element_pair;
+ BOOST_FOREACH (element_pair, elements->mapValue()) {
+ // Get the element's label.
+ std::string label = element_pair.first;
+
+ // Currently everything must be a string.
+ if (element_pair.second->getType() != isc::data::Element::string) {
+ isc_throw (UserFileError, "UserFile entry: " << user_string
+ << "has non-string value for : " << label);
+ }
+
+ std::string value = element_pair.second->stringValue();
+
+ if (label == "type") {
+ id_type_str = value;
+ } else if (label == "id") {
+ id_str = value;
+ } else {
+ // JSON parsing reduces any duplicates to the last value parsed,
+ // so we will never see duplicates here.
+ properties[label]=value;
+ }
+ }
+
+ // First we attempt to translate the id type.
+ UserId::UserIdType id_type;
+ try {
+ id_type = UserId::lookupType(id_type_str);
+ } catch (const std::exception& ex) {
+ isc_throw (UserFileError, "UserFile entry has invalid type: "
+ << user_string << " " << ex.what());
+ }
+
+ // Id type is valid, so attempt to make the user based on that and
+ // the value we have for "id".
+ UserPtr user;
+ try {
+ user.reset(new User(id_type, id_str));
+ } catch (const std::exception& ex) {
+ isc_throw (UserFileError, "UserFile cannot create user form entry: "
+ << user_string << " " << ex.what());
+ }
+
+ // We have a new User, so add in the properties and return it.
+ user->setProperties(properties);
+ return (user);
+}
+
+bool
+UserFile::isOpen() const {
+ return (file_.is_open());
+}
+
+void
+UserFile::close() {
+ try {
+ if (file_.is_open()) {
+ file_.close();
+ }
+ } catch (const std::exception& ex) {
+ // Highly unlikely to occur but let's at least spit out an error.
+ // Beyond that we swallow it for tidiness.
+ std::cout << "UserFile unexpected error closing the file: "
+ << fname_ << " : " << ex.what() << std::endl;
+ }
+}
+
diff --git a/src/hooks/dhcp/user_chk/user_file.h b/src/hooks/dhcp/user_chk/user_file.h
new file mode 100644
index 0000000..b65862e
--- /dev/null
+++ b/src/hooks/dhcp/user_chk/user_file.h
@@ -0,0 +1,135 @@
+// Copyright (C) 2013 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 _USER_FILE_H
+#define _USER_FILE_H
+
+/// @file user_file.h Defines the class, UserFile, which implements the UserDataSource interface for text files.
+
+#include <user_data_source.h>
+#include <user.h>
+
+#include <boost/shared_ptr.hpp>
+#include <fstream>
+#include <string>
+
+using namespace std;
+
+/// @brief Thrown a UserFile encounters an error.
+/// Note that it derives from UserDataSourceError to comply with the interface.
+class UserFileError : public UserDataSourceError {
+public:
+ UserFileError(const char* file, size_t line,
+ const char* what) :
+ UserDataSourceError(file, line, what) { };
+};
+
+/// @brief Provides a UserDataSource implementation for JSON text files.
+/// This class allows a text file of JSON entries to be treated as a source of
+/// User entries. The format of the file is one user entry per line, where
+/// each line contains a JSON string as follows:
+///
+/// { "type" : "<user type>", "id" : "<user_id>" (options) }
+///
+/// where:
+///
+/// <user_type> text label of the id type: "HW_ADDR" or "DUID"
+/// <user_id> the user's id as a string of hex digits without delimiters
+/// (options) zero or more string elements as name-value pairs, separated by
+/// commas: "opt1" : "val1", "other_opt", "77" ...
+///
+/// Each entry must have a valid entry for "type" and a valid entry or "id".
+///
+/// If an entry contains duplicate option names, that option will be assigend
+/// the last value found. This is typical JSON behavior.
+/// Currently, only string option values (i.e. enclosed in quotes) are
+/// supported.
+///
+/// Example file entries might look like this:
+/// @code
+///
+/// { "type" : "HW_ADDR", "id" : "01AC00F03344", "opt1" : "true" }
+/// { "type" : "DUID", "id" : "225060de0a0b", "opt1" : "false" }
+///
+/// @endcode
+class UserFile : public UserDataSource {
+public:
+ /// @brief Maximum length of a single user entry.
+ /// This value is somewhat arbitrary. 4K seems reasonably large. If it
+ /// goes beyond this, then a flat file is not likely the way to go.
+ static const size_t USER_ENTRY_MAX_LEN = 4096;
+
+ /// @brief Constructor
+ ///
+ /// Create a UserFile for the given file name without opening the file.
+ /// @param fname pathname to the input file.
+ ///
+ /// @throw UserFileError if given file name is empty.
+ UserFile(const std::string& fname);
+
+ /// @brief Destructor.
+ ////
+ /// The destructor does call the close method.
+ virtual ~UserFile();
+
+ /// @brief Opens the input file for reading.
+ ///
+ /// Upon successful completion, the file is opened and positioned to start
+ /// reading from the beginning of the file.
+ ///
+ /// @throw UserFileError if the file cannot be opened.
+ virtual void open();
+
+ /// @brief Fetches the next user from the file.
+ ///
+ /// Reads the next user entry from the file and attempts to create a
+ /// new User from the text therein. If there is no more data to be read
+ /// it returns an empty UserPtr.
+ ///
+ /// @return A UserPtr pointing to the new User or an empty pointer on EOF.
+ ///
+ /// @throw UserFileError if an error occurs while reading.
+ virtual UserPtr readNextUser();
+
+ /// @brief Closes the underlying file.
+ ///
+ /// Method is exception safe.
+ virtual void close();
+
+ /// @brief Returns true if the file is open.
+ ///
+ /// @return True if the underlying file is open, false otherwise.
+ virtual bool isOpen() const;
+
+ /// @brief Creates a new User instance from JSON text.
+ ///
+ /// @param user_string string the JSON text for a user entry.
+ ///
+ /// @return A pointer to the newly created User instance.
+ ///
+ /// @throw UserFileError if the entry is invalid.
+ UserPtr makeUser(const std::string& user_string);
+
+private:
+ /// @brief Pathname of the input text file.
+ string fname_;
+
+ /// @brief Input file stream.
+ std::ifstream file_;
+
+};
+
+/// @brief Defines a smart pointer to a UserFile.
+typedef boost::shared_ptr<UserFile> UserFilePtr;
+
+#endif
diff --git a/src/hooks/dhcp/user_chk/user_registry.cc b/src/hooks/dhcp/user_chk/user_registry.cc
new file mode 100644
index 0000000..44b98a5
--- /dev/null
+++ b/src/hooks/dhcp/user_chk/user_registry.cc
@@ -0,0 +1,122 @@
+// Copyright (C) 2013 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 <user_registry.h>
+#include <user.h>
+
+UserRegistry::UserRegistry() {
+}
+
+UserRegistry::~UserRegistry(){
+}
+
+void
+UserRegistry::addUser(UserPtr& user) {
+ if (!user) {
+ isc_throw (UserRegistryError, "UserRegistry cannot add blank user");
+ }
+
+ UserPtr found_user;
+ if ((found_user = findUser(user->getUserId()))) {
+ isc_throw (UserRegistryError, "UserRegistry duplicate user: "
+ << user->getUserId());
+ }
+
+ users_[user->getUserId()] = user;
+}
+
+const UserPtr&
+UserRegistry::findUser(const UserId& id) const {
+ static UserPtr empty;
+ UserMap::const_iterator it = users_.find(id);
+ if (it != users_.end()) {
+ const UserPtr tmp = (*it).second;
+ return ((*it).second);
+ }
+
+ return empty;
+}
+
+void
+UserRegistry::removeUser(const UserId& id) {
+ static UserPtr empty;
+ UserMap::iterator it = users_.find(id);
+ if (it != users_.end()) {
+ users_.erase(it);
+ }
+}
+
+const UserPtr&
+UserRegistry::findUser(const isc::dhcp::HWAddr& hwaddr) const {
+ UserId id(UserId::HW_ADDRESS, hwaddr.hwaddr_);
+ return (findUser(id));
+}
+
+const UserPtr&
+UserRegistry::findUser(const isc::dhcp::DUID& duid) const {
+ UserId id(UserId::DUID, duid.getDuid());
+ return (findUser(id));
+}
+
+void UserRegistry::refresh() {
+ if (!source_) {
+ isc_throw(UserRegistryError,
+ "UserRegistry: cannot refresh, no data source");
+ }
+
+ // If the source isn't open, open it.
+ if (!source_->isOpen()) {
+ source_->open();
+ }
+
+ // Make a copy in case something goes wrong midstream.
+ UserMap backup(users_);
+
+ // Empty the registry then read users from source until source is empty.
+ clearall();
+ try {
+ UserPtr user;
+ while ((user = source_->readNextUser())) {
+ addUser(user);
+ }
+ } catch (const std::exception& ex) {
+ // Source was compromsised so restore registry from backup.
+ users_ = backup;
+ // Close the source.
+ source_->close();
+ isc_throw (UserRegistryError, "UserRegistry: refresh failed during read"
+ << ex.what());
+ }
+
+ // Close the source.
+ source_->close();
+}
+
+void UserRegistry::clearall() {
+ users_.clear();
+}
+
+void UserRegistry::setSource(UserDataSourcePtr& source) {
+ if (!source) {
+ isc_throw (UserRegistryError,
+ "UserRegistry: data source cannot be set to null");
+ }
+
+ source_ = source;
+}
+
+const UserDataSourcePtr& UserRegistry::getSource() {
+ return (source_);
+}
+
diff --git a/src/hooks/dhcp/user_chk/user_registry.h b/src/hooks/dhcp/user_chk/user_registry.h
new file mode 100644
index 0000000..a0fb7dc
--- /dev/null
+++ b/src/hooks/dhcp/user_chk/user_registry.h
@@ -0,0 +1,128 @@
+// Copyright (C) 2013 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 _USER_REGISTRY_H
+#define _USER_REGISTRY_H
+
+/// @file user_registry.h Defines the class, UserRegistry.
+
+#include <dhcp/hwaddr.h>
+#include <dhcp/duid.h>
+#include <exceptions/exceptions.h>
+#include <user.h>
+#include <user_data_source.h>
+
+#include <string>
+
+using namespace std;
+
+/// @brief Thrown UserRegistry encounters an error
+class UserRegistryError : public isc::Exception {
+public:
+ UserRegistryError(const char* file, size_t line,
+ const char* what) :
+ isc::Exception(file, line, what) { };
+};
+
+/// @brief Defines a map of unique Users keyed by UserId.
+typedef std::map<UserId,UserPtr> UserMap;
+
+/// @brief Embodies an update-able, searchable list of unique users
+/// This class provides the means to create and maintain a searchable list
+/// of unique users. List entries are pointers to instances of User, keyed
+/// by their UserIds.
+/// Users may be added and removed from the list individually or the list
+/// may be updated by loading it from a data source, such as a file.
+class UserRegistry {
+public:
+ /// @brief Constructor
+ ///
+ /// Creates a new registry with an empty list of users and no data source.
+ UserRegistry();
+
+ /// @brief Destructor
+ ~UserRegistry();
+
+ /// @brief Adds a given user to the registry.
+ ///
+ /// @param user A pointer to the user to add
+ ///
+ /// @throw UserRegistryError if the user is null or if the user already
+ /// exists in the registry.
+ void addUser(UserPtr& user);
+
+ /// @brief Finds a user in the registry by user id
+ ///
+ /// @param id The user id for which to search
+ ///
+ /// @return A pointer to the user if found or an null pointer if not.
+ const UserPtr& findUser(const UserId& id) const;
+
+ /// @brief Removes a user from the registry by user id
+ ///
+ /// Removes the user entry if found, if not simply return.
+ ///
+ /// @param id The user id of the user to remove
+ void removeUser(const UserId& id);
+
+ /// @brief Finds a user in the registry by hardware address
+ ///
+ /// @param hwaddr The hardware address for which to search
+ ///
+ /// @return A pointer to the user if found or an null pointer if not.
+ const UserPtr& findUser(const isc::dhcp::HWAddr& hwaddr) const;
+
+ /// @brief Finds a user in the registry by DUID
+ ///
+ /// @param duid The DUID for which to search
+ ///
+ /// @return A pointer to the user if found or an null pointer if not.
+ const UserPtr& findUser(const isc::dhcp::DUID& duid) const;
+
+ /// @brief Updates the registry from its data source.
+ ///
+ /// This method will replace the contents of the registry with new content
+ /// read from its data source. It will attempt to open the source and
+ /// then add users from the source to the registry until the source is
+ /// exhausted. If an error occurs accessing the source the registry
+ /// contents will be restored to that of before the call to refresh.
+ ///
+ /// @throw UserRegistryError if the data source has not been set (is null)
+ /// or if an error occurs accessing the data source.
+ void refresh();
+
+ /// @brief Removes all entries from the registry.
+ void clearall();
+
+ /// @brief Returns a reference to the data source.
+ const UserDataSourcePtr& getSource();
+
+ /// @brief Sets the data source to the given value.
+ ///
+ /// @param source reference to the data source to use.
+ ///
+ /// @throw UserRegistryError if new source value is null.
+ void setSource(UserDataSourcePtr& source);
+
+private:
+ /// @brief The registry of users.
+ UserMap users_;
+
+ /// @brief The current data source of users.
+ UserDataSourcePtr source_;
+};
+
+/// @brief Define a smart pointer to a UserRegistry.
+typedef boost::shared_ptr<UserRegistry> UserRegistryPtr;
+
+#endif
diff --git a/src/hooks/dhcp/user_chk/version.cc b/src/hooks/dhcp/user_chk/version.cc
new file mode 100644
index 0000000..eaa9d50
--- /dev/null
+++ b/src/hooks/dhcp/user_chk/version.cc
@@ -0,0 +1,25 @@
+// Copyright (C) 2013 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.
+// version.cc
+
+#include <hooks/hooks.h>
+
+extern "C" {
+
+/// @brief Version function required by Hooks API for compatibility checks.
+int version() {
+ return (BIND10_HOOKS_VERSION);
+}
+
+}
More information about the bind10-changes
mailing list