Kea  2.3.3-git
alloc_engine.h
Go to the documentation of this file.
1 // Copyright (C) 2012-2022 Internet Systems Consortium, Inc. ("ISC")
2 //
3 // This Source Code Form is subject to the terms of the Mozilla Public
4 // License, v. 2.0. If a copy of the MPL was not distributed with this
5 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
6 
7 #ifndef ALLOC_ENGINE_H
8 #define ALLOC_ENGINE_H
9 
10 #include <asiolink/io_address.h>
11 #include <dhcp/classify.h>
12 #include <dhcp/duid.h>
13 #include <dhcp/hwaddr.h>
14 #include <dhcp/pkt4.h>
15 #include <dhcp/pkt6.h>
16 #include <dhcp/option6_ia.h>
17 #include <dhcp/option6_iaaddr.h>
18 #include <dhcp/option6_iaprefix.h>
19 #include <dhcpsrv/allocator.h>
20 #include <dhcpsrv/d2_client_cfg.h>
21 #include <dhcpsrv/host.h>
22 #include <dhcpsrv/subnet.h>
23 #include <dhcpsrv/lease_mgr.h>
24 #include <dhcpsrv/srv_config.h>
25 #include <hooks/callout_handle.h>
27 #include <util/readwrite_mutex.h>
28 
29 #include <boost/shared_ptr.hpp>
30 #include <boost/noncopyable.hpp>
31 
32 #include <functional>
33 #include <list>
34 #include <map>
35 #include <mutex>
36 #include <set>
37 #include <utility>
38 
39 namespace isc {
40 namespace dhcp {
41 
47 class AllocEngine : public boost::noncopyable {
48 public:
49 
59  AllocEngine(uint64_t attempts);
60 
62  virtual ~AllocEngine() { }
63 
64 private:
65 
67  uint64_t attempts_;
68 
70  int hook_index_lease4_select_;
71  int hook_index_lease6_select_;
72 
73 public:
74 
83  class Resource {
84  public:
85 
95  const uint8_t prefix_len,
96  const uint32_t preferred = 0,
97  const uint32_t valid = 0)
98  : address_(address), prefix_len_(prefix_len),
99  preferred_(preferred), valid_(valid) {
100  }
101 
106  return (address_);
107  }
108 
112  uint8_t getPrefixLength() const {
113  return (prefix_len_);
114  }
115 
119  uint32_t getPreferred() const {
120  return (preferred_);
121  }
122 
126  uint32_t getValid() const {
127  return (valid_);
128  }
129 
135  bool equals(const Resource& other) const {
136  return (address_ == other.address_ &&
137  prefix_len_ == other.prefix_len_);
138  }
139 
145  bool operator==(const Resource& other) const {
146  return (equals(other));
147  }
148 
149  protected:
150 
153 
155  uint8_t prefix_len_;
156 
158  uint32_t preferred_;
159 
161  uint32_t valid_;
162  };
163 
175  bool operator() (const Resource& lhr, const Resource& rhr) const {
176  if (lhr.getAddress() == rhr.getAddress()) {
177  return (lhr.getPrefixLength() < rhr.getPrefixLength());
178  } else {
179  return (lhr.getAddress() < rhr.getAddress());
180  }
181  }
182  };
183 
185  typedef std::vector<Resource> HintContainer;
186 
188  typedef std::set<Resource, ResourceCompare> ResourceContainer;
189 
191  typedef std::pair<Host::IdentifierType, std::vector<uint8_t> > IdentifierPair;
192 
194  typedef std::list<IdentifierPair> IdentifierList;
195 
218  struct ClientContext6 : public boost::noncopyable {
219 
221 
222 
227 
234 
239 
242 
247 
250 
253 
256  IdentifierList host_identifiers_;
257 
263  std::map<SubnetID, ConstHostPtr> hosts_;
264 
269 
274 
279  std::string hostname_;
280 
283 
285  ResourceContainer allocated_resources_;
286 
289 
291 
293  struct IAContext {
294 
297  uint32_t iaid_;
298 
301 
306  HintContainer hints_;
307 
316 
324 
328  ResourceContainer new_resources_;
329 
333 
337  IAContext();
338 
345  void addHint(const asiolink::IOAddress& prefix,
346  const uint8_t prefix_len = 128,
347  const uint32_t preferred = 0,
348  const uint32_t valid = 0);
349 
355  void addHint(const Option6IAAddrPtr& iaaddr);
356 
362  void addHint(const Option6IAPrefixPtr& iaprefix);
363 
368  void addNewResource(const asiolink::IOAddress& prefix,
369  const uint8_t prefix_len = 128);
370 
375  bool isNewResource(const asiolink::IOAddress& prefix,
376  const uint8_t prefix_len = 128) const;
377  };
378 
380  std::vector<IAContext> ias_;
381 
389  DdnsParamsPtr getDdnsParams();
390 
395  void addAllocatedResource(const asiolink::IOAddress& prefix,
396  const uint8_t prefix_len = 128);
397 
402  bool isAllocated(const asiolink::IOAddress& prefix,
403  const uint8_t prefix_len = 128) const;
404 
411  const std::vector<uint8_t>& identifier) {
412  host_identifiers_.push_back(IdentifierPair(id_type, identifier));
413  }
414 
421  if (ias_.empty()) {
422  createIAContext();
423  }
424  return (ias_.back());
425  }
426 
432  ias_.push_back(IAContext());
433  };
434 
441  ConstHostPtr currentHost() const;
442 
451  ConstHostPtr globalHost() const;
452 
458  bool hasGlobalReservation(const IPv6Resrv& resv) const;
459 
461  ClientContext6();
462 
484  ClientContext6(const Subnet6Ptr& subnet, const DuidPtr& duid,
485  const bool fwd_dns, const bool rev_dns,
486  const std::string& hostname, const bool fake_allocation,
487  const Pkt6Ptr& query,
488  const hooks::CalloutHandlePtr& callout_handle =
490 
491  private:
495  DdnsParamsPtr ddns_params_;
496  };
497 
581 
603 
652  void reclaimExpiredLeases6(const size_t max_leases, const uint16_t timeout,
653  const bool remove_lease,
654  const uint16_t max_unwarned_cycles = 0);
655 
661  void deleteExpiredReclaimedLeases6(const uint32_t secs);
662 
711  void reclaimExpiredLeases4(const size_t max_leases, const uint16_t timeout,
712  const bool remove_lease,
713  const uint16_t max_unwarned_cycles = 0);
714 
720  void deleteExpiredReclaimedLeases4(const uint32_t secs);
721 
735  static void findReservation(ClientContext6& ctx);
736 
748 
754  static IPv6Resrv makeIPv6Resrv(const Lease6& lease) {
755  if (lease.type_ == Lease::TYPE_NA) {
756  return (IPv6Resrv(IPv6Resrv::TYPE_NA, lease.addr_,
757  (lease.prefixlen_ ? lease.prefixlen_ : 128)));
758  }
759 
760  return (IPv6Resrv(IPv6Resrv::TYPE_PD, lease.addr_, lease.prefixlen_));
761  }
762 
763 public:
780  static void getLifetimes6(ClientContext6& ctx, uint32_t& preferred,
781  uint32_t& valid);
782 private:
783 
819  Lease6Ptr createLease6(ClientContext6& ctx,
820  const isc::asiolink::IOAddress& addr,
821  const uint8_t prefix_len,
822  hooks::CalloutHandle::CalloutNextStep& callout_status);
823 
838  Lease6Collection allocateUnreservedLeases6(ClientContext6& ctx);
839 
856  void
857  allocateReservedLeases6(ClientContext6& ctx, Lease6Collection& existing_leases);
858 
872  void
873  allocateGlobalReservedLeases6(ClientContext6& ctx, Lease6Collection& existing_leases);
874 
883  void
884  removeNonmatchingReservedLeases6(ClientContext6& ctx,
885  Lease6Collection& existing_leases);
886 
894  void
895  removeNonmatchingReservedNoHostLeases6(ClientContext6& ctx,
896  Lease6Collection& existing_leases);
897 
911  void
912  removeNonreservedLeases6(ClientContext6& ctx,
913  Lease6Collection& existing_leases);
914 
947  Lease6Ptr
948  reuseExpiredLease(Lease6Ptr& expired,
949  ClientContext6& ctx,
950  uint8_t prefix_len,
951  hooks::CalloutHandle::CalloutNextStep& callout_status);
952 
971  Lease6Collection updateLeaseData(ClientContext6& ctx,
972  const Lease6Collection& leases);
973 
979  static bool
980  removeLeases(Lease6Collection& container,
981  const asiolink::IOAddress& addr);
982 
995  void extendLease6(ClientContext6& ctx, Lease6Ptr lease);
996 
1004  enum DbReclaimMode {
1005  DB_RECLAIM_REMOVE,
1006  DB_RECLAIM_UPDATE,
1007  DB_RECLAIM_LEAVE_UNCHANGED
1008  };
1009 
1021  template<typename LeasePtrType>
1022  void reclaimExpiredLease(const LeasePtrType& lease,
1023  const bool remove_lease,
1024  const hooks::CalloutHandlePtr& callout_handle);
1025 
1036  template<typename LeasePtrType>
1037  void reclaimExpiredLease(const LeasePtrType& lease,
1038  const hooks::CalloutHandlePtr& callout_handle);
1039 
1050  void reclaimExpiredLease(const Lease6Ptr& lease,
1051  const DbReclaimMode& reclaim_mode,
1052  const hooks::CalloutHandlePtr& callout_handle);
1053 
1064  void reclaimExpiredLease(const Lease4Ptr& lease,
1065  const DbReclaimMode& reclaim_mode,
1066  const hooks::CalloutHandlePtr& callout_handle);
1067 
1086  template<typename LeasePtrType>
1087  void reclaimLeaseInDatabase(const LeasePtrType& lease,
1088  const bool remove_lease,
1089  const std::function<void (const LeasePtrType&)>&
1090  lease_update_fun) const;
1091 
1104  bool reclaimDeclined(const Lease4Ptr& lease);
1105 
1118  bool reclaimDeclined(const Lease6Ptr& lease);
1119 
1120 public:
1121 
1139  struct ClientContext4 : public boost::noncopyable {
1144 
1147 
1150 
1153 
1159 
1162 
1165 
1170  std::string hostname_;
1171 
1174 
1181 
1184 
1187 
1193  std::map<SubnetID, ConstHostPtr> hosts_;
1194 
1201 
1207 
1210  IdentifierList host_identifiers_;
1211 
1215 
1223  DdnsParamsPtr getDdnsParams();
1224 
1225 
1232  const std::vector<uint8_t>& identifier) {
1233  host_identifiers_.push_back(IdentifierPair(id_type, identifier));
1234  }
1235 
1242  ConstHostPtr currentHost() const;
1243 
1252  ConstHostPtr globalHost() const;
1253 
1255  ClientContext4();
1256 
1271  ClientContext4(const Subnet4Ptr& subnet, const ClientIdPtr& clientid,
1272  const HWAddrPtr& hwaddr,
1273  const asiolink::IOAddress& requested_addr,
1274  const bool fwd_dns_update, const bool rev_dns_update,
1275  const std::string& hostname, const bool fake_allocation);
1276 
1277  private:
1281  DdnsParamsPtr ddns_params_;
1282  };
1283 
1285  typedef boost::shared_ptr<ClientContext4> ClientContext4Ptr;
1286 
1393 
1406  static void findReservation(ClientContext4& ctx);
1407 
1419 
1437  static uint32_t getValidLft(const ClientContext4& ctx);
1438 
1439 private:
1440 
1471  Lease4Ptr discoverLease4(ClientContext4& ctx);
1472 
1510  Lease4Ptr requestLease4(ClientContext4& ctx);
1511 
1541  Lease4Ptr createLease4(const ClientContext4& ctx,
1542  const isc::asiolink::IOAddress& addr,
1543  hooks::CalloutHandle::CalloutNextStep& callout_status);
1544 
1558  Lease4Ptr renewLease4(const Lease4Ptr& lease, ClientContext4& ctx);
1559 
1576  Lease4Ptr
1577  reuseExpiredLease4(Lease4Ptr& expired, ClientContext4& ctx,
1578  hooks::CalloutHandle::CalloutNextStep& callout_status);
1579 
1595  Lease4Ptr
1596  allocateOrReuseLease4(const asiolink::IOAddress& address,
1597  ClientContext4& ctx,
1598  hooks::CalloutHandle::CalloutNextStep& callout_status);
1599 
1618  Lease4Ptr allocateUnreservedLease4(ClientContext4& ctx);
1619 
1642  bool updateLease4Information(const Lease4Ptr& lease,
1643  ClientContext4& ctx) const;
1644 
1645 protected:
1660  void updateLease4ExtendedInfo(const Lease4Ptr& lease,
1661  const ClientContext4& ctx) const;
1662 
1678  void updateLease6ExtendedInfo(const Lease6Ptr& lease,
1679  const ClientContext6& ctx) const;
1680 
1681 private:
1682 
1696  void setLeaseReusable(const Lease4Ptr& lease,
1697  const ClientContext4& ctx) const;
1698 
1713  void setLeaseReusable(const Lease6Ptr& lease,
1714  uint32_t current_preferred_lft,
1715  const ClientContext6& ctx) const;
1716 
1717 private:
1718 
1721  uint16_t incomplete_v4_reclamations_;
1722 
1725  uint16_t incomplete_v6_reclamations_;
1726 
1727 public:
1728 
1735  return (rw_mutex_);
1736  }
1737 
1740 };
1741 
1743 typedef boost::shared_ptr<AllocEngine> AllocEnginePtr;
1744 
1745 } // namespace dhcp
1746 } // namespace isc
1747 
1748 #endif // ALLOC_ENGINE_H
Resource(const isc::asiolink::IOAddress &address, const uint8_t prefix_len, const uint32_t preferred=0, const uint32_t valid=0)
Default constructor.
Definition: alloc_engine.h:94
Defines the D2ClientConfig class.
std::map< SubnetID, ConstHostPtr > hosts_
Holds a map of hosts belonging to the client within different subnets.
bool fake_allocation_
Indicates if this is a real or fake allocation.
boost::shared_ptr< DUID > DuidPtr
Definition: duid.h:20
Standard implementation of read-write mutexes with writer preference using C++11 mutex and condition ...
HWAddrPtr hwaddr_
Hardware/MAC address (if available, may be NULL)
Definition: alloc_engine.h:252
Defines a single hint.
Definition: alloc_engine.h:83
Lease6Collection changed_leases_
A pointer to any leases that have changed FQDN information.
Definition: alloc_engine.h:323
HintContainer hints_
Client&#39;s hints.
Definition: alloc_engine.h:306
void updateLease4ExtendedInfo(const Lease4Ptr &lease, const ClientContext4 &ctx) const
Stores additional client query parameters on a V4 lease.
static void findReservation(ClientContext6 &ctx)
Attempts to find appropriate host reservation.
boost::shared_ptr< HWAddr > HWAddrPtr
Shared pointer to a hardware address structure.
Definition: hwaddr.h:154
isc::util::ReadWriteMutex rw_mutex_
The read-write mutex.
static IPv6Resrv makeIPv6Resrv(const Lease6 &lease)
Creates an IPv6Resrv instance from a Lease6.
Definition: alloc_engine.h:754
Lease6Collection old_leases_
A pointer to any old leases that the client had before update but are no longer valid after the updat...
Definition: alloc_engine.h:315
An abstract API for lease database.
static ConstHostPtr findGlobalReservation(ClientContext6 &ctx)
Attempts to find the host reservation for the client.
Defines elements for storing the names of client classes.
boost::shared_ptr< Subnet4 > Subnet4Ptr
A pointer to a Subnet4 object.
Definition: subnet.h:446
static void getLifetimes6(ClientContext6 &ctx, uint32_t &preferred, uint32_t &valid)
Determines the preferred and valid v6 lease lifetimes.
bool early_global_reservations_lookup_
Indicates if early global reservation is enabled.
bool fwd_dns_update_
A boolean value which indicates that server takes responsibility for the forward DNS Update for this ...
Definition: alloc_engine.h:268
DuidPtr duid_
Client identifier.
Definition: alloc_engine.h:249
Lease4Ptr allocateLease4(ClientContext4 &ctx)
Returns IPv4 lease.
Read-Write Mutex.
isc::asiolink::IOAddress getAddress() const
Returns the address.
Definition: alloc_engine.h:105
uint8_t prefix_len_
The prefix length (128 for an address).
Definition: alloc_engine.h:155
IPv6 reservation for a host.
Definition: host.h:161
std::list< IdentifierPair > IdentifierList
Map holding values to be used as host identifiers.
Definition: alloc_engine.h:194
hooks::CalloutHandlePtr callout_handle_
Callout handle associated with the client&#39;s message.
boost::shared_ptr< AllocEngine > AllocEnginePtr
A pointer to the AllocEngine object.
IdentifierList host_identifiers_
A list holding host identifiers extracted from a message received by the server.
boost::shared_ptr< DdnsParams > DdnsParamsPtr
Defines a pointer for DdnsParams instances.
Definition: srv_config.h:172
asiolink::IOAddress requested_address_
An address that the client desires.
void deleteExpiredReclaimedLeases4(const uint32_t secs)
Deletes reclaimed leases expired more than specified amount of time ago.
boost::shared_ptr< Option6IA > Option6IAPtr
A pointer to the Option6IA object.
Definition: option6_ia.h:17
bool early_global_reservations_lookup_
Indicates if early global reservation is enabled.
Definition: alloc_engine.h:238
ResourceContainer new_resources_
Holds addresses and prefixes allocated for this IA.
Definition: alloc_engine.h:328
boost::shared_ptr< Pkt6 > Pkt6Ptr
A pointer to Pkt6 packet.
Definition: pkt6.h:28
Subnet6Ptr subnet_
Subnet selected for the client by the server.
Definition: alloc_engine.h:241
ResourceContainer allocated_resources_
Holds addresses and prefixes allocated for all IAs.
Definition: alloc_engine.h:285
AllocEngine(uint64_t attempts)
Constructor.
Definition: alloc_engine.cc:93
Lease4Ptr conflicting_lease_
A pointer to the object representing a lease in conflict.
boost::shared_ptr< Option6IAPrefix > Option6IAPrefixPtr
Pointer to the Option6IAPrefix object.
boost::shared_ptr< Lease4 > Lease4Ptr
Pointer to a Lease4 structure.
Definition: lease.h:294
Lease4Ptr old_lease_
A pointer to an old lease that the client had before update.
std::map< SubnetID, ConstHostPtr > hosts_
Holds a map of hosts belonging to the client within different subnets.
Definition: alloc_engine.h:263
std::vector< IAContext > ias_
Container holding IA specific contexts.
Definition: alloc_engine.h:380
Context information for the DHCPv6 leases allocation.
Definition: alloc_engine.h:218
Subnet6Ptr host_subnet_
Subnet from which host reservations should be retrieved.
Definition: alloc_engine.h:246
boost::shared_ptr< ClientContext4 > ClientContext4Ptr
Pointer to the ClientContext4.
Lease6Collection renewLeases6(ClientContext6 &ctx)
Renews existing DHCPv6 leases for a given IA.
void reclaimExpiredLeases6(const size_t max_leases, const uint16_t timeout, const bool remove_lease, const uint16_t max_unwarned_cycles=0)
Reclaims expired IPv6 leases.
Subnet4Ptr subnet_
Subnet selected for the client by the server.
uint32_t getValid() const
Returns the optional valid lifetime.
Definition: alloc_engine.h:126
bool unknown_requested_addr_
True when the address DHCPREQUEST&#39;ed by client is not within a dynamic pool the server knows about...
Pkt4Ptr query_
A pointer to the client&#39;s message.
Option6IAPtr ia_rsp_
A pointer to the IA_NA/IA_PD option to be sent in response.
Definition: alloc_engine.h:332
boost::shared_ptr< Pkt4 > Pkt4Ptr
A pointer to Pkt4 object.
Definition: pkt4.h:544
CalloutNextStep
Specifies allowed next steps.
boost::shared_ptr< const Host > ConstHostPtr
Const pointer to the Host object.
Definition: host.h:804
void addHostIdentifier(const Host::IdentifierType &id_type, const std::vector< uint8_t > &identifier)
Convenience function adding host identifier into host_identifiers_ list.
Definition: alloc_engine.h:410
Structure that holds a lease for IPv6 address and/or prefix.
Definition: lease.h:524
std::vector< Resource > HintContainer
Container for client&#39;s hints.
Definition: alloc_engine.h:185
Lease::Type type_
Lease type.
Definition: lease.h:529
uint8_t prefixlen_
IPv6 prefix length.
Definition: lease.h:534
std::vector< Lease6Ptr > Lease6Collection
A collection of IPv6 leases.
Definition: lease.h:671
uint32_t valid_
The valid lifetime (0 when not set).
Definition: alloc_engine.h:161
boost::shared_ptr< ClientId > ClientIdPtr
Shared pointer to a Client ID.
Definition: duid.h:103
isc::util::ReadWriteMutex & getReadWriteMutex()
Get the read-write mutex.
void addHostIdentifier(const Host::IdentifierType &id_type, const std::vector< uint8_t > &identifier)
Convenience function adding host identifier into host_identifiers_ list.
the lease contains non-temporary IPv6 address
Definition: lease.h:47
bool fake_allocation_
Indicates if this is a real or fake allocation.
Definition: alloc_engine.h:233
Defines the logger used by the top-level component of kea-lfc.
Lease6Collection new_leases_
A collection of newly allocated leases.
Definition: alloc_engine.h:288
ClientIdPtr clientid_
Client identifier from the DHCP message.
uint32_t iaid_
The IAID field from IA_NA or IA_PD that is being processed.
Definition: alloc_engine.h:297
Lease::Type type_
Lease type (IA or PD)
Definition: alloc_engine.h:300
bool equals(const Resource &other) const
Compares two AllocEngine::Resource objects for equality.
Definition: alloc_engine.h:135
Pkt6Ptr query_
A pointer to the client&#39;s message.
Definition: alloc_engine.h:226
Lease6Collection allocateLeases6(ClientContext6 &ctx)
Allocates IPv6 leases for a given IA container.
Parameters pertaining to individual IAs.
Definition: alloc_engine.h:293
boost::shared_ptr< CalloutHandle > CalloutHandlePtr
A shared pointer to a CalloutHandle object.
Lease4Ptr new_lease_
A pointer to a newly allocated lease.
isc::asiolink::IOAddress address_
The address or prefix.
Definition: alloc_engine.h:152
Type
Type of lease or pool.
Definition: lease.h:46
bool rev_dns_update_
A boolean value which indicates that server takes responsibility for the reverse DNS Update for this ...
Definition: alloc_engine.h:273
bool fwd_dns_update_
Perform forward DNS update.
static uint32_t getValidLft(const ClientContext4 &ctx)
Returns the valid lifetime based on the v4 context.
void deleteExpiredReclaimedLeases6(const uint32_t secs)
Deletes reclaimed leases expired more than specified amount of time ago.
uint32_t getPreferred() const
Returns the optional preferred lifetime.
Definition: alloc_engine.h:119
isc::asiolink::IOAddress addr_
IPv4 ot IPv6 address.
Definition: lease.h:120
void createIAContext()
Creates new IA context.
Definition: alloc_engine.h:431
IAContext & currentIA()
Returns IA specific context for the currently processed IA.
Definition: alloc_engine.h:420
uint8_t getPrefixLength() const
Returns the prefix length.
Definition: alloc_engine.h:112
void reclaimExpiredLeases4(const size_t max_leases, const uint16_t timeout, const bool remove_lease, const uint16_t max_unwarned_cycles=0)
Reclaims expired IPv4 leases.
uint32_t preferred_
The preferred lifetime (0 when not set).
Definition: alloc_engine.h:158
boost::shared_ptr< Subnet6 > Subnet6Ptr
A pointer to a Subnet6 object.
Definition: subnet.h:604
virtual ~AllocEngine()
Destructor.
Definition: alloc_engine.h:62
IdentifierType
Type of the host identifier.
Definition: host.h:307
hooks::CalloutHandlePtr callout_handle_
Callout handle associated with the client&#39;s message.
Definition: alloc_engine.h:282
bool operator==(const Resource &other) const
Equality operator.
Definition: alloc_engine.h:145
HWAddrPtr hwaddr_
HW address from the DHCP message.
Context information for the DHCPv4 lease allocation.
DHCPv4 and DHCPv6 allocation engine.
Definition: alloc_engine.h:47
boost::shared_ptr< Lease6 > Lease6Ptr
Pointer to a Lease6 structure.
Definition: lease.h:513
std::set< Resource, ResourceCompare > ResourceContainer
Container holding allocated prefixes or addresses.
Definition: alloc_engine.h:188
std::pair< Host::IdentifierType, std::vector< uint8_t > > IdentifierPair
A tuple holding host identifier type and value.
Definition: alloc_engine.h:191
boost::shared_ptr< Option6IAAddr > Option6IAAddrPtr
A pointer to the isc::dhcp::Option6IAAddr object.
bool rev_dns_update_
Perform reverse DNS update.
void updateLease6ExtendedInfo(const Lease6Ptr &lease, const ClientContext6 &ctx) const
Stores additional client query parameters on a V6 lease.
IdentifierList host_identifiers_
A list holding host identifiers extracted from a message received by the server.
Definition: alloc_engine.h:256