| Nisc | Defines the logger used by the top-level component of kea-lfc |
| Nasiodns | |
| CIOFetch | Upstream Fetch Processing |
| CCallback | I/O Fetch Callback |
| CIOFetchData | IOFetch Data |
| Nasiolink | |
| CBufferOverflow | Buffer overflow |
| CBufferTooLarge | Buffer Too Large |
| CDummyAsioSocket | The DummyAsioSocket class is a concrete derived class of IOAsioSocket that is not associated with any real socket |
| CDummyIOCallback | Asynchronous I/O Completion Callback |
| CDummySocket | The DummySocket class is a concrete derived class of IOSocket that is not associated with any real socket |
| CIntervalTimer | The IntervalTimer class is a wrapper for the ASIO boost::asio::system_timer class |
| CIntervalTimerImpl | This class holds a call back function of asynchronous operations |
| CIOAcceptor | Base class for acceptor services in Kea |
| CIOAddress | The IOAddress class represents an IP addresses (version agnostic) |
| CHash | An IOAddress hash enabling the use in the unordered STL containers |
| CIOAsioSocket | I/O Socket with asynchronous operations |
| CIOEndpoint | The IOEndpoint class 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_context class |
| 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 IOSocket class 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 ProcessSpawn class |
| 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 TCPEndpoint class is a concrete derived class of IOEndpoint that represents an endpoint of a TCP packet |
| CTCPSocket | The TCPSocket class is a concrete derived class of IOAsioSocket that represents a TCP socket |
| CTLSAcceptor | Provides a service for accepting new TLS connections |
| CTlsContextBase | TLS context base class |
| CTLSSocket | The TLSSocket class is a concrete derived class of IOAsioSocket that represents a TLS socket |
| CTlsStreamBase | TLS stream base class |
| CUDPEndpoint | The UDPEndpoint class is a concrete derived class of IOEndpoint that represents an endpoint of a UDP packet |
| CUDPSocket | The UDPSocket class is a concrete derived class of IOAsioSocket that 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 ClassCmds class |
| 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 | |
| CAddressTag | Tag for index by ip-address |
| 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 D2UpdateMessage encapsulates a DNS Update message |
| CD2UpdateMgr | D2UpdateMgr creates and manages update transactions |
| CD2UpdateMgrError | Thrown if the update manager encounters a general error |
| CD2Zone | The D2Zone encapsulates 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 DNSClient class handles communication with the DNS server |
| CCallback | Callback for the DNSClient class |
| 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 |
| CFqdnTag | Tag for index by Fqdn |
| 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 |
| CSequenceTag | Tag for insertion order index |
| 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 Element class 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 Element object into a simple type |
| CElementValue< asiolink::IOAddress > | The ElementValue specialization for IOAddress |
| CElementValue< bool > | The ElementValue specialization for boolean |
| CElementValue< double > | The ElementValue specialization for double |
| CElementValue< std::string > | The ElementValue specialization 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 |
| CMySqlLibraryInit | Structure used to initialize and clean up after MySQL library |
| 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 Server objects from the ServerCollection |
| 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 |
| CHash | Hash enabling use in the unordered containers |
| CClientHandler | Client race avoidance RAII handler |
| CClient | Class (aka static) types, methods and members |
| 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 Host object 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 |
| CFQDNScrubbedEmpty | Exception thrown when host name sanitizing reduces the domain name to an empty string |
| 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 Host object 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 |
| CHWAddressIndexTag | Tag for indexes by HW address |
| 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 NetworkState class |
| 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 OpaqueDataTuple object 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 Option4ClientFqdn 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 9915 |
| 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 |
| CReceiverCriticalSection | RAII class creating a critical section for the receiver thread |
| CReceiveTerminate | ReceiveTerminate internal exception |
| 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 Host object (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 |
| CSflqPoolInfo | Describes a SFLQ pool |
| CSharedFlqAllocator | An allocator maintaining a shared queue of free leases |
| 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 |
| CSocketFDError | IfaceMgr exception thrown when there is an error detected for the respective socket file descriptor |
| 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 |
| CStateIndexTag | Tag for index using state (and subnet-id) |
| 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 |
| CSubnetSflqAllocationState | Subnet allocation state used by the shared-flq allocator |
| 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::TSIG class represents the TSIG RDATA as defined in RFC2845 |
| Nch | |
| CA | |
| Ngeneric | |
| Ndetail | |
| CTXTLikeImpl | rdata::TXTLikeImpl class represents the TXT-like RDATA for TXT and SPF types |
| CGeneric | The generic::Generic class 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::RRSIG class represents the RRSIG RDATA as defined in RFC4034 |
| CSOA | |
| CTKEY | rdata::TKEY class represents the TKEY RDATA as defined in RFC2930 |
| CTXT | |
| Nin | |
| CA | |
| CAAAA | |
| CDHCID | rdata::DHCID class represents the DHCID RDATA as defined in RFC4701 |
| CAbstractRdataFactory | The AbstractRdataFactory class 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 Rdata class is an abstract base class that provides a set of common interfaces to manipulate concrete RDATA objects |
| CAbstractMessageRenderer | The AbstractMessageRenderer class is an abstract base class that provides common interfaces for rendering a DNS message into a buffer in wire format |
| CAbstractRRset | The AbstractRRset class 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 BasicRRset class is a concrete derived class of AbstractRRset that defines a straightforward RRset implementation |
| CBasicRRsetImpl | This encapsulates the actual implementation of the BasicRRset class |
| CDNSMessageBADVERS | |
| CDNSMessageFORMERR | |
| CDNSProtocolError | |
| CDNSTextError | Base class for all sorts of text parse errors |
| CEDNS | The EDNS class 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 Message class 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 Message class encapsulates a standard DNS message |
| CMessageImpl | |
| CMessageRenderer | The MessageRenderer is a concrete derived class of AbstractMessageRenderer as a general purpose implementation of the renderer interfaces |
| CMessageRendererImpl | The MessageRendererImpl class is the actual implementation of MessageRenderer |
| 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 Name class 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 Opcode class objects represent standard OPCODEs of the header section of DNS messages as defined in RFC1035 |
| CQuestion | The Question class 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 RdataIterator class is an abstract base class that provides an interface for accessing RDATA objects stored in an RRset |
| CRRClass | The RRClass class 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 RRParamRegistry class represents a registry of parameters to manipulate DNS resource records (RRs) |
| CRRParamRegistryImpl | The RRParamRegistryImpl class is the actual implementation of RRParamRegistry |
| CRRset | The RRset class is a concrete derived class of BasicRRset which contains a pointer to an additional RRset containing associated RRSIG records |
| CRRTTL | The RRTTL class encapsulates TTLs used in DNS resource records |
| CRRType | The RRType class 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 | SectionIterator is 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 TKeyExchange class handles communication with the DNS server |
| CCallback | Callback for the TKeyExchange class |
| 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 CalloutHandle object |
| 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 setGenericBody method 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 |
| CSflqCmds | Wrapper class around SFLQ pool commands |
| CSflqCmdsImpl | Implements the logic for processing commands pertaining to SFLQ pools and data |
| 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 |
| CPoolRangeEqual | Equality comparator for two pools based on their address range |
| CPoolRangeHash | Hash for a Pool based on it's address range |
| CPoolSet | Manages a unique set of Pools of a given protocol family |
| 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 ICMPEndpoint class is a concrete derived class of IOEndpoint that represents an endpoint of a ICMP packet |
| CICMPMsg | Embodies an ICMP message |
| CICMPSocket | The ICMPSocket class is a concrete derived class of IOAsioSocket that 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 |
| 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 |
| CAttrDefAlias | RADIUS attribute aliases |
| 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 |
| CAttrVsa | RADIUS attribute holding vsa |
| CCfgAttributes | Attribute data configuration |
| CAttributeValue | Container value class |
| CExchange | RADIUS Base 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 |
| CRadiusAcctStatus | Class for communication with accounting servers |
| 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 |
| CRadiusAuthStatus | Class for communication with access servers |
| 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 |
| CRadiusStatus | Base class for communication with servers |
| CRadiusSyncAcct | Class for synchronous accounting communication with servers |
| CRadiusSyncAuth | Class for synchronous authentication communication with servers |
| CRadiusTls | Radius service for TLS transport |
| CRadiusTlsStatus | Class for communication with TLS servers |
| CServer | RADIUS server class |
| CTcpExchange | RADIUS/TCP (or RADIUS/TLS) Exchange |
| 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 |
| CUdpClient | UDP client class |
| CUdpExchange | RADIUS/UDP Exchange |
| 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 SubnetCmds class |
| Ntcp | |
| CMtTcpListenerMgr | Manages a thread-pool that is used to drive a TcpListener |
| CTcpClient | TCP/TLS client class |
| CRequestTimeout | TCP request/response timeout value |
| CTcpClientError | A generic error raised by the TcpClient class |
| CTcpClientImpl | TcpClient implementation |
| 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 |
| CRelaxUmask | RAII device to relax umask (adding group write for sockets) |
| CSecurityError | A generic exception that is thrown if a parameter given violates security and enforcement is true |
| CSecurityWarn | A generic exception that is thrown if a parameter given violates security check but enforcement is lax |
| 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 |
| CCSVFileFatalError | Exception thrown when an unrecoverable error occurs such as disk-full on write |
| CCSVRow | Represents a single row of the CSV file |
| CFDEventHandler | File descriptor event handler class handles events for registered file descriptors |
| CFDEventHandlerFactory | File descriptor event handler factory class handles the creation of the FDEventHangler instance according to configuration and OS supported syscalls |
| CHash64 | Hash implementation based on Fowler-Noll-Vo hash function |
| CInputBuffer | The InputBuffer class 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 |
| CMtTestMode | RAII wrapper for MT test mode |
| 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 OutputBuffer class 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 |
| CPIDLock | RAII device to handle a lock file to avoid race conditions |
| CPollEventHandler | File descriptor event handler class handles events for registered file descriptors |
| CReadLockGuard | Read mutex RAII handler |
| CReadWriteMutex | Read-Write Mutex |
| CReconnectCtl | Warehouses reconnect control values |
| CSelectEventHandler | File descriptor event handler class handles events for registered file descriptors |
| 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 | Stopwatch class 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 Element class 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 RRType class 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 | |
1.18.0