Resolver Class Reference

#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 ()
Module *	GetCreator ()
void	TriggerCachedResult ()

Protected Attributes
ModuleRef	Creator
std::string	input
QueryType	querytype
std::string	server
int	myid
CachedQuery *	CQ
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.

Parameters

source	The IP or hostname to resolve
qt	The 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.
cached	The 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.
creator	See the note below.

Exceptions

ModuleException

This 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 ( )

virtual

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  )

virtual

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

Parameters

e	A ResolverError enum containing the error type which has occured.
errormessage	The 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.

Parameters

result	The resulting DNS lookup, either an IP address or a hostname.
ttl	The time-to-live value of the result, in the instance of a cached result, this is the number of seconds remaining before refresh/expiry.
cached	True 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

protected

Cached result, if there is one

Creator

ModuleRef Resolver::Creator

protected

Pointer to creator module (if any, or NULL)

input

std::string Resolver::input

protected

The input data, either a host or an IP address

myid

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

QueryType Resolver::querytype

protected

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

server

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.

time_left

int Resolver::time_left

protected

Time left before cache expiry

---

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

• include/dns.h
• src/dns.cpp