1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
/*
dns.h - dns library declarations based on firedns Copyright (C) 2002 Ian Gulliver
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as
published by the Free Software Foundation.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef _DNS_H
#define _DNS_H
#include <string>
#include "inspircd_config.h"
#include "socket.h"
#include "base.h"
struct dns_ip4list
{
in_addr ip;
dns_ip4list *next;
};
enum ResolverError
{
RESOLVER_NOERROR = 0,
RESOLVER_NSDOWN = 1,
RESOLVER_NXDOMAIN = 2,
RESOLVER_NOTREADY = 3
};
/** The DNS class allows fast nonblocking resolution of hostnames
* and ip addresses. It is based heavily upon firedns by Ian Gulliver.
*/
class DNS : public Extensible
{
private:
in_addr *binip;
char* result;
char localbuf[1024];
int t;
void dns_init();
int myfd;
void dns_init_2(const char* dnsserver);
in_addr *dns_aton4(const char * const ipstring);
char *dns_ntoa4(const in_addr * const ip);
int dns_getip4(const char * const name);
int dns_getip4list(const char * const name);
int dns_getname4(const in_addr * const ip);
char *dns_getresult(const int fd);
in_addr *dns_aton4_s(const char * const ipstring, in_addr * const ip);
char *dns_ntoa4_s(const in_addr * const ip, char * const result);
char *dns_getresult_s(const int fd, char * const result);
in_addr *dns_aton4_r(const char * const ipstring);
char *dns_ntoa4_r(const in_addr * const ip);
char *dns_getresult_r(const int fd);
public:
/** The default constructor uses dns addresses read from /etc/resolv.conf.
* Please note that it will re-read /etc/resolv.conf for each copy of the
* class you instantiate, causing disk access and slow lookups if you create
* a lot of them. Consider passing the constructor a server address as a parameter
* instead.
*/
DNS();
/** This constructor accepts a dns server address. The address must be in dotted
* decimal form, e.g. 1.2.3.4.
*/
DNS(const std::string &dnsserver);
/** The destructor frees all used structures.
*/
~DNS();
/** This method will start the reverse lookup of an ip given in dotted decimal
* format, e.g. 1.2.3.4, and returns true if the lookup was successfully
* initiated.
*/
bool ReverseLookup(const std::string &ip);
/** This method will start the forward lookup of a hostname, e.g. www.inspircd.org,
* and returns true if the lookup was successfully initiated.
*/
bool ForwardLookup(const std::string &host);
/** Used by modules to perform a dns lookup but have the socket engine poll a module, instead of the dns object directly.
*/
bool ForwardLookupWithFD(const std::string &host, int &fd);
/** This method will return true when the lookup is completed. It uses poll internally
* to determine the status of the socket.
*/
bool HasResult();
/** This method will return true if the lookup's fd matches the one provided
*/
bool HasResult(int fd);
/** This method returns the result of your query as a string, depending upon wether you
* called DNS::ReverseLookup() or DNS::ForwardLookup.
*/
std::string GetResult();
std::string GetResultIP();
/** This method returns the file handle used by the dns query socket or zero if the
* query is invalid for some reason, e.g. the dns server not responding.
*/
int GetFD();
void SetNS(const std::string &dnsserver);
};
class Resolver : public Extensible
{
private:
DNS Query;
std::string input;
bool fwd;
std::string server;
int fd;
std::string result;
public:
Resolver(const std::string &source, bool forward, const std::string &dnsserver);
virtual ~Resolver();
virtual void OnLookupComplete(const std::string &result);
virtual void OnError(ResolverError e);
bool ProcessResult();
int GetFd();
};
void init_dns();
void dns_deal_with_classes(int fd);
bool dns_add_class(Resolver* r);
/** This is the handler function for multi-threaded DNS.
* It cannot be a class member as pthread will not let us
* create a thread whos handler function is a member of
* a class (ugh).
*/
void* dns_task(void* arg);
#endif
|
