| Nisc | Defines the logger used by the top-level component of kea-lfc | 
| Nagent |  | 
| CAgentParser | A Bison parser | 
| Cbasic_symbol | A complete symbol | 
| Cby_kind | Type access provider for token (enum) based symbols | 
| Ccontext |  | 
| Csymbol_kind | Symbol kinds | 
| Csymbol_type | "External" symbols: returned by the scanner | 
| Csyntax_error | Syntax errors thrown from user actions | 
| Ctoken | Token kinds | 
| Cvalue_type | A buffer to store and retrieve objects | 
| CAgentSimpleParser |  | 
| CCommandForwardingError | Exception thrown when an error occurred during control command forwarding | 
| CCtrlAgentCfgContext | Control Agent Configuration Context | 
| CCtrlAgentCfgMgr | Ctrl Agent Configuration Manager | 
| CCtrlAgentCommandMgr | Command Manager for Control Agent | 
| CCtrlAgentController | Process Controller for Control Agent Process | 
| CCtrlAgentProcess | Kea Control Agent Application Process | 
| CCtrlAgentResponseCreator | Concrete implementation of the HTTP response creator used by the Control Agent | 
| CCtrlAgentResponseCreatorFactory | HTTP response creator factory for Control Agent | 
| CHttpSocketInfo | Structure used to store HTTP/HTTPS connection data | 
| CParserContext | Parser context is a wrapper around flex/bison instances dedicated to Control-agent config file parser | 
| Nasiodns |  | 
| CIOFetch | Upstream Fetch Processing | 
| CCallback | I/O Fetch Callback | 
| CIOFetchData | IOFetch Data | 
| Nasiolink |  | 
| CBufferOverflow | Buffer overflow | 
| CBufferTooLarge | Buffer Too Large | 
| CDummyAsioSocket | The DummyAsioSocketclass is a concrete derived class ofIOAsioSocketthat is not associated with any real socket | 
| CDummyIOCallback | Asynchronous I/O Completion Callback | 
| CDummySocket | The DummySocketclass is a concrete derived class ofIOSocketthat is not associated with any real socket | 
| CIntervalTimer | The IntervalTimerclass is a wrapper for the ASIOboost::asio::deadline_timerclass | 
| CIntervalTimerImpl | This class holds a call back function of asynchronous operations | 
| CIOAcceptor | Base class for acceptor services in Kea | 
| CIOAddress | The IOAddressclass represents an IP addresses (version agnostic) | 
| CHash | An IOAddresshash enabling the use in the unordered STL containers | 
| CIOAsioSocket | I/O Socket with asynchronous operations | 
| CIOEndpoint | The IOEndpointclass is an abstract base class to represent a communication endpoint | 
| CIOError | An exception that is thrown if an error occurs within the IO module | 
| CIOService | The IOService class is a wrapper for the ASIO io_contextclass | 
| CIOServiceImpl |  | 
| CIOServiceMgr | Class which handles events on IOService objects | 
| CIoServiceThreadPool | Implements a pausable pool of IOService driven threads | 
| CIOSignalSet | Implements an asynchronous "signal" for IOService driven processing | 
| CIOSignalSetImpl | Implementation class of IOSignalSet | 
| CIOSocket | The IOSocketclass is an abstract base class to represent various types of network sockets | 
| CProcessSpawn | Utility class for spawning new processes | 
| CProcessSpawnError | Exception thrown when error occurs during spawning a process | 
| CProcessSpawnImpl | Implementation of the ProcessSpawnclass | 
| CProcessState | Type for process state | 
| CSocketNotOpen | Socket not open | 
| CSocketSetError | Error setting socket options | 
| CStreamService |  | 
| CTCPAcceptor | Provides a service for accepting new TCP connections | 
| CTCPEndpoint | The TCPEndpointclass is a concrete derived class ofIOEndpointthat represents an endpoint of a TCP packet | 
| CTCPSocket | The TCPSocketclass is a concrete derived class ofIOAsioSocketthat represents a TCP socket | 
| CTLSAcceptor | Provides a service for accepting new TLS connections | 
| CTlsContextBase | TLS context base class | 
| CTLSSocket | The TLSSocketclass is a concrete derived class ofIOAsioSocketthat represents a TLS socket | 
| CTlsStreamBase | TLS stream base class | 
| CUDPEndpoint | The UDPEndpointclass is a concrete derived class ofIOEndpointthat represents an endpoint of a UDP packet | 
| CUDPSocket | The UDPSocketclass is a concrete derived class ofIOAsioSocketthat represents a UDP socket | 
| CUnixDomainSocket | Represents unix domain socket implemented in terms of boost asio | 
| CUnixDomainSocketAcceptor | Implements acceptor service for UnixDomainSocket | 
| CUnixDomainSocketEndpoint | Endpoint for UnixDomainSocket | 
| CUnixDomainSocketError | Exception thrown upon socket error | 
| CUnixDomainSocketImpl | Implementation of the unix domain socket | 
| Ncb |  | 
| CBaseConfigBackend | Interface for Kea server specific configuration backend implementations | 
| CBaseConfigBackendMgr | Base class for Configuration Backend Managers (CBM) | 
| CBaseConfigBackendPool | Base class for configuration backend pools | 
| Nclass_cmds |  | 
| CClassCmds | Implements the logic for processing commands pertaining to client classes manipulation | 
| CClassCmdsImpl | Implementation of the ClassCmdsclass | 
| CDependOnKnownError | Thrown upon an attempt to update a class when dependency on KNOWN or UNKNOWN built-in class is removed or added | 
| CInUseError | Thrown upon an attempt to delete a class which would result in leaving dangling dependencies | 
| Nconfig |  | 
| CBadSocketInfo | An exception indicating that specified socket parameters are invalid | 
| CBaseCommandMgr | Commands Manager, responsible for processing external commands | 
| CHandlersPair |  | 
| CClientConnection | Represents client side connection over the unix domain socket | 
| CControlCommand | Encapsulates control command | 
| CSocketPath | Encapsulates socket path | 
| CTimeout | Encapsulates timeout value | 
| CClientConnectionImpl | Implementation of the ClientConnection | 
| CCmdHttpListener | A multi-threaded HTTP listener that can process API commands requests | 
| CCmdResponseCreator | Concrete implementation of the HTTP response creator used for processing API commands | 
| CCmdResponseCreatorFactory | HTTP response creator factory for an API listener | 
| CCmdsImpl | Base class that command handler implementers may use for common tasks | 
| CCommandMgr | Commands Manager implementation for the Kea servers | 
| CCtrlChannelError | A standard control channel exception that is thrown if a function is there is a problem with one of the messages | 
| CHookedCommandMgr | Command Manager which can delegate commands to a hook library | 
| CHttpCommandConfig | HTTP command config aka HTTP control socket info class | 
| CHttpCommandMgr | HTTP Commands Manager implementation for the Kea servers | 
| CHttpCommandMgrImpl | Implementation of the HttpCommandMgr | 
| CHttpCommandResponseCreator | Concrete implementation of the HTTP response creator used for HTTP control socket | 
| CHttpCommandResponseCreatorFactory | HTTP response creator factory for HTTP control socket | 
| CHttpSocketInfo | Structure used to store HTTP/HTTPS connection data | 
| CInvalidCommandHandler | Exception indicating that the handler specified is not valid | 
| CInvalidCommandName | Exception indicating that the command name is not valid | 
| CJSONFeed | State model for asynchronous read of data in JSON format | 
| CJSONFeedError | A generic exception thrown upon an error in the JSONFeed | 
| CSocketError | An exception indicating a problem with socket operation | 
| CUnixCommandConfig | UNIX command config aka UNIX control socket info class | 
| CUnixCommandMgr | Unix Commands Manager implementation for the Kea servers | 
| CUnixCommandMgrImpl | Implementation of the UnixCommandMgr | 
| CUnixSocketInfo | Structure used to store UNIX connection data | 
| Ncryptolink |  | 
| Nossl |  | 
| CSecBuf | Secure Buffers which are wiped out when released | 
| CBadKey | This exception is thrown when the underlying library could not handle the key data | 
| CCryptoLink | Singleton entry point and factory class | 
| CCryptoLinkError | General exception class that is the base for all crypto-related exceptions | 
| CCryptoLinkImpl |  | 
| CHash | Hash support | 
| CHashImpl | Botan implementation of Hash | 
| CHMAC | HMAC support | 
| CHMACImpl | Botan implementation of HMAC | 
| CInitializationError | This exception is thrown if there was a problem initializing the crypto library | 
| CLibraryError | This exception is raised when a general error that was not specifically caught is thrown by the underlying library | 
| CRNG | RNG support | 
| CRNGImpl | Botan implementation of RNG | 
| CUnsupportedAlgorithm | This exception is thrown when a cryptographic action is requested for an algorithm that is not supported by the underlying library | 
| Nd2 |  | 
| CCheckExistsAddTransaction | Embodies the "life-cycle" required to carry out a DDNS Add update | 
| CCheckExistsAddTransactionError | Thrown if the CheckExistsAddTransaction encounters a general error | 
| CCheckExistsRemoveTransaction | Embodies the "life-cycle" required to carry out a DDNS Remove update | 
| CCheckExistsRemoveTransactionError | Thrown if the CheckExistsRemoveTransaction encounters a general error | 
| CD2CfgContext | DHCP-DDNS Configuration Context | 
| CD2CfgError | Exception thrown when the error during configuration handling occurs | 
| CD2CfgMgr | DHCP-DDNS Configuration Manager | 
| CD2Controller | Process Controller for D2 Process This class is the DHCP-DDNS specific derivation of DControllerBase | 
| CD2Params | Acts as a storage vault for D2 global scalar parameters | 
| CD2ParseError | Evaluation error exception raised when trying to parse | 
| CD2Parser | A Bison parser | 
| Cbasic_symbol | A complete symbol | 
| Cby_kind | Type access provider for token (enum) based symbols | 
| Ccontext |  | 
| Csymbol_kind | Symbol kinds | 
| Csymbol_type | "External" symbols: returned by the scanner | 
| Csyntax_error | Syntax errors thrown from user actions | 
| Ctoken | Token kinds | 
| Cvalue_type | A buffer to store and retrieve objects | 
| CD2ParserContext | Evaluation context, an interface to the expression evaluation | 
| CD2Process | DHCP-DDNS Application Process | 
| CD2QueueMgr | D2QueueMgr creates and manages a queue of DNS update requests | 
| CD2QueueMgrError | Thrown if the queue manager encounters a general error | 
| CD2QueueMgrInvalidIndex | Thrown if a queue index is beyond the end of the queue | 
| CD2QueueMgrQueueEmpty | Thrown if the request queue empty and a read is attempted | 
| CD2QueueMgrQueueFull | Thrown if the request queue is full when an enqueue is attempted | 
| CD2QueueMgrReceiveError | Thrown if the queue manager's receive handler is passed a failure result | 
| CD2SimpleParser |  | 
| CD2Stats | Statistics Names | 
| CD2TsigKey | Statistics keeping extension of the DNS TSIGKey class | 
| CD2UpdateMessage | The D2UpdateMessageencapsulates a DNS Update message | 
| CD2UpdateMgr | D2UpdateMgr creates and manages update transactions | 
| CD2UpdateMgrError | Thrown if the update manager encounters a general error | 
| CD2Zone | The D2Zoneencapsulates the Zone section in DNS Update message | 
| CDdnsDomain | Represents a DNS domain that is may be updated dynamically | 
| CDdnsDomainListMgr | Provides storage for and management of a list of DNS domains | 
| CDdnsDomainListMgrParser | Parser for DdnsDomainListMgr | 
| CDdnsDomainListParser | Parser for a list of DdnsDomains | 
| CDdnsDomainParser | Parser for DdnsDomain | 
| CDNSClient | The DNSClientclass handles communication with the DNS server | 
| CCallback | Callback for the DNSClientclass | 
| CDNSClientImpl |  | 
| CDnsServerInfo | Represents a specific DNS Server | 
| CDnsServerInfoListParser | Parser for a list of DnsServerInfos | 
| CDnsServerInfoParser | Parser for DnsServerInfo | 
| CDScalarContext | Storage container for scalar configuration parameters | 
| CInvalidQRFlag | Exception indicating that QR flag has invalid value | 
| CInvalidZoneSection | Exception indicating that Zone section contains invalid content | 
| CNameAddTransaction | Embodies the "life-cycle" required to carry out a DDNS Add update | 
| CNameAddTransactionError | Thrown if the NameAddTransaction encounters a general error | 
| CNameChangeTransaction | Embodies the "life-cycle" required to carry out a DDNS update | 
| CNameChangeTransactionError | Thrown if the transaction encounters a general error | 
| CNameRemoveTransaction | Embodies the "life-cycle" required to carry out a DDNS Remove update | 
| CNameRemoveTransactionError | Thrown if the NameRemoveTransaction encounters a general error | 
| CNotUpdateMessage | Exception indicating that the parsed message is not DNS Update | 
| CSimpleAddTransaction | Embodies the "life-cycle" required to carry out a DDNS Add update | 
| CSimpleAddTransactionError | Thrown if the SimpleAddTransaction encounters a general error | 
| CSimpleAddWithoutDHCIDTransaction | Embodies the "life-cycle" required to carry out a DDNS Add update without checking for conflicts | 
| CSimpleAddWithoutDHCIDTransactionError | Thrown if the SimpleAddWithoutDHCIDTransaction encounters a general error | 
| CSimpleRemoveTransaction | Embodies the "life-cycle" required to carry out a DDNS Remove update | 
| CSimpleRemoveTransactionError | Thrown if the SimpleRemoveTransaction encounters a general error | 
| CSimpleRemoveWithoutDHCIDTransaction | Embodies the "life-cycle" required to carry out a DDNS Remove update without removing any matching DHCID RRs | 
| CSimpleRemoveWithoutDHCIDTransactionError | Thrown if the SimpleRemoveWithoutDHCIDTransaction encounters a general error | 
| CTSIGKeyInfo | Represents a TSIG Key | 
| CTSIGKeyInfoListParser | Parser for a list of TSIGKeyInfos | 
| CTSIGKeyInfoParser | Parser for TSIGKeyInfo | 
| CTSIGVerifyError | Exception indicating that a signed, inbound message failed to verify | 
| Ndata |  | 
| CBaseStampedElement | This class represents configuration element which is associated with database identifier and the modification timestamp | 
| CBigIntElement | Wrapper over int128_t | 
| CBoolElement |  | 
| CCfgToElement | Abstract class for configuration Cfg_* classes | 
| CDefaultCredential | Exception thrown on attempt to use a default credential | 
| CDefaultCredentials | Base class for default credentials | 
| CDoubleElement |  | 
| CElement | The Elementclass represents a piece of data, used by the command channel and configuration parts | 
| CPosition | Represents the position of the data element within a configuration string | 
| CElementValue | Template class for converting a value encapsulated in the Elementobject into a simple type | 
| CElementValue< asiolink::IOAddress > | The ElementValuespecialization for IOAddress | 
| CElementValue< bool > | The ElementValuespecialization for boolean | 
| CElementValue< double > | The ElementValuespecialization for double | 
| CElementValue< std::string > | The ElementValuespecialization for string | 
| CHierarchyTraversalTest | Structure holding the test functions used to traverse the element hierarchy | 
| CIntElement | Notes: IntElement type is changed to int64_t | 
| CJSONError | A standard Data module exception that is thrown if a parse error is encountered when constructing an Element from a string | 
| CListElement |  | 
| CMapElement |  | 
| CNullElement |  | 
| CServerTag | Represents a server tag | 
| CSimpleDefault | This array defines a single entry of default values | 
| CSimpleParser | A simple parser | 
| CStampedElement | This class represents configuration element which is associated with database identifier, modification timestamp and servers | 
| CStampedValue | This class represents a named configuration parameter, e.g | 
| CStampedValueModificationTimeIndexTag | Tag for the index for access by modification time | 
| CStampedValueNameIndexTag | Tag for the index for access by value name | 
| CStringElement |  | 
| CTypeError | A standard Data module exception that is thrown if a function is called for an Element that has a wrong type (e.g | 
| CUserContext | Base class for user context | 
| Ndb |  | 
| CAmbiguousDatabase | Specification of the database backend to be used yields multiple results | 
| CAuditEntry | Represents a single entry in the audit table | 
| CAuditEntryModificationTimeIdTag | Tag used to access index by modification time | 
| CAuditEntryObjectIdTag | Tag used to access index by object id | 
| CAuditEntryObjectTypeTag | Tag used to access index by object type | 
| CBackendSelector | Config Backend selector | 
| CDatabaseConnection | Common database connection class | 
| CEnterTest | RAII device to set the test mode | 
| CDataTruncated | Data is truncated | 
| CDB_LOG | DB_LOG_* logic | 
| CDB_LOG_DEBUG |  | 
| CDB_LOG_ERROR |  | 
| CDB_LOG_FATAL | All DB_LOG specializations | 
| CDB_LOG_INFO |  | 
| CDB_LOG_WARN |  | 
| CDbAccessParser | Parse Database Parameters | 
| CDbConfigError | Error detected in the database configuration | 
| CDbConnectionInitWithRetry | RAII class to enable DB reconnect retries on server startup | 
| CDbConnectionUnusable | Exception thrown when a specific connection has been rendered unusable either through loss of connectivity or API lib error | 
| CDbInvalidPort | Invalid port number | 
| CDbInvalidReadOnly | Invalid 'readonly' value specification | 
| CDbInvalidTimeout | Invalid Timeout | 
| CDbLogger | Database logger class | 
| CDbOpenError | Exception thrown on failure to open database | 
| CDbOpenErrorWithRetry | Exception thrown on failure to open database but permit retries | 
| CDbOperationError | Exception thrown on failure to execute a database function | 
| CDuplicateEntry | Database duplicate entry error | 
| CInvalidAddressFamily | Invalid address family used as input to Lease Manager | 
| CInvalidRange | Upper bound address is lower than lower bound address while retrieving a range of leases | 
| CInvalidType | Invalid type exception | 
| CMultipleRecords | Multiple lease records found where one expected | 
| CMySqlBinding | MySQL binding used in prepared statements | 
| CMySqlBindingTraits | Trait class for column types supported in MySQL | 
| CMySqlBindingTraits< boost::posix_time::ptime > | Specialization for MySQL TIMESTAMP type | 
| CMySqlBindingTraits< float > |  | 
| CMySqlBindingTraits< int16_t > | Speclialization for MySQL SMALLINT type | 
| CMySqlBindingTraits< int32_t > | Specialization for MySQL INT type | 
| CMySqlBindingTraits< int64_t > | Specialization for MySQL BIGINT type | 
| CMySqlBindingTraits< int8_t > | Specialization for MySQL TINYINT type | 
| CMySqlBindingTraits< std::string > | Specialization for MySQL TEXT type | 
| CMySqlBindingTraits< uint16_t > | Specialization for MySQL SMALLINT UNSIGNED type | 
| CMySqlBindingTraits< uint32_t > | Specialization for MySQL INT UNSIGNED type | 
| CMySqlBindingTraits< uint64_t > | Specialization for MySQL BIGINT UNSIGNED type | 
| CMySqlBindingTraits< uint8_t > | Specialization for MySQL TINYINT UNSIGNED type | 
| CMySqlConnection | Common MySQL Connector Pool | 
| CMySqlFreeResult | Fetch and Release MySQL Results | 
| CMySqlHolder | MySQL Handle Holder | 
| CMySqlTransaction | RAII object representing MySQL transaction | 
| CNoDatabaseName | Exception thrown if name of database is not specified | 
| CNoRowsAffected | Thrown when it is expected that some rows are affected, usually during a DELETE or an UPDATE, but none are | 
| CNoSuchDatabase | Error when specified database could not be found in the server configuration | 
| CNullKeyError | Key is NULL but was specified NOT NULL | 
| CPgSqlConnection | Common PgSql Connector Pool | 
| CPgSqlExchange | Base class for marshalling data to and from PostgreSQL | 
| CPgSqlHolder | Postgresql connection handle Holder | 
| CPgSqlResult | RAII wrapper for PostgreSQL Result sets | 
| CPgSqlResultRowWorker | Convenience class which facilitates fetching column values from a result set row | 
| CPgSqlTaggedStatement | Define a PostgreSQL statement | 
| CPgSqlTransaction | RAII object representing a PostgreSQL transaction | 
| CPsqlBindArray |  | 
| CReadOnlyDb | Attempt to modify data in read-only database | 
| CSchemaInitializationFailed | Thrown when an initialization of the schema failed | 
| CServer | Represents information about a Kea server in the database | 
| CServerFetcher | Utility class used to fetch Serverobjects from theServerCollection | 
| CServerSelector | Server selector for associating objects in a database with specific servers | 
| CServerTagIndexTag | Tag identifying an index by server tag | 
| CTaggedStatement | MySQL Selection Statements | 
| Nddns_tuning |  | 
| CDdnsTuningImpl | DDNS Tuning implementation | 
| CExpressionCache | ExpressionCache stores expressions per subnet | 
| Ndhcp |  | 
| Ntest |  | 
| CLogContentTest | Test class for testing things that emit log entries | 
| CUnixControlClient | Class that acts as a UnixCommandSocket client | 
| CAddressIndexTag | Tag for indexes by address | 
| CAddressRange | Structure representing IP address range | 
| CAllocationState | Base class for representing allocation state in pools and subnets | 
| CAllocator | Base class for all address/prefix allocation algorithms | 
| CAllocEngine | DHCPv4 and DHCPv6 allocation engine | 
| CClientContext4 | Context information for the DHCPv4 lease allocation | 
| CClientContext6 | Context information for the DHCPv6 leases allocation | 
| CIAContext | Parameters pertaining to individual IAs | 
| CResource | Defines a single hint | 
| CResourceCompare | Resource compare class | 
| CAllocFailed | An exception that is thrown when allocation module fails (e.g | 
| CAuthKey | Authentication keys | 
| CBadDataTypeCast | Exception to be thrown when cast to the data type was unsuccessful | 
| CBadHostAddress | Exception thrown when invalid IP address has been specified for Host | 
| CBaseHostDataSource | Base interface for the classes implementing simple data source for host reservations | 
| CBaseNetworkParser | Common configuration parser for shared networks and subnets | 
| CCacheHostDataSource | Abstract interface extending base simple data source for host reservations to host cache | 
| CCBControlDHCP | Base class for implementing mechanisms to control the use of the Configuration Backends by DHCPv4 and DHCPv6 servers | 
| CCBControlDHCPv4 | Implementation of the mechanisms to control the use of the Configuration Backends by the DHCPv4 server | 
| CCBControlDHCPv6 | Implementation of the mechanisms to control the use of the Configuration Backends by the DHCPv6 server | 
| CCfg4o6 | This structure contains information about DHCP4o6 (RFC7341) | 
| CCfgConsistency | Parameters for various consistency checks | 
| CCfgDbAccess | Holds access parameters and the configuration of the lease and hosts database connection | 
| CCfgDUID | Holds manual configuration of the server identifier (DUID) | 
| CCfgExpiration | Holds configuration parameters pertaining to lease expiration and lease affinity | 
| CCfgGlobals | Class to store configured global parameters | 
| CCfgHostDbAccess |  | 
| CCfgHostOperations | Represents global configuration for host reservations | 
| CCfgHosts | Represents the host reservations specified in the configuration file | 
| CCfgHostsList | Utility class to represent host reservation configurations internally as a map keyed by subnet IDs, externally as a list Element | 
| CCfgIface | Represents selection of interfaces for DHCP server | 
| CCfgLeaseDbAccess | Utility class for unparsing | 
| CCfgMACSource | Wrapper class that holds MAC/hardware address sources | 
| CCfgMgr | Configuration Manager | 
| CCfgMultiThreading | Utility class to apply multi threading configurations | 
| CCfgOption | Represents option data configuration for the DHCP server | 
| CCfgOptionDef | Represents option definitions used by the DHCP server | 
| CCfgRSOO | Represents configuration of the RSOO options for the DHCP server | 
| CCfgSharedNetworks | This class holds configuration of shared networks | 
| CCfgSharedNetworks4 | Represents configuration of IPv4 shared networks | 
| CCfgSharedNetworks6 | Represents configuration of IPv6 shared networks | 
| CCfgSubnets4 | Holds subnets configured for the DHCPv4 server | 
| CCfgSubnets6 | Holds subnets configured for the DHCPv6 server | 
| CClassLeaseCounter | Container that maintains counts of leases per class and lease type | 
| CClassNameTag | Tag for the name index | 
| CClassSequenceTag | Tag for the sequence index | 
| CClientClassDef | Embodies a single client class definition | 
| CClientClassDefListParser | Parser for a list of client class definitions | 
| CClientClassDefParser | Parser for a single client class definition | 
| CClientClassDictionary | Maintains a list of ClientClassDef's | 
| CClientClasses | Container for storing client class names | 
| CClientHandler | Client race avoidance RAII handler | 
| CClientId | Holds Client identifier or client IPv4 address | 
| CClientIdSubnetIdIndexTag | Tag for indexes by client-id, subnet-id tuple | 
| CCompatibilityParser |  | 
| CConfigBackendDHCPv4 | Interface implemented by DHCPv4 configuration backends | 
| CConfigBackendDHCPv4Mgr | Configuration Backend Manager for DHCPv4 servers | 
| CConfigBackendDHCPv6 | Interface implemented by DHCPv6 configuration backends | 
| CConfigBackendDHCPv6Mgr | Configuration Backend Manager for DHCPv6 servers | 
| CConfigBackendPoolDHCPv4 | Implementation of the Configuration Backend Pool for DHCPv4 | 
| CConfigBackendPoolDHCPv6 | Implementation of the Configuration Backend Pool for DHCPv6 | 
| CControlledDhcpv4Srv | Controlled version of the DHCPv4 server | 
| CControlledDhcpv6Srv | Controlled version of the DHCPv6 server | 
| CControlSocketsParser | Parser for the control-sockets structure | 
| CCSVLeaseFile4 | Provides methods to access CSV file with DHCPv4 leases | 
| CCSVLeaseFile6 | Provides methods to access CSV file with DHCPv6 leases | 
| CD2ClientConfig | Acts as a storage vault for D2 client configuration | 
| CD2ClientConfigParser | Parser for D2ClientConfig | 
| CD2ClientError | An exception that is thrown if an error occurs while configuring the D2 DHCP DDNS client | 
| CD2ClientMgr | D2ClientMgr isolates Kea from the details of being a D2 client | 
| CDdnsParams | Convenience container for conveying DDNS behavioral parameters It is intended to be created per Packet exchange using the selected subnet passed into functions that require them | 
| CDhcp4o6IpcBase | This class implements the communication between the DHCPv4 and DHCPv6 servers to allow for transmission of the DHCPv4 query and DHCPv4 response messages | 
| CDhcp4o6IpcError | Exception thrown when error occurs as a result of use of IPC | 
| CDhcp4ParseError | Evaluation error exception raised when trying to parse | 
| CDhcp4Parser | A Bison parser | 
| Cbasic_symbol | A complete symbol | 
| Cby_kind | Type access provider for token (enum) based symbols | 
| Ccontext |  | 
| Csymbol_kind | Symbol kinds | 
| Csymbol_type | "External" symbols: returned by the scanner | 
| Csyntax_error | Syntax errors thrown from user actions | 
| Ctoken | Token kinds | 
| Cvalue_type | A buffer to store and retrieve objects | 
| CDhcp4to6Ipc | Handles DHCPv4-over-DHCPv6 IPC on the DHCPv4 server side | 
| CDhcp6ParseError | Evaluation error exception raised when trying to parse | 
| CDhcp6Parser | A Bison parser | 
| Cbasic_symbol | A complete symbol | 
| Cby_kind | Type access provider for token (enum) based symbols | 
| Ccontext |  | 
| Csymbol_kind | Symbol kinds | 
| Csymbol_type | "External" symbols: returned by the scanner | 
| Csyntax_error | Syntax errors thrown from user actions | 
| Ctoken | Token kinds | 
| Cvalue_type | A buffer to store and retrieve objects | 
| CDhcp6to4Ipc | Handles DHCPv4-over-DHCPv6 IPC on the DHCPv6 server side | 
| CDhcpConfigError | To be removed. Please use ConfigError instead | 
| CDHCPQueueControlParser | Parser for the configuration of DHCP packet queue controls | 
| CDhcpv4Exchange | DHCPv4 message exchange | 
| CDhcpv4Srv | DHCPv4 server service | 
| CDHCPv6DiscardMessageError | This exception is thrown when DHCP server hits the error which should result in discarding the message being processed | 
| CDhcpv6Srv | DHCPv6 server service | 
| CDnrInstance | Represents DNR Instance which is used both in DHCPv4 and DHCPv6 Encrypted DNS Option | 
| CDUID | Holds DUID (DHCPv6 Unique Identifier) | 
| CDUIDConfigParser | Parser for server DUID configuration | 
| CDUIDFactory | Factory for generating DUIDs (DHCP Unique Identifiers) | 
| CDuidIaidTypeIndexTag | Tag for indexes by DUID, IAID, lease type tuple | 
| CDuidIndexTag | Tag for index using DUID | 
| CDuplicateAddress | Exception thrown when duplicated address specified | 
| CDuplicateClientClassDef | Error that occurs when an attempt is made to add a duplicate class to a class dictionary | 
| CDuplicateHost | Exception thrown when the duplicate Hostobject is detected | 
| CDuplicateIfaceName | Exception thrown when duplicated interface names specified | 
| CDuplicateListeningIface | Exception thrown when the same interface has been specified twice | 
| CDuplicateOptionDefinition | Exception to be thrown when the particular option definition duplicates existing option definition | 
| CDuplicateSubnetID | Exception thrown upon attempt to add subnet with an ID that belongs to the subnet that already exists | 
| CEvalBadLabel | EvalBadLabel is thrown when a label can't be found | 
| CEvalBadStack | EvalBadStack is thrown when more or less parameters are on the stack than expected | 
| CEvalTypeError | EvalTypeError is thrown when a value on the stack has a content with an unexpected type | 
| CExpirationConfigParser | Parser for the configuration parameters pertaining to the processing of expired leases | 
| CExpirationIndexTag | Tag for indexes by expiration time | 
| CExpressionParser | Parser for a logical expression | 
| CFreeLeaseQueueAllocator | An allocator maintaining a queue of free leases | 
| CHost | Represents a device with IPv4 and/or IPv6 reservations | 
| CHostDataSourceFactory | Host Data Source Factory | 
| CHostMgr | Host Manager | 
| CHostnameIndexTag | Tag for index using hostname | 
| CHostNotFound | Exception thrown when a Hostobject is expected, but none are found | 
| CHostPageSize | Wraps value holding size of the page with host reservations | 
| CHostReservationIdsParser | Parser for a list of host identifiers | 
| CHostReservationIdsParser4 | Parser for a list of host identifiers for DHCPv4 | 
| CHostReservationIdsParser6 | Parser for a list of host identifiers for DHCPv6 | 
| CHostReservationParser | Parser for a single host reservation entry | 
| CHostReservationParser4 | Parser for a single host reservation for DHCPv4 | 
| CHostReservationParser6 | Parser for a single host reservation for DHCPv6 | 
| CHostReservationsListParser | Parser for a list of host reservations for a subnet | 
| CHostResrv6Tuple | Defines one entry for the Host Container for v6 hosts | 
| CHWAddr | Hardware type that represents information from DHCPv4 packet | 
| CHWAddressSubnetIdIndexTag | Tag for indexes by HW address, subnet-id tuple | 
| CIdentifierBaseType | Base type used to define a common smart pointer for all derived types | 
| CIdentifierType |  | 
| CIface | Represents a single network interface | 
| CIfaceCollection | Collection of pointers to network interfaces | 
| CIfaceDetectError | IfaceMgr exception thrown thrown when interface detection fails | 
| CIfaceMgr | Handles network interfaces, transmission and reception | 
| CSocketCallbackInfo | Keeps callback information for external sockets | 
| CIfaceNotFound | IfaceMgr exception thrown when there is no suitable interface | 
| CIfacesConfigParser | Parser for the configuration of interfaces | 
| CInvalidDataType | Exception to be thrown when invalid type specified as template parameter | 
| CInvalidIfaceName | Exception thrown when specified interface name is invalid | 
| CInvalidOption4FqdnDomainName | Exception thrown when invalid domain name is specified | 
| CInvalidOption4FqdnFlags | Exception thrown when invalid flags have been specified for DHCPv4 Client FQDN Option | 
| CInvalidOption6FqdnDomainName | Exception thrown when invalid domain name is specified | 
| CInvalidOption6FqdnFlags | Exception thrown when invalid flags have been specified for DHCPv6 Client Fqdn Option | 
| CInvalidOptionDnrDomainName | Exception thrown when invalid domain name is specified | 
| CInvalidOptionDnrSvcParams | Exception thrown when Service parameters have wrong format | 
| CInvalidOptionSpace | Exception to be thrown when invalid option space is specified | 
| CInvalidOptionValue | Exception to be thrown when invalid option value has been specified for a particular option definition | 
| CInvalidPacketFilter | Exception thrown when invalid packet filter object specified | 
| CInvalidPacketHeader | Exception thrown when error occurred during parsing packet's headers | 
| CInvalidQueueParameter | Invalid queue parameter exception | 
| CInvalidQueueType | Invalid Queue type exception | 
| CInvalidSocketType | Exception thrown when invalid socket type has been specified for the given family | 
| CIOAddressListListTag | Tag for the list of IO addresses as a list | 
| CIOAddressListSetTag | Tag for the list of IO addresses as a set | 
| CIPRangePermutation | Random IP address/prefix permutation based on Fisher-Yates shuffle | 
| CIPv6Resrv | IPv6 reservation for a host | 
| CIterativeAllocator | Address/prefix allocator that iterates over all addresses | 
| CKeyFromKeyExtractor | Utility class which cascades two key extractors | 
| CLease | Common structure for IPv4 and IPv6 leases | 
| CLease4 | Structure that holds a lease for IPv4 address | 
| CLease6 | Structure that holds a lease for IPv6 address and/or prefix | 
| CLease6ExtendedInfo | Lease6 extended informations for Bulk Lease Query | 
| CLeaseAddressIndexTag | Tag for indexes by lease address | 
| CLeaseFileLoader | Utility class to manage bulk of leases in the lease files | 
| CLeaseFileStats | Provides statistics for leases | 
| CLeaseMgr | Abstract Lease Manager | 
| CLeaseMgrFactory | Lease Manager Factory | 
| CLeasePageSize | Wraps value holding size of the page with leases | 
| CLeaseStatsQuery | Base class for fulfilling a statistical lease data query | 
| CLeaseStatsRow | Contains a single row of lease statistical data | 
| CLegalLogDbLogger | Legal log database logger class in RAII style | 
| CLegalLogMgr | LegalLogMgr abstract class | 
| CLegalLogMgrError | Thrown if a LegalLogMgr encounters an error | 
| CLegalLogMgrFactory | Backend Store Factory | 
| CLFCSetup | Represents a configuration for Lease File Cleanup | 
| CLibDHCP |  | 
| CMACSourcesListConfigParser | Parser for MAC/hardware acquisition sources | 
| CMalformedOptionDefinition | Exception to be thrown when option definition is invalid | 
| CManagedScopedOptionsCopyContainer |  | 
| CMemfile_LeaseMgr | Concrete implementation of a lease database backend using flat file | 
| CMemfileLeaseMgrInit | Initialization structure used to register and deregister Memfile Lease Mgr | 
| CMemfileLeaseStatsQuery | Base Memfile derivation of the statistical lease data query | 
| CMemfileLeaseStatsQuery4 | Memfile derivation of the IPv4 statistical lease data query | 
| CMemfileLeaseStatsQuery6 | Memfile derivation of the IPv6 statistical lease data query | 
| CMultiThreadingConfigParser | Simple parser for multi-threading structure | 
| CNetwork | Common interface representing a network to which the DHCP clients are connected | 
| CRelayInfo | Holds optional information about relay | 
| CNetwork4 | Specialization of the Network object for DHCPv4 case | 
| CNetwork6 | Specialization of the Network object for DHCPv6 case | 
| CNetworkState | Controls the DHCP service enabling status | 
| CNetworkStateImpl | Implementation of the NetworkStateclass | 
| CNoHostDataSourceManager | No host data source instance exception | 
| CNoLeaseManager | No lease manager exception | 
| CNoSuchAddress | Exception thrown when specified unicast address is not assigned to the interface specified | 
| CNoSuchIface | Exception thrown when specified interface doesn't exist in a system | 
| CNoSuchLease | Attempt to update lease that was not there | 
| COpaqueDataTuple | Represents a single instance of the opaque data preceded by length | 
| COpaqueDataTupleError | Exception to be thrown when the operation on OpaqueDataTupleobject results in an error | 
| COption |  | 
| COption4AddrLst | DHCPv4 Option class for handling list of IPv4 addresses | 
| COption4ClientFqdn | Represents DHCPv4 Client FQDN Option (code 81) | 
| CRcode | Represents the value of one of the RCODE1 or RCODE2 fields | 
| COption4ClientFqdnImpl | Implements the logic for the Option6ClientFqdn class | 
| COption4Dnr | Represents DHCPv4 Encrypted DNS Option (code 162) | 
| COption4SlpServiceScope | This class represents SLP Service Scope option (79) from RFC2610 | 
| COption6AddrLst | DHCPv6 Option class for handling list of IPv6 addresses | 
| COption6Auth | This class represents Authentication (11) DHCPv6 option | 
| COption6ClientFqdn | Represents DHCPv6 Client FQDN Option (code 39) | 
| COption6ClientFqdnImpl | Implements the logic for the Option6ClientFqdn class | 
| COption6Dnr | Represents DHCPv6 Encrypted DNS Option (code 144) | 
| COption6IA |  | 
| COption6IAAddr |  | 
| COption6IAPrefix | Class that represents IAPREFIX option in DHCPv6 | 
| COption6PDExclude | DHCPv6 option class representing Prefix Exclude Option (RFC 6603) | 
| COption6StatusCode | This class represents Status Code option (13) from RFC 8415 | 
| COptionClasslessStaticRoute | Represents DHCPv4 Classless Static Route Option (code 121) | 
| COptionCustom | Option with defined data fields represented as buffers that can be accessed using data field index | 
| COptionDataListParser | Parser for option data values within a subnet | 
| COptionDataParser | Parser for option data value | 
| COptionDataTypeTraits | Trait class for data types supported in DHCP option definitions | 
| COptionDataTypeTraits< asiolink::IOAddress > | IPv4 and IPv6 address type is supported | 
| COptionDataTypeTraits< bool > | Bool type is supported | 
| COptionDataTypeTraits< int16_t > | Int16_t type is supported | 
| COptionDataTypeTraits< int32_t > | Int32_t type is supported | 
| COptionDataTypeTraits< int8_t > | Int8_t type is supported | 
| COptionDataTypeTraits< OptionBuffer > | Binary type is supported | 
| COptionDataTypeTraits< std::string > | String type is supported | 
| COptionDataTypeTraits< uint16_t > | Uint16_t type is supported | 
| COptionDataTypeTraits< uint32_t > | Uint32_t type is supported | 
| COptionDataTypeTraits< uint8_t > | Uint8_t type is supported | 
| COptionDataTypeUtil | Utility class for option data types | 
| COptionDefinition | Base class representing a DHCP option definition | 
| COptionDefListParser | Parser for a list of option definitions | 
| COptionDefParams | Parameters being used to make up an option definition | 
| COptionDefParamsEncapsulation | Encapsulation of option definition parameters and the structure size | 
| COptionDefParser | Parser for a single option definition | 
| COptionDefSpaceContainer | Class of option definition space container | 
| COptionDescriptor | Option descriptor | 
| COptionIdIndexTag | A tag for accessing DHCP options and definitions by id | 
| COptionInt | Forward declaration to OptionInt | 
| COptionIntArray | Forward declaration to OptionIntArray | 
| COptionOpaqueDataTuples | This class encapsulates a collection of data tuples and could be used by multiple options | 
| COptionParseError | Wrapper exception thrown by unpackOptionsX functions to add option type and len to the underlying error | 
| COptionSpace | DHCP option space | 
| COptionSpace6 | DHCPv6 option space with enterprise number assigned | 
| COptionSpaceContainer | Simple container for option spaces holding various items | 
| COptionString | Class which represents an option carrying a single string value | 
| COptionVendor | This class represents vendor-specific information option | 
| COptionVendorClass | This class encapsulates DHCPv6 Vendor Class and DHCPv4 V-I Vendor Class options | 
| CPacketFilterChangeDenied | Exception thrown when it is not allowed to set new Packet Filter | 
| CPacketQueue | Interface for managing a queue of inbound DHCP packets | 
| CPacketQueueMgr | Packet Queue Managers (PQM) | 
| CPacketQueueMgr4 | Packet Queue Manager for DHCPv4 servers | 
| CPacketQueueMgr6 | Packet Queue Manager for DHCPv6 servers | 
| CPacketQueueRing | Provides a ring-buffer implementation of the PacketQueue interface | 
| CPacketQueueRing4 | DHCPv4 packet queue buffer implementation | 
| CPacketQueueRing6 | DHCPv6 packet queue buffer implementation | 
| CParser4Context | Evaluation context, an interface to the expression evaluation | 
| CParser6Context | Evaluation context, an interface to the expression evaluation | 
| CPdPoolParser | Parser for IPv6 prefix delegation definitions | 
| CPdPoolsListParser | Parser for a list of prefix delegation pools | 
| CPkt | Base class for classes representing DHCP messages | 
| CPkt4 | Represents DHCPv4 packet | 
| CPkt4o6 | Represents DHCPv4-over-DHCPv6 packet | 
| CPkt6 | Represents a DHCPv6 packet | 
| CRelayInfo | Structure that describes a single relay information | 
| CPktEvent | Describes an event during the life cycle of a packet | 
| CPktFilter | Abstract packet handling class | 
| CPktFilter6 | Abstract packet handling class for DHCPv6 | 
| CPktFilterBPF | Packet handling class using Berkeley Packet Filtering (BPF) | 
| CPktFilterInet | Packet handling class using AF_INET socket family | 
| CPktFilterInet6 | A DHCPv6 packet handling class using datagram sockets | 
| CPktFilterLPF | Packet handling class using Linux Packet Filtering | 
| CPool | Base class for Pool4 and Pool6 | 
| CPool4 | Pool information for IPv4 addresses | 
| CPool4Parser | Parser for IPv4 pool definitions | 
| CPool6 | Pool information for IPv6 addresses and prefixes | 
| CPool6Parser | Parser for IPv6 pool definitions | 
| CPoolFreeLeaseQueueAllocationState | Pool allocation state used by the FLQ allocator | 
| CPoolIterativeAllocationState | Pool allocation state used by the iterative allocator | 
| CPoolParser | Parser for a single pool definition | 
| CPoolRandomAllocationState | Pool allocation state used by the random allocator | 
| CPools4ListParser | Specialization of the pool list parser for DHCPv4 | 
| CPools6ListParser | Specialization of the pool list parser for DHCPv6 | 
| CPoolsListParser | Parser for a list of pools | 
| CPrefixLen | Encapsulates prefix length | 
| CPrefixRange | Structure representing delegated prefix range | 
| CPSID | Encapsulates PSID value | 
| CPSIDLen | Encapsulates PSID length | 
| CRandomAllocator | An allocator offering addresses in a random order | 
| CRelayIdIndexTag | Tag for index using relay-id | 
| CRelayInfoParser | Parser for additional relay information | 
| CRemoteIdIndexTag | Tag for index using remote-id | 
| CReservedAddress | Exception thrown when an address is already reserved by a Hostobject (DuplicateHost is same identity, ReservedAddress same address) | 
| CResourceBusy | Thrown by lock users when a resource lock cannot be obtained | 
| CResourceHandler | Resource race avoidance RAII handler | 
| CResourceHandler4 | Resource race avoidance RAII handler for DHCPv4 | 
| CRFCViolation | An exception that is thrown if a DHCPv6 protocol violation occurs while processing a message (e.g | 
| CSanityChecker | Code used to conduct various sanity checks | 
| CSanityChecksParser | Simple parser for sanity-checks structure | 
| CScopedEnableOptionsCopy | RAII object enabling copying options retrieved from the packet | 
| CScopedPktOptionsCopy | RAII object enabling duplication of the stored options and restoring the original options on destructor | 
| CScopedSubOptionsCopy | RAII object enabling duplication of the stored options and restoring the original options on destructor | 
| CSharedNetwork4 | Shared network holding IPv4 subnets | 
| CSharedNetwork4Parser | Implements parser for IPv4 shared networks | 
| CSharedNetwork6 | Shared network holding IPv6 subnets | 
| CSharedNetwork6Parser | Implements parser for IPv6 shared networks | 
| CSharedNetworkFetcher | A class containing static convenience methods to fetch the shared networks from the containers | 
| CSharedNetworkIdIndexTag | A tag for accessing index by id | 
| CSharedNetworkModificationTimeIndexTag | Tag for the index for searching by shared network modification time | 
| CSharedNetworkNameIndexTag | A tag for accessing index by shared network name | 
| CSharedNetworkRandomAccessIndexTag | A tag for accessing random access index | 
| CSharedNetworkServerIdIndexTag | A tag for accessing index by server identifier | 
| CSharedNetworksListParser | Parser for a list of shared networks | 
| CSignalInterruptOnSelect | Exception thrown when a call to select is interrupted by a signal | 
| CSimpleParser4 |  | 
| CSimpleParser6 |  | 
| CSkipRemainingOptionsError | Exception thrown during option unpacking This exception is thrown when an error has occurred, unpacking an option from a packet and we wish to abandon any any further unpacking efforts and allow the server to attempt to process the packet as it stands | 
| CSkipThisOptionError | Exception thrown during option unpacking This exception is thrown when an error has occurred unpacking an option from a packet and rather than drop the whole packet, we wish to simply skip over the option (i.e | 
| CSocketConfigError | IfaceMgr exception thrown thrown when socket opening or configuration failed | 
| CSocketInfo | Holds information about socket | 
| CSocketNotFound | IfaceMgr exception thrown when there is no suitable socket found | 
| CSocketReadError | IfaceMgr exception thrown thrown when error occurred during reading data from socket | 
| CSocketWriteError | IfaceMgr exception thrown thrown when error occurred during sending data through socket | 
| CSrvConfig | Specifies current DHCP configuration | 
| CSubClassRelation | Defines a subclass to template class relation | 
| CSubnet |  | 
| CSubnet4 | A configuration holder for IPv4 subnet | 
| CSubnet4ConfigParser |  | 
| CSubnet6 | A configuration holder for IPv6 subnet | 
| CSubnet6ConfigParser |  | 
| CSubnetAllocationState | Common base class for subnet-specific allocation states | 
| CSubnetConfigParser | This class parses a single subnet | 
| CSubnetFetcher | A class containing static convenience methods to fetch the subnets from the containers | 
| CSubnetIdIndexTag | Tag for indexes by subnet-id (and address for v6) | 
| CSubnetIdPoolIdIndexTag | Tag for indexes by subnet-id and pool-id | 
| CSubnetIterativeAllocationState | Subnet allocation state used by the iterative allocator | 
| CSubnetModificationTimeIndexTag | Tag for the index for searching by subnet modification time | 
| CSubnetPrefixIndexTag | Tag for the index for searching by subnet prefix | 
| CSubnets4ListConfigParser | This class parses list of DHCP4 subnets | 
| CSubnets6ListConfigParser | This class parses a list of DHCP6 subnets | 
| CSubnetSelector | Subnet selector used to specify parameters used to select a subnet | 
| CSubnetServerIdIndexTag | Tag for the index for searching by server identifier | 
| CSubnetSubnetIdIndexTag | Tag for the index for searching by subnet identifier | 
| CTemplateClassNameTag | Tag for the name index | 
| CTemplateClassSequenceTag | Tag for the sequence index | 
| CTemplateClientClassDef |  | 
| CTimerMgr | Manages a pool of asynchronous interval timers | 
| CTimerMgrImpl | Implementation of the TimerMgr | 
| CToken | Base class for all tokens | 
| CTokenAnd | Token that represents logical and operator | 
| CTokenBranch | Token that represents unconditional branch | 
| CTokenConcat | Token that represents concat operator (concatenates two other tokens) | 
| CTokenEqual | Token that represents equality operator (compares two other tokens) | 
| CTokenFilterIA_NA | Filter all IA_NA so that no option is matched by the expression | 
| CTokenFilterIA_NASuboption | Filter all IA_NA so that no sub-option is matched by the expression | 
| CTokenFilterIA_PD | Filter all IA_PD so that no option is matched by the expression | 
| CTokenFilterIA_PDSuboption | Filter all IA_PD so that no sub-option is matched by the expression | 
| CTokenHexString | Token representing a constant string in hexadecimal format | 
| CTokenIfElse | Token that represents an alternative | 
| CTokenInt16ToText | Token representing a 16 bit integer as a string | 
| CTokenInt32ToText | Token representing a 32 bit integer as a string | 
| CTokenInt8ToText | Token representing an 8 bit integer as a string | 
| CTokenInteger | Token representing an unsigned 32 bit integer | 
| CTokenIpAddress | Token representing an IP address as a constant string | 
| CTokenIpAddressToText | Token representing an IP address as a string | 
| CTokenLabel | Token label i.e | 
| CTokenLeaseIA_NA | Filter the IA_NA (3) option containing the OPTION_IAADDR (5) option matching the respective lease | 
| CTokenLeaseIA_NASuboption | Filter the IA_NA (3) option containing the OPTION_IAADDR (5) option matching the respective lease | 
| CTokenLeaseIA_PD | Filter the IA_PD (25) option containing the OPTION_IAPREFIX (25) option matching the respective lease | 
| CTokenLeaseIA_PDSuboption | Filter the IA_PD (25) option containing the OPTION_IAPREFIX (25) option matching the respective lease | 
| CTokenLowerCase | Token representing a constant lower case string | 
| CTokenMatch | Token that represents regular expression (regex) matching | 
| CTokenMember | Token that represents client class membership | 
| CTokenNot | Token that represents logical negation operator | 
| CTokenOption | Token that represents a value of an option | 
| CTokenOr | Token that represents logical or operator | 
| CTokenPkt | Token that represents meta data of a DHCP packet | 
| CTokenPkt4 | Token that represents fields of a DHCPv4 packet | 
| CTokenPkt6 | Token that represents fields of DHCPv6 packet | 
| CTokenPopAndBranchFalse | Token that represents pop and branch if false | 
| CTokenPopOrBranchFalse | Token that represents pop or branch if false | 
| CTokenPopOrBranchTrue | Token that represents pop or branch if true | 
| CTokenRelay4Option | Represents a sub-option inserted by the DHCPv4 relay | 
| CTokenRelay6Field | Token that represents a value of a field within a DHCPv6 relay encapsulation | 
| CTokenRelay6Option | Token that represents a value of an option within a DHCPv6 relay encapsulation | 
| CTokenSplit |  | 
| CTokenString | The order where Token subtypes are declared should be: | 
| CTokenSubOption | Token that represents sub-options in DHCPv4 and DHCPv6 | 
| CTokenSubstring | Token that represents the substring operator (returns a portion of the supplied string) | 
| CTokenToHexString | Token that converts to hexadecimal string | 
| CTokenUInt16ToText | Token representing a 16 bit unsigned integer as a string | 
| CTokenUInt32ToText | Token representing a 32 bit unsigned integer as a string | 
| CTokenUInt8ToText | Token representing an 8 bit unsigned integer as a string | 
| CTokenUpperCase | Token representing a constant upper case string | 
| CTokenVendor | Token that represents vendor options in DHCPv4 and DHCPv6 | 
| CTokenVendorClass | Token that represents vendor class options in DHCPv4 and DHCPv6 | 
| CTrackingLeaseMgr | Introduces callbacks into the LeaseMgr | 
| CCallback | A structure representing a registered callback | 
| CValueStorage | A template class that stores named elements of a given data type | 
| CWritableHostDataSource | Interface for retrieving writable host reservations | 
| Ndhcp_ddns |  | 
| CD2Dhcid | Container class for handling the DHCID value within a NameChangeRequest | 
| CDhcidRdataComputeError | Exception thrown when there is an error occurred during computation of the DHCID | 
| CNameChangeListener | Abstract interface for receiving NameChangeRequests | 
| CRequestReceiveHandler | Abstract class for defining application layer receive callbacks | 
| CNameChangeRequest | Represents a DHCP-DDNS client request | 
| CNameChangeSender | Abstract interface for sending NameChangeRequests | 
| CRequestSendHandler | Abstract class for defining application layer send callbacks | 
| CNameChangeUDPListener | Provides the ability to receive NameChangeRequests via UDP socket | 
| CNameChangeUDPSender | Provides the ability to send NameChangeRequests via UDP socket | 
| CNcrListenerError | Exception thrown if an NcrListenerError encounters a general error | 
| CNcrListenerOpenError | Exception thrown if an error occurs during IO source open | 
| CNcrListenerReceiveError | Exception thrown if an error occurs initiating an IO receive | 
| CNcrMessageError | Exception thrown when NameChangeRequest marshalling error occurs | 
| CNcrSenderError | Thrown when a NameChangeSender encounters an error | 
| CNcrSenderOpenError | Exception thrown if an error occurs during IO source open | 
| CNcrSenderQueueFull | Exception thrown if an error occurs initiating an IO send | 
| CNcrSenderSendError | Exception thrown if an error occurs initiating an IO send | 
| CNcrUDPError | Thrown when a UDP level exception occurs | 
| CUDPCallback | Implements the callback class passed into UDPSocket calls | 
| CData | Container class which stores service invocation related data | 
| Ndns |  | 
| Nmaster_lexer_internal |  | 
| CInputSource | An input source that is used internally by MasterLexer | 
| COpenError | Exception thrown when we fail to open the input file | 
| CUngetBeforeBeginning | Exception thrown when ungetChar() is made to go before the start of buffer | 
| CState | Tokenization state for MasterLexer | 
| Nrdata |  | 
| Nany |  | 
| CTSIG | rdata::TSIGclass represents the TSIG RDATA as defined in RFC2845 | 
| Nch |  | 
| CA |  | 
| Ngeneric |  | 
| Ndetail |  | 
| CTXTLikeImpl | rdata::TXTLikeImplclass represents the TXT-like RDATA for TXT and SPF types | 
| CGeneric | The generic::Genericclass represents generic "unknown" RDATA | 
| CGenericImpl |  | 
| CNS |  | 
| COPT |  | 
| CPseudoRR | A class representing a pseudo RR (or option) within an OPT RR (see RFC 6891) | 
| CPTR |  | 
| CRRSIG | rdata::RRSIGclass represents the RRSIG RDATA as defined in RFC4034 | 
| CSOA |  | 
| CTKEY | rdata::TKEYclass represents the TKEY RDATA as defined in RFC2930 | 
| CTXT |  | 
| Nin |  | 
| CA |  | 
| CAAAA |  | 
| CDHCID | rdata::DHCIDclass represents the DHCID RDATA as defined in RFC4701 | 
| CAbstractRdataFactory | The AbstractRdataFactoryclass is an abstract base class to encapsulate a set of Rdata factory methods in a polymorphic way | 
| CCharStringTooLong | A standard DNS module exception that is thrown if RDATA parser encounters a character-string (as defined in RFC1035) exceeding the maximum allowable length ( MAX_CHARSTRING_LEN) | 
| CInvalidRdataLength | A standard DNS module exception that is thrown if RDATA parser encounters an invalid or inconsistent data length | 
| CInvalidRdataText | A standard DNS module exception that is thrown if RDATA parser fails to recognize a given textual representation | 
| CRdata | The Rdataclass is an abstract base class that provides a set of common interfaces to manipulate concrete RDATA objects | 
| CAbstractMessageRenderer | The AbstractMessageRendererclass is an abstract base class that provides common interfaces for rendering a DNS message into a buffer in wire format | 
| CAbstractRRset | The AbstractRRsetclass is an abstract base class that models a DNS RRset | 
| CBadEscape | A standard DNS module exception that is thrown if the name parser fails to decode a back-slash escaped sequence | 
| CBadLabelType | A standard DNS module exception that is thrown if the name parser encounters an obsolete or incomplete label type | 
| CBasicRRset | The BasicRRsetclass is a concrete derived class ofAbstractRRsetthat defines a straightforward RRset implementation | 
| CBasicRRsetImpl | This encapsulates the actual implementation of the BasicRRsetclass | 
| CDNSMessageBADVERS |  | 
| CDNSMessageFORMERR |  | 
| CDNSProtocolError |  | 
| CDNSTextError | Base class for all sorts of text parse errors | 
| CEDNS | The EDNSclass represents the EDNS OPT RR defined in RFC2671 | 
| CEmptyLabel | A standard DNS module exception that is thrown if the name parser encounters an empty label in the middle of a name | 
| CEmptyRRset | A standard DNS module exception that is thrown if an RRset object does not contain any RDATA where required | 
| CException |  | 
| CIncompleteName | A standard DNS module exception that is thrown if the name parser finds the input (string or wire-format data) is incomplete | 
| CIncompleteRRClass | A standard DNS module exception that is thrown if an RRClass object is being constructed from a incomplete (too short) wire-format data | 
| CIncompleteRRTTL | A standard DNS module exception that is thrown if an RRTTL object is being constructed from a incomplete (too short) wire-format data | 
| CIncompleteRRType | A standard DNS module exception that is thrown if an RRType object is being constructed from a incomplete (too short) wire-format data | 
| CInvalidMessageOperation | A standard DNS module exception that is thrown if a Messageclass method is called that is prohibited for the current mode of the message | 
| CInvalidMessageSection | A standard DNS module exception that is thrown if a section iterator is being constructed for an incompatible section | 
| CInvalidMessageUDPSize | A standard DNS module exception that is thrown if a UDP buffer size smaller than the standard default maximum (DEFAULT_MAX_UDPSIZE) is being specified for the message | 
| CInvalidRRClass | A standard DNS module exception that is thrown if an RRClass object is being constructed from an unrecognized string | 
| CInvalidRRTTL | A standard DNS module exception that is thrown if an RRTTL object is being constructed from an unrecognized string | 
| CInvalidRRType | A standard DNS module exception that is thrown if an RRType object is being constructed from an unrecognized string | 
| CLabelSequence | Light-weight Accessor to Name data | 
| CMasterLexer | Tokenizer for parsing DNS master files | 
| CLexerError | Exception thrown from a wrapper version of MasterLexer::getNextToken()for non fatal errors | 
| CReadError | Exception thrown when we fail to read from the input stream or file | 
| CMasterLoader | A class able to load DNS master files | 
| CMasterLoaderImpl | Private implementation class for the MasterLoader | 
| CMasterLoaderCallbacks | Set of issue callbacks for a loader | 
| CMasterLoaderError | Error while loading by MasterLoader without specifying the MANY_ERRORS option | 
| CMasterToken | Tokens for MasterLexer | 
| CStringRegion | A simple representation of a range of a string | 
| CMessage | The Messageclass encapsulates a standard DNS message | 
| CMessageImpl |  | 
| CMessageRenderer | The MessageRendereris a concrete derived class ofAbstractMessageRendereras a general purpose implementation of the renderer interfaces | 
| CMessageRendererImpl | The MessageRendererImplclass is the actual implementation ofMessageRenderer | 
| CMessageTooShort | A standard DNS module exception that is thrown if a wire format message parser encounters a short length of data that don't even contain the full header section | 
| CMissingNameOrigin | Thrown when origin is null and is needed | 
| CName | The Nameclass encapsulates DNS names | 
| CNameComparisonResult | This is a supplemental class used only as a return value of Name::compare() and LabelSequence::compare() | 
| CNameParserException | Base class for name parser exceptions | 
| COpcode | The Opcodeclass objects represent standard OPCODEs of the header section of DNS messages as defined in RFC1035 | 
| CQuestion | The Questionclass encapsulates the common search key of DNS lookup, consisting of owner name, RR type and RR class | 
| CRcode | DNS Response Codes (RCODEs) class | 
| CRdataFactory |  | 
| CRdataIterator | The RdataIteratorclass is an abstract base class that provides an interface for accessing RDATA objects stored in an RRset | 
| CRRClass | The RRClassclass encapsulates DNS resource record classes | 
| CRRClassExists | A standard DNS module exception that is thrown if a new RR class is being registered with a different type string | 
| CRRParamRegistry | The RRParamRegistryclass represents a registry of parameters to manipulate DNS resource records (RRs) | 
| CRRParamRegistryImpl | The RRParamRegistryImplclass is the actual implementation ofRRParamRegistry | 
| CRRset | The RRsetclass is a concrete derived class ofBasicRRsetwhich contains a pointer to an additional RRset containing associated RRSIG records | 
| CRRTTL | The RRTTLclass encapsulates TTLs used in DNS resource records | 
| CRRType | The RRTypeclass encapsulates DNS resource record types | 
| CRRTypeExists | A standard DNS module exception that is thrown if a new RR type is being registered with a different type string | 
| CSectionIterator | SectionIteratoris a templated class to provide standard-compatible iterators for Questions and RRsets for a given DNS message section | 
| CSectionIteratorImpl | Template version of Section Iterator | 
| CSerial | This class defines DNS serial numbers and serial arithmetic | 
| CTooLongLabel | A standard DNS module exception that is thrown if the name parser encounters too long a label | 
| CTooLongName | A standard DNS module exception that is thrown if the name parser encounters too long a name | 
| CTSIGContext | TSIG session context | 
| CTSIGContextImpl |  | 
| CTSIGContextError | An exception that is thrown for logic errors identified in TSIG sign/verify operations | 
| CTSIGError | TSIG errors | 
| CTSIGKey | TSIG key | 
| CTSIGKeyImpl |  | 
| CTSIGKeyRing | A simple repository of a set of TSIGKey objects | 
| CFindResult | A helper structure to represent the search result of TSIGKeyRing::find() | 
| CTSIGKeyRingImpl |  | 
| CTSIGRecord | TSIG resource record | 
| Neval |  | 
| CEvalContext | Evaluation context, an interface to the expression evaluation | 
| CEvalParseError | Evaluation error exception raised when trying to parse an exceptions | 
| CEvalParser | A Bison parser | 
| Cbasic_symbol | A complete symbol | 
| Cby_kind | Type access provider for token (enum) based symbols | 
| Ccontext |  | 
| Csymbol_kind | Symbol kinds | 
| Csymbol_type | "External" symbols: returned by the scanner | 
| Csyntax_error | Syntax errors thrown from user actions | 
| Ctoken | Token kinds | 
| Cvalue_type | A buffer to store and retrieve objects | 
| Nflex_option |  | 
| CFlexOptionImpl | Flex Option implementation | 
| COptionConfig | Base option configuration | 
| CSubOptionConfig | Sub-option configuration | 
| Ngss_tsig |  | 
| CDnsServer | GSS-TSIG hook configuration for a server | 
| CDnsServerIdTag | Tag for the id access index for searching DNS server | 
| CDnsServerIndexTag | Tag for the random access index for searching DNS server | 
| CGssApiBuffer | GSS-API buffer | 
| CGssApiCred | GSS-API credential | 
| CGssApiError | GSS-API exception | 
| CGssApiLastError | Last error base class | 
| CGssApiName | GSS-API name | 
| CGssApiOid | GSS-API OID | 
| CGssApiOidSet | GSS-API OID set | 
| CGssApiSecCtx | GSS-API security context | 
| CGssCredExpired |  | 
| CGssTsigCfg | GSS-TSIG hook configuration | 
| CGssTsigContext | GSS-TSIG overwrite of the DNS TSIGContext class | 
| CGssTsigImpl | GSS-TSIG hook implementation | 
| CGssTsigKey | GSS-TSIG extension of the D2 TSIG key class | 
| CGssTsigKeyNameTag | Tag for the name index for searching GSS-TSIG key | 
| CGssTsigKeyServerTag | Tag for the server ID index for searching GSS-TSIG key | 
| CManagedKey | Managed GSS-TSIG key | 
| CTKeyExchange | The TKeyExchangeclass handles communication with the DNS server | 
| CCallback | Callback for the TKeyExchangeclass | 
| CTKeyExchangeImpl |  | 
| Nha |  | 
| CCommandCreator | Holds a collection of functions which generate commands used for High Availability | 
| CCommunicationState | Holds communication state between the two HA peers | 
| CCommunicationState4 | Holds communication state between DHCPv4 servers | 
| CConnectingClient4 | Structure holding information about the client which has sent the packet being analyzed | 
| CRejectedClient4 | Structure holding information about the client who has a rejected lease update | 
| CCommunicationState6 | Holds communication state between DHCPv6 servers | 
| CConnectingClient6 | Structure holding information about a client which sent a packet being analyzed | 
| CRejectedClient6 | Structure holding information about the client who has a rejected lease update | 
| CHAConfig | Storage for High Availability configuration | 
| CPeerConfig | HA peer configuration | 
| CStateConfig | Configuration specific to a single HA state | 
| CStateMachineConfig | State machine configuration information | 
| CHAConfigParser | Configuration parser for High Availability | 
| CHAConfigValidationError | Exception thrown when configuration validation fails | 
| CHAImpl | High Availability hooks library implementation | 
| CHARelationshipMapper | Holds associations between objects and HA relationships | 
| CHAService | High availability service | 
| CLeaseSyncFilter | Checks if a lease fetched from the other server should be synchronized into the local lease database | 
| CLeaseUpdateBacklog | Queue holding a backlog of unsent lease updates | 
| CQueryFilter | DHCP query filtering class | 
| Nhooks |  | 
| CCalloutHandle | Per-packet callout handle | 
| CCalloutHandleAssociate | Base class for classes which need to be associated with a CalloutHandleobject | 
| CCalloutManager | Callout Manager | 
| CDuplicateHook | Duplicate hook | 
| CHookLibInfo | Entity that holds information about hook libraries and their parameters | 
| CHookLibraryScriptsChecker |  | 
| CHooksConfig | Wrapper class that holds hooks libraries configuration | 
| CHooksLibrariesParser | Parser for hooks library list | 
| CHooksManager | Hooks Manager | 
| CInvalidHooksLibraries | Exception thrown when a library failed to validate | 
| CLibrariesStillOpened | Libraries still opened | 
| CLibraryHandle | Library handle | 
| CLibraryManager | Library manager | 
| CLibraryManagerCollection | Library manager collection | 
| CLoadLibrariesNotCalled | LoadLibraries not called | 
| CNoCalloutManager | No Callout Manager | 
| CNoSuchArgument | No such argument | 
| CNoSuchCalloutContext | No such callout context item | 
| CNoSuchHook | Invalid hook | 
| CNoSuchLibrary | No such library | 
| CParkingLot | Parking lot for objects, e.g | 
| CParkingInfo | Holds information about parked object | 
| CParkingLotHandle | Provides a limited view to the ParkingLot | 
| CParkingLots | Collection of parking lots for various hook points | 
| CPointerConverter | Local class for conversion of void pointers to function pointers | 
| CScopedCalloutHandleState | Wrapper class around callout handle which automatically resets handle's state | 
| CServerHooks | Server hook collection | 
| Nhost_cache |  | 
| CHCConfigParser | Configuration parser for Host Cache | 
| CHCEntryListParser | Host cache content parser | 
| CHCEntryParser | Host cache entry parser | 
| CHostAddress4IndexTag | Tag for the index for searching by reserved IPv4 address | 
| CHostCache | Host Cache implementation | 
| CHostCacheImpl | Host Cache hooks library implementation | 
| CHostHashedIndexTag | Tag for the hashed index | 
| CHostIdentifierIndexTag | Tag for the index for searching by identifier | 
| CHostResrv6Tuple | Defines one entry for the Host Container for v6 hosts | 
| CHostSequencedIndexTag | Tag for the sequenced index | 
| CResv6AddressIndexTag | Tag for the index for searching by address | 
| CResv6SubnetAddressIndexTag | Tag for the index for searching by subnet and address | 
| Nhost_cmds |  | 
| CHostCmds | A wrapper class that provides handlers for the commands supported by this hooks library | 
| CHostCmdsImpl | Wrapper class around reservation command handlers | 
| CParameters | Parameters specified for reservation-get and reservation-del | 
| CHostDataParser | A class for parsing extended host reservation data | 
| Nhttp |  | 
| CBasicAuthHttpHeaderContext | Represents basic HTTP authentication header | 
| CBasicHttpAuth | Represents a basic HTTP authentication | 
| CBasicHttpAuthClient | Basic HTTP authentication client configuration | 
| CBasicHttpAuthConfig | Basic HTTP authentication configuration | 
| CCallSetGenericBody | Encapsulates the boolean value indicating if the HttpResponse constructor should call its setGenericBodymethod during construction | 
| CCfgHttpHeader | Config HTTP header | 
| CHostHttpHeader | Represents HTTP Host header | 
| CHttpAuthConfig | Base type of HTTP authentication configuration | 
| CHttpClient | HTTP client class | 
| CRequestTimeout | HTTP request/response timeout value | 
| CHttpClientError | A generic error raised by the HttpClient class | 
| CHttpClientImpl | HttpClient implementation | 
| CHttpConnection | Accepts and handles a single HTTP connection | 
| CTransaction | Represents a single exchange of the HTTP messages | 
| CHttpConnectionError | Generic error reported within HttpConnection class | 
| CHttpConnectionPool | Pool of active HTTP connections | 
| CHttpDateTime | This class parses and generates time values used in HTTP | 
| CHttpHeader | Represents HTTP header including a header name and value | 
| CHttpHeaderContext | HTTP header context | 
| CHttpListener | HTTP listener | 
| CIdleTimeout | Idle connection timeout | 
| CRequestTimeout | HTTP request timeout value | 
| CHttpListenerError | A generic error raised by the HttpListener class | 
| CHttpListenerImpl | Implementation of the HttpListener | 
| CHttpMessage | Base class for HttpRequest and HttpResponse | 
| CHttpMessageError | Generic exception thrown by HttpMessage class | 
| CHttpMessageNonExistingHeader | Exception thrown when attempt is made to retrieve a non-existing header | 
| CHttpMessageParserBase | Base class for the HTTP message parsers | 
| CHttpParseError | Exception thrown when an error during parsing HTTP message has occurred | 
| CHttpRequest | Represents HTTP request message | 
| CHttpRequestContext | HTTP request context | 
| CHttpRequestError | Generic exception thrown by HttpRequest class | 
| CHttpRequestJsonError | Exception thrown when body of the HTTP message is not JSON | 
| CHttpRequestParser | A generic parser for HTTP requests | 
| CHttpResponse | Represents HTTP response message | 
| CHttpResponseContext | HTTP response context | 
| CHttpResponseCreator | Specifies an interface for classes creating HTTP responses from HTTP requests | 
| CHttpResponseCreatorFactory | Specifies the interface for implementing custom factory classes used to create instances of HttpResponseCreator | 
| CHttpResponseError | Generic exception thrown by HttpResponse class | 
| CHttpResponseJson | Represents HTTP response with JSON content | 
| CHttpResponseJsonError | Exception thrown when body of the HTTP message is not JSON | 
| CHttpResponseParser | A generic parser for HTTP responses | 
| CHttpTimeConversionError | Exception thrown when there is an error during time conversion | 
| CHttpVersion | HTTP protocol version | 
| CPostHttpRequest | Represents HTTP POST request | 
| CPostHttpRequestJson | Represents HTTP POST request with JSON body | 
| CUrl | Represents an URL | 
| Nlease_cmds |  | 
| CBindingVariable | Embodies a named expression, whose output when evaluated can be stored in a lease's user-context | 
| CBindingVariableCache | BindingVariableCache stores binding variables | 
| CBindingVariableMgr | Singleton which warehouses the configured binding variables, and evaluation of variables for a given lease and packet pair | 
| CLease4Parser | Parser for Lease4 structure | 
| CLease6Parser | Parser for Lease6 structure | 
| CLeaseCmds | Implements the logic for processing commands pertaining to lease manipulation | 
| CLeaseCmdsImpl | Wrapper class around reservation command handlers | 
| CParameters | Parameters specified for lease commands | 
| CVariableNameTag | Tag for the name index | 
| CVariableSequenceTag | Tag for the sequence index | 
| CVariableSourceTag | Tag for the source index | 
| Nlease_query |  | 
| CAddressList | Manages a unique list of IP addresses | 
| CBlqMsg | Lease Query specific wrapper around DHCPx packet | 
| CBlqQuery | Holds a bulk lease query query packet | 
| CBlqResponse | Holds a bulk lease query response packet | 
| CBulkLeaseQuery | Base class for providing control flow for processing a bulk query | 
| CBulkLeaseQuery4 | Provides control flow for processing a bulk query | 
| CBulkLeaseQuery6 | Provides control flow for processing a bulk query | 
| CBulkLeaseQueryService |  | 
| CAdvancedConfig | Manages (advanced) configuration | 
| CLeaseQueryConnection | Derivation of TcpConnection used for Bulk LeaseQuery | 
| CLeaseQueryImpl | Provides configuration and control flow for processing queries | 
| CLeaseQueryImpl4 | Provides configuration and for processing DHCPv4 lease queries | 
| CLeaseQueryImpl6 | Provides configuration and control flow for processing queries | 
| CLeaseQueryImplFactory |  | 
| CLeaseQueryListener | Derivation of TcpListener specific to Bulk Lease Query | 
| CMtLeaseQueryListenerMgr | Manages a thread-pool that is used to drive a LeaseQueryListener | 
| CQueryTerminated | Thrown on hook termination | 
| CXidQueue | Wrapper around a chronological list of queries, uniquely keyed by transaction id | 
| Nlegal_log |  | 
| CLegalSyslog |  | 
| CRotatingFile | RotatingFile implements an appending text file which rotates to a new file on a daily basis | 
| CRotatingFileInit | Initialization structure used to register and deregister RotateFile Forensic Log Mgr | 
| Nlfc |  | 
| CInvalidUsage | Exception thrown when the command line is invalid | 
| CLFCController | Process controller for LFC process | 
| CRunTimeFail | Exceptions thrown when a method is unable to manipulate (remove or rename) a file | 
| Nlimits |  | 
| CAddressLimitConfiguration | Configuration manager for address limiting | 
| CConfiguration | Datastore used for configuring functionally dedicated parts of the limits library | 
| CLimitManager | Provides the capability to limit the number of leases or the response rate | 
| CPrefixLimitConfiguration | Configuration manager for prefix limiting | 
| CProtectedTimeSeries | Holds a number of time points, used in limiting by a single criterion, and a mutex to protect concurrent reads and writes | 
| CRateLimit | Single rate-limiting entry configured as "rate-limit": "<n> packet[s] per <time-unit>" | 
| CRateLimitConfiguration | Configuration manager for rate limiting | 
| Nlog |  | 
| Ninternal |  | 
| CBufferAppender | Buffering Logger Appender | 
| CLogBufferAddAfterFlush | Buffer add after flush | 
| Ninterprocess |  | 
| CInterprocessSync | Interprocess Sync Class | 
| CInterprocessSyncFile | File-based Interprocess Sync Class | 
| CInterprocessSyncFileError | InterprocessSyncFileError | 
| CInterprocessSyncLocker | Interprocess Sync Locker Class | 
| CInterprocessSyncNull | Null Interprocess Sync Class | 
| CBadInterprocessSync | Bad Interprocess Sync | 
| CFormatFailure | Format Failure | 
| CFormatter | The log message formatter | 
| CLevel | Log level structure | 
| CLogger | Logger Class | 
| CLoggerImpl | Console Logger Implementation | 
| CLoggerLevelImpl | Implementation aspects of logging levels | 
| CLoggerManager | Logger Manager | 
| CLoggerManagerImpl | Logger Manager Implementation | 
| CLoggerNameError | Logger Name Error | 
| CLoggerNameNull | Logger Name is null | 
| CLoggerSpecification |  | 
| CLoggingNotInitialized | Logging Not Initialized | 
| CMessageDictionary | Message Dictionary | 
| CMessageException | Message Exception | 
| CMessageInitializer | Initialize Message Dictionary | 
| CMessageReader | Read Message File | 
| CMismatchedPlaceholders | Mismatched Placeholders | 
| COutputOption |  | 
| Nnetconf |  | 
| CCfgControlSocket | Represents a Control Socket | 
| CCfgServer | Represents a Managed CfgServer | 
| CControlSocketBase | Base class for control socket communication | 
| CControlSocketConfigParser | Parser for CfgControlSocket | 
| CControlSocketError | Exception thrown when the error during communication | 
| CHttpControlSocket | Class for control socket communication over HTTP socket | 
| CNetconfAgent | Netconf agent | 
| CNetconfCfgMgr | Ctrl Netconf Configuration Manager | 
| CNetconfConfig | Netconf Configuration Context | 
| CNetconfController | Process Controller for Netconf Process | 
| CNetconfParser | A Bison parser | 
| Cbasic_symbol | A complete symbol | 
| Cby_kind | Type access provider for token (enum) based symbols | 
| Ccontext |  | 
| Csymbol_kind | Symbol kinds | 
| Csymbol_type | "External" symbols: returned by the scanner | 
| Csyntax_error | Syntax errors thrown from user actions | 
| Ctoken | Token kinds | 
| Cvalue_type | A buffer to store and retrieve objects | 
| CNetconfProcess | Kea Netconf Application Process | 
| CNetconfSimpleParser |  | 
| CParserContext | Parser context is a wrapper around flex/bison instances dedicated to Netconf-agent config file parser | 
| CServerConfigParser | Parser for CfgServer | 
| CStdoutControlSocket | Class for control socket communication over stdout | 
| CUnixControlSocket | Class for control socket communication over UNIX socket | 
| Nperfdhcp |  | 
| CAbstractScen | Abstract Scenario class | 
| CAvalancheScen | Avalanche Scenario class | 
| CBasePerfSocket | Socket wrapper structure | 
| CBasicScen | Basic Scenario class | 
| CCommandOptions | Command Options | 
| CLeaseType | A class encapsulating the type of lease being requested from the server | 
| CCustomCounter | Custom Counter | 
| CEnumClassHash |  | 
| CExchangeStats | Exchange Statistics | 
| CLocalizedOption | DHCP option at specific offset | 
| CPacketStorage | Represents a list of packets with a sequential and random access to list elements | 
| CPerfPkt4 | PerfPkt4 (DHCPv4 packet) | 
| CPerfPkt6 | PerfPkt6 (DHCPv6 packet) | 
| CPerfSocket | Socket wrapper structure | 
| CPktTransform | Read and write raw data to DHCP packets | 
| CRateControl | A message sending rate control class for perfdhcp | 
| CReceiver | A receiving DHCP packets class | 
| CStatsMgr | Statistics Manager | 
| CTestControl | Test Control class | 
| CNumberGenerator | Number generator class | 
| CRandomGenerator | Random numbers generator class | 
| CSequentialGenerator | Sequential numbers generator class | 
| Nperfmon |  | 
| CAlarm | Defines an alarm for a duration | 
| CAlarmParser | Parses configuration parameters for a single Alarm | 
| CAlarmPrimaryKeyTag | Tag for index by primary key (DurationKey) | 
| CAlarmStore | Maintains an in-memory store of alarms | 
| CDuplicateAlarm | Exception thrown when an attempt was made to add a duplicate key to either the duration or alarm stores | 
| CDuplicateDurationKey | Exception thrown when an attempt was made to add a duplicate duration to the store | 
| CDurationDataInterval | Embodies a span of time (i.e | 
| CDurationKey | Houses the composite key that uniquely identifies a duration: | 
| CDurationKeyParser | Parses configuration parameters for a single DurationKey | 
| CDurationKeyTag | Tag for index by primary key (DurationKey) | 
| CIntervalStartTag | Tag for index by interval start time | 
| CMonitoredDuration |  | 
| CMonitoredDurationStore | Maintains an in-memory store of durations | 
| CPerfMonConfig | Houses the PerfMon configuration parameters for a single scope (e.g | 
| CPerfMonMgr | Singleton which provides overall configuration, control, and state of the PerfMon hook library | 
| Nping_check |  | 
| CAddressIndexTag | Tag for index by target address | 
| CConfigCache | ConfigCache stores ping check config per subnet | 
| CDuplicateContext | Exception thrown when an attempt was made to add a duplicate context | 
| CExpirationIndexTag | Tag for index by expiration time | 
| CICMPEndpoint | The ICMPEndpointclass is a concrete derived class ofIOEndpointthat represents an endpoint of a ICMP packet | 
| CICMPMsg | Embodies an ICMP message | 
| CICMPSocket | The ICMPSocketclass is a concrete derived class ofIOAsioSocketthat represents a ICMP socket | 
| CNextToSendIndexTag | Tag for index by send wait start time | 
| CPingChannel | Provides thread-safe ICMP ECHO REQUEST/ECHO REPLY service | 
| CPingCheckConfig | Houses the Ping check configuration parameters for a single scope (e.g | 
| CPingCheckMgr | Ping Check Manager | 
| CPingContext | Embodies the life cycle of a ping check test for a single address for a single DHCPDISCOVER | 
| CPingContextStore | Maintains an in-memory store of PingContexts | 
| CQueryIndexTag | Tag for index by the query packet | 
| CSocketCallback | Functor associated with the socket object | 
| CStateIndexTag | Tag for index by state | 
| Nprocess |  | 
| CCBControlBase | Base class for implementing server specific mechanisms to control the use of the Configuration Backends | 
| CConfigBase | Base class for all configurations | 
| CConfigControlInfo | Embodies configuration information used during a server's configuration process | 
| CConfigControlParser | Implements parser for config control information, "config-control" | 
| CConfigDbInfo | Provides configuration information used during a server's configuration process | 
| CDaemon | Base class for all services | 
| CDaemonPIDExists | Exception thrown when the PID file points to a live PID | 
| CDCfgMgrBase | Configuration Manager | 
| CDCfgMgrBaseError | Exception thrown if the configuration manager encounters an error | 
| CDControllerBase | Application Controller | 
| CDControllerBaseError | Exception thrown when the controller encounters an operational error | 
| CDProcessBase | Application Process Interface | 
| CDProcessBaseError | Exception thrown if the process encountered an operational error | 
| CInvalidUsage | Exception thrown when the command line is invalid | 
| CLaunchError | Exception thrown when the controller launch fails | 
| CLogConfigParser | Configures log4cplus by translating Kea configuration structures | 
| CLoggingDestination | Defines single logging destination | 
| CLoggingInfo | Structure that describes one logging entry | 
| CProcessInitError | Exception thrown when the application process fails | 
| CProcessRunError | Exception thrown when the application process encounters an operation in its event loop (i.e | 
| CVersionMessage | Exception used to convey version info upwards | 
| Nradius |  | 
| CAttrDef | RADIUS attribute definition | 
| CAttrDefs | RADIUS attribute definitions | 
| CAttribute | RADIUS attribute base class | 
| CAttributes | Collection of attributes | 
| CAttrInt | RADIUS attribute holding integers | 
| CAttrIpAddr | RADIUS attribute holding IPv4 addresses | 
| CAttrIpv6Addr | RADIUS attribute holding IPv6 addresses | 
| CAttrIpv6Prefix | RADIUS attribute holding IPv6 prefixes | 
| CAttrString | RADIUS attribute derived classes: do not use them directly outside unit tests, instead use Attribute class/static factory methods | 
| CCfgAttributes | Attribute data configuration | 
| CAttributeValue | Container value class | 
| CExchange | RADIUS Exchange | 
| CInHook | InHook class (RAII style) | 
| CIntCstDef | RADIUS integer constant definitions | 
| CLeaseTS | Create timestamp entry | 
| CMessage | RADIUS Message | 
| CRadiusAccess | Radius access class | 
| CRadiusAccounting | Radius accounting class | 
| CRadiusAcct | Class for accounting communication with servers | 
| CRadiusAcctEnv | Class of Radius accounting environments | 
| CRadiusAcctHandler | Class of Radius accounting communication handler | 
| CRadiusAsyncAcct | Class for asynchronous accounting communication with servers | 
| CRadiusAsyncAuth | Class for asynchronous authentication communication with servers | 
| CRadiusAttributeListParser | Attribute list parser for Radius | 
| CRadiusAttributeParser | Attribute configuration parser for Radius | 
| CRadiusAuth | Class for authentication communication with servers | 
| CRadiusAuthEnv | Class of Radius access environments | 
| CRadiusAuthHandler | Class of Radius access communication handler | 
| CRadiusAuthPendingRequest | Class of pending Radius access request | 
| CRadiusAuthPendingRequests | Class of pending Radius access requests | 
| CRadiusBackend | Host backend for Radius | 
| CRadiusBackendImpl | Implementation of host backend for Radius | 
| CRadiusConfigParser | Configuration parser for Radius | 
| CRadiusImpl | Radius hooks library implementation | 
| CRadiusRequest | Base class for communication with servers | 
| CRadiusServerListParser | Server list parser for Radius | 
| CRadiusServerParser | Server parser for Radius | 
| CRadiusService | Radius service | 
| CRadiusServiceParser | Service parser for Radius | 
| CRadiusSyncAcct | Class for synchronous accounting communication with servers | 
| CRadiusSyncAuth | Class for synchronous authentication communication with servers | 
| CServer | RADIUS server class | 
| CTMAddressIndexTag | Tag for the index for searching by address | 
| CTMTimestampIndexTag | Tag for the index for searching by timestamp | 
| CTypeError | A standard Data module exception that is thrown if a function is called for an Element that has a wrong type (e.g | 
| Nrun_script |  | 
| CRunScriptImpl | Run Script implementation | 
| Nstat_cmds |  | 
| CLeaseStatCmdsImpl | Implements command handling for stat-leaseX-get commands | 
| CParameters | Wrapper class for stat-leaseX-get command parameters | 
| CNotFound | Exception thrown no subnets fall within the selection criteria This exception is thrown when a valid combination of query parameters excludes all known (i.e | 
| CStatCmds | Implements the logic for processing commands pertaining to stat manipulation | 
| Nstats |  | 
| CDuplicateStat | Exception indicating that a given statistic is duplicated | 
| CInvalidStatType | Exception thrown if invalid statistic type is used | 
| CObservation | Represents a single observable characteristic (a 'statistic') | 
| CStatContext | Statistics context | 
| CStatsMgr | Statistics Manager class | 
| Nsubnet_cmds |  | 
| CConfigDiffManager | Manager which handles the delta (differences) between two subnets serialized as a JSON tree (usually a user provided subnet configuration and an already existing subnet configuration) | 
| CSubnetCmds | Implements the logic for processing commands pertaining to subnets manipulation | 
| CSubnetCmdsImpl | Implementation of the SubnetCmdsclass | 
| Ntcp |  | 
| CMtTcpListenerMgr | Manages a thread-pool that is used to drive a TcpListener | 
| CTcpConnection | Accepts and handles a single TCP connection | 
| CTcpConnectionError | Generic error reported within TcpConnection class | 
| CTcpConnectionPool | Pool of active TCP connections | 
| CTcpListener | Implements a class that listens for, accepts, and manages TCP connections | 
| CIdleTimeout | Idle connection timeout | 
| CTcpListenerError | A generic error raised by the TcpListener class | 
| CTcpMessage | Base class for TCP messages | 
| CTcpRequest | Abstract class used to receive an inbound message | 
| CTcpResponse | Abstract class used to create and send an outbound response | 
| CTcpStreamRequest | Implement a simple length:data input stream message | 
| CTcpStreamResponse | Implements a simple length:data output stream message | 
| Ntest |  | 
| CEnvVarWrapper | Wrapper for environment variable that restores the variable to its original value | 
| CMultiThreadingTest | A RAII class which disables the multi threading on exit of scope | 
| CSandbox | A Sandbox class that provides access to unit test unique temporary folder | 
| CThreadedTest | Base class for tests requiring threads | 
| Nutil |  | 
| Nencode |  | 
| CBase16Encoder | Class for encoding and decoding binary data using Base16 (aka Hex) as described in RFC 4648 | 
| CBase32HexEncoder | Class for encoding and decoding binary data using Base32Hex as described in RFC 4648 | 
| CBase64Encoder | Class for encoding and decoding binary data using Base64 as described in RFC 4648 | 
| CBaseNEncoder | Class for encoding and decoding binary data using an algorithm described in RFC 4648 | 
| Nfile |  | 
| CPath | Paths on a filesystem | 
| CPathChecker | Embodies a supported path against which file paths can be validated | 
| CTemporaryDirectory |  | 
| Nstr |  | 
| CStringSanitizer | Implements a regular expression based string scrubber | 
| CStringSanitizerImpl |  | 
| CStringTokenError | A Set of C++ Utilities for Manipulating Strings | 
| CCSCallbackSet | Embodies a named set of CriticalSection callbacks | 
| CCSCallbackSetList | Maintains list of unique CSCallbackSets | 
| CCSVFile | Provides input/output access to CSV files | 
| CCSVFileError | Exception thrown when an error occurs during CSV file processing | 
| CCSVRow | Represents a single row of the CSV file | 
| CHash64 | Hash implementation based on Fowler-Noll-Vo hash function | 
| CInputBuffer | The InputBufferclass is a buffer abstraction for manipulating read-only data | 
| CInvalidTime | A standard DNS (or ISC) module exception that is thrown if a time conversion function encounters bad input | 
| CLabeledValue | Implements the concept of a constant value with a text label | 
| CLabeledValueError | Thrown if an error is encountered handling a LabeledValue | 
| CLabeledValueSet | Implements a set of unique LabeledValues | 
| CMemorySegment | Memory Segment Class | 
| CMemorySegmentError | General error that can be thrown by a MemorySegment implementation | 
| CMemorySegmentGrown | Exception that is thrown, when allocating space in a MemorySegment results in growing the underlying segment | 
| CMemorySegmentLocal | Malloc/free based Memory Segment class | 
| CMemorySegmentOpenError | Exception that can be thrown when constructing a MemorySegment object | 
| CMultiThreadingCriticalSection | RAII class creating a critical section | 
| CMultiThreadingLock | RAII lock object to protect the code in the same scope with a mutex | 
| CMultiThreadingMgr | Multi Threading Manager | 
| COptional | A template representing an optional value | 
| COutputBuffer | The OutputBufferclass is a buffer abstraction for manipulating mutable data | 
| CPIDCantReadPID | Exception thrown when an error occurs trying to read a PID from an opened file | 
| CPIDFile | Class to help with processing PID files | 
| CPIDFileError | Exception thrown when an error occurs during PID file processing | 
| CReadLockGuard | Read mutex RAII handler | 
| CReadWriteMutex | Read-Write Mutex | 
| CReconnectCtl | Warehouses reconnect control values | 
| CStagedValue | This class implements set/commit mechanism for a single object | 
| CState | Defines a State within the State Model | 
| CStateModel | Implements a finite state machine | 
| CStateModelError | Thrown if the state machine encounters a general error | 
| CStateSet | Implements a unique set or dictionary of states | 
| CStopwatch | Utility class to measure code execution times | 
| CStopwatchImpl | Stopwatchclass implementation | 
| CThreadPool | Defines a thread pool which uses a thread pool queue for managing work items | 
| CTriplet | This template specifies a parameter value | 
| CUnlockGuard | Unlock Guard | 
| CVersionedColumn | Contains the metadata for a single column in a file | 
| CVersionedCSVFile | Implements a CSV file that supports multiple versions of the file's "schema" | 
| CVersionedCSVFileError | Exception thrown when an error occurs during CSV file processing | 
| CWatchedThread | Provides a thread and controls for monitoring its activities | 
| CWatchSocket | Provides an IO "ready" semaphore for use with select() or poll() WatchSocket exposes a single open file descriptor, the "select-fd" which can be marked as being ready to read (i.e | 
| CWatchSocketError | Exception thrown if an error occurs during IO source open | 
| CWriteLockGuard | Write mutex RAII handler | 
| Nyang |  | 
| CAdaptor | JSON adaptor between canonical Kea and YANG models | 
| CAdaptorConfig | JSON adaptor for Kea server configurations | 
| CAdaptorHost | JSON adaptor for host reservations quoting identifiers | 
| CAdaptorOption | JSON adaptor for option data or definition setting defaults | 
| CAdaptorPool | JSON adaptor for pools between canonical Kea and YANG models | 
| CAdaptorSubnet | JSON adaptor for subnets adding IDs and canonizes relays | 
| CMissingKey | Missing key error | 
| CMissingNode | Missing node error | 
| CNetconfError | Generic NETCONF error | 
| CTranslator | Between YANG and JSON translator class for basic values | 
| CTranslatorClass | Client class translation between YANG and JSON | 
| CTranslatorClasses | A translator class for converting a client class list between YANG and JSON | 
| CTranslatorConfig | DHCP configuration translation between YANG and JSON | 
| CTranslatorControlSocket | Control socket translation between YANG and JSON | 
| CTranslatorDatabase | Database access translation between YANG and JSON | 
| CTranslatorDatabases | A translator class for converting a database access list between YANG and JSON | 
| CTranslatorHost | Translation between YANG and JSON for a single host reservation | 
| CTranslatorHosts | A translator class for converting host reservations list between YANG and JSON | 
| CTranslatorLogger | Logger translation between YANG and JSON | 
| CTranslatorLoggers | A translator class for converting a logger list between YANG and JSON | 
| CTranslatorOptionData | Option data translation between YANG and JSON | 
| CTranslatorOptionDataList | A translator class for converting an option data list between YANG and JSON | 
| CTranslatorOptionDef | Option definition translation between YANG and JSON | 
| CTranslatorOptionDefList | Currently supports kea-dhcp[46]-server models | 
| CTranslatorPdPool | Prefix delegation pool translation between YANG and JSON | 
| CTranslatorPdPools | A translator class for converting a pd-pool list between YANG and JSON | 
| CTranslatorPool | A translator class for converting a pool between YANG and JSON | 
| CTranslatorPools | A translator class for converting pools between YANG and JSON | 
| CTranslatorSharedNetwork | Shared network translation between YANG and JSON | 
| CTranslatorSharedNetworks | A translator class for converting a shared network list between YANG and JSON | 
| CTranslatorSubnet | Subnet (aka network range) translation between YANG and JSON | 
| CTranslatorSubnets | A translator class for converting a subnet list between YANG and JSON | 
| CBadValue | A generic exception that is thrown if a parameter given to a method is considered invalid in that context | 
| CConfigError | An exception that is thrown if an error occurs while configuring any server | 
| CException | This is a base class for exceptions thrown from the DNS library module | 
| CInvalidOperation | A generic exception that is thrown if a function is called in a prohibited way | 
| CInvalidParameter | A generic exception that is thrown if a parameter given to a method or function is considered invalid and no other specific exceptions are suitable to describe the error | 
| CMultiThreadingInvalidOperation | Exception thrown when a worker thread is trying to stop or pause the respective thread pool (which would result in a dead-lock) | 
| CNotFound | A generic exception that is thrown when an object can not be found | 
| CNotImplemented | A generic exception that is thrown when a function is not implemented | 
| COutOfRange | A generic exception that is thrown if a parameter given to a method would refer to or modify out-of-range data | 
| CParseError | Evaluation error exception raised when trying to parse | 
| CToElementError | Cannot unparse error | 
| CUnexpected | A generic exception that is thrown when an unexpected error condition occurs | 
| Nuser_chk | Defines the logger used by the user check hooks library | 
| CUser | Represents a unique DHCP user This class is used to represent a specific DHCP user who is identified by a unique id and who possesses a set of properties | 
| CUserDataSource | Defines an interface for reading user data into a registry | 
| CUserDataSourceError | Thrown if UserDataSource encounters an error | 
| CUserFile | Provides a UserDataSource implementation for JSON text files | 
| CUserFileError | Thrown a UserFile encounters an error | 
| CUserId | Encapsulates a unique identifier for a DHCP client | 
| CUserRegistry | Embodies an update-able, searchable list of unique users This class provides the means to create and maintain a searchable list of unique users | 
| CUserRegistryError | Thrown UserRegistry encounters an error | 
| CAddrInfo | RAII wrapper over struct addrinfo | 
| CCalloutHandle | Per-packet callout handle | 
| CDhcpConfigError | To be removed. Please use ConfigError instead | 
| CDUID | Holds DUID (DHCPv6 Unique Identifier) | 
| CElement | The Elementclass represents a piece of data, used by the command channel and configuration parts | 
| CPosition | Represents the position of the data element within a configuration string | 
| CException | This is a base class for exceptions thrown from the DNS library module | 
| CJSONError | A standard Data module exception that is thrown if a parse error is encountered when constructing an Element from a string | 
| CLeaseCmdsConflict | Exception thrown when a command failed due to a conflict | 
| COption6IAAddr |  | 
| COption6IAPrefix | Class that represents IAPREFIX option in DHCPv6 | 
| Cpair | STL class | 
| CPkt4 | Represents DHCPv4 packet | 
| CRRType | The RRTypeclass encapsulates DNS resource record types | 
| Cstring | STL class | 
| Cconst_iterator | STL iterator class | 
| Cconst_reverse_iterator | STL iterator class | 
| Citerator | STL iterator class | 
| Creverse_iterator | STL iterator class | 
| Cunique_ptr | STL class | 
| CUnknownLoggingDestination |  | 
| Cvector | STL class | 
| Cconst_iterator | STL iterator class | 
| Cconst_reverse_iterator | STL iterator class | 
| Citerator | STL iterator class | 
| Creverse_iterator | STL iterator class | 
| Cyy_buffer_state |  | 
| Cyy_trans_info |  |