Member add6Options (Pkt6Ptr &response, const UserPtr &user)

: if packets have no vendor opt... do we need to add it if its not there? If so how?

This file should be moved to dhcpsrv eventually as the classification is server side concept. Client has no notion of classifying incoming server messages as it usually talks to only one server. That move is not possible yet, as the Pkt4 and Pkt6 classes have server-side implementation, even though they reside in the dhcp directory.

Page DHCPv4 Server Component

Note: the current implementation doesn't allow configuration of the server's behavior with respect to DNS Updates. This is planned for the future. The default behavior is constituted by the set of constants defined in the (upper part of) dhcp4_srv.cc file. Once the configuration is implemented, these constants will be removed.

Currently the FIFO queue is not processed after the NameChangeRequests are generated and added to it. In the future implementation steps it is planned to create a code which will check if there are any outstanding requests in the queue and send them to the kea-dhcp-ddns module when server is idle waiting for DHCP messages.

Page DHCPv6 Server Component

Currently the FIFO queue is not processed after the NameChangeRequests are generated and added to it. In the future implementation steps it is planned to create a code which will check if there are any outstanding requests in the queue and send them to the kea-dhcp-ddns module when server is idle waiting for DHCP messages.

Member DOCSIS3_V6_ORO

define remaining docsis3 v6 codes

Member generate_output_record (const std::string &id_type_str, const std::string &id_val_str, const std::string &addr_str, const bool &registered)

This ought to be replaced with an abstract output similar to UserDataSource to allow greater flexibility.

Member GNU_CC_VERSION

Version 6.0 will need to be tested.

Namespace isc

: This header file and its .cc counterpart are very similar between DHCPv4 and DHCPv6. They should be merged.

Member isc::agent::CtrlAgentProcess::configure (isc::data::ConstElementPtr config_set, bool check_only=false)

: If the parameter is a hostname, we need to resolve it.

Member isc::asiolink::IOAddress::increase (const IOAddress &addr)

Determine if we have a use-case for increasing the address by more than one. Increase by one is used in AllocEngine. This method could take extra parameter that specifies the value by which the address should be increased.

Member isc::asiolink::TCPSocket< C >::asyncSend (const void *data, size_t length, const IOEndpoint *endpoint, C &callback)

arrange for the buffer passed to be preceded by the count

Member isc::asiolink::TLSSocket< C >::asyncSend (const void *data, size_t length, const IOEndpoint *endpoint, C &callback)

arrange for the buffer passed to be preceded by the count

Class isc::ConfigError

: move this header into simple_parser.h

: create an isc_throw like macro to add the position more easily.

: replace all references to DhcpConfigError with ConfigError, then remove DhcpConfigError.

Member isc::d2::CheckExistsRemoveTransaction::CheckExistsRemoveTransaction (asiolink::IOServicePtr &io_service, dhcp_ddns::NameChangeRequestPtr &ncr, DdnsDomainPtr &forward_domain, DdnsDomainPtr &reverse_domain, D2CfgMgrPtr &cfg_mgr)

Currently none have been identified.

Member isc::d2::CheckExistsRemoveTransaction::removingFwdRRsHandler ()

Should we go ahead with the reverse remove?

Member isc::d2::D2CfgMgr::forwardUpdatesEnabled ()

This could be expanded to include the check of a configurable boolean value.

Member isc::d2::D2CfgMgr::IPV4_REV_ZONE_SUFFIX

This should be configurable.

Member isc::d2::D2CfgMgr::IPV6_REV_ZONE_SUFFIX

This should be configurable.

Member isc::d2::D2CfgMgr::reverseUpdatesEnabled ()

This could be expanded to include the check of a configurable boolean value.

Class isc::d2::D2Controller

Currently, this class provides only the minimum required specialized behavior to run the DHCP-DDNS service. It may very well expand as the service implementation evolves. Some thought was given to making DControllerBase a templated class but the labor savings versus the potential number of virtual methods which may be overridden didn't seem worth the clutter at this point.

Class isc::d2::D2ParseError

: This probably should be common for Dhcp4 and Dhcp6.

Member isc::d2::D2Process::checkQueueStatus ()

Possible timer for self-defense? We could conceivably get into a condition where we never get the event, which would leave us stuck in stopping. This is hugely unlikely but possible?

this value should probably be configurable.

This may need a safety valve such as retry count or a timer to keep from endlessly retrying over and over, with little time in between.

Member isc::d2::D2Process::configure (isc::data::ConstElementPtr config_set, bool check_only=false)

NOTE This could be turned into a bitmask of flags if we find other things that need reconfiguration. It might also be useful if we did some analysis to decide what if anything we need to do.)

Member isc::d2::D2Process::reconfigureQueueMgr ()

Add TCP/IP once it's supported

Should that change then we will have to expand the state model to accommodate this.

Remove this once we provide a secure mechanism.

This method assumes only 1 type of listener. This will change to support at least a TCP version, possibly some form of RDBMS listener as well.

Member isc::d2::D2Process::run ()

- if queue isn't empty, we may need to persist its contents this might be the place to do it, once there is a persistence mgr. This may also be better in checkQueueStatus.

Class isc::d2::D2QueueMgrQueueFull

use or remove it.

Class isc::d2::D2QueueMgrReceiveError

use or remove it.

Member isc::d2::D2UpdateMgr::clearTransactionList ()

For now this just wipes them out. We might need something more elegant, that allows a cancel first.

Class isc::d2::DdnsDomain

Currently the name entry for a domain is just a std::string. It may be worthwhile to change this to a dns::Name for purposes of better validation and matching capabilities.

Member isc::d2::DdnsDomainListMgr::matchDomain (const std::string &fqdn, DdnsDomainPtr &domain)

This is a very basic match method, which expects valid FQDNs both as input and for the DdnsDomain::getName(). Currently both are simple strings and there is no normalization (i.e. added trailing dots if missing).

Class isc::d2::DNSClient

Ultimately, this class will support both TCP and UDP Transport. Currently only UDP is supported and can be specified as a preferred protocol. DNSClient constructor will throw an exception if TCP is specified. Once both protocols are supported, the DNSClient logic will try to obey caller's preference. However, it may use the other protocol if on its own discretion, when there is a legitimate reason to do so. For example, if communication with the server using preferred protocol fails.

Member isc::d2::DNSClientImpl::response_

Trac# 3286 has been opened against dns::Message::fromWire. Should the behavior of fromWire change the behavior here with could be reexamined).

Member isc::d2::DnsServerInfoParser::parse (data::ConstElementPtr server_config, data::ConstElementPtr domain_config, const TSIGKeyInfoMapPtr keys)

when resolvable hostname is supported we create the entry as follows:

Member isc::d2::NameChangeTransaction::DNS_UPDATE_DEFAULT_TIMEOUT

This value will be made configurable in the very near future under trac3268. For now we will define it to 100 milliseconds so unit tests will run within a reasonable amount of time.

Member isc::d2::NameChangeTransaction::NameChangeTransaction (asiolink::IOServicePtr &io_service, dhcp_ddns::NameChangeRequestPtr &ncr, DdnsDomainPtr &forward_domain, DdnsDomainPtr &reverse_domain, D2CfgMgrPtr &cfg_mgr)

if io_service is NULL we are multi-threading and should instantiate our own

Member isc::d2::NameRemoveTransaction::NameRemoveTransaction (asiolink::IOServicePtr &io_service, dhcp_ddns::NameChangeRequestPtr &ncr, DdnsDomainPtr &forward_domain, DdnsDomainPtr &reverse_domain, D2CfgMgrPtr &cfg_mgr)

Currently none have been identified.

Member isc::d2::NameRemoveTransaction::removingFwdRRsHandler ()

Should we go ahead with the reverse remove?

Member isc::d2::RequestQueue

This may be replaced with an actual class in the future.

Member isc::d2::SimpleRemoveTransaction::SimpleRemoveTransaction (asiolink::IOServicePtr &io_service, dhcp_ddns::NameChangeRequestPtr &ncr, DdnsDomainPtr &forward_domain, DdnsDomainPtr &reverse_domain, D2CfgMgrPtr &cfg_mgr)

Currently none have been identified.

Member isc::d2::SimpleRemoveWithoutDHCIDTransaction::SimpleRemoveWithoutDHCIDTransaction (asiolink::IOServicePtr &io_service, dhcp_ddns::NameChangeRequestPtr &ncr, DdnsDomainPtr &forward_domain, DdnsDomainPtr &reverse_domain, D2CfgMgrPtr &cfg_mgr)

Currently none have been identified.

Member isc::data::BaseStampedElement::BaseStampedElement ()

Change it to microsec_clock once we transition to subsecond precision.

Member isc::data::BaseStampedElement::updateModificationTime ()

Change it to microsec_clock once we transition to subsecond precision.

Class isc::data::StampedElement

Find a better name for StampedElement.

Member isc::db::DatabaseConnection::MAX_DB_TIME

: Is this common for MySQL and Postgres? Maybe we should have specific values for each backend?

Member isc::db::MYSQL_DEFAULT_CONNECTION_TIMEOUT

: Migrate this default value to src/bin/dhcpX/simple_parserX.cc

Member isc::db::MySqlBinding::convertFromDatabaseTime (const MYSQL_TIME &database_time)

Use fractional seconds instead of 0 when minimum supported MySQL version has it.

Member isc::db::MySqlBinding::convertToDatabaseTime (const boost::posix_time::ptime &input_time, MYSQL_TIME &output_time)

Use fractional seconds instead of 0 when minimum supported MySQL version has it.

Member isc::db::PGSQL_DEFAULT_CONNECTION_TIMEOUT

: migrate this default timeout to src/bin/dhcpX/simple_parserX.cc

Member isc::db::PsqlBindArray::addTempString (const std::string &str)

Eventually this could replace add(std::string&)? This would mean all bound strings would be internally copies rather than perhaps belonging to the originating object such as Host::hostname_. One the one hand it would make all strings handled one-way only, on the other hand it would mean duplicating strings where it isn't strictly necessary.

Class isc::db::ServerSelector

Add server selector for selecting only those configuration elements that are associated with all servers (and not with any particular server tags). Translating this to SQL queries it would probably be an empty or non-existing server tag.

Member isc::dhcp::CfgMgr::CONFIG_LIST_SIZE

Make it configurable.

Member isc::dhcp::CfgOptionDef::getAll (const std::string &option_space) const

Does option space require any validation here?

Member isc::dhcp::CfgSubnets4::add (const Subnet4Ptr &subnet)

: Check that this new subnet does not cross boundaries of any other already defined subnet.

Member isc::dhcp::CfgSubnets4::getLinks (const asiolink::IOAddress &link_addr) const

: extend to consider whether a shared network is a link.

Member isc::dhcp::CfgSubnets4::selectSubnet (const asiolink::IOAddress &address, const ClientClasses &client_classes=ClientClasses()) const

This method requires performance improvement! It currently iterates over all existing subnets to find the one which fulfills the search criteria. The subnet storage is implemented as a simple STL vector which precludes fast searches using specific keys. Hence, full scan is required. To improve the search performance a different container type is required, e.g. multi-index container, or something of a similar functionality.

Member isc::dhcp::CfgSubnets4::selectSubnet (const std::string &iface, const ClientClasses &client_classes) const

This method requires performance improvement! It currently iterates over all existing subnets to find the one which fulfills the search criteria. The subnet storage is implemented as a simple STL vector which precludes fast searches using specific keys. Hence, full scan is required. To improve the search performance a different container type is required, e.g. multi-index container, or something of a similar functionality.

Member isc::dhcp::CfgSubnets4::selectSubnet (const SubnetSelector &selector) const

This method requires performance improvement! It currently iterates over all existing subnets (possibly a couple of times) to find the one which fulfills the search criteria. The subnet storage is implemented as a simple STL vector which precludes fast searches using specific keys. Hence, full scan is required. To improve the search performance a different container type is required, e.g. multi-index container, or something of a similar functionality.

Member isc::dhcp::CfgSubnets4::selectSubnet4o6 (const SubnetSelector &selector) const

: Add additional selection criteria. See https://gitlab.isc.org/isc-projects/kea/wikis/designs/dhcpv4o6-design for details.

Member isc::dhcp::CfgSubnets6::add (const Subnet6Ptr &subnet)

: Check that this new subnet does not cross boundaries of any other already defined subnet.

Member isc::dhcp::CfgSubnets6::getLinks (const asiolink::IOAddress &link_addr) const

: extend to consider whether a shared network is a link.

Member isc::dhcp::CfgSubnets6::selectSubnet (const SubnetSelector &selector) const

This method requires performance improvement! It currently iterates over all existing subnets (possibly a couple of times) to find the one which fulfills the search criteria. The subnet storage is implemented as a simple STL vector which precludes fast searches using specific keys. Hence, full scan is required. To improve the search performance a different container type is required, e.g. multi-index container, or something of a similar functionality.

Member isc::dhcp::CfgSubnets6::selectSubnet (const asiolink::IOAddress &address, const ClientClasses &client_classes=ClientClasses(), const bool is_relay_address=false) const

This method requires performance improvement! It currently iterates over all existing subnets (possibly a couple of times) to find the one which fulfills the search criteria. The subnet storage is implemented as a simple STL vector which precludes fast searches using specific keys. Hence, full scan is required. To improve the search performance a different container type is required, e.g. multi-index container, or something of a similar functionality.

Class isc::dhcp::CSVLeaseFile4

This class doesn't validate the lease values read from the file. The Lease4 is a structure that should be itself responsible for this validation. However, the next function may need to be updated to use the validation capability of Lease4.

Member isc::dhcp::CSVLeaseFile4::next (Lease4Ptr &lease)

Make sure that the values read from the file are correct. The appropriate Lease4 validation mechanism should be used.

Class isc::dhcp::CSVLeaseFile6

This class doesn't validate the lease values read from the file. The Lease6 is a structure that should be itself responsible for this validation. However, the next function may need to be updated to use the validation capability of Lease6.

Member isc::dhcp::CSVLeaseFile6::next (Lease6Ptr &lease)

Make sure that the values read from the file are correct. The appropriate Lease6 validation mechanism should be used.

Member isc::dhcp::D2ClientConfig::validateContents ()

perhaps more validation we should do yet? Are there any invalid combinations of options we need to test against?

Member isc::dhcp::D2ClientMgr::setD2ClientConfig (D2ClientConfigPtr &new_config)

- Should we consider anything queued to be wrong? If only server values changed content might still be right but if content values changed (e.g. suffix or an override flag) then the queued contents might now be invalid. There is no way to regenerate them if they are wrong.

Member isc::dhcp::D2ClientMgr::suspendUpdates ()

This logic may change in NameChangeSender is altered allow queuing while stopped. Currently when a sender is not in send mode it will not accept additional messages.

For now we will disable updates and stop sending. This at least provides a means to shut it off if there are errors.

Class isc::dhcp::Dhcp4ParseError

: This probably should be common for Dhcp4 and Dhcp6.

Member isc::dhcp::Dhcp4Parser::parse ()

: the code or name parameters are required.

: an identifier parameter is required.

Class isc::dhcp::Dhcp6ParseError

: This probably should be common for Dhcp4 and Dhcp6.

Member isc::dhcp::Dhcp6Parser::parse ()

: an identifier parameter is required.

: the code or name parameters are required.

: an identifier parameter is required.

Class isc::dhcp::Dhcpv4Exchange

This is the initial version of this class. In the future a lot of code from the Dhcpv4Srv class will be migrated here.

Member isc::dhcp::Dhcpv4Exchange::removeDependentEvaluatedClasses (const Pkt4Ptr &query)

: keep the list of dependent evaluated classes so remove only them.

Member isc::dhcp::Dhcpv4Srv::acceptServerId (const Pkt4Ptr &pkt) const

Currently we only check server identifiers configured at the subnet, shared network, client class and global levels. This should be sufficient for most of cases. At this point, trying to support server identifiers on the host reservations level seems to be an overkill and is probably not needed. In fact, at this point we don't know the reservations for the client communicating with the server. We may revise some of these choices in the future.

Member isc::dhcp::Dhcpv4Srv::adjustIfaceData (Dhcpv4Exchange &ex)

Consider an optimization that we use local address from the query if this address is not broadcast.

Member isc::dhcp::Dhcpv4Srv::assignLease (Dhcpv4Exchange &ex)

The server should check what ciaddr the client has supplied in ciaddr. Currently the ciaddr is ignored except for the subnet selection. If the client supplied an invalid address, the server will also return an invalid address here.

Member isc::dhcp::Dhcpv4Srv::d2ClientErrorHandler (const dhcp_ddns::NameChangeSender::Result result, dhcp_ddns::NameChangeRequestPtr &ncr)

We may wish to make this more robust or sophisticated.

We may wish to revisit this, but for now we will simply turn them off.

Member isc::dhcp::Dhcpv4Srv::Dhcpv4Srv (uint16_t server_port=DHCP4_SERVER_PORT, uint16_t client_port=0, const bool use_bcast=true, const bool direct_response_desired=true)

call loadLibraries() when handling configuration changes

Member isc::dhcp::Dhcpv4Srv::processClientName (Dhcpv4Exchange &ex)

It could be configurable what sort of updates the server is doing when Hostname option was sent.

Member isc::dhcp::Dhcpv4Srv::serverDecline (hooks::CalloutHandlePtr &callout_handle, Pkt4Ptr &query, Lease4Ptr lease, bool lease_exists)

implement a new hook point, lease4_server_declined_lease (name subject to change).

Member isc::dhcp::Dhcpv4Srv::setTeeTimes (const Lease4Ptr &lease, const ConstSubnet4Ptr &subnet, Pkt4Ptr resp)

This logic to be modified if we decide to support infinite lease times.

Member isc::dhcp::Dhcpv6Srv::assignIA_NA (const isc::dhcp::Pkt6Ptr &query, AllocEngine::ClientContext6 &ctx, Option6IAPtr ia)

: Handle more than one lease

Member isc::dhcp::Dhcpv6Srv::copyClientOptions (const Pkt6Ptr &question, Pkt6Ptr &answer)

: Should throw if there is no client-id (except anonymous INF-REQUEST)

Member isc::dhcp::Dhcpv6Srv::createNameChangeRequests (const Pkt6Ptr &answer, AllocEngine::ClientContext6 &ctx)

Currently we create NCR with the first IPv6 address that is carried in one of the IA_NAs. In the future, the NCR API should be extended to map multiple IPv6 addresses to a single FQDN. In such case, this return statement will be removed.

Add support for multiple IAADDR options in the IA_NA.

IA_NA may contain multiple addresses. We should process each address individually. Currently we only process the first one.

Member isc::dhcp::Dhcpv6Srv::d2ClientErrorHandler (const dhcp_ddns::NameChangeSender::Result result, dhcp_ddns::NameChangeRequestPtr &ncr)

We may wish to make this more robust or sophisticated.

We may wish to revisit this, but for now we will simply turn them off.

Member isc::dhcp::Dhcpv6Srv::Dhcpv6Srv (uint16_t server_port=DHCP6_SERVER_PORT, uint16_t client_port=0)

call loadLibraries() when handling configuration changes

Member isc::dhcp::Dhcpv6Srv::extendIA_NA (const Pkt6Ptr &query, AllocEngine::ClientContext6 &ctx, Option6IAPtr ia)

For simplicity and due to limitations of LeaseMgr we don't get the binding for the client for which we don't get subnet id. Subnet id is a required value when searching for the bindings. The fact that we can't identify the subnet for the returning client doesn't really mean that the client has no binding. It is possible that due to server's reconfiguration the subnet has been removed or modified since the client has got his lease. We may need to rethink whether it is appropriate to send no binding if the subnet hasn't been found for the client.

Member isc::dhcp::Dhcpv6Srv::extendIA_PD (const Pkt6Ptr &query, AllocEngine::ClientContext6 &ctx, Option6IAPtr ia)

We should consider unification of the server behavior for address assignment and prefix delegation with respect to Rebind message processing. The RFC 8415, section 18.3.5 doesn't really differentiate between IA_NA and IA_PD in how they should be processed by the server. The intention of the spec is as follows:

: We may consider in which cases we could determine whether the delegated prefixes are appropriate for the link to which the client's interface is attached. Just not being able to select the subnet may not be enough, because there might be other DHCP servers around that are configured to handle that subnet. Therefore we don't fully follow all the paths in section 18.3.5 of RFC 8415 to respond with zero lifetimes for the prefixes being rebound.

Member isc::dhcp::Dhcpv6Srv::extendLeases (const Pkt6Ptr &query, Pkt6Ptr &reply, AllocEngine::ClientContext6 &ctx)

add support for IA_TA

Member isc::dhcp::Dhcpv6Srv::processRebind (AllocEngine::ClientContext6 &ctx)

There are cases when the Rebind message should be discarded by the DHCP server. One of those is when the server doesn't have a record of the client and it is unable to determine whether the client is on the appropriate link or not. We don't seem to do it now.

Member isc::dhcp::Dhcpv6Srv::processRelease (AllocEngine::ClientContext6 &ctx)

If client sent a release and we should remove outstanding DNS records.

Member isc::dhcp::Dhcpv6Srv::releaseLeases (const Pkt6Ptr &release, Pkt6Ptr &reply, AllocEngine::ClientContext6 &ctx)

Consider supporting more than one address in a single IA. It is allowed by RFC 8415, but it is not widely implemented. The only software that supports that is Dibbler, but its author seriously doubts if anyone is really using it. Clients that want more than one address or prefix just include more instances of IA options.

Add support for IA_TA

Member isc::dhcp::Dhcpv6Srv::removeDependentEvaluatedClasses (const Pkt6Ptr &pkt)

: keep the list of dependent evaluated classes so remove only them.

Member isc::dhcp::Dhcpv6Srv::setTeeTimes (uint32_t preferred_lft, const ConstSubnet6Ptr &subnet, Option6IAPtr &resp)

This logic to be modified if we decide to support infinite lease times.

Member isc::dhcp::Dhcpv6Srv::testServerID (const Pkt6Ptr &pkt)

Currently we always check server identifier regardless if it is allowed in the received message or not (per RFC 8415). If the server identifier is not allowed in the message, the sanityCheck function should deal with it.

Class isc::dhcp::DUIDConfigParser

Add support for DUID-UUID in the parser.

Class isc::dhcp::Host

This class offers basic functionality for storing host information. It will need to be extended to allow for the following operations:

remove and replace IPv6 reservations
remove and replace client classes
disable IPv4 reservation without a need to set it to the 0.0.0.0 address Note that the last three operations are mainly required for managing host reservations which will be implemented later.

Member isc::dhcp::HostContainer

This container will be extended to search for Host objects associated with a specific IPv4 address or IPv6 prefix/length.

Member isc::dhcp::HWAddr::source_

This is a stub implementation. Proper implementation will move constants from Pkt::HWADDR_SOURCE_* here. Currently always initialized to zero.

Member isc::dhcp::Iface::closeSockets (const uint16_t family)

Replace the AF_INET and AF_INET6 values with an enum which will not be confused with the actual socket type.

Member isc::dhcp::Iface::flag_loopback_

: Make those fields protected once we start supporting more than just Linux

Member isc::dhcp::Iface::SocketCollection

: Add SocketCollectionConstIter type

Member isc::dhcp::IfaceMgr::openSockets4 (const uint16_t port=DHCP4_SERVER_PORT, const bool use_bcast=true, IfaceMgrErrorMsgCallback error_handler=0, const bool skip_opened=false)

It is possible that additional parameters will have to be added to the error handler, e.g. Iface if it was really supposed to do some more sophisticated error handling.

Member isc::dhcp::IfaceMgr::openSockets6 (const uint16_t port=DHCP6_SERVER_PORT, IfaceMgrErrorMsgCallback error_handler=0, const bool skip_opened=false)

It is possible that additional parameters will have to be added to the error handler, e.g. Iface if it was really supposed to do some more sophisticated error handling.

Member isc::dhcp::IfaceMgr::receive4Direct (uint32_t timeout_sec, uint32_t timeout_usec=0)

: marginal performance optimization. We could create the set once and then use its copy for select(). Please note that select() modifies provided set to indicated which sockets have something to read.

Member isc::dhcp::IfaceMgr::receive6Direct (uint32_t timeout_sec, uint32_t timeout_usec=0)

: marginal performance optimization. We could create the set once and then use its copy for select(). Please note that select() modifies provided set to indicated which sockets have something to read.

Class isc::dhcp::IPRangePermutation

Methods of this class should be called in thread safe context. Otherwise they should be made thread safe.

Member isc::dhcp::Lease4::client_id_

Should this be a pointer to a client ID or the ID itself? Compare with the DUID in the Lease6 structure.

Member isc::dhcp::Lease4::remote_id_

: Add DHCPv4 failover related fields here

Member isc::dhcp::Lease4::statesToText (const uint32_t state)

Currently it simply returns common states for DHCPv4 and DHCPv6. This method will have to be extended to handle DHCPv4 specific states when they are defined.

Member isc::dhcp::Lease6::Lease6 (Lease::Type type, const isc::asiolink::IOAddress &addr, DuidPtr duid, uint32_t iaid, uint32_t preferred, uint32_t valid, SubnetID subnet_id, const HWAddrPtr &hwaddr=HWAddrPtr(), uint8_t prefixlen=128)

: Add DHCPv6 failover related fields here

Member isc::dhcp::Lease6::statesToText (const uint32_t state)

Currently it simply returns common states for DHCPv4 and DHCPv6. This method will have to be extended to handle DHCPv6 specific states when they are defined.

Member isc::dhcp::Lease6::toText () const

: print out DUID

Member isc::dhcp::LeaseMgr::getVersion (const std::string &timer_name=std::string()) const =0

: We will need to implement 3 version functions eventually: A. abstract API version B. backend version C. database version (stored in the database scheme)

Class isc::dhcp::LeaseMgrFactory

: Will need to develop some form of registration mechanism for user-supplied backends (so that there is no need to modify the code).

Member isc::dhcp::LibDHCP::optionSpaceToVendorId (const std::string &option_space)

remove this function once when the conversion is dealt by the appropriate functions returning options by option space names.

Class isc::dhcp::NetworkState

We should consider migrating the database recovery to the same mechanism we use for the HA. The reference counting works because the database connection classes ensure that for each request to disable the DHCP service, there is a corresponding request to enable the service. It prevents the situation that the service remains disabled because there were more requests to disable than to enable the service. It is hard to ensure the same consistency for the HA.

Class isc::dhcp::Option6IAPrefix

Currently, the constructor which creates the option from the textual format doesn't set non-significant bits to 0. This is because it is assumed that the prefixes from the string are created locally (not received over the wire) and should be validated before the option is created. If we wanted to set non-significant bits to 0 when the prefix is created from the textual format it would have some performance implications, because the option would need to be turned into wire format, appropriate bits set to 0 and then option would need to be created again from the wire format. We may consider doing it if we find a use case where it is required.

Member isc::dhcp::Option::Factory (Option::Universe u, uint16_t type, const OptionBuffer &buf)

Passing a separate buffer for each option means that a copy was done. We can avoid it by passing 2 iterators.

Member isc::dhcp::Option::Option (Universe u, uint16_t type, OptionBufferConstIter first, OptionBufferConstIter last)

This can be templated to use different containers, not just vector. Prototype should look like this: template<typename InputIterator> Option(Universe u, uint16_t type, InputIterator first, InputIterator last);

Member isc::dhcp::Option::Option (Universe u, uint16_t type, const OptionBuffer &data)

Migrate V6 options to that approach.

Member isc::dhcp::Option::packOptions (isc::util::OutputBuffer &buf, bool check=true) const

The set of exceptions thrown by this function depend on exceptions thrown by pack methods invoked on objects representing sub options. We should consider whether to aggregate those into one exception which can be documented here.

Member isc::dhcp::Option::toString () const

: Implement actual conversion in derived classes.

Member isc::dhcp::Option::unpackOptions (const OptionBuffer &buf)

The set of exceptions thrown by this function depend on exceptions thrown by unpack methods invoked on objects representing sub options. We should consider whether to aggregate those into one exception which can be documented here.

Member isc::dhcp::OptionContainer

we may want to search for options using option spaces when they are implemented.

Member isc::dhcp::OptionCustom::OptionCustom (const OptionDefinition &def, Universe u, OptionBufferConstIter first, OptionBufferConstIter last)

list all exceptions thrown by ctor.

Member isc::dhcp::OptionCustom::OptionCustom (const OptionDefinition &def, Universe u, const OptionBuffer &data)

list all exceptions thrown by ctor.

Member isc::dhcp::OptionDefContainer

: need an index to search options using option space name once option spaces are implemented.

Class isc::dhcp::OptionDefinition

Extend the comment to describe "generic factories".

Extend this class with more factory functions.

Derive from UserContext without breaking the multi index.

Member isc::dhcp::OptionInt< T >::OptionInt (Option::Universe u, uint16_t type, T value)

Extend constructor to set encapsulated option space name.

Member isc::dhcp::OptionInt< T >::OptionInt (Option::Universe u, uint16_t type, OptionBufferConstIter begin, OptionBufferConstIter end)

Extend constructor to set encapsulated option space name.

Class isc::dhcp::OptionOpaqueDataTuples

The class is similar to the class used by the DHCPv6 Vendor Class (16) and DHCPv4 V-I Vendor Class (124) options, though they include an enterprise (or vendor) ID in the option. In the future it may make sense to rewrite the OptionVendorClass to derive from this class.

Member isc::dhcp::OptionSpaceContainer< ContainerType, ItemType, Selector >::getOptionSpaceNames () const

This function is likely to be removed once we create a structure of OptionSpaces defined through the configuration manager.

Class isc::dhcp::OptionString

In the future this class may be extended with some more string content checks and encoding methods if required.

Member isc::dhcp::OptionVendor::OptionVendor (Option::Universe u, OptionBufferConstIter begin, OptionBufferConstIter end)

Extend constructor to set encapsulated option space name.

Member isc::dhcp::PacketQueueRing< PacketTypePtr >::setCapacity (size_t capacity)

should probably throw if it's zero

- do we want to change size on the fly? This might need to be private, called only by constructor

Member isc::dhcp::Pkt4::getLabel () const

If and when client id is extracted into Pkt4, this method should use the instance member rather than fetch it every time.

Member isc::dhcp::Pkt6::addRelayInfo (const RelayInfo &relay)

: Implement type checks here (e.g. we could receive relay-forw in relay-repl)

Member isc::dhcp::Pkt6::copyRelayInfo (const Pkt6Ptr &question)

: Implement support for ERO (Echo Request Option, RFC4994)

Member isc::dhcp::Pkt6::getLabel () const

Do not print HW address as it is unclear how it should be retrieved if there is no access to user configuration which specifies the order of various techniques to be used to retrieve it.

Member isc::dhcp::Pkt6::packTCP ()

This function is not implemented yet.

Member isc::dhcp::Pkt6::unpackRelayMsg ()

: check that each option appears at most once

: implement ERO (Echo Request Option, RFC 4994) here

: log here that there are additional unparsed bytes

Member isc::dhcp::Pkt6::unpackTCP ()

This function is not implemented yet.

Member isc::dhcp::Pkt::getMAC (uint32_t hw_addr_src)

: Implement an array of method pointers instead of set of ifs

Member isc::dhcp::PktFilterBPF::receive (Iface &iface, const SocketInfo &socket_info)

BPF may occasionally append more than one packet in a single read. Our current libdhcp++ API is oriented towards receiving one packet at the time so we just pick first usable packet here and drop other packets. In the future the additional packets should be queued and processed. For now, we just iterate over the packets in the buffer and pick the first usable one.

Member isc::dhcp::Pool6::Pool6 (const asiolink::IOAddress &prefix, const uint8_t prefix_len, const uint8_t delegated_len, const asiolink::IOAddress &excluded_prefix, const uint8_t excluded_prefix_len)

Check that the prefixes actually match. Theoretically, a user could specify a prefix which sets insignificant bits. We should clear insignificant bits based on the prefix length but this should be considered a part of the IOAddress class, perhaps and requires a bit of work (mainly in terms of testing).

Member isc::dhcp::Pool::clientSupported (const ClientClasses &client_classes) const

: currently doing the same as network which needs improving.

Member isc::dhcp::SanityChecker::checkLeaseInternal (LeasePtrType &lease, const CfgConsistencyPtr &checks, const SubnetsType &subnets)

: add a check if the address is within specified dynamic pool if not, check if the address is reserved.

Member isc::dhcp::SharedNetwork4::getPreferredSubnet (const ConstSubnet4Ptr &selected_subnet) const

Need extensions to this logic when we support more than one client class for a subnet.

Class isc::dhcp::SrvConfig

Migrate all other configuration parameters from cfgmgr.h here

Member isc::dhcp::SrvConfig::getConfigSummary (const uint32_t selection) const

Implement reporting a summary of interfaces being used for receiving and sending DHCP messages. This will be implemented with ticket #3512.

Currently this method uses CfgMgr accessors to get the configuration parameters. Once these parameters are migrated from the CfgMgr this method will have to be modified accordingly.

Member isc::dhcp::SrvConfig::merge (ConfigBase &other)

Add support for merging other configuration elements.

Member isc::dhcp::SrvConfig::toElement () const

accept empty list

Member isc::dhcp::Subnet4Collection

We should consider optimizing subnet selection by leveraging the indexing capabilities of this container, e.g. searching for a subnet by interface name, relay address etc.

Member isc::dhcp::Subnet6Collection

We should consider optimizing subnet selection by leveraging the indexing capabilities of this container, e.g. searching for a subnet by interface name, relay address etc.

Member isc::dhcp::Subnet6ConfigParser::duplicateOptionWarning (uint32_t code, asiolink::IOAddress &addr)

A means to know the correct logger and perhaps a common message would allow this message to be emitted by the base class.

Member isc::dhcp::test::LogContentTest::LogContentTest ()

add support to adjust the severity and debug level to allow for better control over the statements that get logged.

Member isc::dhcp_ddns::NameChangeProtocol

TCP is intended to be implemented prior 1.0 release.

Give some thought to an ANY protocol which might try first as UDP then as TCP, etc.

Member isc::dhcp_ddns::NameChangeRequest::getRequestId () const

Currently this is the DHCID, in the future we may add a unique ID per request to allow for correlating messages and events between the DHCP servers and the D2 server. If we do that we shall also need to add or update other functions to: set the request ID, add it to the JSON strings, etc. The primary purpose of this function is to provide a consistent way to identify requests for logging purposes.

Member isc::dhcp_ddns::NameChangeRequest::NameChangeRequest ()

Currently, fromWire makes use of the ability to create an empty NameChangeRequest and then builds it bit by bit. This means that it is technically possible to create one and attempt to use in ways other than intended and its invalid content may or may not be handled gracefully by consuming code. It might be wise to revisit this structuring such that we do not use a default constructor and only allow valid instantiations.

Member isc::dhcp_ddns::NameChangeRequest::validateContent ()

This is an initial implementation which provides a minimal amount of validation. FQDN, DHCID, and IP Address members are all currently strings, these may be replaced with richer classes.

Member isc::dns::Name::Name (const char *name_data, size_t data_len, const Name *origin, bool downcase=false)

Should we make it private and the parser a friend, to hide the constructor?

Member isc::dns::TSIGContext::verify (const TSIGRecord *const record, const void *const data, const size_t data_len)

Signature truncation support based on RFC4635

Class isc::dns::TSIGRecord

So the plan is to eventually provide the "from wire" constructor. It's not yet provided in the current phase of development.

Member isc::ha::CommunicationState::setPartnerTime (const std::string &time_text)

Consider some other time formats which include millisecond precision.

Member isc::ha::HAImpl::buffer4Receive (hooks::CalloutHandle &callout_handle)

Add unit tests to verify the behavior for different malformed packets.

Member isc::ha::HAImpl::buffer6Receive (hooks::CalloutHandle &callout_handle)

Add unit tests to verify the behavior for different malformed packets.

Class isc::hooks::HooksConfig

add toElement() unit tests

Member isc::hooks::HooksConfig::equal (const HooksConfig &other) const

: This comparision assumes that the library order is not relevant, so [ lib1, lib2 ] is equal to [ lib2, lib1 ]. However, this is not strictly true, because callouts execution is called in other they're loaded. Therefore changing the libraries order may change the server behavior.

Member isc::hooks::HooksConfig::loadLibraries (bool multi_threading_enabled) const

: Delete any stored CalloutHandles before reloading the libraries

Member isc::hooks::ServerHooks::registerHook (const std::string &name)

: See ticket 5251 and 5208 for details.

: We also need to call CalloutManager::ensureVectorSize(), so it adjusts its vector. Since CalloutManager is not a singleton, there's no getInstance() or similar. Also, CalloutManager uses ServerHooks, so such a call would induce circular dependencies. Ugh.

Member isc::lease_cmds::LeaseCmdsImpl::lease6WipeHandler (CalloutHandle &handle)

: consider extending the code with wipe-leases:

of specific type (v6)
from specific shared network
from specific pool

Member isc::log::initLogger (isc::log::Severity severity=isc::log::DEBUG, int dbglevel=isc::log::MAX_DEBUG_LEVEL)

: Rename. This function overloads the initLogger() function that can be used to initialize production programs. This may lead to confusion.

Member isc::netconf::NetconfConfig::getConfiguredGlobals () const

revisit this at the toElement first use.

Member isc::perfdhcp::BasicScen::run () override

: need to implement adaptive time here, so the sleep time is not fixed, but adjusts to current situation.

Member isc::perfdhcp::ExchangeStats::printMainStats () const

Currently the number of orphans is not displayed because Reply messages received for Renew and Releases are counted as orphans for the 4-way exchanges, which is wrong. We will need to move the orphans counting out of the Statistics Manager so as orphans counter is increased only if the particular message is not identified as a response to any of the messages sent by perfdhcp.

Member isc::perfdhcp::PerfSocket::openSocket (CommandOptions &options) const

: find out why port 68 is wrong here.

Member isc::perfdhcp::TestControl::byte2Hex (const uint8_t b)

Consider moving this function to src/lib/util.

Member isc::perfdhcp::TestControl::cleanCachedPackets ()

The cache size might be controlled from the command line.

Instead of cleaning packets periodically we could just stop adding new packets when the certain threshold has been reached.

Member isc::perfdhcp::TestControl::factoryIana6 (dhcp::Option::Universe u, uint16_t type, const dhcp::OptionBuffer &buf)

add support for IA Address options.

allow different values of T1, T2 and IAID.

Member isc::perfdhcp::TestControl::factoryIapd6 (dhcp::Option::Universe u, uint16_t type, const dhcp::OptionBuffer &buf)

allow different values of T1, T2 and IAID.

Member isc::perfdhcp::TestControl::generateDuid (uint8_t &randomized)

add support for other types of DUID.

: add support for DUIDs of different sizes.

Member isc::perfdhcp::TestControl::HW_ETHER_LEN

Make this variable length as there are cases when HW address is longer than this (e.g. 20 bytes).

Member isc::perfdhcp::TestControl::processReceivedPacket4 (const dhcp::Pkt4Ptr &pkt4)

add defines for packet type index that can be used to access template_buffers_.

Member isc::perfdhcp::TestControl::processReceivedPacket6 (const dhcp::Pkt6Ptr &pkt6)

add defines for packet type index that can be used to access template_buffers_.

Member isc::perfdhcp::TestControl::sendPackets (const uint64_t packets_num, const bool preload=false)

do not count responses in preload mode as orphans.

add defines for packet type index that can be used to access template_buffers_.

Member isc::perfdhcp::TestControl::setDefaults6 (const dhcp::Pkt6Ptr &pkt)

: support more level of encapsulation, at the moment we only support one, via -A1 option.

Member isc::perfdhcp::TestControl::vector2Hex (const std::vector< uint8_t > &vec, const std::string &separator="")

Consider moving this function to src/lib/util.

Member isc::perfmon::PerfMonMgr::io_service_

Not sure if we really care. When not in service, traffic will effectively stop. Any active durations will eventually report once via timer but nothing more until traffic resumes.

Member isc::perfmon::PerfMonMgr::reportToStatsMgr (MonitoredDurationPtr duration)

- decide if we want to report min and max values too.

Member isc::process::CBControlBase< ConfigBackendMgrType >::databaseConfigFetch (const ConfigPtr &srv_cfg, const FetchMode &fetch_mode=FetchMode::FETCH_ALL)

We need a separate API call for the latter case to only fetch the last audit entry rather than all of them.

Consider reverting to the initial value to reload the entire configuration if the update failed.

Member isc::process::ConfigControlParser::parse (const data::ConstElementPtr &config_control)

do we still need access_string for this at all? can't we just use params directly and get rid of the string now that DatabaseConnection::toElement(map) exists?

Member isc::process::Daemon::writeConfigFile (const std::string &config_file, isc::data::ConstElementPtr cfg=isc::data::ConstElementPtr()) const

: this logically more belongs to CPL process file. Once Daemon is merged with CPL architecture, it will be a better fit.

Member isc::process::DControllerBase::initSignalHandling ()

block everything we don't handle

Member isc::process::DControllerBase::processSignal (int signum)

Provide a convenient way for derivations to register additional signals.

Member isc::process::DControllerBase::setCheckOnly (bool value)

this method and setVerbose are currently not used.

Member isc::stats::StatsMgr::addObservationInternal (const ObservationPtr &stat)

: Implement contexts.

Member isc::stats::StatsMgr::getObservationInternal (const std::string &name) const

: Implement contexts.

Member isc::util::CSVFile::append (const CSVRow &row) const

Apparently, seekp and seekg are interchangeable. A call to seekp results in moving the input pointer too. This is ok for now. It means that when the append() is called, the read pointer is moved to the EOF. For the current use cases we only read a file and then append a new content. If we come up with the scenarios when read and write is needed at the same time, we may revisit this: perhaps remember the old pointer. Also, for safety, we call both functions so as we are sure that both pointers are moved.

Class isc::yang::TranslatorOptionDef

: Support for ietf-dhcpv6-server model.

Class isc::yang::TranslatorOptionDefList

: Support for ietf-dhcpv6-server model.

Member isc::yang::TranslatorSubnet::getSubnetIetf6 (libyang::DataNode const &data_node)

: reservations

: timers

: option-data

Member isc::yang::TranslatorSubnet::setSubnetIetf6 (const std::string &xpath, isc::data::ConstElementPtr elem)

: reservations

: option-data

Page libkea-dhcpsrv - Server DHCP Library

better DHCPv4-over-DHCPv6 selection, e.g., handle relayed messages and return best (vs first) match.

Page libkea-process - Controllable Process Layer (CPL)

Eventually, some sort of secure socket interface which supports remote control operations such as configuration changes or status reporting will likely be implemented.

Member registry_fname

Hard-coded for now, this should be configurable.

Member user_chk_output_fname

Hard-coded for now, this should be configurable.