InspIRCd  2.0
Public Member Functions | Protected Attributes | List of all members
Resolver Class Referenceabstract

#include <dns.h>

Inheritance diagram for Resolver:

Public Member Functions

 Resolver (const std::string &source, QueryType qt, bool &cached, Module *creator)
virtual ~Resolver ()
virtual void OnLookupComplete (const std::string &result, unsigned int ttl, bool cached)=0
virtual void OnError (ResolverError e, const std::string &errormessage)
int GetId ()
ModuleGetCreator ()
void TriggerCachedResult ()

Protected Attributes

ModuleRef Creator
std::string input
QueryType querytype
std::string server
int myid
int time_left

Detailed Description

The Resolver class is a high-level abstraction for resolving DNS entries. It can do forward and reverse IPv4 lookups, and where IPv6 is supported, will also be able to do those, transparent of protocols. Module developers must extend this class via inheritence, and then insert a pointer to their derived class into the core using Server::AddResolver(). Once you have done this, the class will be able to receive callbacks. There are two callbacks which can occur by calling virtual methods, one is a success situation, and the other an error situation.

Constructor & Destructor Documentation

◆ Resolver()

Resolver::Resolver ( const std::string &  source,
QueryType  qt,
bool &  cached,
Module creator 

Initiate DNS lookup. Your class should not attempt to delete or free these objects, as the core will do this for you. They must always be created upon the heap using new, as you cannot be sure at what time they will be deleted. Allocating them on the stack or attempting to delete them yourself could cause the object to go 'out of scope' and cause a segfault in the core if the result arrives at a later time.

sourceThe IP or hostname to resolve
qtThe query type to perform. Resolution of 'A', 'AAAA', 'PTR' and 'CNAME' records is supported. Use one of the QueryType enum values to initiate this type of lookup. Resolution of 'AAAA' ipv6 records is always supported, regardless of wether InspIRCd is built with ipv6 support. To look up reverse records, specify one of DNS_QUERY_PTR4 or DNS_QUERY_PTR6 depending on the type of address you are looking up.
cachedThe constructor will set this boolean to true or false depending on whether the DNS lookup you are attempting is cached (and not expired) or not. If the value is cached, upon return this will be set to true, otherwise it will be set to false. You should pass this value to InspIRCd::AddResolver(), which will then influence the behaviour of the method and determine whether a cached or non-cached result is obtained. The value in this variable is always correct for the given request when the constructor exits.
creatorSee the note below.
ModuleExceptionThis class may throw an instance of ModuleException, in the event a lookup could not be allocated, or a similar hard error occurs such as the network being down. This will also be thrown if an invalid IP address is passed when resolving a 'PTR' record.

NOTE: If you are instantiating your DNS lookup from a module, you should set the value of creator to point at your Module class. This way if your module is unloaded whilst lookups are in progress, they can be safely removed and your module will not crash the server.

High level abstraction of dns used by application at large

◆ ~Resolver()

Resolver::~Resolver ( )

The default destructor does nothing.

Destroy a resolver

Member Function Documentation

◆ GetCreator()

Module * Resolver::GetCreator ( )

Returns the creator module, or NULL

◆ GetId()

int Resolver::GetId ( )

Returns the id value of this class. This is primarily used by the core to determine where in various tables to place a pointer to your class, but it is safe to call and use this method. As specified in RFC1035, each dns request has a 16 bit ID value, ranging from 0 to 65535. If there is an issue and the core cannot send your request, this method will return -1.

Get the request id associated with this class

◆ OnError()

void Resolver::OnError ( ResolverError  e,
const std::string &  errormessage 

If an error occurs (such as NXDOMAIN, no domain name found) then this method will be called.

eA ResolverError enum containing the error type which has occured.
errormessageThe error text of the error that occured.

Called when an error occurs

Reimplemented in UserResolver.

◆ OnLookupComplete()

virtual void Resolver::OnLookupComplete ( const std::string &  result,
unsigned int  ttl,
bool  cached 
pure virtual

When your lookup completes, this method will be called.

resultThe resulting DNS lookup, either an IP address or a hostname.
ttlThe time-to-live value of the result, in the instance of a cached result, this is the number of seconds remaining before refresh/expiry.
cachedTrue if the result is a cached result, false if it was requested from the DNS server.

Implemented in UserResolver.

◆ TriggerCachedResult()

void Resolver::TriggerCachedResult ( )

If the result is a cached result, this triggers the objects OnLookupComplete. This is done because it is not safe to call the abstract virtual method from the constructor.

Member Data Documentation

◆ CQ

CachedQuery* Resolver::CQ

Cached result, if there is one

◆ Creator

ModuleRef Resolver::Creator

Pointer to creator module (if any, or NULL)

◆ input

std::string Resolver::input

The input data, either a host or an IP address

◆ myid

int Resolver::myid

The ID allocated to your lookup. This is a pseudo-random number between 0 and 65535, a value of -1 indicating a failure. The core uses this to route results to the correct objects.

◆ querytype

QueryType Resolver::querytype

True if a forward lookup is being performed, false if otherwise

◆ server

std::string Resolver::server

The DNS erver being used for lookups. If this is an empty string, the value of ServerConfig::DNSServer is used instead.

◆ time_left

int Resolver::time_left

Time left before cache expiry

The documentation for this class was generated from the following files: