13 files changed, 35 insertions, 35 deletions
diff --git a/src/lib/log/logger.cc b/src/lib/log/logger.cc
index f7d6799481..c9840febb4 100644
--- a/src/lib/log/logger.cc
+++ b/src/lib/log/logger.cc
@@ -44,9 +44,9 @@ void Logger::initLoggerImpl() {
 Logger::~Logger() {
     delete loggerptr_;
 
-    // The next statement is required for the BIND 10 hooks framework, where
-    // a statically-linked BIND 10 loads and unloads multiple libraries. See
-    // the hooks documentation for more details.
+    // The next statement is required for the Kea hooks framework, where a
+    // statically-linked Kea loads and unloads multiple libraries. See the hooks
+    // documentation for more details.
     loggerptr_ = 0;
 }
 
diff --git a/src/lib/log/logger.h b/src/lib/log/logger.h
index 2dbc176d49..797591bb93 100644
--- a/src/lib/log/logger.h
+++ b/src/lib/log/logger.h
@@ -38,7 +38,7 @@ class InterprocessSync;
 
 /// \page LoggingApi Logging API
 /// \section LoggingApiOverview Overview
-/// BIND 10 logging uses the concepts of the widely-used Java logging
+/// Kea logging uses the concepts of the widely-used Java logging
 /// package log4j (http://logging.apache.log/log4j), albeit implemented
 /// in C++ using an open-source port.  Features of the system are:
 ///
@@ -57,12 +57,12 @@ class InterprocessSync;
 /// to the logger severity level or greater, e.g. if the logger's severity
 /// is WARN, only messages logged at WARN, ERROR or FATAL will be output.
 ///
-/// \section LoggingApiLoggerNames BIND 10 Logger Names
-/// Within BIND 10, the root logger root logger is given the name of the
+/// \section LoggingApiLoggerNames Kea Logger Names
+/// Within Kea, the root logger root logger is given the name of the
 /// program (via the stand-alone function setRootLoggerName()). Other loggers
 /// are children of the root logger and are named "<program>.<sublogger>".
 /// This name appears in logging output, allowing users to identify both
-/// the BIND 10 program and the component within the program that generated
+/// the Kea program and the component within the program that generated
 /// the message.
 ///
 /// When creating a logger, the abbreviated name "<sublogger>" can be used;
diff --git a/src/lib/log/logger_impl.cc b/src/lib/log/logger_impl.cc
index 96f021df66..49c8e6fd16 100644
--- a/src/lib/log/logger_impl.cc
+++ b/src/lib/log/logger_impl.cc
@@ -36,7 +36,7 @@
 
 #include <util/strutil.h>
 
-// Note: as log4cplus and the BIND 10 logger have many concepts in common, and
+// Note: as log4cplus and the Kea logger have many concepts in common, and
 // thus many similar names, to disambiguate types we don't "use" the log4cplus
 // namespace: instead, all log4cplus types are explicitly qualified.
 
diff --git a/src/lib/log/logger_impl.h b/src/lib/log/logger_impl.h
index 60f4c58b43..d63141fb21 100644
--- a/src/lib/log/logger_impl.h
+++ b/src/lib/log/logger_impl.h
@@ -29,7 +29,7 @@
 // log4cplus logger header file
 #include <log4cplus/logger.h>
 
-// BIND-10 logger files
+// Kea logger files
 #include <log/logger_level_impl.h>
 #include <log/message_types.h>
 #include <log/interprocess/interprocess_sync.h>
@@ -46,14 +46,14 @@ namespace log {
 /// This particular implementation is based on log4cplus (from sourceforge:
 /// http://log4cplus.sourceforge.net).  Particular items of note:
 ///
-/// a) BIND 10 loggers have names of the form "program.sublogger".  In other
+/// a) Kea loggers have names of the form "program.sublogger".  In other
 /// words, each of the loggers is a sub-logger of the main program logger.
 /// In log4cplus, there is a root logger (called "root" according to the
 /// documentation, but actually unnamed) and all loggers created are subloggers
 /// if it.
 ///
 /// In this implementation, the log4cplus root logger is unused.  Instead, the
-/// BIND 10 root logger is created as a child of the log4cplus root logger,
+/// Kea root logger is created as a child of the log4cplus root logger,
 /// and all other loggers used in the program are created as sub-loggers of
 /// that.  In this way, the logging system can just include the name of the
 /// logger in each message without the need to specially consider if the
diff --git a/src/lib/log/logger_level_impl.cc b/src/lib/log/logger_level_impl.cc
index bfc4748198..c728df6fc0 100644
--- a/src/lib/log/logger_level_impl.cc
+++ b/src/lib/log/logger_level_impl.cc
@@ -34,11 +34,11 @@ isc::log::Logger logger("log");
 namespace isc {
 namespace log {
 
-// Convert BIND 10 level to a log4cplus logging level.
+// Convert Kea level to a log4cplus logging level.
 log4cplus::LogLevel
 LoggerLevelImpl::convertFromBindLevel(const Level& level) {
 
-    // BIND 10 logging levels are small integers so we can do a table lookup
+    // Kea logging levels are small integers so we can do a table lookup
     static const log4cplus::LogLevel log4cplus_levels[] = {
         log4cplus::NOT_SET_LOG_LEVEL,
         log4cplus::DEBUG_LOG_LEVEL,
@@ -81,7 +81,7 @@ LoggerLevelImpl::convertFromBindLevel(const Level& level) {
     }
 }
 
-// Convert log4cplus logging level to BIND 10 debug level.  It is up to the
+// Convert log4cplus logging level to Kea debug level.  It is up to the
 // caller to validate that the debug level is valid.
 Level
 LoggerLevelImpl::convertToBindLevel(const log4cplus::LogLevel loglevel) {
diff --git a/src/lib/log/logger_level_impl.h b/src/lib/log/logger_level_impl.h
index 4e18e4695c..1296a5e873 100644
--- a/src/lib/log/logger_level_impl.h
+++ b/src/lib/log/logger_level_impl.h
@@ -33,9 +33,9 @@ namespace log {
 /// defines the following logging levels: OFF_LOG_LEVEL, FATAL_LOG_LEVEL,
 /// ERROR_LOG_LEVEL, WARN_LOG_LEVEL, INFO_LOG_LEVEL, DEBUG_LOG_LEVEL,
 /// TRACE_LOG_LEVEL, ALL_LOG_LEVEL (which here will be abbreviated OFF, FATAL
-/// etc.).  Within the context of BIND-10, OFF, TRACE and ALL are not used
+/// etc.).  Within the context of Kea, OFF, TRACE and ALL are not used
 /// and the idea of DEBUG has been extended, as will be seen below.  In
-/// BIND 10 terms, this is known as "severity"; the "logging level" usage will
+/// Kea terms, this is known as "severity"; the "logging level" usage will
 /// usually be used when talking about log4cplus aspects of the idea (as
 /// log4cplus uses that teminology).
 ///
@@ -60,7 +60,7 @@ namespace log {
 /// it corresponds to the default level of DEBUG.
 ///
 /// This class comprises nothing more than static methods to aid the conversion
-/// of logging levels between log4cplus and BIND 10, and to register those
+/// of logging levels between log4cplus and Kea, and to register those
 /// levels with log4cplus.
 
 class LoggerLevelImpl {
@@ -72,33 +72,33 @@ public:
     typedef log4cplus::tstring LogLevelString;
 #endif
 
-    /// \brief Convert BIND 10 level to log4cplus logging level
+    /// \brief Convert Kea level to log4cplus logging level
     ///
-    /// Converts the BIND 10 severity level into a log4cplus logging level.
-    /// If the severity is DEBUG, the current BIND 10 debug level is taken
+    /// Converts the Kea severity level into a log4cplus logging level.
+    /// If the severity is DEBUG, the current Kea debug level is taken
     /// into account when doing the conversion.
     ///
-    /// \param level BIND 10 severity and debug level
+    /// \param level Kea severity and debug level
     ///
     /// \return Equivalent log4cplus logging level.
     static
     log4cplus::LogLevel convertFromBindLevel(const isc::log::Level& level);
 
-    /// \brief Convert log4cplus logging level to BIND 10 logging level
+    /// \brief Convert log4cplus logging level to Kea logging level
     ///
-    /// Converts the log4cplus log level into a BIND 10 severity level.
+    /// Converts the log4cplus log level into a Kea severity level.
     /// The log4cplus log level may be non-standard in which case it is
-    /// encoding a BIND 10 debug level as well.
+    /// encoding a Kea debug level as well.
     ///
     /// \param loglevel log4cplus log level
     ///
-    /// \return Equivalent BIND 10 severity and debug level
+    /// \return Equivalent Kea severity and debug level
     static
     isc::log::Level convertToBindLevel(const log4cplus::LogLevel loglevel);
 
     /// \brief Convert string to log4cplus logging level
     ///
-    /// BIND 10 extends the set of logging levels in log4cplus with a group
+    /// Kea extends the set of logging levels in log4cplus with a group
     /// of debug levels.  These are given names DEBUG0 through DEBUG99 (with
     /// DEBUG0 being equivalent to DEBUG, the standard log level.  If the name
     /// is DEBUGn but n lies outside the range of debug levels, debug level
diff --git a/src/lib/log/logger_manager.cc b/src/lib/log/logger_manager.cc
index 114d32effd..c2e91c676f 100644
--- a/src/lib/log/logger_manager.cc
+++ b/src/lib/log/logger_manager.cc
@@ -107,7 +107,7 @@ LoggerManager::init(const std::string& root, isc::log::Severity severity,
     initSeverity() = severity;
     initDebugLevel() = dbglevel;
 
-    // Create the BIND 10 root logger and set the default severity and
+    // Create the Kea root logger and set the default severity and
     // debug level.  This is the logger that has the name of the application.
     // All other loggers created in this application will be its children.
     setRootLoggerName(root);
diff --git a/src/lib/log/logger_manager_impl.cc b/src/lib/log/logger_manager_impl.cc
index 9fb4d570ae..987c7c1ea4 100644
--- a/src/lib/log/logger_manager_impl.cc
+++ b/src/lib/log/logger_manager_impl.cc
@@ -225,7 +225,7 @@ void LoggerManagerImpl::initRootLogger(isc::log::Severity severity,
     // ignoring it.
     log4cplus::Logger::getRoot().setLogLevel(log4cplus::OFF_LOG_LEVEL);
 
-    // Set the level for the BIND 10 root logger to the given severity and
+    // Set the level for the Kea root logger to the given severity and
     // debug level.
     log4cplus::Logger b10root = log4cplus::Logger::getInstance(
                                                     getRootLoggerName());
diff --git a/src/lib/log/logger_manager_impl.h b/src/lib/log/logger_manager_impl.h
index 7a49820120..d67e90a383 100644
--- a/src/lib/log/logger_manager_impl.h
+++ b/src/lib/log/logger_manager_impl.h
@@ -43,7 +43,7 @@ struct OutputOption;
 /// of those specifications.
 ///
 /// Note: the logging has been implemented using a "pimpl" idiom to conceal
-/// the underlying implementation (log4cplus) from the BIND 10 interface.
+/// the underlying implementation (log4cplus) from the Kea interface.
 /// This requires that there be an implementation class, even though in this
 /// case, all the implementation class methods can be declared static.
 
@@ -80,7 +80,7 @@ public:
     /// messages) is called before a message is logged, log4cplus will output
     /// a message to stderr noting that logging has not been initialized.
     ///
-    /// It is assumed here that the name of the BIND 10 root logger can be
+    /// It is assumed here that the name of the Kea root logger can be
     /// obtained from the global function getRootLoggerName().
     ///
     /// \param severity Severity to be associated with this logger
@@ -144,7 +144,7 @@ private:
 
     /// \brief Set default layout and severity for root logger
     ///
-    /// Initializes the root logger to BIND 10 defaults - console or buffered
+    /// Initializes the root logger to Kea defaults - console or buffered
     /// output and the passed severity/debug level.
     ///
     /// \param severity Severity of messages that the logger should output.
diff --git a/src/lib/log/logger_unittest_support.cc b/src/lib/log/logger_unittest_support.cc
index d073a2f31a..1266cb3c10 100644
--- a/src/lib/log/logger_unittest_support.cc
+++ b/src/lib/log/logger_unittest_support.cc
@@ -170,7 +170,7 @@ void initLogger(isc::log::Severity severity, int dbglevel) {
     // the default severity, debug level and destination with those specified
     // in the environment variables.  (The two-step approach is used as the
     // setUnitTestRootLoggerCharacteristics() function is used in several
-    // places in the BIND 10 tests, and it avoid duplicating code.)
+    // places in the Kea tests, and it avoid duplicating code.)
     resetUnitTestRootLogger();
 } 
 
diff --git a/src/lib/log/tests/logger_example.cc b/src/lib/log/tests/logger_example.cc
index 729fdacabf..79d49ffad1 100644
--- a/src/lib/log/tests/logger_example.cc
+++ b/src/lib/log/tests/logger_example.cc
@@ -131,7 +131,7 @@ int main(int argc, char** argv) {
     // is encountered, the previous one is added to the list.
     //
     // One complication is that there is deemed to be a default active when
-    // the parsing starts (console output for the BIND 10 root logger).  This
+    // the parsing starts (console output for the Kea root logger).  This
     // is included in the logging specifications UNLESS the first switch on
     // the command line is a "-l" flag starting a new logger.  To track this,
     // the "sw_found" flag is set when a switch is completely processed. The
diff --git a/src/lib/log/tests/logger_level_impl_unittest.cc b/src/lib/log/tests/logger_level_impl_unittest.cc
index dacd2023d5..3f7f82055e 100644
--- a/src/lib/log/tests/logger_level_impl_unittest.cc
+++ b/src/lib/log/tests/logger_level_impl_unittest.cc
@@ -38,7 +38,7 @@ protected:
 };
 
 
-// Checks that the log4cplus and BIND 10 levels convert correctly
+// Checks that the log4cplus and Kea levels convert correctly
 TEST_F(LoggerLevelImplTest, DefaultConversionFromBind) {
     log4cplus::LogLevel fatal =
         LoggerLevelImpl::convertFromBindLevel(Level(FATAL));
diff --git a/src/lib/log/tests/logger_unittest.cc b/src/lib/log/tests/logger_unittest.cc
index d8027b4fbc..e0d7b9a33b 100644
--- a/src/lib/log/tests/logger_unittest.cc
+++ b/src/lib/log/tests/logger_unittest.cc
@@ -436,7 +436,7 @@ private:
     bool was_unlocked_;
 };
 
-// Checks that the logger logs exclusively and other BIND 10 components
+// Checks that the logger logs exclusively and other Kea components
 // are locked out.
 
 TEST_F(LoggerTest, Lock) {