From: Tomek Mrugalski Date: Tue, 1 Aug 2017 19:03:46 +0000 (+0200) Subject: [5272] lease4-add, lease6-add implemented X-Git-Tag: trac5124a_base~20^2~11 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=92280f3da1cfb353d6a6e274b66c08482a38f223;p=thirdparty%2Fkea.git [5272] lease4-add, lease6-add implemented --- diff --git a/src/hooks/dhcp/lease_cmds/.gitignore b/src/hooks/dhcp/lease_cmds/.gitignore new file mode 100644 index 0000000000..310e853700 --- /dev/null +++ b/src/hooks/dhcp/lease_cmds/.gitignore @@ -0,0 +1,4 @@ +/lease_cmds_messages.cc +/lease_cmds_messages.h +/s-messages +/html diff --git a/src/hooks/dhcp/lease_cmds/lease_cmds.cc b/src/hooks/dhcp/lease_cmds/lease_cmds.cc index c3f507937d..0e24a36c22 100644 --- a/src/hooks/dhcp/lease_cmds/lease_cmds.cc +++ b/src/hooks/dhcp/lease_cmds/lease_cmds.cc @@ -57,7 +57,7 @@ public: TYPE_HWADDR, ///< query by hardware address (v4 only) TYPE_DUID ///< query by DUID (v6 only) } Type; - + /// @brief Specifies subnet-id (always used) SubnetID subnet_id; @@ -71,13 +71,31 @@ public: /// @brief Specifies identifier value (used when query_by_addr is false) isc::dhcp::DuidPtr duid; + static Type txtToType(const std::string& txt) { + if (txt == "address") { + return (Parameters::TYPE_ADDR); + } else if (txt == "hw-address") { + return (Parameters::TYPE_HWADDR); + } else if (txt == "duid") { + return (Parameters::TYPE_DUID); + } else { + isc_throw(BadValue, "Incorrect identifier type: " + << txt << ", the only supported values are: " + "address, hw-address, duid"); + } + } + /// @brief specifies parameter types (true = query by address, false = /// query by indetifier-type,identifier) Type query_type; + Lease::Type lease_type; + + uint32_t iaid; + /// @brief Default contstructor. Parameters() - :addr("::"), query_type(TYPE_ADDR) { + :addr("::"), query_type(TYPE_ADDR), lease_type(Lease::TYPE_NA), iaid(0) { } }; @@ -135,8 +153,8 @@ private: /// "valid-lft": 3600, /// "expire": 1499282530, /// "subnet-id": 1, - /// "fdqn_fwd": true, - /// "fqdn_rev": true, + /// "fdqn-fwd": true, + /// "fqdn-rev": true, /// "hostname": "myhost.example.org", /// "state": 0 /// } @@ -236,6 +254,7 @@ private: }; LeaseCmdsImpl::LeaseCmdsImpl() { + /// @todo: Remove family_ family_ = CfgMgr::instance().getFamily(); registerCommands(); @@ -311,32 +330,34 @@ LeaseCmdsImpl::leaseAddHandler(const std::string& name, isc_throw(isc::BadValue, "'lease' parameters must be specified"); } + ConstSrvConfigPtr config = CfgMgr::instance().getCurrentCfg(); + Lease4Ptr lease4; Lease6Ptr lease6; if (v4) { - LeaseDataParser4 parser; - lease4 = parser.parse(lease_data); + Lease4Parser parser; + lease4 = parser.parse(config, lease_data); - checkLeaseIntegrity(lease4); + // checkLeaseIntegrity(config, lease4); if (lease4) { - LeaseMgrFactory::instance().add(lease4); + LeaseMgrFactory::instance().addLease(lease4); } } else { - LeaseDataParser6 parser; - lease6 = parser.parse(lease_data); + Lease6Parser parser; + lease6 = parser.parse(config, lease_data); - checkLeaseIntegrity(lease6); + // checkLeaseIntegrity(config, lease6); if (lease6) { - LeaseMgrFactory::instance().add(lease6); + LeaseMgrFactory::instance().addLease(lease6); } } } catch (const std::exception& ex) { - LOG_ERROR(lease_cmds_logger, LEASE_CMDS_RESERV_ADD_FAILED) + LOG_ERROR(lease_cmds_logger, v4 ? LEASE_CMDS_ADD4_FAILED : LEASE_CMDS_ADD6_FAILED) .arg(txt) .arg(ex.what()); return (createAnswer(CONTROL_RESULT_ERROR, ex.what())); @@ -366,15 +387,14 @@ LeaseCmdsImpl::getParameters(const ConstElementPtr& params) { } x.subnet_id = tmp->intValue(); - tmp = params->get("ip-address"); - ConstLeasePtr host; + tmp = params->get("address"); if (tmp) { if (tmp->getType() != Element::string) { - isc_throw(BadValue, "'ip-address' is not a string."); + isc_throw(BadValue, "'address' is not a string."); } x.addr = IOAddress(tmp->stringValue()); - x.query_by_addr = true; + x.query_type = Parameters::TYPE_ADDR; return (x); } @@ -394,32 +414,29 @@ LeaseCmdsImpl::getParameters(const ConstElementPtr& params) { } // Got the parameters. Let's see if their values make sense. - - // Try to parse the identifier value first. - try { - x.ident = util::str::quotedStringToBinary(ident->stringValue()); - if (x.ident.empty()) { - util::str::decodeFormattedHexString(ident->stringValue(), - x.ident); - } - } catch (...) { - // The string doesn't match any known pattern, so we have to - // report an error at this point. - isc_throw(BadValue, "Unable to parse 'identifier' value."); + // Try to convert identifier-type + x.query_type = Parameters::txtToType(type->stringValue()); + + switch (x.query_type) { + case Parameters::TYPE_HWADDR: { + HWAddr hw = HWAddr::fromText(ident->stringValue()); + x.hwaddr = HWAddrPtr(new HWAddr(hw)); + break; } - - if (x.ident.empty()) { - isc_throw(BadValue, "Unable to query for empty 'identifier'."); + case Parameters::TYPE_DUID: { + DUID duid = DUID::fromText(ident->stringValue()); + x.duid = DuidPtr(new DUID(duid)); + } + case Parameters::TYPE_ADDR: { + // We should never get here. The address clause should have been caught + // earlier. + return (x); + } + default: { + isc_throw(BadValue, "Identifier type " << type->stringValue() << + " is not supported."); } - - // Next, try to convert identifier-type - try { - x.type = Lease::getIdentifierType(type->stringValue()); - } catch (const std::exception& ex) { - isc_throw(BadValue, "Value of 'identifier-type' was not recognized."); } - - x.query_by_addr = false; return (x); } @@ -433,77 +450,93 @@ LeaseCmdsImpl::leaseGetHandler(const std::string& name, ConstElementPtr params) p = getParameters(params); switch (p.query_type) { - case TYPE_ADDR: { + case Parameters::TYPE_ADDR: { // Query by address if (v4) { - lease4 = LeaseMgr::instance().getLease4(p.subnet_id, p.addr); + lease4 = LeaseMgrFactory::instance().getLease4(p.addr); } else { - lease6 = LeaseMgr::instance().getLease6(p.subnet_id, p.addr); + lease6 = LeaseMgrFactory::instance().getLease6(p.lease_type, p.addr); } break; } - case TYPE_HWADDR: + case Parameters::TYPE_HWADDR: if (v4) { - lease4 = LeaseMgr::instance().getLease4(p.subnet_id, p.hwaddr); + if (!p.hwaddr) { + return (createAnswer(CONTROL_RESULT_ERROR, + "Program error: Query by hw-address " + "requires hwaddr to be specified")); + } + lease4 = LeaseMgrFactory::instance().getLease4(*p.hwaddr, p.subnet_id); } else { return (createAnswer(CONTROL_RESULT_ERROR, "Query by hw-address is not allowed in v6.")); } - case TYPE_DUID: - if (v6) { - lease6 = LeaseMgr::instance().getLease6(p.subnet_id, p.duid); + case Parameters::TYPE_DUID: + if (!v4) { + if (!p.duid) { + return (createAnswer(CONTROL_RESULT_ERROR, + "Program error: Query by duid " + "requires duid to be specified")); + } + lease6 = LeaseMgrFactory::instance().getLease6(p.lease_type, *p.duid, + p.iaid, p.subnet_id); } else { return (createAnswer(CONTROL_RESULT_ERROR, "Query by duid is not allowed in v4.")); } - default: - return (createAnswer(CONTROL_RESULT_ERROR, - "Unknown query type: " << static_cast(p.query_type))); + default: { + stringstream tmp; + tmp << "Unknown query type: " << static_cast(p.query_type); + return (createAnswer(CONTROL_RESULT_ERROR, tmp.str())); + } } } catch (const std::exception& ex) { - return (createAnswer(CONTROL_RESULT_ERROR, - "Failure during leaseX-get: " << ex.what())); + stringstream tmp; + tmp << "Failure during leaseX-get: " << ex.what(); + return (createAnswer(CONTROL_RESULT_ERROR, tmp.str())); } ElementPtr lease_json; if (v4 && lease4) { - lease_json = lease4->toElement4(); + lease_json = lease4->toElement(); + return (createAnswer(CONTROL_RESULT_SUCCESS, "DHCPv4 lease found.", lease_json)); } if (!v4 && lease6) { - lease_json = lease6->toElement6(); + lease_json = lease6->toElement(); + return (createAnswer(CONTROL_RESULT_SUCCESS, "DHCPv6 lease found.", lease_json)); } - if (lease) { - return (createAnswer(CONTROL_RESULT_SUCCESS, "Lease found.", lease_json)); - } else { - return (createAnswer(CONTROL_RESULT_SUCCESS, "Lease not found.")); - } + + // If we got here, the lease has not been found. + return (createAnswer(CONTROL_RESULT_EMPTY, "Lease not found.")); } ConstElementPtr -LeaseCmdsImpl::reservationDelHandler(const std::string& /*name*/, - ConstElementPtr params) { +LeaseCmdsImpl::leaseDelHandler(const std::string& name, + ConstElementPtr params) { Parameters p; - bool deleted; + bool deleted = false; +#if 0 try { p = getParameters(params); if (p.query_by_addr) { // try to delete by address - deleted = LeaseMgr::instance().del(p.subnet_id, p.addr); + deleted = LeaseMgrFactory::instance().del(p.subnet_id, p.addr); } else { // try to delete by identifier if (family_ == AF_INET) { - deleted = LeaseMgr::instance().del4(p.subnet_id, p.type, - &p.ident[0], p.ident.size()); + deleted = LeaseMgrFactory::instance().del4(p.subnet_id, p.type, + &p.ident[0], p.ident.size()); } else { - deleted = LeaseMgr::instance().del6(p.subnet_id, p.type, - &p.ident[0], p.ident.size()); + deleted = LeaseMgrFactory::instance().del6(p.subnet_id, p.type, + &p.ident[0], p.ident.size()); } } } catch (const std::exception& ex) { return (createAnswer(CONTROL_RESULT_ERROR, ex.what())); } +#endif if (deleted) { return (createAnswer(CONTROL_RESULT_SUCCESS, "Lease deleted.")); @@ -513,8 +546,18 @@ LeaseCmdsImpl::reservationDelHandler(const std::string& /*name*/, } } +ConstElementPtr +LeaseCmdsImpl::leaseUpdateHandler(const string& command, ConstElementPtr args) { + return (createAnswer(CONTROL_RESULT_ERROR, "not implemented yet.")); +} + +ConstElementPtr +LeaseCmdsImpl::leaseWipeHandler(const string& command, ConstElementPtr args) { + return (createAnswer(CONTROL_RESULT_ERROR, "not implemented yet.")); +} + + uint16_t LeaseCmdsImpl::family_ = AF_INET; -LeaseDataSourcePtr LeaseCmdsImpl::db_storage_; LeaseCmds::LeaseCmds() :impl_(new LeaseCmdsImpl()) { diff --git a/src/hooks/dhcp/lease_cmds/lease_cmds_messages.mes b/src/hooks/dhcp/lease_cmds/lease_cmds_messages.mes index f222135f78..9f5b5b019e 100644 --- a/src/hooks/dhcp/lease_cmds/lease_cmds_messages.mes +++ b/src/hooks/dhcp/lease_cmds/lease_cmds_messages.mes @@ -18,11 +18,11 @@ the log message. This info message indicates that the Lease Commands hooks library has been removed successfully. -% LEASE_CMDS_ADD4_FAILED Lease4-add command failed (parameters: %1, reason: %2) +% LEASE_CMDS_ADD4_FAILED lease4-add command failed (parameters: %1, reason: %2) The lease4-add command has failed. Both the reason as well as the parameters passed are logged. -% LEASE_CMDS_ADD6_FAILED Lease4-add command failed (parameters: %1, reason: %2) +% LEASE_CMDS_ADD6_FAILED Lease6-add command failed (parameters: %1, reason: %2) The lease6-add command has failed. Both the reason as well as the parameters passed are logged. diff --git a/src/hooks/dhcp/lease_cmds/lease_parser.cc b/src/hooks/dhcp/lease_cmds/lease_parser.cc index d5130a17e4..5382a9854a 100644 --- a/src/hooks/dhcp/lease_cmds/lease_parser.cc +++ b/src/hooks/dhcp/lease_cmds/lease_parser.cc @@ -4,14 +4,242 @@ // License, v. 2.0. If a copy of the MPL was not distributed with this // file, You can obtain one at http://mozilla.org/MPL/2.0/. +#include +#include +#include +#include +#include -// V4: -// address,hwaddr,client_id,valid_lifetime,expire,subnet_id,fqdn_fwd,fqdn_rev,hostname,state +#include -// V6: -// address,duid,valid_lifetime,expire,subnet_id,pref_lifetime,lease_type,iaid,prefix_len,fqdn_fwd,fqdn_rev,hostname,hwaddr,state +using namespace std; +using namespace isc::dhcp; +using namespace isc::data; +using namespace isc::asiolink; -#include +// Can't use a constructor as a function +namespace { +IOAddress buildIOAddress(const std::string& str) { return (IOAddress(str)); } +}; + +namespace isc { +namespace lease_cmds { + +IOAddress +LeaseParser::getIOAddress(const ConstElementPtr& scope, + const std::string& name) { + return (getAndConvert(scope, name, "address")); +} + +Lease4Ptr +Lease4Parser::parse(ConstSrvConfigPtr& cfg, + const ConstElementPtr& lease_info) { + if (!lease_info) { + isc_throw(BadValue, "lease information missing"); + } + + // These are mandatory parameters. + IOAddress addr = getIOAddress(lease_info, "ip-address"); + SubnetID subnet_id = getUint32(lease_info, "subnet-id"); + + if (!addr.isV4()) { + isc_throw(BadValue, "Non-IPv4 address specified: " << addr); + } + + // Not a most straightforward conversion, but it works. + string hwaddr_txt = getString(lease_info, "hw-address"); + HWAddr hwaddr = HWAddr::fromText(hwaddr_txt); + HWAddrPtr hwaddr_ptr = HWAddrPtr(new HWAddr(hwaddr)); + + Subnet4Ptr subnet = cfg->getCfgSubnets4()->getSubnet(subnet_id); + if (!subnet) { + isc_throw(BadValue, "Invalid subnet-id: No IPv4 subnet with subnet-id=" + << subnet_id << " currently configured."); + } + + // Client-id is optional. + ClientIdPtr client_id; + if (lease_info->contains("client-id")) { + string txt = getString(lease_info, "client-id"); + client_id = ClientId::fromText(txt); + } + + // These parameters are optional. If not specified, we'll derive them from + // the current subnet configuration, if possible. + uint32_t valid_lft = 0; + if (lease_info->contains("valid-lft")) { + valid_lft = getUint32(lease_info, "valid-lft"); + } else { + valid_lft = subnet->getValid(); + } + + /// Let's calculate client last transmission time (cltt). If expiration + /// timestamp is specified explicitly, we will use that. Note there are no + /// checks whether this is in the past. There may be valid cases when user + /// wants to insert expired leases, e.g. when migrating from one DHCP server + /// to another and wants to migrate the database as is, without disarding + /// any leases. + time_t cltt; + if (lease_info->contains("expire")) { + int64_t tmp = getUint32(lease_info, "expire"); + cltt = static_cast(tmp - valid_lft); + } else { + cltt = time(NULL); + } + + bool fqdn_fwd = false; + if (lease_info->contains("fqdn-fwd")) { + fqdn_fwd = getBoolean(lease_info, "fqdn-fwd"); + } + bool fqdn_rev = false; + if (lease_info->contains("fqdn-rev")) { + fqdn_rev = getBoolean(lease_info, "fqdn-rev"); + } + string hostname; + if (lease_info->contains("hostname")) { + hostname = getString(lease_info, "hostname"); + } + if (hostname.empty() && (fqdn_fwd || fqdn_rev)) { + isc_throw(BadValue, "No hostname specified and either forward or reverse" + " fqdn was set to true."); + } + + uint32_t state = 0; + if (lease_info->contains("state")) { + state = getUint8(lease_info, "state"); + } + + // Let's fabricate some data and we're ready to go. + uint32_t t1 = subnet->getT1(); + uint32_t t2 = subnet->getT2(); + + Lease4Ptr l(new Lease4(addr, hwaddr_ptr, client_id, valid_lft, t1, t2, + cltt, subnet_id, + fqdn_fwd, fqdn_rev, hostname)); + l->state_ = state; + return (l); +} + +Lease6Ptr +Lease6Parser::parse(ConstSrvConfigPtr& cfg, + const ConstElementPtr& lease_info) { + if (!lease_info) { + isc_throw(BadValue, "lease information missing"); + } + + // These are mandatory parameters. + IOAddress addr = getIOAddress(lease_info, "ip-address"); + SubnetID subnet_id = getUint32(lease_info, "subnet-id"); + + if (addr.isV4()) { + isc_throw(BadValue, "Non-IPv6 address specified: " << addr); + } + + // Not a most straightforward conversion, but it works. + string duid_txt = getString(lease_info, "duid"); + DUID duid = DUID::fromText(duid_txt); + DuidPtr duid_ptr = DuidPtr(new DUID(duid)); + + Subnet6Ptr subnet = cfg->getCfgSubnets6()->getSubnet(subnet_id); + if (!subnet) { + isc_throw(BadValue, "Invalid subnet-id: No IPv6 subnet with subnet-id=" + << subnet_id << " currently configured."); + } + + Lease::Type type = Lease::TYPE_NA; + uint8_t prefix_len = 128; + if (lease_info->contains("type")) { + string txt = getString(lease_info, "type"); + if (txt == "IA_NA") { + type = Lease::TYPE_NA; + } else if (txt == "IA_TA") { + type = Lease::TYPE_TA; + } else if (txt == "IA_PD") { + type = Lease::TYPE_PD; + + prefix_len = getUint8(lease_info, "prefix-len"); + } else { + isc_throw(BadValue, "Incorrect lease type: " << txt << ", the only " + "supported values are: na, ta and pd"); + } + } + + uint32_t iaid = getUint32(lease_info, "iaid"); + + // Hw-address is optional in v6 leases. + HWAddrPtr hwaddr_ptr; + if (lease_info->contains("hw-address")) { + string hwaddr_txt = getString(lease_info, "hw-address"); + HWAddr hwaddr = HWAddr::fromText(hwaddr_txt); + hwaddr_ptr = HWAddrPtr(new HWAddr(hwaddr)); + } + + // These parameters are optional. If not specified, we'll derive them + // from the current subnet configuration, if possible. + uint32_t valid_lft = 0; + if (lease_info->contains("valid-lft")) { + valid_lft = getUint32(lease_info, "valid-lft"); + } else { + valid_lft = subnet->getValid(); + } + + // These parameters are optional. If not specified, we'll derive them + // from the current subnet configuration, if possible. + uint32_t pref_lft = 0; + if (lease_info->contains("preferred-lft")) { + pref_lft = getUint32(lease_info, "preferred-lft"); + } else { + pref_lft = subnet->getValid(); + } + + /// Let's calculate client last transmission time (cltt). If expiration + /// timestamp is specified explicitly, we will use that. Note there are + /// no checks whether this is in the past. There may be valid cases when + /// user wants to insert expired leases, e.g. when migrating from one + /// DHCP server to another and wants to migrate the database as is, without + /// disarding any leases. + time_t cltt; + if (lease_info->contains("expire")) { + int64_t tmp = getUint32(lease_info, "expire"); + cltt = static_cast(tmp - valid_lft); + } else { + cltt = time(NULL); + } + + bool fqdn_fwd = false; + if (lease_info->contains("fqdn-fwd")) { + fqdn_fwd = getBoolean(lease_info, "fqdn-fwd"); + } + bool fqdn_rev = false; + if (lease_info->contains("fqdn-rev")) { + fqdn_rev = getBoolean(lease_info, "fqdn-rev"); + } + string hostname; + if (lease_info->contains("hostname")) { + hostname = getString(lease_info, "hostname"); + } + if (hostname.empty() && (fqdn_fwd || fqdn_rev)) { + isc_throw(BadValue, "No hostname specified and either forward or reverse" + " fqdn was set to true."); + } + + uint32_t state = 0; + if (lease_info->contains("state")) { + state = getUint8(lease_info, "state"); + } + + // Let's fabricate some data and we're ready to go. + uint32_t t1 = subnet->getT1(); + uint32_t t2 = subnet->getT2(); + Lease6Ptr l(new Lease6(type, addr, duid_ptr, iaid, pref_lft, valid_lft, t1, t2, + subnet_id, fqdn_fwd, fqdn_rev, hostname, + hwaddr_ptr, prefix_len)); + l->cltt_ = cltt; + l->state_ = state; + return (l); +} - +}; +}; diff --git a/src/hooks/dhcp/lease_cmds/lease_parser.h b/src/hooks/dhcp/lease_cmds/lease_parser.h index 5d29c9254a..cd0e9836db 100644 --- a/src/hooks/dhcp/lease_cmds/lease_parser.h +++ b/src/hooks/dhcp/lease_cmds/lease_parser.h @@ -1,4 +1,4 @@ -// Copyright (C) 2014-2017 Internet Systems Consortium, Inc. ("ISC") +// Copyright (C) 2017 Internet Systems Consortium, Inc. ("ISC") // // This Source Code Form is subject to the terms of the Mozilla Public // License, v. 2.0. If a copy of the MPL was not distributed with this @@ -10,28 +10,96 @@ #include #include #include +#include namespace isc { namespace lease_cmds { -/// @brief Parser for a single Lease information. +/// @brief Base class for Lease4 and Lease6 parsers class LeaseParser : public isc::data::SimpleParser { +protected: + + /// @brief Returns an address from JSON structure + /// + /// @param scope a map the element will be searched at + /// @param name key name to be searched for + /// @return IOAddress representation + isc::asiolink::IOAddress getIOAddress(const isc::data::ConstElementPtr& scope, + const std::string& name); }; +/// @brief Parser for Lease4 structure +/// +/// It expects the data in the following format: +/// { +/// "ip-address": "192.0.2.1", +/// "hw-address": "00:01:02:03:04:05", +/// "client-id": "this-is-a-client", +/// "valid-lft": 3600, +/// "cltt": 12345678, +/// "expire": 1499282530, +/// "subnet-id": 1, +/// "fdqn-fwd": true, +/// "fqdn-rev": true, +/// "hostname": "myhost.example.org", +/// "state": 0 +/// } class Lease4Parser : public LeaseParser { public: - virtual isc::dhcp::Lease4Ptr parse(const isc::data::ConstElementPtr& lease_info); + + /// @brief Parses Element tree and tries to convert to Lease4 + /// + /// See @ref Lease6Parser class description for expected format. + /// + /// @param cfg Currently running config (used for sanity checks and defaults) + /// @param lease_info structure to be parsed + /// @return A pointer to Lease4 + /// @throw BadValue if any of the parameters is invalid + /// @throw DhcpConfigError if mandatory parameter is missing + virtual isc::dhcp::Lease4Ptr parse(isc::dhcp::ConstSrvConfigPtr& cfg, + const isc::data::ConstElementPtr& lease_info); + + /// @brief virtual dtor (does nothing) virtual ~Lease4Parser() {} }; +/// @brief Parser for Lease6 structure +/// +/// { +/// "address": "2001:db8::1", +/// "duid": "00:01:02:03:04:05", +/// "type": "IA_NA", +/// "cltt": 12345678, +/// "preferred-lft": 3600, +/// "valid-lft": 3600, +/// "expire": 1499282530, +/// "subnet-id": 1, +/// "fdqn-fwd": true, +/// "fqdn-rev": true, +/// "hostname": "myhost.example.org", +/// "state": 0 +/// } + +/// It expects the input data to use the following format: class Lease6Parser : public LeaseParser { public: - virtual isc::dhcp::Lease6Ptr parse(const isc::data::ConstElementPtr& lease_info); + /// @brief Parses Element tree and tries to convert to Lease4 + /// + /// See @ref Lease6Parser class description for expected format. + /// + /// @param cfg Currently running config (used for sanity checks and defaults) + /// @param lease_info structure to be parsed + /// @return A pointer to Lease4 + /// @throw BadValue if any of the parameters is invalid + /// @throw DhcpConfigError if mandatory parameter is missing + virtual isc::dhcp::Lease6Ptr parse(isc::dhcp::ConstSrvConfigPtr& cfg, + const isc::data::ConstElementPtr& lease_info); + + /// @brief virtual dtor (does nothing) virtual ~Lease6Parser() {} }; - + }; // end of isc::dhcp namespace }; // end of isc namespace #endif - diff --git a/src/hooks/dhcp/lease_cmds/tests/.gitignore b/src/hooks/dhcp/lease_cmds/tests/.gitignore new file mode 100644 index 0000000000..f0773b7d32 --- /dev/null +++ b/src/hooks/dhcp/lease_cmds/tests/.gitignore @@ -0,0 +1,5 @@ +host_cmds_unittests +host_cmds_unittests.log +host_cmds_unittests.trs +test-suite.log +*~ \ No newline at end of file diff --git a/src/hooks/dhcp/lease_cmds/version.cc b/src/hooks/dhcp/lease_cmds/version.cc new file mode 100644 index 0000000000..d3f705769f --- /dev/null +++ b/src/hooks/dhcp/lease_cmds/version.cc @@ -0,0 +1,17 @@ +// Copyright (C) 2017 Internet Systems Consortium, Inc. ("ISC") +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#include +#include + +extern "C" { + +/// @brief returns Kea hooks version. +int version() { + return (KEA_HOOKS_VERSION); +} + +}