ResolvSocket Class Reference
[Asynchronous DNS]

Async DNS resolver socket. More...

#include <ResolvSocket.h>

Inheritance diagram for ResolvSocket:

[legend]

Collaboration diagram for ResolvSocket:

[legend]

List of all members.

Public Member Functions
	ResolvSocket (ISocketHandler &)
	ResolvSocket (ISocketHandler &, Socket *parent, const std::string &host, port_t port, bool ipv6=false)
	ResolvSocket (ISocketHandler &, Socket *parent, ipaddr_t)
	~ResolvSocket ()
void	OnAccept ()
	Called when an incoming connection has been completed.
void	OnLine (const std::string &line)
	Callback fires when a socket in line protocol has read one full line.
void	OnDetached ()
	Callback fires when a new socket thread has started and this socket is ready for operation again.
void	OnDelete ()
	Called before a socket class is deleted by the ISocketHandler.
void	SetId (int x)
int	GetId ()
void	OnConnect ()
	Called when a connection has completed.
Private Types
typedef std::map< std::string, std::map< std::string, std::string > >	cache_t
typedef std::map< std::string, std::map< std::string, time_t > >	timeout_t
Private Member Functions
	ResolvSocket (const ResolvSocket &s)
ResolvSocket &	operator= (const ResolvSocket &)
Private Attributes
std::string	m_query
std::string	m_data
bool	m_bServer
Socket *	m_parent
	Pointer to ListenSocket class, valid for incoming sockets.
int	m_resolv_id
std::string	m_resolv_host
port_t	m_resolv_port
ipaddr_t	m_resolv_address
bool	m_cached
Static Private Attributes
static cache_t	m_cache
static timeout_t	m_cache_to
static Mutex	m_cache_mutex

---

Detailed Description

Async DNS resolver socket.

Definition at line 45 of file ResolvSocket.h.

---

Member Typedef Documentation

typedef std::map<std::string, std::map<std::string, std::string> > ResolvSocket::cache_t [private]

Definition at line 48 of file ResolvSocket.h.

typedef std::map<std::string, std::map<std::string, time_t> > ResolvSocket::timeout_t [private]

Definition at line 50 of file ResolvSocket.h.

---

Constructor & Destructor Documentation

ResolvSocket::ResolvSocket

(

ISocketHandler &

h

)

Definition at line 63 of file ResolvSocket.cpp.

References TcpSocket::SetLineProtocol().

:TcpSocket(h)
,m_bServer(false)
,m_parent(NULL)
#ifdef ENABLE_IPV6
,m_resolve_ipv6(false)
#endif
,m_cached(false)
{
        SetLineProtocol();
}

ResolvSocket::ResolvSocket	(	ISocketHandler &	h,
		Socket *	parent,
		const std::string &	host,
		port_t	port,
		bool	ipv6 = false
	)

Definition at line 76 of file ResolvSocket.cpp.

References TcpSocket::SetLineProtocol().

:TcpSocket(h)
,m_bServer(false)
,m_parent(parent)
,m_resolv_host(host)
,m_resolv_port(port)
#ifdef ENABLE_IPV6
,m_resolve_ipv6(ipv6)
#endif
,m_cached(false)
{
        SetLineProtocol();
}

ResolvSocket::ResolvSocket	(	ISocketHandler &	h,
		Socket *	parent,
		ipaddr_t	a
	)

Definition at line 91 of file ResolvSocket.cpp.

References TcpSocket::SetLineProtocol().

:TcpSocket(h)
,m_bServer(false)
,m_parent(parent)
,m_resolv_port(0)
,m_resolv_address(a)
#ifdef ENABLE_IPV6
,m_resolve_ipv6(false)
#endif
,m_cached(false)
{
        SetLineProtocol();
}

ResolvSocket::~ResolvSocket

(

)

Definition at line 121 of file ResolvSocket.cpp.

{
}

ResolvSocket::ResolvSocket

(

const ResolvSocket &

s

)

[inline, private]

Definition at line 76 of file ResolvSocket.h.

: TcpSocket(s) {} // copy constructor

---

Member Function Documentation

void ResolvSocket::OnAccept

(

)

[inline, virtual]

Called when an incoming connection has been completed.

Reimplemented from Socket.

Definition at line 61 of file ResolvSocket.h.

{ m_bServer = true; }

void ResolvSocket::OnLine

(

const std::string &

line

)

[virtual]

Callback fires when a socket in line protocol has read one full line.

Parameters:

line

Line read

Reimplemented from TcpSocket.

Definition at line 126 of file ResolvSocket.cpp.

References DEB, Socket::Detach(), Parse::getrest(), Parse::getword(), Socket::Handler(), m_bServer, m_cache, m_cache_mutex, m_cache_to, m_cached, m_data, m_parent, m_query, m_resolv_host, m_resolv_id, m_resolv_port, TcpSocket::OnResolved(), Socket::OnResolveFailed(), Socket::OnReverseResolved(), ISocketHandler::Resolving(), TcpSocket::Send(), Socket::SetCloseAndDelete(), Utility::u2ip(), and ISocketHandler::Valid().

{
        Parse pa(line, ":");
        if (m_bServer)
        {
                m_query = pa.getword();
                m_data = pa.getrest();
DEB(            fprintf(stderr, " *** ResolvSocket server; query=%s, data=%s\n", m_query.c_str(), m_data.c_str());)
                // %! check cache
                {
                        Lock lock(m_cache_mutex);
                        if (m_cache[m_query].find(m_data) != m_cache[m_query].end())
                        {
                                if (time(NULL) - m_cache_to[m_query][m_data] < 3600) // ttl
                                {
                                        std::string result = m_cache[m_query][m_data];
DEB(fprintf(stderr, " *** Returning cache for [%s][%s] = '%s'\n", m_query.c_str(), m_data.c_str(), result.c_str());)
                                        Send("Cached\n");
                                        if (!result.size()) /* failed */
                                        {
                                                Send("Failed\n\n");
                                                SetCloseAndDelete();
                                                return;
                                        }
                                        else
                                        if (m_query == "gethostbyname")
                                        {
                                                Send("A: " + result + "\n\n");
                                                SetCloseAndDelete();
                                                return;
                                        }
                                        else
#ifdef ENABLE_IPV6
#ifdef IPPROTO_IPV6
                                        if (m_query == "gethostbyname2")
                                        {
                                                Send("AAAA: " + result + "\n\n");
                                                SetCloseAndDelete();
                                                return;
                                        }
                                        else
#endif
#endif
                                        if (m_query == "gethostbyaddr")
                                        {
                                                Send("Name: " + result + "\n\n");
                                                SetCloseAndDelete();
                                                return;
                                        }
                                }
                        }
                }
                if (!Detach()) // detach failed?
                {
                        SetCloseAndDelete();
                }
                return;
        }
        std::string key = pa.getword();
        std::string value = pa.getrest();
DEB(    fprintf(stderr, " *** ResolvSocket response;  %s: %s\n", key.c_str(), value.c_str());)

        if (key == "Cached")
        {
                m_cached = true;
        }
        else
        if (key == "Failed" && m_parent)
        {
DEB(            fprintf(stderr, " ************ Resolve failed\n");)
                if (Handler().Resolving(m_parent) || Handler().Valid(m_parent))
                {
                        m_parent -> OnResolveFailed(m_resolv_id);
                }
                // update cache
                if (!m_cached)
                {
                        Lock lock(m_cache_mutex);
DEB(fprintf(stderr, " *** Update cache for [%s][%s] = '%s'\n", m_query.c_str(), m_data.c_str(), value.c_str());)
                        m_cache[m_query][m_data] = value;
                        m_cache_to[m_query][m_data] = time(NULL);
                }
                m_parent = NULL;
        }
        else
        if (key == "Name" && !m_resolv_host.size() && m_parent)
        {
                if (Handler().Resolving(m_parent) || Handler().Valid(m_parent))
                {
                        m_parent -> OnReverseResolved(m_resolv_id, value);
                }
                // update cache
                if (!m_cached)
                {
                        Lock lock(m_cache_mutex);
DEB(fprintf(stderr, " *** Update cache for [%s][%s] = '%s'\n", m_query.c_str(), m_data.c_str(), value.c_str());)
                        m_cache[m_query][m_data] = value;
                        m_cache_to[m_query][m_data] = time(NULL);
                }
                m_parent = NULL;
        }
        else
        if (key == "A" && m_parent)
        {
                if (Handler().Resolving(m_parent) || Handler().Valid(m_parent))
                {
                        ipaddr_t l;
                        Utility::u2ip(value, l); // ip2ipaddr_t
                        m_parent -> OnResolved(m_resolv_id, l, m_resolv_port);
                }
                // update cache
                if (!m_cached)
                {
                        Lock lock(m_cache_mutex);
DEB(fprintf(stderr, " *** Update cache for [%s][%s] = '%s'\n", m_query.c_str(), m_data.c_str(), value.c_str());)
                        m_cache[m_query][m_data] = value;
                        m_cache_to[m_query][m_data] = time(NULL);
                }
                m_parent = NULL; // always use first ip in case there are several
        }
#ifdef ENABLE_IPV6
#ifdef IPPROTO_IPV6
        else
        if (key == "AAAA" && m_parent)
        {
                if (Handler().Resolving(m_parent) || Handler().Valid(m_parent))
                {
                        in6_addr a;
                        Utility::u2ip(value, a);
                        m_parent -> OnResolved(m_resolv_id, a, m_resolv_port);
                }
                // update cache
                if (!m_cached)
                {
                        Lock lock(m_cache_mutex);
DEB(fprintf(stderr, " *** Update cache for [%s][%s] = '%s'\n", m_query.c_str(), m_data.c_str(), value.c_str());)
                        m_cache[m_query][m_data] = value;
                        m_cache_to[m_query][m_data] = time(NULL);
                }
                m_parent = NULL;
        }
#endif
#endif
}

void ResolvSocket::OnDetached

(

)

[virtual]

Callback fires when a new socket thread has started and this socket is ready for operation again.

See also:

ResolvSocket

Reimplemented from Socket.

Definition at line 272 of file ResolvSocket.cpp.

References AI_NUMERICHOST, DEB, Socket::Handler(), Utility::isipv4(), Utility::isipv6(), Utility::l2ip(), ISocketHandler::LogError(), m_data, m_query, Utility::reverse(), TcpSocket::Send(), Socket::SetCloseAndDelete(), and Utility::u2ip().

{
DEB(    fprintf(stderr, " *** ResolvSocket::OnDetached(); query=%s, data=%s\n", m_query.c_str(), m_data.c_str());)
        if (m_query == "gethostbyname")
        {
                struct sockaddr_in sa;
                if (Utility::u2ip(m_data, sa))
                {
                        std::string ip;
                        Utility::l2ip(sa.sin_addr, ip);
                        Send("A: " + ip + "\n");
                }
                else
                {
                        Send("Failed\n");
                }
                Send("\n");
        }
        else
#ifdef ENABLE_IPV6
#ifdef IPPROTO_IPV6
        if (m_query == "gethostbyname2")
        {
                struct sockaddr_in6 sa;
                if (Utility::u2ip(m_data, sa))
                {
                        std::string ip;
                        Utility::l2ip(sa.sin6_addr, ip);
                        Send("AAAA: " + ip + "\n");
                }
                else
                {
                        Send("Failed\n");
                }
                Send("\n");
        }
        else
#endif
#endif
        if (m_query == "gethostbyaddr")
        {
                if (Utility::isipv4( m_data ))
                {
                        struct sockaddr_in sa;
                        if (!Utility::u2ip(m_data, sa, AI_NUMERICHOST))
                        {
                                Send("Failed: convert to sockaddr_in failed\n");
                        }
                        else
                        {
                                std::string name;
                                if (!Utility::reverse( (struct sockaddr *)&sa, sizeof(sa), name))
                                {
                                        Send("Failed: ipv4 reverse lookup of " + m_data + "\n");
                                }
                                else
                                {
                                        Send("Name: " + name + "\n");
                                }
                        }
                }
                else
#ifdef ENABLE_IPV6
#ifdef IPPROTO_IPV6
                if (Utility::isipv6( m_data ))
                {
                        struct sockaddr_in6 sa;
                        if (!Utility::u2ip(m_data, sa, AI_NUMERICHOST))
                        {
                                Send("Failed: convert to sockaddr_in6 failed\n");
                        }
                        else
                        {
                                std::string name;
                                if (!Utility::reverse( (struct sockaddr *)&sa, sizeof(sa), name))
                                {
                                        Send("Failed: ipv6 reverse lookup of " + m_data + "\n");
                                }
                                else
                                {
                                        Send("Name: " + name + "\n");
                                }
                        }
                }
                else
#endif
#endif
                {
                        Send("Failed: malformed address\n");
                }
                Send("\n");
        }
        else
        {
                std::string msg = "Unknown query type: " + m_query;
                Handler().LogError(this, "OnDetached", 0, msg);
                Send("Unknown\n\n");
        }
        SetCloseAndDelete();
}

void ResolvSocket::OnDelete

(

)

[virtual]

Called before a socket class is deleted by the ISocketHandler.

Reimplemented from Socket.

Definition at line 409 of file ResolvSocket.cpp.

References DEB, Socket::Handler(), m_cache, m_cache_mutex, m_cache_to, m_cached, m_data, m_parent, m_query, m_resolv_id, and Socket::OnResolveFailed().

{
        if (m_parent)
        {
                if (Handler().Resolving(m_parent) || Handler().Valid(m_parent))
                {
                        m_parent -> OnResolveFailed(m_resolv_id);
                }
                // update cache
                if (!m_cached)
                {
                        Lock lock(m_cache_mutex);
                        std::string value;
DEB(fprintf(stderr, " *** Update cache for [%s][%s] = '%s'\n", m_query.c_str(), m_data.c_str(), value.c_str());)
                        m_cache[m_query][m_data] = value;
                        m_cache_to[m_query][m_data] = time(NULL);
                }
                m_parent = NULL;
        }
}

void ResolvSocket::SetId

(

int

x

)

[inline]

Definition at line 66 of file ResolvSocket.h.

{ m_resolv_id = x; }

int ResolvSocket::GetId

(

)

[inline]

Definition at line 67 of file ResolvSocket.h.

{ return m_resolv_id; }

void ResolvSocket::OnConnect

(

)

[virtual]

Called when a connection has completed.

Reimplemented from Socket.

Definition at line 374 of file ResolvSocket.cpp.

References Utility::l2ip(), m_data, m_query, m_resolv_address, m_resolv_host, and TcpSocket::Send().

{
        if (m_resolv_host.size())
        {
#ifdef ENABLE_IPV6
                std::string msg = (m_resolve_ipv6 ? "gethostbyname2 " : "gethostbyname ") + m_resolv_host + "\n";
                m_query = m_resolve_ipv6 ? "gethostbyname2" : "gethostbyname";
#else
                std::string msg = "gethostbyname " + m_resolv_host + "\n";
                m_query = "gethostbyname";
#endif
                m_data = m_resolv_host;
                Send( msg );
                return;
        }
#ifdef ENABLE_IPV6
        if (m_resolve_ipv6)
        {
                std::string tmp;
                Utility::l2ip(m_resolv_address6, tmp);
                m_query = "gethostbyaddr";
                m_data = tmp;
                std::string msg = "gethostbyaddr " + tmp + "\n";
                Send( msg );
        }
#endif
        std::string tmp;
        Utility::l2ip(m_resolv_address, tmp);
        m_query = "gethostbyaddr";
        m_data = tmp;
        std::string msg = "gethostbyaddr " + tmp + "\n";
        Send( msg );
}

ResolvSocket& ResolvSocket::operator=

(

const ResolvSocket &

)

[inline, private]

Definition at line 77 of file ResolvSocket.h.

{ return *this; } // assignment operator

---

Member Data Documentation

std::string ResolvSocket::m_query [private]

Definition at line 79 of file ResolvSocket.h.

Referenced by OnConnect(), OnDelete(), OnDetached(), and OnLine().

std::string ResolvSocket::m_data [private]

Definition at line 80 of file ResolvSocket.h.

Referenced by OnConnect(), OnDelete(), OnDetached(), and OnLine().

bool ResolvSocket::m_bServer [private]

Definition at line 81 of file ResolvSocket.h.

Referenced by OnLine().

Socket* ResolvSocket::m_parent [private]

Pointer to ListenSocket class, valid for incoming sockets.

Reimplemented from Socket.

Definition at line 82 of file ResolvSocket.h.

Referenced by OnDelete(), and OnLine().

int ResolvSocket::m_resolv_id [private]

Definition at line 83 of file ResolvSocket.h.

Referenced by OnDelete(), and OnLine().

std::string ResolvSocket::m_resolv_host [private]

Definition at line 84 of file ResolvSocket.h.

Referenced by OnConnect(), and OnLine().

port_t ResolvSocket::m_resolv_port [private]

Definition at line 85 of file ResolvSocket.h.

Referenced by OnLine().

ipaddr_t ResolvSocket::m_resolv_address [private]

Definition at line 86 of file ResolvSocket.h.

Referenced by OnConnect().

ResolvSocket::cache_t ResolvSocket::m_cache [static, private]

Definition at line 91 of file ResolvSocket.h.

Referenced by OnDelete(), and OnLine().

ResolvSocket::timeout_t ResolvSocket::m_cache_to [static, private]

Definition at line 92 of file ResolvSocket.h.

Referenced by OnDelete(), and OnLine().

Mutex ResolvSocket::m_cache_mutex [static, private]

Definition at line 93 of file ResolvSocket.h.

Referenced by OnDelete(), and OnLine().

bool ResolvSocket::m_cached [private]

Definition at line 94 of file ResolvSocket.h.

Referenced by OnDelete(), and OnLine().

---

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

• ResolvSocket.h
• ResolvSocket.cpp