#include <dhcp4/dhcp4to6_ipc.h>
#include <dhcp4/parser_context.h>
#include <dhcp4/json_config_parser.h>
+#include <dhcp/libdhcp++.h>
#include <dhcpsrv/cfgmgr.h>
#include <dhcpsrv/cfg_db_access.h>
#include <hooks/hooks.h>
#include <signal.h>
#include <sstream>
+using namespace isc::config;
using namespace isc::data;
using namespace isc::db;
using namespace isc::dhcp;
using namespace isc::hooks;
-using namespace isc::config;
using namespace isc::stats;
using namespace std;
ControlledDhcpv4Srv* ControlledDhcpv4Srv::server_ = NULL;
-void
-ControlledDhcpv4Srv::init(const std::string& file_name) {
- // Configure the server using JSON file.
- ConstElementPtr result = loadConfigFile(file_name);
- int rcode;
- ConstElementPtr comment = isc::config::parseAnswer(rcode, result);
- if (rcode != 0) {
- string reason = comment ? comment->stringValue() :
- "no details available";
- isc_throw(isc::BadValue, reason);
- }
-
- // We don't need to call openActiveSockets() or startD2() as these
- // methods are called in processConfig() which is called by
- // processCommand("config-set", ...)
-
- // Set signal handlers. When the SIGHUP is received by the process
- // the server reconfiguration will be triggered. When SIGTERM or
- // SIGINT will be received, the server will start shutting down.
- signal_set_.reset(new isc::util::SignalSet(SIGINT, SIGHUP, SIGTERM));
- // Set the pointer to the handler function.
- signal_handler_ = signalHandler;
-}
-
-void ControlledDhcpv4Srv::cleanup() {
- // Nothing to do here. No need to disconnect from anything.
-}
-
/// @brief Configure DHCPv4 server using the configuration file specified.
///
/// This function is used to both configure the DHCP server on its startup
/// @param file_name Configuration file location.
/// @return status of the command
ConstElementPtr
-ControlledDhcpv4Srv::loadConfigFile(const std::string& file_name) {
+ControlledDhcpv4Srv::loadConfigFile(const string& file_name) {
// This is a configuration backend implementation that reads the
// configuration from a JSON file.
return (result);
}
+void
+ControlledDhcpv4Srv::init(const string& file_name) {
+ // Configure the server using JSON file.
+ ConstElementPtr result = loadConfigFile(file_name);
+ int rcode;
+ ConstElementPtr comment = isc::config::parseAnswer(rcode, result);
+ if (rcode != 0) {
+ string reason = comment ? comment->stringValue() :
+ "no details available";
+ isc_throw(isc::BadValue, reason);
+ }
+
+ // We don't need to call openActiveSockets() or startD2() as these
+ // methods are called in processConfig() which is called by
+ // processCommand("config-set", ...)
+
+ // Set signal handlers. When the SIGHUP is received by the process
+ // the server reconfiguration will be triggered. When SIGTERM or
+ // SIGINT will be received, the server will start shutting down.
+ signal_set_.reset(new isc::util::SignalSet(SIGINT, SIGHUP, SIGTERM));
+ // Set the pointer to the handler function.
+ signal_handler_ = signalHandler;
+}
+
+void ControlledDhcpv4Srv::cleanup() {
+ // Nothing to do here. No need to disconnect from anything.
+}
ConstElementPtr
ControlledDhcpv4Srv::commandShutdownHandler(const string&, ConstElementPtr) {
ControlledDhcpv4Srv::getInstance()->shutdown();
} else {
LOG_WARN(dhcp4_logger, DHCP4_NOT_RUNNING);
- ConstElementPtr answer = isc::config::createAnswer(1,
- "Shutdown failure.");
+ ConstElementPtr answer = isc::config::createAnswer(CONTROL_RESULT_ERROR,
+ "Shutdown failure.");
return (answer);
}
- ConstElementPtr answer = isc::config::createAnswer(0, "Shutting down.");
+ ConstElementPtr answer = isc::config::createAnswer(CONTROL_RESULT_SUCCESS, "Shutting down.");
return (answer);
}
ConstElementPtr
ControlledDhcpv4Srv::commandLibReloadHandler(const string&, ConstElementPtr) {
-
/// @todo delete any stored CalloutHandles referring to the old libraries
/// Get list of currently loaded libraries and reload them.
HookLibsCollection loaded = HooksManager::getLibraryInfo();
bool status = HooksManager::loadLibraries(loaded);
if (!status) {
LOG_ERROR(dhcp4_logger, DHCP4_HOOKS_LIBS_RELOAD_FAIL);
- ConstElementPtr answer = isc::config::createAnswer(1,
+ ConstElementPtr answer = isc::config::createAnswer(CONTROL_RESULT_ERROR,
"Failed to reload hooks libraries.");
return (answer);
}
- ConstElementPtr answer = isc::config::createAnswer(0,
+ ConstElementPtr answer = isc::config::createAnswer(CONTROL_RESULT_SUCCESS,
"Hooks libraries successfully reloaded.");
return (answer);
}
ConstElementPtr
ControlledDhcpv4Srv::commandConfigReloadHandler(const string&,
ConstElementPtr /*args*/) {
-
// Get configuration file name.
- std::string file = ControlledDhcpv4Srv::getInstance()->getConfigFile();
+ string file = ControlledDhcpv4Srv::getInstance()->getConfigFile();
try {
LOG_INFO(dhcp4_logger, DHCP4_DYNAMIC_RECONFIGURATION).arg(file);
return (loadConfigFile(file));
ConstElementPtr /*args*/) {
ConstElementPtr config = CfgMgr::instance().getCurrentCfg()->toElement();
- return (createAnswer(0, config));
+ return (createAnswer(CONTROL_RESULT_SUCCESS, config));
}
ConstElementPtr
if (filename.empty()) {
// filename parameter was not specified, so let's use whatever we remember
+ // from the command-line
filename = getConfigFile();
}
ConstElementPtr cfg = CfgMgr::instance().getCurrentCfg()->toElement();
size = writeConfigFile(filename, cfg);
} catch (const isc::Exception& ex) {
- return (createAnswer(CONTROL_RESULT_ERROR, string("Error during write-config:")
+ return (createAnswer(CONTROL_RESULT_ERROR, string("Error during write-config: ")
+ ex.what()));
}
if (size == 0) {
ConstElementPtr
ControlledDhcpv4Srv::commandConfigSetHandler(const string&,
ConstElementPtr args) {
- const int status_code = CONTROL_RESULT_ERROR; // 1 indicates an error
+ const int status_code = CONTROL_RESULT_ERROR;
ConstElementPtr dhcp4;
string message;
// the logging first in case there's a configuration failure.
int rcode = 0;
isc::config::parseAnswer(rcode, result);
- if (rcode == 0) {
+ if (rcode == CONTROL_RESULT_SUCCESS) {
CfgMgr::instance().getStagingCfg()->applyLoggingCfg();
// Update the fetch globals callback.
}
ConstElementPtr
-ControlledDhcpv4Srv::commandDhcpDisableHandler(const std::string&,
+ControlledDhcpv4Srv::commandDhcpDisableHandler(const string&,
ConstElementPtr args) {
std::ostringstream message;
int64_t max_period = 0;
}
ConstElementPtr
-ControlledDhcpv4Srv::commandDhcpEnableHandler(const std::string&, ConstElementPtr) {
+ControlledDhcpv4Srv::commandDhcpEnableHandler(const string&, ConstElementPtr) {
network_state_->enableService();
return (config::createAnswer(CONTROL_RESULT_SUCCESS, "DHCP service successfully enabled"));
}
ElementPtr extended = Element::create(Dhcpv4Srv::getVersion(true));
ElementPtr arguments = Element::createMap();
arguments->set("extended", extended);
- ConstElementPtr answer = isc::config::createAnswer(0,
+ ConstElementPtr answer = isc::config::createAnswer(CONTROL_RESULT_SUCCESS,
Dhcpv4Srv::getVersion(false),
arguments);
return (answer);
ControlledDhcpv4Srv::commandBuildReportHandler(const string&,
ConstElementPtr) {
ConstElementPtr answer =
- isc::config::createAnswer(0, isc::detail::getConfigReport());
+ isc::config::createAnswer(CONTROL_RESULT_SUCCESS, isc::detail::getConfigReport());
return (answer);
}
ControlledDhcpv4Srv* srv = ControlledDhcpv4Srv::getInstance();
if (!srv) {
- ConstElementPtr no_srv = isc::config::createAnswer(1,
- "Server object not initialized, so can't process command '" +
- command + "', arguments: '" + txt + "'.");
+ ConstElementPtr no_srv = isc::config::createAnswer(CONTROL_RESULT_ERROR,
+ "Server object not initialized, so can't process command '" +
+ command + "', arguments: '" + txt + "'.");
return (no_srv);
}
return (srv->commandConfigWriteHandler(command, args));
}
- ConstElementPtr answer = isc::config::createAnswer(1,
- "Unrecognized command:" + command);
- return (answer);
+
+ return (isc::config::createAnswer(CONTROL_RESULT_ERROR,
+ "Unrecognized command: " + command));
} catch (const Exception& ex) {
- return (isc::config::createAnswer(1, "Error while processing command '"
- + command + "':" + ex.what() +
+ return (isc::config::createAnswer(CONTROL_RESULT_ERROR,
+ "Error while processing command '" +
+ command + "': " + ex.what() +
", params: '" + txt + "'"));
}
}
ControlledDhcpv4Srv* srv = ControlledDhcpv4Srv::getInstance();
- // Single stream instance used in all error clauses
- std::ostringstream err;
-
if (!srv) {
- err << "Server object not initialized, can't process config.";
- return (isc::config::createAnswer(1, err.str()));
+ ConstElementPtr no_srv = isc::config::createAnswer(
+ CONTROL_RESULT_ERROR,
+ "Server object not initialized, can't process config.");
+ return (no_srv);
}
ConstElementPtr answer = configureDhcp4Server(*srv, config);
return (answer);
}
} catch (const std::exception& ex) {
- err << "Failed to process configuration:" << ex.what();
- return (isc::config::createAnswer(1, err.str()));
+ return (isc::config::createAnswer(CONTROL_RESULT_ERROR,
+ "Failed to process configuration: " +
+ string(ex.what())));
}
// Re-open lease and host database with new parameters.
cfg_db->setAppendedParameters("universe=4");
cfg_db->createManagers();
} catch (const std::exception& ex) {
- err << "Unable to open database: " << ex.what();
- return (isc::config::createAnswer(1, err.str()));
+ return (isc::config::createAnswer(CONTROL_RESULT_ERROR,
+ "Unable to open database: " +
+ string(ex.what())));
}
// Server will start DDNS communications if its enabled.
try {
srv->startD2();
} catch (const std::exception& ex) {
- err << "Error starting DHCP_DDNS client after server reconfiguration: "
- << ex.what();
- return (isc::config::createAnswer(1, err.str()));
+ std::ostringstream err;
+ err << "error starting DHCP_DDNS client "
+ " after server reconfiguration: " << ex.what();
+ return (isc::config::createAnswer(CONTROL_RESULT_ERROR, err.str()));
}
// Setup DHCPv4-over-DHCPv6 IPC
std::ostringstream err;
err << "error starting DHCPv4-over-DHCPv6 IPC "
" after server reconfiguration: " << ex.what();
- return (isc::config::createAnswer(1, err.str()));
+ return (isc::config::createAnswer(CONTROL_RESULT_ERROR, err.str()));
}
// Configure DHCP packet queueing
qc = CfgMgr::instance().getStagingCfg()->getDHCPQueueControl();
if (IfaceMgr::instance().configureDHCPPacketQueue(AF_INET, qc)) {
LOG_INFO(dhcp4_logger, DHCP4_CONFIG_PACKET_QUEUE)
- .arg(IfaceMgr::instance().getPacketQueue4()->getInfoStr());
+ .arg(IfaceMgr::instance().getPacketQueue4()->getInfoStr());
}
} catch (const std::exception& ex) {
+ std::ostringstream err;
err << "Error setting packet queue controls after server reconfiguration: "
<< ex.what();
- return (isc::config::createAnswer(1, err.str()));
+ return (isc::config::createAnswer(CONTROL_RESULT_ERROR, err.str()));
}
// Configuration may change active interfaces. Therefore, we have to reopen
server_);
} catch (const std::exception& ex) {
+ std::ostringstream err;
err << "unable to setup timers for periodically running the"
" reclamation of the expired leases: "
<< ex.what() << ".";
- return (isc::config::createAnswer(1, err.str()));
+ return (isc::config::createAnswer(CONTROL_RESULT_ERROR, err.str()));
}
+ // Setup config backend polling, if configured for it.
auto ctl_info = CfgMgr::instance().getStagingCfg()->getConfigControlInfo();
if (ctl_info) {
long fetch_time = static_cast<long>(ctl_info->getConfigFetchWaitTime());
ControlledDhcpv4Srv* srv = ControlledDhcpv4Srv::getInstance();
- // Single stream instance used in all error clauses
- std::ostringstream err;
-
if (!srv) {
- err << "Server object not initialized, can't process config.";
- return (isc::config::createAnswer(1, err.str()));
+ ConstElementPtr no_srv = isc::config::createAnswer(CONTROL_RESULT_ERROR,
+ "Server object not initialized, can't process config.");
+ return (no_srv);
}
return (configureDhcp4Server(*srv, config, true));
CommandMgr::instance().registerCommand("config-get",
boost::bind(&ControlledDhcpv4Srv::commandConfigGetHandler, this, _1, _2));
- CommandMgr::instance().registerCommand("config-reload",
- boost::bind(&ControlledDhcpv4Srv::commandConfigReloadHandler, this, _1, _2));
-
CommandMgr::instance().registerCommand("config-set",
boost::bind(&ControlledDhcpv4Srv::commandConfigSetHandler, this, _1, _2));
+ CommandMgr::instance().registerCommand("config-reload",
+ boost::bind(&ControlledDhcpv4Srv::commandConfigReloadHandler, this, _1, _2));
+
CommandMgr::instance().registerCommand("config-test",
boost::bind(&ControlledDhcpv4Srv::commandConfigTestHandler, this, _1, _2));
CommandMgr::instance().registerCommand("dhcp-disable",
boost::bind(&ControlledDhcpv4Srv::commandDhcpDisableHandler, this, _1, _2));
- CommandMgr::instance().registerCommand("libreload",
- boost::bind(&ControlledDhcpv4Srv::commandLibReloadHandler, this, _1, _2));
-
CommandMgr::instance().registerCommand("leases-reclaim",
boost::bind(&ControlledDhcpv4Srv::commandLeasesReclaimHandler, this, _1, _2));
+ CommandMgr::instance().registerCommand("libreload",
+ boost::bind(&ControlledDhcpv4Srv::commandLibReloadHandler, this, _1, _2));
+
CommandMgr::instance().registerCommand("shutdown",
boost::bind(&ControlledDhcpv4Srv::commandShutdownHandler, this, _1, _2));
CommandMgr::instance().registerCommand("statistic-get",
boost::bind(&StatsMgr::statisticGetHandler, _1, _2));
- CommandMgr::instance().registerCommand("statistic-reset",
- boost::bind(&StatsMgr::statisticResetHandler, _1, _2));
-
- CommandMgr::instance().registerCommand("statistic-remove",
- boost::bind(&StatsMgr::statisticRemoveHandler, _1, _2));
-
- //CommandMgr::instance().registerCommand("statistic-setMaxSampleAge",
- // boost::bind(&StatsMgr::statisticSetMaxSampleAgeHandler, _1, _2));
-
- //CommandMgr::instance().registerCommand("statistic-setMaxSampleCount",
- // boost::bind(&StatsMgr::statisticSetMaxSampleCountHandler, _1, _2));
-
CommandMgr::instance().registerCommand("statistic-get-all",
boost::bind(&StatsMgr::statisticGetAllHandler, _1, _2));
+ CommandMgr::instance().registerCommand("statistic-reset",
+ boost::bind(&StatsMgr::statisticResetHandler, _1, _2));
+
CommandMgr::instance().registerCommand("statistic-reset-all",
boost::bind(&StatsMgr::statisticResetAllHandler, _1, _2));
+ CommandMgr::instance().registerCommand("statistic-remove",
+ boost::bind(&StatsMgr::statisticRemoveHandler, _1, _2));
+
CommandMgr::instance().registerCommand("statistic-remove-all",
boost::bind(&StatsMgr::statisticRemoveAllHandler, _1, _2));
+ CommandMgr::instance().registerCommand("statistic-set-max-sample-age",
+ boost::bind(&StatsMgr::statisticSetMaxSampleAgeHandler, _1, _2));
+
+ CommandMgr::instance().registerCommand("statistic-set-max-sample-count",
+ boost::bind(&StatsMgr::statisticSetMaxSampleCountHandler, _1, _2));
}
void ControlledDhcpv4Srv::shutdown() {
// Deregister any registered commands (please keep in alphabetic order)
CommandMgr::instance().deregisterCommand("build-report");
CommandMgr::instance().deregisterCommand("config-get");
+ CommandMgr::instance().deregisterCommand("config-set");
CommandMgr::instance().deregisterCommand("config-reload");
CommandMgr::instance().deregisterCommand("config-test");
CommandMgr::instance().deregisterCommand("config-write");
+ CommandMgr::instance().deregisterCommand("dhcp-enable");
+ CommandMgr::instance().deregisterCommand("dhcp-disable");
CommandMgr::instance().deregisterCommand("leases-reclaim");
CommandMgr::instance().deregisterCommand("libreload");
- CommandMgr::instance().deregisterCommand("config-set");
- CommandMgr::instance().deregisterCommand("dhcp-disable");
- CommandMgr::instance().deregisterCommand("dhcp-enable");
CommandMgr::instance().deregisterCommand("shutdown");
+ CommandMgr::instance().deregisterCommand("version-get");
CommandMgr::instance().deregisterCommand("statistic-get");
CommandMgr::instance().deregisterCommand("statistic-get-all");
- CommandMgr::instance().deregisterCommand("statistic-remove");
- CommandMgr::instance().deregisterCommand("statistic-remove-all");
CommandMgr::instance().deregisterCommand("statistic-reset");
CommandMgr::instance().deregisterCommand("statistic-reset-all");
- //CommandMgr::instance().deregisterCommand("statistic-setMaxSampleAge");
- //CommandMgr::instance().deregisterCommand("statistic-setMaxSampleCount");
- CommandMgr::instance().deregisterCommand("version-get");
+ CommandMgr::instance().deregisterCommand("statistic-remove");
+ CommandMgr::instance().deregisterCommand("statistic-remove-all");
+ CommandMgr::instance().deregisterCommand("statistic-set-max-sample-age");
+ CommandMgr::instance().deregisterCommand("statistic-set-max-sample-count");
} catch (...) {
// Don't want to throw exceptions from the destructor. The server
;
}
- server_ = NULL; // forget this instance. Noone should call any handlers at
- // this stage.
+ server_ = NULL; // forget this instance. There should be no callback anymore
+ // at this stage anyway.
}
void ControlledDhcpv4Srv::sessionReader(void) {
#include <cc/data.h>
#include <cc/command_interpreter.h>
#include <config/command_mgr.h>
-#include <dhcp/libdhcp++.h>
-#include <dhcpsrv/cfgmgr.h>
-#include <dhcpsrv/cfg_db_access.h>
#include <dhcp6/ctrl_dhcp6_srv.h>
-#include <dhcp6/dhcp6to4_ipc.h>
#include <dhcp6/dhcp6_log.h>
-#include <dhcp6/json_config_parser.h>
#include <dhcp6/parser_context.h>
+#include <dhcp6/dhcp6to4_ipc.h>
+#include <dhcp6/json_config_parser.h>
+#include <dhcp/libdhcp++.h>
+#include <dhcpsrv/cfgmgr.h>
+#include <dhcpsrv/cfg_db_access.h>
+#include <hooks/hooks.h>
#include <hooks/hooks_manager.h>
#include <stats/stats_mgr.h>
#include <cfgrpt/config_report.h>
#include <sstream>
using namespace isc::config;
+using namespace isc::data;
using namespace isc::db;
using namespace isc::dhcp;
-using namespace isc::data;
using namespace isc::hooks;
using namespace isc::stats;
using namespace std;
/// @param file_name Configuration file location.
/// @return status of the command
ConstElementPtr
-ControlledDhcpv6Srv::loadConfigFile(const std::string& file_name) {
+ControlledDhcpv6Srv::loadConfigFile(const string& file_name) {
// This is a configuration backend implementation that reads the
// configuration from a JSON file.
try {
if (file_name.empty()) {
// Basic sanity check: file name must not be empty.
- isc_throw(isc::BadValue, "JSON configuration file not specified. Please "
- "use -c command line option.");
+ isc_throw(isc::BadValue, "JSON configuration file not specified."
+ " Please use -c command line option.");
}
// Read contents of the file and parse it as JSON
// Now check is the returned result is successful (rcode=0) or not
// (see @ref isc::config::parseAnswer).
int rcode;
- isc::data::ConstElementPtr comment =
- isc::config::parseAnswer(rcode, result);
+ ConstElementPtr comment = isc::config::parseAnswer(rcode, result);
if (rcode != 0) {
string reason = comment ? comment->stringValue() :
"no details available";
return (result);
}
-
void
-ControlledDhcpv6Srv::init(const std::string& file_name) {
+ControlledDhcpv6Srv::init(const string& file_name) {
// Configure the server using JSON file.
ConstElementPtr result = loadConfigFile(file_name);
int rcode;
// Nothing to do here. No need to disconnect from anything.
}
-
ConstElementPtr
ControlledDhcpv6Srv::commandShutdownHandler(const string&, ConstElementPtr) {
- if (ControlledDhcpv6Srv::server_) {
- ControlledDhcpv6Srv::server_->shutdown();
+ if (ControlledDhcpv6Srv::getInstance()) {
+ ControlledDhcpv6Srv::getInstance()->shutdown();
} else {
LOG_WARN(dhcp6_logger, DHCP6_NOT_RUNNING);
- ConstElementPtr answer = isc::config::createAnswer(1, "Shutdown failure.");
+ ConstElementPtr answer = isc::config::createAnswer(CONTROL_RESULT_ERROR,
+ "Shutdown failure.");
return (answer);
}
- ConstElementPtr answer = isc::config::createAnswer(0, "Shutting down.");
+ ConstElementPtr answer = isc::config::createAnswer(CONTROL_RESULT_SUCCESS, "Shutting down.");
return (answer);
}
bool status = HooksManager::loadLibraries(loaded);
if (!status) {
LOG_ERROR(dhcp6_logger, DHCP6_HOOKS_LIBS_RELOAD_FAIL);
- ConstElementPtr answer = isc::config::createAnswer(1,
+ ConstElementPtr answer = isc::config::createAnswer(CONTROL_RESULT_ERROR,
"Failed to reload hooks libraries.");
return (answer);
}
- ConstElementPtr answer = isc::config::createAnswer(0,
+ ConstElementPtr answer = isc::config::createAnswer(CONTROL_RESULT_SUCCESS,
"Hooks libraries successfully reloaded.");
return (answer);
}
ControlledDhcpv6Srv::commandConfigReloadHandler(const string&,
ConstElementPtr /*args*/) {
// Get configuration file name.
- std::string file = ControlledDhcpv6Srv::getInstance()->getConfigFile();
+ string file = ControlledDhcpv6Srv::getInstance()->getConfigFile();
try {
LOG_INFO(dhcp6_logger, DHCP6_DYNAMIC_RECONFIGURATION).arg(file);
return (loadConfigFile(file));
ConstElementPtr /*args*/) {
ConstElementPtr config = CfgMgr::instance().getCurrentCfg()->toElement();
- return (createAnswer(0, config));
+ return (createAnswer(CONTROL_RESULT_SUCCESS, config));
}
ConstElementPtr
-ControlledDhcpv6Srv::commandConfigWriteHandler(const string&, ConstElementPtr args) {
+ControlledDhcpv6Srv::commandConfigWriteHandler(const string&,
+ ConstElementPtr args) {
string filename;
if (args) {
ConstElementPtr cfg = CfgMgr::instance().getCurrentCfg()->toElement();
size = writeConfigFile(filename, cfg);
} catch (const isc::Exception& ex) {
- return (createAnswer(CONTROL_RESULT_ERROR, string("Error during write-config:")
+ return (createAnswer(CONTROL_RESULT_ERROR, string("Error during write-config: ")
+ ex.what()));
}
if (size == 0) {
}
ConstElementPtr
-ControlledDhcpv6Srv::commandDhcpDisableHandler(const std::string&,
+ControlledDhcpv6Srv::commandDhcpDisableHandler(const string&,
ConstElementPtr args) {
std::ostringstream message;
int64_t max_period = 0;
}
ConstElementPtr
-ControlledDhcpv6Srv::commandDhcpEnableHandler(const std::string&, ConstElementPtr) {
+ControlledDhcpv6Srv::commandDhcpEnableHandler(const string&, ConstElementPtr) {
network_state_->enableService();
return (config::createAnswer(CONTROL_RESULT_SUCCESS, "DHCP service successfully enabled"));
}
ElementPtr extended = Element::create(Dhcpv6Srv::getVersion(true));
ElementPtr arguments = Element::createMap();
arguments->set("extended", extended);
- ConstElementPtr answer = isc::config::createAnswer(0,
+ ConstElementPtr answer = isc::config::createAnswer(CONTROL_RESULT_SUCCESS,
Dhcpv6Srv::getVersion(false),
arguments);
return (answer);
}
ConstElementPtr
-ControlledDhcpv6Srv::commandBuildReportHandler(const string&, ConstElementPtr) {
+ControlledDhcpv6Srv::commandBuildReportHandler(const string&,
+ ConstElementPtr) {
ConstElementPtr answer =
- isc::config::createAnswer(0, isc::detail::getConfigReport());
+ isc::config::createAnswer(CONTROL_RESULT_SUCCESS, isc::detail::getConfigReport());
return (answer);
}
ConstElementPtr
ControlledDhcpv6Srv::commandLeasesReclaimHandler(const string&,
ConstElementPtr args) {
- int status_code = 1;
+ int status_code = CONTROL_RESULT_ERROR;
string message;
// args must be { "remove": <bool> }
}
isc::data::ConstElementPtr
-ControlledDhcpv6Srv::processCommand(const std::string& command,
- isc::data::ConstElementPtr args) {
+ControlledDhcpv6Srv::processCommand(string& command,
+ ConstElementPtr args) {
string txt = args ? args->str() : "(none)";
LOG_DEBUG(dhcp6_logger, DBG_DHCP6_COMMAND, DHCP6_COMMAND_RECEIVED)
ControlledDhcpv6Srv* srv = ControlledDhcpv6Srv::getInstance();
if (!srv) {
- ConstElementPtr no_srv = isc::config::createAnswer(1,
- "Server object not initialized, can't process command '" +
- command + "', arguments: '" + txt + "'.");
+ ConstElementPtr no_srv = isc::config::createAnswer(CONTROL_RESULT_ERROR,
+ "Server object not initialized, so can't process command '" +
+ command + "', arguments: '" + txt + "'.");
return (no_srv);
}
}
- return (isc::config::createAnswer(1, "Unrecognized command:"
- + command));
-
+ return (isc::config::createAnswer(CONTROL_RESULT_ERROR,
+ "Unrecognized command: " + command));
} catch (const Exception& ex) {
- return (isc::config::createAnswer(1, "Error while processing command '"
- + command + "':" + ex.what()));
+ return (isc::config::createAnswer(CONTROL_RESULT_ERROR,
+ "Error while processing command '" +
+ command + "': " + ex.what() +
+ ", params: '" + txt + "'"));
}
}
isc::data::ConstElementPtr
-ControlledDhcpv6Srv::processConfig(isc::data::ConstElementPtr config) {
+ControlledDhcpv6Srv::processConfig(ConstElementPtr config) {
LOG_DEBUG(dhcp6_logger, DBG_DHCP6_COMMAND, DHCP6_CONFIG_RECEIVED)
.arg(config->str());
return (answer);
}
} catch (const std::exception& ex) {
- return (isc::config::createAnswer(1, "Failed to process configuration:"
- + string(ex.what())));
+ return (isc::config::createAnswer(CONTROL_RESULT_ERROR,
+ "Failed to process configuration: " +
+ string(ex.what())));
}
// Re-open lease and host database with new parameters.
cfg_db->setAppendedParameters("universe=6");
cfg_db->createManagers();
} catch (const std::exception& ex) {
- return (isc::config::createAnswer(1, "Unable to open database: "
- + std::string(ex.what())));
+ return (isc::config::createAnswer(CONTROL_RESULT_ERROR,
+ "Unable to open database: " +
+ string(ex.what())));
}
// Regenerate server identifier if needed.
try {
- const std::string duid_file =
- std::string(CfgMgr::instance().getDataDir()) + "/" +
- std::string(SERVER_DUID_FILE);
+ const string duid_file =
+ string(CfgMgr::instance().getDataDir()) + "/" +
+ string(SERVER_DUID_FILE);
DuidPtr duid = CfgMgr::instance().getStagingCfg()->getCfgDUID()->create(duid_file);
server_->serverid_.reset(new Option(Option::V6, D6O_SERVERID, duid->getDuid()));
if (duid) {
} catch (const std::exception& ex) {
std::ostringstream err;
err << "unable to configure server identifier: " << ex.what();
- return (isc::config::createAnswer(1, err.str()));
+ return (isc::config::createAnswer(CONTROL_RESULT_ERROR, err.str()));
}
// Server will start DDNS communications if its enabled.
std::ostringstream err;
err << "error starting DHCP_DDNS client "
" after server reconfiguration: " << ex.what();
- return (isc::config::createAnswer(1, err.str()));
+ return (isc::config::createAnswer(CONTROL_RESULT_ERROR, err.str()));
}
// Setup DHCPv4-over-DHCPv6 IPC
std::ostringstream err;
err << "error starting DHCPv4-over-DHCPv6 IPC "
" after server reconfiguration: " << ex.what();
- return (isc::config::createAnswer(1, err.str()));
+ return (isc::config::createAnswer(CONTROL_RESULT_ERROR, err.str()));
}
// Configure DHCP packet queueing
std::ostringstream err;
err << "Error setting packet queue controls after server reconfiguration: "
<< ex.what();
- return (isc::config::createAnswer(1, err.str()));
+ return (isc::config::createAnswer(CONTROL_RESULT_ERROR, err.str()));
}
// Configuration may change active interfaces. Therefore, we have to reopen
err << "unable to setup timers for periodically running the"
" reclamation of the expired leases: "
<< ex.what() << ".";
- return (isc::config::createAnswer(1, err.str()));
+ return (isc::config::createAnswer(CONTROL_RESULT_ERROR, err.str()));
}
// Setup config backend polling, if configured for it.
ControlledDhcpv6Srv::checkConfig(isc::data::ConstElementPtr config) {
LOG_DEBUG(dhcp6_logger, DBG_DHCP6_COMMAND, DHCP6_CONFIG_RECEIVED)
- .arg(config->str());
+ .arg(config->str());
ControlledDhcpv6Srv* srv = ControlledDhcpv6Srv::getInstance();
if (!srv) {
- ConstElementPtr no_srv = isc::config::createAnswer(1,
+ ConstElementPtr no_srv = isc::config::createAnswer(CONTROL_RESULT_ERROR,
"Server object not initialized, can't process config.");
return (no_srv);
}
uint16_t client_port)
: Dhcpv6Srv(server_port, client_port), io_service_(),
timer_mgr_(TimerMgr::instance()) {
- if (server_) {
+ if (getInstance()) {
isc_throw(InvalidOperation,
"There is another Dhcpv6Srv instance already.");
}
- server_ = this; // remember this instance for use in callback
+ server_ = this; // remember this instance for later use in handlers
// TimerMgr uses IO service to run asynchronous timers.
TimerMgr::instance()->setIOService(getIOService());
CommandMgr::instance().registerCommand("config-get",
boost::bind(&ControlledDhcpv6Srv::commandConfigGetHandler, this, _1, _2));
+ CommandMgr::instance().registerCommand("config-set",
+ boost::bind(&ControlledDhcpv6Srv::commandConfigSetHandler, this, _1, _2));
+
CommandMgr::instance().registerCommand("config-reload",
boost::bind(&ControlledDhcpv6Srv::commandConfigReloadHandler, this, _1, _2));
CommandMgr::instance().registerCommand("config-write",
boost::bind(&ControlledDhcpv6Srv::commandConfigWriteHandler, this, _1, _2));
- CommandMgr::instance().registerCommand("dhcp-disable",
- boost::bind(&ControlledDhcpv6Srv::commandDhcpDisableHandler, this, _1, _2));
-
CommandMgr::instance().registerCommand("dhcp-enable",
boost::bind(&ControlledDhcpv6Srv::commandDhcpEnableHandler, this, _1, _2));
+ CommandMgr::instance().registerCommand("dhcp-disable",
+ boost::bind(&ControlledDhcpv6Srv::commandDhcpDisableHandler, this, _1, _2));
+
CommandMgr::instance().registerCommand("leases-reclaim",
boost::bind(&ControlledDhcpv6Srv::commandLeasesReclaimHandler, this, _1, _2));
CommandMgr::instance().registerCommand("libreload",
boost::bind(&ControlledDhcpv6Srv::commandLibReloadHandler, this, _1, _2));
- CommandMgr::instance().registerCommand("config-set",
- boost::bind(&ControlledDhcpv6Srv::commandConfigSetHandler, this, _1, _2));
-
CommandMgr::instance().registerCommand("shutdown",
boost::bind(&ControlledDhcpv6Srv::commandShutdownHandler, this, _1, _2));
CommandMgr::instance().registerCommand("statistic-remove-all",
boost::bind(&StatsMgr::statisticRemoveAllHandler, _1, _2));
- CommandMgr::instance().registerCommand("statistic-setMaxSampleAge",
+ CommandMgr::instance().registerCommand("statistic-set-max-sample-age",
boost::bind(&StatsMgr::statisticSetMaxSampleAgeHandler, _1, _2));
- CommandMgr::instance().registerCommand("statistic-setMaxSampleCount",
+ CommandMgr::instance().registerCommand("statistic-set-max-sample-count",
boost::bind(&StatsMgr::statisticSetMaxSampleCountHandler, _1, _2));
}
CommandMgr::instance().deregisterCommand("config-reload");
CommandMgr::instance().deregisterCommand("config-test");
CommandMgr::instance().deregisterCommand("config-write");
- CommandMgr::instance().deregisterCommand("dhcp-disable");
CommandMgr::instance().deregisterCommand("dhcp-enable");
+ CommandMgr::instance().deregisterCommand("dhcp-disable");
CommandMgr::instance().deregisterCommand("leases-reclaim");
CommandMgr::instance().deregisterCommand("libreload");
CommandMgr::instance().deregisterCommand("shutdown");
+ CommandMgr::instance().deregisterCommand("version-get");
CommandMgr::instance().deregisterCommand("statistic-get");
CommandMgr::instance().deregisterCommand("statistic-get-all");
- CommandMgr::instance().deregisterCommand("statistic-remove");
- CommandMgr::instance().deregisterCommand("statistic-remove-all");
CommandMgr::instance().deregisterCommand("statistic-reset");
CommandMgr::instance().deregisterCommand("statistic-reset-all");
- CommandMgr::instance().deregisterCommand("version-get");
+ CommandMgr::instance().deregisterCommand("statistic-remove");
+ CommandMgr::instance().deregisterCommand("statistic-remove-all");
+ CommandMgr::instance().deregisterCommand("statistic-set-max-sample-age");
+ CommandMgr::instance().deregisterCommand("statistic-set-max-sample-count");
} catch (...) {
// Don't want to throw exceptions from the destructor. The server
void ControlledDhcpv6Srv::sessionReader(void) {
// Process one asio event. If there are more events, iface_mgr will call
// this callback more than once.
- if (server_) {
- server_->io_service_.run_one();
+ if (getInstance()) {
+ getInstance()->io_service_.run_one();
}
}
if (reopened) {
// Cancel the timer.
if (TimerMgr::instance()->isTimerRegistered("Dhcp6DbReconnectTimer")) {
- TimerMgr::instance()->cancel("Dhcp6DbReconnectTimer"); }
+ TimerMgr::instance()->cancel("Dhcp6DbReconnectTimer");
+ }
// Set network state to service enabled
network_state_->enableService();
- // Toss the reconnct control, we're done with it
+ // Toss the reconnect control, we're done with it
db_reconnect_ctl.reset();
} else {
if (!db_reconnect_ctl->checkRetries()) {
if (!TimerMgr::instance()->isTimerRegistered("Dhcp6DbReconnectTimer")) {
TimerMgr::instance()->registerTimer("Dhcp6DbReconnectTimer",
boost::bind(&ControlledDhcpv6Srv::dbReconnect, this,
- db_reconnect_ctl),
+ db_reconnect_ctl),
db_reconnect_ctl->retryInterval(),
asiolink::IntervalTimer::ONE_SHOT);
}
projects / thirdparty / kea.git / commitdiff
