47namespace ph = std::placeholders;
52struct CtrlDhcp4Hooks {
53 int hooks_index_dhcp4_srv_configured_;
77void signalHandler(
int signo) {
79 if (signo == SIGHUP) {
82 }
else if ((signo == SIGTERM) || (signo == SIGINT)) {
98 start_ = boost::posix_time::second_clock::universal_time();
106 string reason = comment ? comment->stringValue() :
107 "no details available";
140 if (file_name.empty()) {
143 " Please use -c command line option.");
157 "a map, i.e., start with { and end with } and contain "
158 "at least an entry called 'Dhcp4' that itself is a map. "
160 <<
" is a valid JSON, but its top element is not a map."
161 " Did you forget to add { } around your configuration?");
171 "processCommand(\"config-set\", json)");
179 string reason = comment ? comment->stringValue() :
180 "no details available";
183 }
catch (
const std::exception& ex) {
189 .arg(file_name).arg(ex.what());
191 << file_name <<
"': " << ex.
what());
203ControlledDhcpv4Srv::commandShutdownHandler(
const string&,
ConstElementPtr args) {
220 "parameter 'exit-value' is not an integer"));
223 exit_value = param->intValue();
232ControlledDhcpv4Srv::commandLibReloadHandler(
const string&,
ConstElementPtr) {
247 bool multi_threading_enabled =
true;
248 uint32_t thread_count = 0;
249 uint32_t queue_size = 0;
251 multi_threading_enabled, thread_count, queue_size);
255 "(WARNING: libreload is deprecated).");
257 }
catch (
const std::exception& ex) {
263 "Hooks libraries successfully reloaded "
264 "(WARNING: libreload is deprecated).");
269ControlledDhcpv4Srv::commandConfigReloadHandler(
const string&,
278 }
catch (
const std::exception& ex) {
285 "Config reload failed: " +
string(ex.what())));
290ControlledDhcpv4Srv::commandConfigGetHandler(
const string&,
300ControlledDhcpv4Srv::commandConfigHashGetHandler(
const string&,
312ControlledDhcpv4Srv::commandConfigWriteHandler(
const string&,
321 if (filename_param) {
324 "passed parameter 'filename' is not a string"));
326 filename = filename_param->stringValue();
330 if (filename.empty()) {
336 if (filename.empty()) {
338 "Please specify filename explicitly."));
361 + filename +
" successful", params));
365ControlledDhcpv4Srv::commandConfigSetHandler(
const string&,
374 message =
"Missing mandatory 'arguments' parameter.";
376 dhcp4 = args->get(
"Dhcp4");
378 message =
"Missing mandatory 'Dhcp4' parameter.";
380 message =
"'Dhcp4' parameter expected to be a map.";
385 if (message.empty()) {
386 for (
auto const& obj : args->mapValue()) {
387 const string& obj_name = obj.first;
388 if (obj_name !=
"Dhcp4") {
391 if (message.empty()) {
392 message =
"Unsupported '" + obj_name +
"' parameter";
394 message +=
" (and '" + obj_name +
"')";
398 if (!message.empty()) {
403 if (!message.empty()) {
460 }
catch (
const std::exception& ex) {
461 std::ostringstream err;
462 err <<
"Error initializing hooks: "
471ControlledDhcpv4Srv::commandConfigTestHandler(
const string&,
480 message =
"Missing mandatory 'arguments' parameter.";
482 dhcp4 = args->get(
"Dhcp4");
484 message =
"Missing mandatory 'Dhcp4' parameter.";
486 message =
"'Dhcp4' parameter expected to be a map.";
491 if (message.empty()) {
492 for (
auto const& obj : args->mapValue()) {
493 const string& obj_name = obj.first;
494 if (obj_name !=
"Dhcp4") {
497 if (message.empty()) {
498 message =
"Unsupported '" + obj_name +
"' parameter";
500 message +=
" (and '" + obj_name +
"')";
504 if (!message.empty()) {
509 if (!message.empty()) {
529ControlledDhcpv4Srv::commandDhcpDisableHandler(
const std::string&,
531 std::ostringstream message;
532 int64_t max_period = 0;
544 message <<
"arguments for the 'dhcp-disable' command must be a map";
549 if (max_period_element) {
552 message <<
"'max-period' argument must be a number";
556 max_period = max_period_element->intValue();
557 if (max_period <= 0) {
558 message <<
"'max-period' must be positive integer";
564 if (origin_element) {
565 switch (origin_element->getType()) {
567 origin = origin_element->stringValue();
568 if (origin ==
"ha-partner") {
570 }
else if (origin !=
"user") {
571 if (origin.empty()) {
572 origin =
"(empty string)";
574 message <<
"invalid value used for 'origin' parameter: "
579 type = origin_element->intValue();
583 message <<
"'origin' argument must be a string or a number";
590 if (message.tellp() == 0) {
591 message <<
"DHCPv4 service disabled";
592 if (max_period > 0) {
593 message <<
" for " << max_period <<
" seconds";
598 network_state_->delayedEnableService(
static_cast<unsigned>(max_period),
612ControlledDhcpv4Srv::commandDhcpEnableHandler(
const std::string&,
614 std::ostringstream message;
625 message <<
"arguments for the 'dhcp-enable' command must be a map";
630 if (origin_element) {
631 switch (origin_element->getType()) {
633 origin = origin_element->stringValue();
634 if (origin ==
"ha-partner") {
636 }
else if (origin !=
"user") {
637 if (origin.empty()) {
638 origin =
"(empty string)";
640 message <<
"invalid value used for 'origin' parameter: "
645 type = origin_element->intValue();
649 message <<
"'origin' argument must be a string or a number";
656 if (message.tellp() == 0) {
661 "DHCP service successfully enabled"));
669ControlledDhcpv4Srv::commandVersionGetHandler(
const string&,
ConstElementPtr) {
672 arguments->set(
"extended", extended);
680ControlledDhcpv4Srv::commandBuildReportHandler(
const string&,
688ControlledDhcpv4Srv::commandLeasesReclaimHandler(
const string&,
695 message =
"Missing mandatory 'remove' parameter.";
699 message =
"Missing mandatory 'remove' parameter.";
701 message =
"'remove' parameter expected to be a boolean.";
703 bool remove_lease = remove_name->boolValue();
704 server_->
alloc_engine_->reclaimExpiredLeases4(0, 0, remove_lease);
706 message =
"Reclamation of expired leases is complete.";
714ControlledDhcpv4Srv::commandServerTagGetHandler(
const std::string&,
716 const std::string& tag =
725ControlledDhcpv4Srv::commandConfigBackendPullHandler(
const std::string&,
747 server_->
getCBControl()->databaseConfigFetch(srv_cfg, mode);
748 }
catch (
const std::exception& ex) {
752 "On demand configuration update failed: " +
756 "On demand configuration update successful."));
760ControlledDhcpv4Srv::commandStatusGetHandler(
const string&,
765 auto now = boost::posix_time::second_clock::universal_time();
767 if (!
start_.is_not_a_date_time()) {
768 auto uptime = now -
start_;
773 if (!last_commit.is_not_a_date_time()) {
774 auto reload = now - last_commit;
779 if (mt_mgr.getMode()) {
786 queue_stats->add(
Element::create(mt_mgr.getThreadPool().getQueueStat(10)));
787 queue_stats->add(
Element::create(mt_mgr.getThreadPool().getQueueStat(100)));
788 queue_stats->add(
Element::create(mt_mgr.getThreadPool().getQueueStat(1000)));
789 status->set(
"packet-queue-statistics", queue_stats);
798 for (std::string
const&
error : interface->getErrors()) {
805 if (socket_errors->empty()) {
810 if (reconnect_ctl && reconnect_ctl->retriesLeft()) {
815 sockets->set(
"errors", socket_errors);
817 status->set(
"sockets", sockets);
823ControlledDhcpv4Srv::commandStatisticSetMaxSampleCountAllHandler(
const string&,
835ControlledDhcpv4Srv::commandStatisticSetMaxSampleAgeAllHandler(
const string&,
850 string txt = args ? args->str() :
"(none)";
853 .arg(command).arg(txt);
859 "Server object not initialized, so can't process command '" +
860 command +
"', arguments: '" + txt +
"'.");
865 if (command ==
"shutdown") {
866 return (srv->commandShutdownHandler(command, args));
868 }
else if (command ==
"libreload") {
869 return (srv->commandLibReloadHandler(command, args));
871 }
else if (command ==
"config-reload") {
872 return (srv->commandConfigReloadHandler(command, args));
874 }
else if (command ==
"config-set") {
875 return (srv->commandConfigSetHandler(command, args));
877 }
else if (command ==
"config-get") {
878 return (srv->commandConfigGetHandler(command, args));
880 }
else if (command ==
"config-hash-get") {
881 return (srv->commandConfigHashGetHandler(command, args));
883 }
else if (command ==
"config-test") {
884 return (srv->commandConfigTestHandler(command, args));
886 }
else if (command ==
"dhcp-disable") {
887 return (srv->commandDhcpDisableHandler(command, args));
889 }
else if (command ==
"dhcp-enable") {
890 return (srv->commandDhcpEnableHandler(command, args));
892 }
else if (command ==
"version-get") {
893 return (srv->commandVersionGetHandler(command, args));
895 }
else if (command ==
"build-report") {
896 return (srv->commandBuildReportHandler(command, args));
898 }
else if (command ==
"leases-reclaim") {
899 return (srv->commandLeasesReclaimHandler(command, args));
901 }
else if (command ==
"config-write") {
902 return (srv->commandConfigWriteHandler(command, args));
904 }
else if (command ==
"server-tag-get") {
905 return (srv->commandServerTagGetHandler(command, args));
907 }
else if (command ==
"config-backend-pull") {
908 return (srv->commandConfigBackendPullHandler(command, args));
910 }
else if (command ==
"status-get") {
911 return (srv->commandStatusGetHandler(command, args));
919 + command +
"': " + ex.
what() +
920 ", params: '" + txt +
"'"));
933 std::ostringstream err;
936 err <<
"Server object not initialized, can't process config.";
953 }
catch (
const std::exception& ex) {
954 err <<
"Failed to process configuration:" << ex.what();
961 std::bind(&ControlledDhcpv4Srv::dbLostCallback, srv, ph::_1);
964 std::bind(&ControlledDhcpv4Srv::dbRecoveredCallback, srv, ph::_1);
967 std::bind(&ControlledDhcpv4Srv::dbFailedCallback, srv, ph::_1);
970 string params =
"universe=4";
971 if (cfg_db->getExtendedInfoTablesEnabled()) {
972 params +=
" extended-info-tables=true";
974 cfg_db->setAppendedParameters(params);
975 cfg_db->createManagers();
979 }
catch (
const std::exception& ex) {
980 err <<
"Unable to open database: " << ex.what();
987 }
catch (
const std::exception& ex) {
988 err <<
"Error starting DHCP_DDNS client after server reconfiguration: "
996 }
catch (
const std::exception& ex) {
997 err <<
"error starting DHCPv4-over-DHCPv6 IPC "
998 " after server reconfiguration: " << ex.what();
1011 }
catch (
const std::exception& ex) {
1012 err <<
"Error setting packet queue controls after server reconfiguration: "
1020 std::bind(&ControlledDhcpv4Srv::openSocketsFailedCallback, srv, ph::_1);
1036 setupTimers(&ControlledDhcpv4Srv::reclaimExpiredLeases,
1037 &ControlledDhcpv4Srv::deleteExpiredReclaimedLeases,
1040 }
catch (
const std::exception& ex) {
1041 err <<
"unable to setup timers for periodically running the"
1042 " reclamation of the expired leases: "
1043 << ex.what() <<
".";
1050 long fetch_time =
static_cast<long>(ctl_info->getConfigFetchWaitTime());
1053 if (fetch_time > 0) {
1060 fetch_time = 1000 * fetch_time;
1063 boost::shared_ptr<unsigned> failure_count(
new unsigned(0));
1065 registerTimer(
"Dhcp4CBFetchTimer",
1066 std::bind(&ControlledDhcpv4Srv::cbFetchUpdates,
1080 if (notify_libraries) {
1081 return (notify_libraries);
1091 }
catch (
const std::exception& ex) {
1092 err <<
"Error initializing the lease allocators: "
1103 }
catch (
const std::exception& ex) {
1104 err <<
"Error applying multi threading settings: "
1123 callout_handle->setArgument(
"io_context", srv->
getIOService());
1125 callout_handle->setArgument(
"json_config", config);
1126 callout_handle->setArgument(
"server_config",
CfgMgr::instance().getStagingCfg());
1135 callout_handle->getArgument(
"error",
error);
1137 error =
"unknown error";
1152 "Server object not initialized, can't process config.");
1163 uint16_t client_port )
1167 "There is another Dhcpv4Srv instance already.");
1186 std::bind(&ControlledDhcpv4Srv::commandBuildReportHandler,
this, ph::_1, ph::_2));
1189 std::bind(&ControlledDhcpv4Srv::commandConfigBackendPullHandler,
this, ph::_1, ph::_2));
1192 std::bind(&ControlledDhcpv4Srv::commandConfigGetHandler,
this, ph::_1, ph::_2));
1195 std::bind(&ControlledDhcpv4Srv::commandConfigHashGetHandler,
this, ph::_1, ph::_2));
1198 std::bind(&ControlledDhcpv4Srv::commandConfigReloadHandler,
this, ph::_1, ph::_2));
1201 std::bind(&ControlledDhcpv4Srv::commandConfigSetHandler,
this, ph::_1, ph::_2));
1204 std::bind(&ControlledDhcpv4Srv::commandConfigTestHandler,
this, ph::_1, ph::_2));
1207 std::bind(&ControlledDhcpv4Srv::commandConfigWriteHandler,
this, ph::_1, ph::_2));
1210 std::bind(&ControlledDhcpv4Srv::commandDhcpEnableHandler,
this, ph::_1, ph::_2));
1213 std::bind(&ControlledDhcpv4Srv::commandDhcpDisableHandler,
this, ph::_1, ph::_2));
1216 std::bind(&ControlledDhcpv4Srv::commandLibReloadHandler,
this, ph::_1, ph::_2));
1219 std::bind(&ControlledDhcpv4Srv::commandLeasesReclaimHandler,
this, ph::_1, ph::_2));
1222 std::bind(&ControlledDhcpv4Srv::commandServerTagGetHandler,
this, ph::_1, ph::_2));
1225 std::bind(&ControlledDhcpv4Srv::commandShutdownHandler,
this, ph::_1, ph::_2));
1228 std::bind(&ControlledDhcpv4Srv::commandStatusGetHandler,
this, ph::_1, ph::_2));
1231 std::bind(&ControlledDhcpv4Srv::commandVersionGetHandler,
this, ph::_1, ph::_2));
1256 std::bind(&ControlledDhcpv4Srv::commandStatisticSetMaxSampleAgeAllHandler,
this, ph::_1, ph::_2));
1262 std::bind(&ControlledDhcpv4Srv::commandStatisticSetMaxSampleCountAllHandler,
this, ph::_1, ph::_2));
1283 timer_mgr_->unregisterTimers();
1330ControlledDhcpv4Srv::reclaimExpiredLeases(
const size_t max_leases,
1331 const uint16_t timeout,
1332 const bool remove_lease,
1333 const uint16_t max_unwarned_cycles) {
1335 server_->
alloc_engine_->reclaimExpiredLeases4(max_leases, timeout,
1337 max_unwarned_cycles);
1338 }
catch (
const std::exception& ex) {
1347ControlledDhcpv4Srv::deleteExpiredReclaimedLeases(
const uint32_t secs) {
1348 server_->
alloc_engine_->deleteExpiredReclaimedLeases4(secs);
1354ControlledDhcpv4Srv::dbLostCallback(
ReconnectCtlPtr db_reconnect_ctl) {
1355 if (!db_reconnect_ctl) {
1362 if (db_reconnect_ctl->retriesLeft() == db_reconnect_ctl->maxRetries() &&
1363 db_reconnect_ctl->alterServiceState()) {
1371 if (!db_reconnect_ctl->retriesLeft() ||
1372 !db_reconnect_ctl->retryInterval()) {
1374 .arg(db_reconnect_ctl->retriesLeft())
1375 .arg(db_reconnect_ctl->retryInterval());
1376 if (db_reconnect_ctl->exitOnFailure()) {
1386ControlledDhcpv4Srv::dbRecoveredCallback(
ReconnectCtlPtr db_reconnect_ctl) {
1387 if (!db_reconnect_ctl) {
1394 if (db_reconnect_ctl->alterServiceState()) {
1400 db_reconnect_ctl->resetRetries();
1406ControlledDhcpv4Srv::dbFailedCallback(
ReconnectCtlPtr db_reconnect_ctl) {
1407 if (!db_reconnect_ctl) {
1414 .arg(db_reconnect_ctl->maxRetries());
1416 if (db_reconnect_ctl->exitOnFailure()) {
1424ControlledDhcpv4Srv::openSocketsFailedCallback(
ReconnectCtlPtr reconnect_ctl) {
1425 if (!reconnect_ctl) {
1432 .arg(reconnect_ctl->maxRetries());
1434 if (reconnect_ctl->exitOnFailure()) {
1440ControlledDhcpv4Srv::cbFetchUpdates(
const SrvConfigPtr& srv_cfg,
1441 boost::shared_ptr<unsigned> failure_count) {
1449 (*failure_count) = 0;
1451 }
catch (
const std::exception& ex) {
1458 if (++(*failure_count) > 10) {
A generic exception that is thrown if a parameter given to a method is considered invalid in that con...
This is a base class for exceptions thrown from the DNS library module.
virtual const char * what() const
Returns a C-style character string of the cause of the exception.
A generic exception that is thrown if a function is called in a prohibited way.
A generic exception that is thrown when an unexpected error condition occurs.
void clearIOServices()
Clear the list of IOService objects.
static IOServiceMgr & instance()
Access the IOServiceMgr singleton instance.
void pollIOServices()
Poll IOService objects.
Implements an asynchronous "signal" for IOService driven processing.
static void setIOService(isc::asiolink::IOServicePtr io_service)
Set the I/O service.
void registerCommand(const std::string &cmd, CommandHandler handler)
Registers specified command handler for a given command.
static std::string getHash(const isc::data::ConstElementPtr &config)
returns a hash of a given Element structure
void deregisterCommand(const std::string &cmd)
Deregisters specified command handler.
void closeCommandSocket()
Shuts down any open control sockets.
static CommandMgr & instance()
CommandMgr is a singleton class.
void setIOService(const asiolink::IOServicePtr &io_service)
Sets IO service to be used by the command manager.
static ElementPtr create(const Position &pos=ZERO_POSITION())
static ElementPtr createMap(const Position &pos=ZERO_POSITION())
Creates an empty MapElement type ElementPtr.
static ElementPtr createList(const Position &pos=ZERO_POSITION())
Creates an empty ListElement type ElementPtr.
static void setIOService(const isc::asiolink::IOServicePtr &io_service)
Sets IO service to be used by the database backends.
static DbCallback db_recovered_callback_
Optional callback function to invoke if an opened connection recovery succeeded.
static DbCallback db_failed_callback_
Optional callback function to invoke if an opened connection recovery failed.
static DbCallback db_lost_callback_
Optional callback function to invoke if an opened connection is lost.
RAII class to enable DB reconnect retries on server startup.
static const std::string FLUSH_RECLAIMED_TIMER_NAME
Name of the timer for flushing reclaimed leases.
static const std::string RECLAIM_EXPIRED_TIMER_NAME
Name of the timer for reclaiming expired leases.
static OpenSocketsFailedCallback open_sockets_failed_callback_
Optional callback function to invoke if all retries of the opening sockets fail.
void rollback()
Removes staging configuration.
static CfgMgr & instance()
returns a single instance of Configuration Manager
SrvConfigPtr getStagingCfg()
Returns a pointer to the staging configuration.
void commit()
Commits the staging configuration.
SrvConfigPtr getCurrentCfg()
Returns a pointer to the current configuration.
static void apply(data::ConstElementPtr value)
apply multi threading configuration
static void extract(data::ConstElementPtr value, bool &enabled, uint32_t &thread_count, uint32_t &queue_size)
Extract multi-threading parameters from a given configuration.
Controlled version of the DHCPv4 server.
virtual ~ControlledDhcpv4Srv()
Destructor.
static isc::data::ConstElementPtr finishConfigHookLibraries(isc::data::ConstElementPtr config)
Configuration checker for hook libraries.
isc::data::ConstElementPtr loadConfigFile(const std::string &file_name)
Configure DHCPv4 server using the configuration file specified.
void cleanup()
Performs cleanup, immediately before termination.
static isc::data::ConstElementPtr processCommand(const std::string &command, isc::data::ConstElementPtr args)
Command processor.
ControlledDhcpv4Srv(uint16_t server_port=DHCP4_SERVER_PORT, uint16_t client_port=0)
Constructor.
static isc::data::ConstElementPtr checkConfig(isc::data::ConstElementPtr config)
Configuration checker.
void init(const std::string &config_file)
Initializes the server.
static isc::data::ConstElementPtr processConfig(isc::data::ConstElementPtr config)
Configuration processor.
static ControlledDhcpv4Srv * getInstance()
Returns pointer to the sole instance of Dhcpv4Srv.
virtual void shutdownServer(int exit_value)
Initiates shutdown procedure for the whole DHCPv4 server.
static Dhcp4to6Ipc & instance()
Returns pointer to the sole instance of Dhcp4to6Ipc.
virtual void open()
Open communication socket.
void startD2()
Starts DHCP_DDNS client IO if DDNS updates are enabled.
void shutdown() override
Instructs the server to shut down.
asiolink::IOServicePtr & getIOService()
Returns pointer to the IO service used by the server.
boost::shared_ptr< AllocEngine > alloc_engine_
Allocation Engine.
bool inTestMode() const
Checks if the server is running in unit test mode.
NetworkStatePtr & getNetworkState()
Returns pointer to the network state used by the server.
static std::string getVersion(bool extended)
returns Kea version on stdout and exit.
bool useBroadcast() const
Return bool value indicating that broadcast flags should be set on sockets.
NetworkStatePtr network_state_
Holds information about disabled DHCP service and/or disabled subnet/network scopes.
uint16_t getServerPort() const
Get UDP port on which server should listen.
CBControlDHCPv4Ptr getCBControl() const
Returns an object which controls access to the configuration backends.
static void create()
Creates new instance of the HostMgr.
static IfaceMgr & instance()
IfaceMgr is a singleton class.
static void destroy()
Destroy lease manager.
static void commitRuntimeOptionDefs()
Commits runtime option definitions.
static const unsigned int DB_CONNECTION
The network state is being altered by the DB connection recovery mechanics.
static const unsigned int USER_COMMAND
Origin of the network state transition.
static const unsigned int HA_REMOTE_COMMAND
The network state is being altered by a "dhcp-disable" or "dhcp-enable" command sent by a HA partner.
Evaluation context, an interface to the expression evaluation.
isc::data::ElementPtr parseFile(const std::string &filename, ParserType parser_type)
Run the parser on the file specified.
@ PARSER_DHCP4
This parser will parse the content as Dhcp4 config wrapped in a map (that's the regular config file)
Manages a pool of asynchronous interval timers.
static const TimerMgrPtr & instance()
Returns pointer to the sole instance of the TimerMgr.
@ NEXT_STEP_DROP
drop the packet
static int registerHook(const std::string &name)
Register Hook.
static bool calloutsPresent(int index)
Are callouts present?
static bool unloadLibraries()
Unload libraries.
static bool loadLibraries(const HookLibsCollection &libraries, bool multi_threading_enabled=false)
Load and reload libraries.
static boost::shared_ptr< CalloutHandle > createCalloutHandle()
Return callout handle.
static void callCallouts(int index, CalloutHandle &handle)
Calls the callouts for a given hook.
static HookLibsCollection getLibraryInfo()
Return list of loaded libraries with its parameters.
static void prepareUnloadLibraries()
Prepare the unloading of libraries.
std::string getConfigFile() const
Returns config file name.
virtual size_t writeConfigFile(const std::string &config_file, isc::data::ConstElementPtr cfg=isc::data::ConstElementPtr()) const
Writes current configuration to specified file.
isc::asiolink::IOSignalSetPtr signal_set_
A pointer to the object installing custom signal handlers.
boost::posix_time::ptime start_
Timestamp of the start of the daemon.
void setExitValue(int value)
Sets the exit value.
isc::data::ConstElementPtr redactConfig(isc::data::ConstElementPtr const &config)
Redact a configuration.
Statistics Manager class.
static StatsMgr & instance()
Statistics Manager accessor method.
RAII class creating a critical section.
static MultiThreadingMgr & instance()
Returns a single instance of Multi Threading Manager.
ThreadPool< std::function< void()> > & getThreadPool()
Get the dhcp thread pool.
void apply(bool enabled, uint32_t thread_count, uint32_t queue_size)
Apply the multi-threading related settings.
This file contains several functions and constants that are used for handling commands and responses ...
Contains declarations for loggers used by the DHCPv4 server component.
Defines the Dhcp4o6Ipc class.
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
isc::data::ConstElementPtr statisticSetMaxSampleCountAllHandler(const isc::data::ConstElementPtr ¶ms)
Handles statistic-sample-count-set-all command.
static isc::data::ConstElementPtr statisticResetHandler(const std::string &name, const isc::data::ConstElementPtr ¶ms)
Handles statistic-reset command.
static isc::data::ConstElementPtr statisticGetAllHandler(const std::string &name, const isc::data::ConstElementPtr ¶ms)
Handles statistic-get-all command.
static isc::data::ConstElementPtr statisticRemoveHandler(const std::string &name, const isc::data::ConstElementPtr ¶ms)
Handles statistic-remove command.
static isc::data::ConstElementPtr statisticGetHandler(const std::string &name, const isc::data::ConstElementPtr ¶ms)
Handles statistic-get command.
isc::data::ConstElementPtr statisticSetMaxSampleAgeAllHandler(const isc::data::ConstElementPtr ¶ms)
Handles statistic-sample-age-set-all command.
static isc::data::ConstElementPtr statisticResetAllHandler(const std::string &name, const isc::data::ConstElementPtr ¶ms)
Handles statistic-reset-all command.
static isc::data::ConstElementPtr statisticSetMaxSampleAgeHandler(const std::string &name, const isc::data::ConstElementPtr ¶ms)
Handles statistic-sample-age-set command.
static isc::data::ConstElementPtr statisticRemoveAllHandler(const std::string &name, const isc::data::ConstElementPtr ¶ms)
Handles statistic-remove-all command.
static isc::data::ConstElementPtr statisticSetMaxSampleCountHandler(const std::string &name, const isc::data::ConstElementPtr ¶ms)
Handles statistic-sample-count-set command.
uint32_t getMaxSampleCountDefault() const
Get default count limit.
const StatsDuration & getMaxSampleAgeDefault() const
Get default duration limit.
#define LOG_ERROR(LOGGER, MESSAGE)
Macro to conveniently test error output and log it.
#define LOG_INFO(LOGGER, MESSAGE)
Macro to conveniently test info output and log it.
#define LOG_WARN(LOGGER, MESSAGE)
Macro to conveniently test warn output and log it.
#define LOG_FATAL(LOGGER, MESSAGE)
Macro to conveniently test fatal output and log it.
#define LOG_DEBUG(LOGGER, LEVEL, MESSAGE)
Macro to conveniently test debug output and log it.
boost::shared_ptr< IOService > IOServicePtr
Defines a smart pointer to an IOService instance.
const int CONTROL_RESULT_EMPTY
Status code indicating that the specified command was completed correctly, but failed to produce any ...
const int CONTROL_RESULT_ERROR
Status code indicating a general failure.
ConstElementPtr createAnswer()
Creates a standard config/command level success answer message (i.e.
ConstElementPtr parseAnswer(int &rcode, const ConstElementPtr &msg)
const int CONTROL_RESULT_SUCCESS
Status code indicating a successful operation.
boost::shared_ptr< const Element > ConstElementPtr
boost::shared_ptr< Element > ElementPtr
std::string getConfigReport()
const isc::log::MessageID DHCP4_NOT_RUNNING
const isc::log::MessageID DHCP4_DYNAMIC_RECONFIGURATION_FAIL
const isc::log::MessageID DHCP4_CONFIG_RECEIVED
const isc::log::MessageID DHCP4_DYNAMIC_RECONFIGURATION_SUCCESS
boost::shared_ptr< CfgDbAccess > CfgDbAccessPtr
A pointer to the CfgDbAccess.
boost::shared_ptr< Iface > IfacePtr
Type definition for the pointer to an Iface object.
const isc::log::MessageID DHCP4_DB_RECONNECT_NO_DB_CTL
const isc::log::MessageID DHCP4_CB_PERIODIC_FETCH_UPDATES_RETRIES_EXHAUSTED
const isc::log::MessageID DHCP4_CONFIG_PACKET_QUEUE
boost::shared_ptr< SrvConfig > SrvConfigPtr
Non-const pointer to the SrvConfig.
const isc::log::MessageID DHCP4_CB_ON_DEMAND_FETCH_UPDATES_FAIL
const isc::log::MessageID DHCP4_CONFIG_LOAD_FAIL
const int DBG_DHCP4_COMMAND
Debug level used to log receiving commands.
const isc::log::MessageID DHCP4_HOOKS_LIBS_RELOAD_FAIL
const isc::log::MessageID DHCP4_DB_RECONNECT_DISABLED
const isc::log::MessageID DHCP4_CONFIG_UNRECOVERABLE_ERROR
const isc::log::MessageID DHCP4_DEPRECATED
const isc::log::MessageID DHCP4_DB_RECONNECT_SUCCEEDED
isc::data::ConstElementPtr configureDhcp4Server(Dhcpv4Srv &server, isc::data::ConstElementPtr config_set, bool check_only, bool extra_checks)
Configure DHCPv4 server (Dhcpv4Srv) with a set of configuration values.
const isc::log::MessageID DHCP4_COMMAND_RECEIVED
const isc::log::MessageID DHCP4_MULTI_THREADING_INFO
const isc::log::MessageID DHCP4_OPEN_SOCKETS_NO_RECONNECT_CTL
isc::log::Logger dhcp4_logger(DHCP4_APP_LOGGER_NAME)
Base logger for DHCPv4 server.
const isc::log::MessageID DHCP4_DB_RECONNECT_FAILED
const isc::log::MessageID DHCP4_OPEN_SOCKETS_FAILED
const isc::log::MessageID DHCP4_DYNAMIC_RECONFIGURATION
const isc::log::MessageID DHCP4_RECLAIM_EXPIRED_LEASES_FAIL
const isc::log::MessageID DHCP4_CONFIG_UNSUPPORTED_OBJECT
const isc::log::MessageID DHCP4_CB_PERIODIC_FETCH_UPDATES_FAIL
const isc::log::MessageID DHCP4_DB_RECONNECT_LOST_CONNECTION
std::vector< HookLibInfo > HookLibsCollection
A storage for information about hook libraries.
boost::shared_ptr< CalloutHandle > CalloutHandlePtr
A shared pointer to a CalloutHandle object.
long toSeconds(const StatsDuration &dur)
Returns the number of seconds in a duration.
boost::shared_ptr< ReconnectCtl > ReconnectCtlPtr
Pointer to an instance of ReconnectCtl.
Defines the logger used by the top-level component of kea-lfc.
void reset()
reset the thread pool stopping threads and clearing the internal queue