InspIRCd  2.0
 All Classes Namespaces Functions Variables Typedefs Enumerations
Public Member Functions | Protected Attributes | List of all members
Resolver Class Referenceabstract

#include <dns.h>

Inheritance diagram for Resolver:
UserResolver

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
 
CachedQueryCQ
 
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 ( 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.

Parameters
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.
Exceptions
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 ( )
virtual

The default destructor does nothing.

Destroy a resolver

Member Function Documentation

Module * Resolver::GetCreator ( )

Returns the creator module, or NULL

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

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

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

Parameters
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.

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

When your lookup completes, this method will be called.

Parameters
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.

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

CachedQuery* Resolver::CQ
protected

Cached result, if there is one

ModuleRef Resolver::Creator
protected

Pointer to creator module (if any, or NULL)

std::string Resolver::input
protected

The input data, either a host or an IP address

int Resolver::myid
protected

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 Resolver::querytype
protected

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

std::string Resolver::server
protected

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

int Resolver::time_left
protected

Time left before cache expiry


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