ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/svn/ircd-hybrid/branches/8.2.x/src/res.c

Comparing:
ircd-hybrid-7.2/src/irc_res.c (file contents), Revision 992 by michael, Mon Aug 17 19:19:16 2009 UTC vs.
ircd-hybrid/branches/8.2.x/src/res.c (file contents), Revision 4312 by michael, Thu Jul 31 17:02:26 2014 UTC

#	Line 1 | Line 1
1		/*
2	<	* A rewrite of Darren Reeds original res.c As there is nothing
3	<	* left of Darrens original code, this is now licensed by the hybrid group.
2	>	*  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3	>	*
4	>	*  Copyright (c) 1997-2014 ircd-hybrid development team
5	>	*
6	>	*  This program is free software; you can redistribute it and/or modify
7	>	*  it under the terms of the GNU General Public License as published by
8	>	*  the Free Software Foundation; either version 2 of the License, or
9	>	*  (at your option) any later version.
10	>	*
11	>	*  This program is distributed in the hope that it will be useful,
12	>	*  but WITHOUT ANY WARRANTY; without even the implied warranty of
13	>	*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14	>	*  GNU General Public License for more details.
15	>	*
16	>	*  You should have received a copy of the GNU General Public License
17	>	*  along with this program; if not, write to the Free Software
18	>	*  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
19	>	*  USA
20	>	*/
21	>
22	>	/*! \file res.c
23	>	* \brief ircd resolver functions
24	>	* \version $Id$
25	>	*/
26	>
27	>	/*
28	>	* A rewrite of Darren Reed's original res.c As there is nothing
29	>	* left of Darren's original code, this is now licensed by the hybrid group.
30		* (Well, some of the function names are the same, and bits of the structs..)
31		* You can use it where it is useful, free even. Buy us a beer and stuff.
32		*
33		* The authors takes no responsibility for any damage or loss
34		* of property which results from the use of this software.
35		*
10	–	* $Id$
11	–	*
36		* July 1999 - Rewrote a bunch of stuff here. Change hostent builder code,
37		*     added callbacks and reference counting of returned hostents.
38		*     --Bleep (Thomas Helvey <tomh@inxpress.net>)
39		*
40		* This was all needlessly complicated for irc. Simplified. No more hostent
41	<	* All we really care about is the IP -> hostname mappings. Thats all.
41	>	* All we really care about is the IP -> hostname mappings. That's all.
42		*
43		* Apr 28, 2003 --cryogen and Dianora
44		*/
45
46		#include "stdinc.h"
23	–	#include "tools.h"
24	–	#include "client.h"
47		#include "list.h"
48	<	#include "common.h"
48	>	#include "client.h"
49		#include "event.h"
50		#include "irc_string.h"
29	–	#include "sprintf_irc.h"
51		#include "ircd.h"
52		#include "numeric.h"
32	–	#include "restart.h"
53		#include "rng_mt.h"
54		#include "fdlist.h"
35	–	#include "fileio.h" /* for fbopen / fbclose / fbputs */
55		#include "s_bsd.h"
56	<	#include "s_log.h"
56	>	#include "log.h"
57	>	#include "misc.h"
58		#include "send.h"
59		#include "memory.h"
60	<	#include "irc_res.h"
61	<	#include "irc_reslib.h"
62	<	#include "irc_getnameinfo.h"
60	>	#include "mempool.h"
61	>	#include "res.h"
62	>	#include "reslib.h"
63
64		#if (CHAR_BIT != 8)
65	<	#error this code needs to be able to address individual octets
65	>	#error this code needs to be able to address individual octets
66		#endif
67
68		static PF res_readreply;
69
70	<	#define MAXPACKET      1024  /* rfc sez 512 but we expand names so ... */
71	<	#define RES_MAXALIASES 35    /* maximum aliases allowed */
52	<	#define RES_MAXADDRS   35    /* maximum addresses allowed */
53	<	#define AR_TTL         600   /* TTL in seconds for dns cache entries */
70	>	#define MAXPACKET      1024  /**< rfc says 512 but we expand names so ... */
71	>	#define AR_TTL         600   /**< TTL in seconds for dns cache entries */
72
73	<	/* RFC 1104/1105 wasn't very helpful about what these fields
73	>	/*
74	>	* RFC 1104/1105 wasn't very helpful about what these fields
75		* should be named, so for now, we'll just name them this way.
76	<	* we probably should look at what named calls them or something.
76	>	* We probably should look at what named calls them or something.
77		*/
78		#define TYPE_SIZE         (size_t)2
79		#define CLASS_SIZE        (size_t)2
#	Line 62 | Line 81 | static PF res_readreply;
81		#define RDLENGTH_SIZE     (size_t)2
82		#define ANSWER_FIXED_SIZE (TYPE_SIZE + CLASS_SIZE + TTL_SIZE + RDLENGTH_SIZE)
83
84	<	typedef enum
84	>	typedef enum
85		{
86	<	REQ_IDLE,  /* We're doing not much at all */
87	<	REQ_PTR,   /* Looking up a PTR */
88	<	REQ_A,     /* Looking up an A, possibly because AAAA failed */
86	>	REQ_IDLE,  /**< We're doing not much at all */
87	>	REQ_PTR,   /**< Looking up a PTR */
88	>	REQ_A,     /**< Looking up an A, possibly because AAAA failed */
89		#ifdef IPV6
90	<	REQ_AAAA,  /* Looking up an AAAA */
90	>	REQ_AAAA,  /**< Looking up an AAAA */
91		#endif
92	<	REQ_CNAME  /* We got a CNAME in response, we better get a real answer next */
92	>	REQ_CNAME  /**< We got a CNAME in response, we better get a real answer next */
93		} request_state;
94
95	<	struct reslist
95	>	struct reslist
96		{
97	<	dlink_node node;
98	<	int id;
99	<	int sent;                /* number of requests sent */
100	<	request_state state;     /* State the resolver machine is in */
101	<	time_t ttl;
102	<	char type;
103	<	char retries;            /* retry counter */
104	<	char sends;              /* number of sends (>1 means resent) */
105	<	char resend;             /* send flag. 0 == dont resend */
106	<	time_t sentat;
107	<	time_t timeout;
108	<	struct irc_ssaddr addr;
109	<	char *name;
110	<	dns_callback_fnc callback;
92	<	void *callback_ctx;
97	>	dlink_node node;            /**< Doubly linked list node. */
98	>	int id;                     /**< Request ID (from request header). */
99	>	int sent;                   /**< Number of requests sent */
100	>	request_state state;        /**< State the resolver machine is in */
101	>	char type;                  /**< Current request type. */
102	>	char retries;               /**< Retry counter */
103	>	unsigned int sends;         /**< Number of sends (>1 means resent). */
104	>	char resend;                /**< Send flag; 0 == don't resend. */
105	>	time_t sentat;              /**< Timestamp we last sent this request. */
106	>	time_t timeout;             /**< When this request times out. */
107	>	struct irc_ssaddr addr;     /**< Address for this request. */
108	>	char *name;                 /**< Hostname for this request. */
109	>	dns_callback_fnc callback;  /**< Callback function on completion. */
110	>	void *callback_ctx;         /**< Context pointer for callback. */
111		};
112
113		static fde_t ResolverFileDescriptor;
114	<	static dlink_list request_list = { NULL, NULL, 0 };
114	>	static dlink_list request_list;
115	>	static mp_pool_t *dns_pool;
116
98	–	static void rem_request(struct reslist *request);
99	–	static struct reslist *make_request(dns_callback_fnc callback, void *);
100	–	static void do_query_name(dns_callback_fnc callback, void *,
101	–	const char *, struct reslist *, int);
102	–	static void do_query_number(dns_callback_fnc callback, void *ctx,
103	–	const struct irc_ssaddr *,
104	–	struct reslist *request);
105	–	static void query_name(const char *name, int query_class, int query_type,
106	–	struct reslist *request);
107	–	static int send_res_msg(const char *buf, int len, int count);
108	–	static void resend_query(struct reslist *request);
109	–	static int proc_answer(struct reslist *request, HEADER *header, char *, char *);
110	–	static struct reslist *find_id(int id);
111	–	static struct DNSReply *make_dnsreply(struct reslist *request);
112	–
113	–	extern struct irc_ssaddr irc_nsaddr_list[IRCD_MAXNS];
114	–	extern int irc_nscount;
115	–	extern char irc_domain[HOSTLEN+1];
117
118	+	/*
119	+	* rem_request - remove a request from the list.
120	+	* This must also free any memory that has been allocated for
121	+	* temporary storage of DNS results.
122	+	*/
123	+	static void
124	+	rem_request(struct reslist *request)
125	+	{
126	+	dlinkDelete(&request->node, &request_list);
127	+
128	+	MyFree(request->name);
129	+	mp_pool_release(request);
130	+	}
131	+
132	+	/*
133	+	* make_request - Create a DNS request record for the server.
134	+	*/
135	+	static struct reslist *
136	+	make_request(dns_callback_fnc callback, void *ctx)
137	+	{
138	+	struct reslist *request = mp_pool_get(dns_pool);
139	+
140	+	request->sentat       = CurrentTime;
141	+	request->retries      = 2;
142	+	request->resend       = 1;
143	+	request->timeout      = 4;  /* Start at 4 and exponential inc. */
144	+	request->state        = REQ_IDLE;
145	+	request->callback     = callback;
146	+	request->callback_ctx = ctx;
147	+
148	+	dlinkAdd(request, &request->node, &request_list);
149	+	return request;
150	+	}
151
152		/*
153		* int
#	Line 127 | Line 161 | extern char irc_domain[HOSTLEN+1];
161		*      revised for ircd, cryogen(stu) may03
162		*/
163		static int
164	<	res_ourserver(const struct irc_ssaddr *inp)
164	>	res_ourserver(const struct irc_ssaddr *inp)
165		{
166		#ifdef IPV6
167		const struct sockaddr_in6 *v6;
168		const struct sockaddr_in6 *v6in = (const struct sockaddr_in6 *)inp;
169		#endif
170		const struct sockaddr_in *v4;
171	<	const struct sockaddr_in *v4in = (const struct sockaddr_in *)inp;
138	<	int ns;
171	>	const struct sockaddr_in *v4in = (const struct sockaddr_in *)inp;
172
173	<	for (ns = 0; ns < irc_nscount; ns++)
173	>	for (unsigned int i = 0; i < irc_nscount; ++i)
174		{
175	<	const struct irc_ssaddr *srv = &irc_nsaddr_list[ns];
175	>	const struct irc_ssaddr *srv = &irc_nsaddr_list[i];
176		#ifdef IPV6
177		v6 = (const struct sockaddr_in6 *)srv;
178		#endif
179		v4 = (const struct sockaddr_in *)srv;
180
181	<	/* could probably just memcmp(srv, inp, srv.ss_len) here
181	>	/*
182	>	* Could probably just memcmp(srv, inp, srv.ss_len) here
183		* but we'll air on the side of caution - stu
150	–	*
184		*/
185		switch (srv->ss.ss_family)
186		{
#	Line 155 | Line 188 | res_ourserver(const struct irc_ssaddr *i
188		case AF_INET6:
189		if (srv->ss.ss_family == inp->ss.ss_family)
190		if (v6->sin6_port == v6in->sin6_port)
191	<	if ((memcmp(&v6->sin6_addr.s6_addr, &v6in->sin6_addr.s6_addr,
192	<	sizeof(struct in6_addr)) == 0) ||
193	<	(memcmp(&v6->sin6_addr.s6_addr, &in6addr_any,
161	<	sizeof(struct in6_addr)) == 0))
162	<	return(1);
191	>	if (!memcmp(&v6->sin6_addr.s6_addr, &v6in->sin6_addr.s6_addr,
192	>	sizeof(struct in6_addr)))
193	>	return 1;
194		break;
195		#endif
196		case AF_INET:
197		if (srv->ss.ss_family == inp->ss.ss_family)
198		if (v4->sin_port == v4in->sin_port)
199	<	if ((v4->sin_addr.s_addr == INADDR_ANY) ||
200	<	(v4->sin_addr.s_addr == v4in->sin_addr.s_addr))
170	<	return(1);
199	>	if (v4->sin_addr.s_addr == v4in->sin_addr.s_addr)
200	>	return 1;
201		break;
202		default:
203		break;
204		}
205		}
206
207	<	return(0);
178	<	}
179	<
180	<	/*
181	<	* timeout_query_list - Remove queries from the list which have been
182	<	* there too long without being resolved.
183	<	*/
184	<	static time_t
185	<	timeout_query_list(time_t now)
186	<	{
187	<	dlink_node *ptr;
188	<	dlink_node *next_ptr;
189	<	struct reslist *request;
190	<	time_t next_time = 0;
191	<	time_t timeout   = 0;
192	<
193	<	DLINK_FOREACH_SAFE(ptr, next_ptr, request_list.head)
194	<	{
195	<	request = ptr->data;
196	<	timeout = request->sentat + request->timeout;
197	<
198	<	if (now >= timeout)
199	<	{
200	<	if (--request->retries <= 0)
201	<	{
202	<	(*request->callback)(request->callback_ctx, NULL, NULL);
203	<	rem_request(request);
204	<	continue;
205	<	}
206	<	else
207	<	{
208	<	request->sentat = now;
209	<	request->timeout += request->timeout;
210	<	resend_query(request);
211	<	}
212	<	}
213	<
214	<	if ((next_time == 0) || timeout < next_time)
215	<	{
216	<	next_time = timeout;
217	<	}
218	<	}
219	<
220	<	return((next_time > now) ? next_time : (now + AR_TTL));
221	<	}
222	<
223	<	/*
224	<	* timeout_resolver - check request list
225	<	*/
226	<	static void
227	<	timeout_resolver(void *notused)
228	<	{
229	<	timeout_query_list(CurrentTime);
207	>	return 0;
208		}
209
210		/*
#	Line 245 | Line 223 | start_resolver(void)
223		return;
224
225		/* At the moment, the resolver FD data is global .. */
226	<	comm_setselect(&ResolverFileDescriptor, COMM_SELECT_READ,
249	<	res_readreply, NULL, 0);
250	<	eventAdd("timeout_resolver", timeout_resolver, NULL, 1);
226	>	comm_setselect(&ResolverFileDescriptor, COMM_SELECT_READ, res_readreply, NULL, 0);
227		}
228		}
229
230		/*
255	–	* init_resolver - initialize resolver and resolver library
256	–	*/
257	–	void
258	–	init_resolver(void)
259	–	{
260	–	memset(&ResolverFileDescriptor, 0, sizeof(fde_t));
261	–	start_resolver();
262	–	}
263	–
264	–	/*
231		* restart_resolver - reread resolv.conf, reopen socket
232		*/
233		void
234		restart_resolver(void)
235		{
236		fd_close(&ResolverFileDescriptor);
271	–	eventDelete(timeout_resolver, NULL); /* -ddosen */
237		start_resolver();
238		}
239
240		/*
241	<	* add_local_domain - Add the domain to hostname, if it is missing
277	<	* (as suggested by eps@TOASTER.SFSU.EDU)
278	<	*/
279	<	void
280	<	add_local_domain(char *hname, size_t size)
281	<	{
282	<	/* try to fix up unqualified names
283	<	*/
284	<	if (strchr(hname, '.') == NULL)
285	<	{
286	<	if (irc_domain[0])
287	<	{
288	<	size_t len = strlen(hname);
289	<
290	<	if ((strlen(irc_domain) + len + 2) < size)
291	<	{
292	<	hname[len++] = '.';
293	<	strcpy(hname + len, irc_domain);
294	<	}
295	<	}
296	<	}
297	<	}
298	<
299	<	/*
300	<	* rem_request - remove a request from the list.
301	<	* This must also free any memory that has been allocated for
302	<	* temporary storage of DNS results.
303	<	*/
304	<	static void
305	<	rem_request(struct reslist *request)
306	<	{
307	<	dlinkDelete(&request->node, &request_list);
308	<	MyFree(request->name);
309	<	MyFree(request);
310	<	}
311	<
312	<	/*
313	<	* make_request - Create a DNS request record for the server.
314	<	*/
315	<	static struct reslist *
316	<	make_request(dns_callback_fnc callback, void *ctx)
317	<	{
318	<	struct reslist *request;
319	<
320	<	request = (struct reslist *)MyMalloc(sizeof(struct reslist));
321	<
322	<	request->sentat       = CurrentTime;
323	<	request->retries      = 3;
324	<	request->resend       = 1;
325	<	request->timeout      = 4;    /* start at 4 and exponential inc. */
326	<	request->state        = REQ_IDLE;
327	<	request->callback     = callback;
328	<	request->callback_ctx = ctx;
329	<
330	<	dlinkAdd(request, &request->node, &request_list);
331	<	return(request);
332	<	}
333	<
334	<	/*
335	<	* delete_resolver_queries - cleanup outstanding queries
241	>	* delete_resolver_queries - cleanup outstanding queries
242		* for which there no longer exist clients or conf lines.
243		*/
244		void
245		delete_resolver_queries(const void *vptr)
246		{
247	<	dlink_node *ptr;
342	<	dlink_node *next_ptr;
343	<	struct reslist *request;
247	>	dlink_node *ptr = NULL, *ptr_next = NULL;
248
249	<	DLINK_FOREACH_SAFE(ptr, next_ptr, request_list.head)
249	>	DLINK_FOREACH_SAFE(ptr, ptr_next, request_list.head)
250		{
251	<	if ((request = ptr->data) != NULL)
252	<	{
253	<	if (request->callback_ctx == vptr)
254	<	rem_request(request);
351	<	}
251	>	struct reslist *request = ptr->data;
252	>
253	>	if (request->callback_ctx == vptr)
254	>	rem_request(request);
255		}
256		}
257
#	Line 356 | Line 259 | delete_resolver_queries(const void *vptr
259		* send_res_msg - sends msg to all nameservers found in the "_res" structure.
260		* This should reflect /etc/resolv.conf. We will get responses
261		* which arent needed but is easier than checking to see if nameserver
262	<	* isnt present. Returns number of messages successfully sent to
262	>	* isn't present. Returns number of messages successfully sent to
263		* nameservers or -1 if no successful sends.
264		*/
265		static int
266	<	send_res_msg(const char *msg, int len, int rcount)
266	>	send_res_msg(const char *msg, int len, unsigned int rcount)
267		{
365	–	int i;
268		int sent = 0;
269	<	int max_queries = IRCD_MIN(irc_nscount, rcount);
269	>	unsigned int max_queries = IRCD_MIN(irc_nscount, rcount);
270
271		/* RES_PRIMARY option is not implemented
272		* if (res.options & RES_PRIMARY || 0 == max_queries)
#	Line 372 | Line 274 | send_res_msg(const char *msg, int len, i
274		if (max_queries == 0)
275		max_queries = 1;
276
277	<	for (i = 0; i < max_queries; i++)
277	>	for (unsigned int i = 0; i < max_queries; ++i)
278		{
279	<	if (sendto(ResolverFileDescriptor.fd, msg, len, 0,
280	<	(struct sockaddr*)&(irc_nsaddr_list[i]),
281	<	irc_nsaddr_list[i].ss_len) == len)
279	>	if (sendto(ResolverFileDescriptor.fd, msg, len, 0,
280	>	(struct sockaddr*)&(irc_nsaddr_list[i]),
281	>	irc_nsaddr_list[i].ss_len) == len)
282		++sent;
283		}
284
285	<	return(sent);
285	>	return sent;
286		}
287
288		/*
#	Line 389 | Line 291 | send_res_msg(const char *msg, int len, i
291		static struct reslist *
292		find_id(int id)
293		{
294	<	dlink_node *ptr;
393	<	struct reslist *request;
294	>	dlink_node *ptr = NULL;
295
296		DLINK_FOREACH(ptr, request_list.head)
297		{
298	<	request = ptr->data;
298	>	struct reslist *request = ptr->data;
299
300		if (request->id == id)
301	<	return(request);
301	>	return request;
302		}
303
304	<	return(NULL);
404	<	}
405	<
406	<	/*
407	<	* gethost_byname_type - get host address from name
408	<	*
409	<	*/
410	<	void
411	<	gethost_byname_type(dns_callback_fnc callback, void *ctx, const char *name, int type)
412	<	{
413	<	assert(name != 0);
414	<	do_query_name(callback, ctx, name, NULL, type);
304	>	return NULL;
305		}
306
307		/*
308	<	* gethost_byname - wrapper for _type - send T_AAAA first if IPV6 supported
308	>	* query_name - generate a query based on class, type and name.
309		*/
310	<	void
311	<	gethost_byname(dns_callback_fnc callback, void *ctx, const char *name)
310	>	static void
311	>	query_name(const char *name, int query_class, int type,
312	>	struct reslist *request)
313		{
314	<	#ifdef IPV6
315	<	gethost_byname_type(callback, ctx, name, T_AAAA);
425	<	#else
426	<	gethost_byname_type(callback, ctx, name, T_A);
427	<	#endif
428	<	}
314	>	char buf[MAXPACKET];
315	>	int request_len = 0;
316
317	<	/*
318	<	* gethost_byaddr - get host name from address
319	<	*/
320	<	void
321	<	gethost_byaddr(dns_callback_fnc callback, void *ctx, const struct irc_ssaddr *addr)
322	<	{
323	<	do_query_number(callback, ctx, addr, NULL);
317	>	memset(buf, 0, sizeof(buf));
318	>
319	>	if ((request_len = irc_res_mkquery(name, query_class, type,
320	>	(unsigned char *)buf, sizeof(buf))) > 0)
321	>	{
322	>	HEADER *header = (HEADER *)buf;
323	>
324	>	/*
325	>	* Generate an unique id.
326	>	* NOTE: we don't have to worry about converting this to and from
327	>	* network byte order, the nameserver does not interpret this value
328	>	* and returns it unchanged.
329	>	*/
330	>	do
331	>	header->id = (header->id + genrand_int32()) & 0xFFFF;
332	>	while (find_id(header->id));
333	>
334	>	request->id = header->id;
335	>	++request->sends;
336	>
337	>	request->sent += send_res_msg(buf, request_len, request->sends);
338	>	}
339		}
340
341		/*
#	Line 445 | Line 347 | do_query_name(dns_callback_fnc callback,
347		{
348		char host_name[HOSTLEN + 1];
349
350	<	strlcpy(host_name, name, HOSTLEN + 1);
449	<	add_local_domain(host_name, HOSTLEN + 1);
350	>	strlcpy(host_name, name, sizeof(host_name));
351
352		if (request == NULL)
353		{
354		request       = make_request(callback, ctx);
355	<	request->name = MyMalloc(strlen(host_name) + 1);
355	>	request->name = MyCalloc(strlen(host_name) + 1);
356		request->type = type;
357		strcpy(request->name, host_name);
358		#ifdef IPV6
#	Line 474 | Line 375 | do_query_number(dns_callback_fnc callbac
375		const struct irc_ssaddr *addr,
376		struct reslist *request)
377		{
378	<	char ipbuf[128];
478	<	const unsigned char *cp;
378	>	char ipbuf[128] = "";
379
380		if (addr->ss.ss_family == AF_INET)
381		{
382		const struct sockaddr_in *v4 = (const struct sockaddr_in *)addr;
383	<	cp = (const unsigned char*)&v4->sin_addr.s_addr;
383	>	const unsigned char *cp = (const unsigned char *)&v4->sin_addr.s_addr;
384
385	<	ircsprintf(ipbuf, "%u.%u.%u.%u.in-addr.arpa.",
386	<	(unsigned int)(cp[3]), (unsigned int)(cp[2]),
387	<	(unsigned int)(cp[1]), (unsigned int)(cp[0]));
385	>	snprintf(ipbuf, sizeof(ipbuf), "%u.%u.%u.%u.in-addr.arpa.",
386	>	(unsigned int)(cp[3]), (unsigned int)(cp[2]),
387	>	(unsigned int)(cp[1]), (unsigned int)(cp[0]));
388		}
389		#ifdef IPV6
390		else if (addr->ss.ss_family == AF_INET6)
391		{
392		const struct sockaddr_in6 *v6 = (const struct sockaddr_in6 *)addr;
393	<	cp = (const unsigned char *)&v6->sin6_addr.s6_addr;
393	>	const unsigned char *cp = (const unsigned char *)&v6->sin6_addr.s6_addr;
394
395	<	sprintf(ipbuf, "%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x."
396	<	"%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.ip6.arpa.",
397	<	(unsigned int)(cp[15]&0xf), (unsigned int)(cp[15]>>4),
398	<	(unsigned int)(cp[14]&0xf), (unsigned int)(cp[14]>>4),
399	<	(unsigned int)(cp[13]&0xf), (unsigned int)(cp[13]>>4),
400	<	(unsigned int)(cp[12]&0xf), (unsigned int)(cp[12]>>4),
401	<	(unsigned int)(cp[11]&0xf), (unsigned int)(cp[11]>>4),
402	<	(unsigned int)(cp[10]&0xf), (unsigned int)(cp[10]>>4),
403	<	(unsigned int)(cp[9]&0xf), (unsigned int)(cp[9]>>4),
404	<	(unsigned int)(cp[8]&0xf), (unsigned int)(cp[8]>>4),
405	<	(unsigned int)(cp[7]&0xf), (unsigned int)(cp[7]>>4),
406	<	(unsigned int)(cp[6]&0xf), (unsigned int)(cp[6]>>4),
407	<	(unsigned int)(cp[5]&0xf), (unsigned int)(cp[5]>>4),
408	<	(unsigned int)(cp[4]&0xf), (unsigned int)(cp[4]>>4),
409	<	(unsigned int)(cp[3]&0xf), (unsigned int)(cp[3]>>4),
410	<	(unsigned int)(cp[2]&0xf), (unsigned int)(cp[2]>>4),
411	<	(unsigned int)(cp[1]&0xf), (unsigned int)(cp[1]>>4),
412	<	(unsigned int)(cp[0]&0xf), (unsigned int)(cp[0]>>4));
395	>	snprintf(ipbuf, sizeof(ipbuf),
396	>	"%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x."
397	>	"%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.ip6.arpa.",
398	>	(unsigned int)(cp[15] & 0xf), (unsigned int)(cp[15] >> 4),
399	>	(unsigned int)(cp[14] & 0xf), (unsigned int)(cp[14] >> 4),
400	>	(unsigned int)(cp[13] & 0xf), (unsigned int)(cp[13] >> 4),
401	>	(unsigned int)(cp[12] & 0xf), (unsigned int)(cp[12] >> 4),
402	>	(unsigned int)(cp[11] & 0xf), (unsigned int)(cp[11] >> 4),
403	>	(unsigned int)(cp[10] & 0xf), (unsigned int)(cp[10] >> 4),
404	>	(unsigned int)(cp[9] & 0xf), (unsigned int)(cp[9] >> 4),
405	>	(unsigned int)(cp[8] & 0xf), (unsigned int)(cp[8] >> 4),
406	>	(unsigned int)(cp[7] & 0xf), (unsigned int)(cp[7] >> 4),
407	>	(unsigned int)(cp[6] & 0xf), (unsigned int)(cp[6] >> 4),
408	>	(unsigned int)(cp[5] & 0xf), (unsigned int)(cp[5] >> 4),
409	>	(unsigned int)(cp[4] & 0xf), (unsigned int)(cp[4] >> 4),
410	>	(unsigned int)(cp[3] & 0xf), (unsigned int)(cp[3] >> 4),
411	>	(unsigned int)(cp[2] & 0xf), (unsigned int)(cp[2] >> 4),
412	>	(unsigned int)(cp[1] & 0xf), (unsigned int)(cp[1] >> 4),
413	>	(unsigned int)(cp[0] & 0xf), (unsigned int)(cp[0] >> 4));
414		}
415		#endif
416		if (request == NULL)
#	Line 517 | Line 418 | do_query_number(dns_callback_fnc callbac
418		request       = make_request(callback, ctx);
419		request->type = T_PTR;
420		memcpy(&request->addr, addr, sizeof(struct irc_ssaddr));
421	<	request->name = MyMalloc(HOSTLEN + 1);
421	>	request->name = MyCalloc(HOSTLEN + 1);
422		}
423
424		query_name(ipbuf, C_IN, T_PTR, request);
425		}
426
427		/*
428	<	* query_name - generate a query based on class, type and name.
428	>	* gethost_byname_type - get host address from name
429	>	*
430		*/
431	<	static void
432	<	query_name(const char *name, int query_class, int type,
531	<	struct reslist *request)
431	>	void
432	>	gethost_byname_type(dns_callback_fnc callback, void *ctx, const char *name, int type)
433		{
434	<	char buf[MAXPACKET];
435	<	int request_len = 0;
436	<
536	<	memset(buf, 0, sizeof(buf));
537	<
538	<	if ((request_len = irc_res_mkquery(name, query_class, type,
539	<	(unsigned char *)buf, sizeof(buf))) > 0)
540	<	{
541	<	HEADER *header = (HEADER *)buf;
542	<
543	<	/*
544	<	* generate an unique id
545	<	* NOTE: we don't have to worry about converting this to and from
546	<	* network byte order, the nameserver does not interpret this value
547	<	* and returns it unchanged
548	<	*/
549	<	do
550	<	header->id = (header->id + genrand_int32()) & 0xffff;
551	<	while (find_id(header->id));
434	>	assert(name);
435	>	do_query_name(callback, ctx, name, NULL, type);
436	>	}
437
438	<	request->id = header->id;
439	<	++request->sends;
438	>	/*
439	>	* gethost_byname - wrapper for _type - send T_AAAA first if IPV6 supported
440	>	*/
441	>	void
442	>	gethost_byname(dns_callback_fnc callback, void *ctx, const char *name)
443	>	{
444	>	#ifdef IPV6
445	>	gethost_byname_type(callback, ctx, name, T_AAAA);
446	>	#else
447	>	gethost_byname_type(callback, ctx, name, T_A);
448	>	#endif
449	>	}
450
451	<	request->sent += send_res_msg(buf, request_len, request->sends);
452	<	}
451	>	/*
452	>	* gethost_byaddr - get host name from address
453	>	*/
454	>	void
455	>	gethost_byaddr(dns_callback_fnc callback, void *ctx, const struct irc_ssaddr *addr)
456	>	{
457	>	do_query_number(callback, ctx, addr, NULL);
458		}
459
460		static void
#	Line 572 | Line 472 | resend_query(struct reslist *request)
472		do_query_name(NULL, NULL, request->name, request, request->type);
473		break;
474		#ifdef IPV6
475	<	case T_AAAA:
576	<	/* didnt work, try A */
475	>	case T_AAAA:  /* Didn't work, try A */
476		if (request->state == REQ_AAAA)
477		do_query_name(NULL, NULL, request->name, request, T_A);
478		#endif
#	Line 586 | Line 485 | resend_query(struct reslist *request)
485		* proc_answer - process name server reply
486		*/
487		static int
488	<	proc_answer(struct reslist *request, HEADER* header, char* buf, char* eob)
488	>	proc_answer(struct reslist *request, HEADER *header, char *buf, char *eob)
489		{
490		char hostbuf[HOSTLEN + 100]; /* working buffer */
491		unsigned char *current;      /* current position in buf */
593	–	int query_class;             /* answer class */
492		int type;                    /* answer type */
493		int n;                       /* temp count */
494		int rd_length;
#	Line 605 | Line 503 | proc_answer(struct reslist *request, HEA
503		if ((n = irc_dn_skipname(current, (unsigned char *)eob)) < 0)
504		break;
505
506	<	current += (size_t) n + QFIXEDSZ;
506	>	current += (size_t)n + QFIXEDSZ;
507		}
508
509		/*
510	<	* process each answer sent to us blech.
510	>	* Process each answer sent to us blech.
511		*/
512		while (header->ancount > 0 && (char *)current < eob)
513		{
#	Line 618 | Line 516 | proc_answer(struct reslist *request, HEA
516		n = irc_dn_expand((unsigned char *)buf, (unsigned char *)eob, current,
517		hostbuf, sizeof(hostbuf));
518
519	<	if (n < 0)
520	<	{
623	<	/*
624	<	* broken message
625	<	*/
626	<	return(0);
627	<	}
628	<	else if (n == 0)
629	<	{
630	<	/*
631	<	* no more answers left
632	<	*/
633	<	return(0);
634	<	}
519	>	if (n < 0  /* Broken message */ || n == 0  /* No more answers left */)
520	>	return 0;
521
522		hostbuf[HOSTLEN] = '\0';
523
524	<	/* With Address arithmetic you have to be very anal
524	>	/*
525	>	* With Address arithmetic you have to be very anal
526		* this code was not working on alpha due to that
527		* (spotted by rodder/jailbird/dianora)
528		*/
529	<	current += (size_t) n;
529	>	current += (size_t)n;
530
531		if (!(((char *)current + ANSWER_FIXED_SIZE) < eob))
532		break;
533
534		type = irc_ns_get16(current);
535		current += TYPE_SIZE;
649	–
650	–	query_class = irc_ns_get16(current);
536		current += CLASS_SIZE;
652	–
653	–	request->ttl = irc_ns_get32(current);
537		current += TTL_SIZE;
655	–
538		rd_length = irc_ns_get16(current);
539		current += RDLENGTH_SIZE;
540
541	<	/*
542	<	* Wait to set request->type until we verify this structure
541	>	/*
542	>	* Wait to set request->type until we verify this structure
543		*/
544		switch (type)
545		{
546		case T_A:
547		if (request->type != T_A)
548	<	return(0);
548	>	return 0;
549
550		/*
551	<	* check for invalid rd_length or too many addresses
551	>	* Check for invalid rd_length or too many addresses
552		*/
553		if (rd_length != sizeof(struct in_addr))
554	<	return(0);
554	>	return 0;
555	>
556		v4 = (struct sockaddr_in *)&request->addr;
557		request->addr.ss_len = sizeof(struct sockaddr_in);
558		v4->sin_family = AF_INET;
559		memcpy(&v4->sin_addr, current, sizeof(struct in_addr));
560	<	return(1);
560	>	return 1;
561		break;
562		#ifdef IPV6
563		case T_AAAA:
564		if (request->type != T_AAAA)
565	<	return(0);
565	>	return 0;
566	>
567		if (rd_length != sizeof(struct in6_addr))
568	<	return(0);
568	>	return 0;
569	>
570		request->addr.ss_len = sizeof(struct sockaddr_in6);
571		v6 = (struct sockaddr_in6 *)&request->addr;
572		v6->sin6_family = AF_INET6;
573		memcpy(&v6->sin6_addr, current, sizeof(struct in6_addr));
574	<	return(1);
574	>	return 1;
575		break;
576		#endif
577		case T_PTR:
578		if (request->type != T_PTR)
579	<	return(0);
579	>	return 0;
580	>
581		n = irc_dn_expand((unsigned char *)buf, (unsigned char *)eob,
582	<	current, hostbuf, sizeof(hostbuf));
583	<	if (n < 0)
584	<	return(0); /* broken message */
699	<	else if (n == 0)
700	<	return(0); /* no more answers left */
582	>	current, hostbuf, sizeof(hostbuf));
583	>	if (n < 0  /* Broken message */ || n == 0  /* No more answers left */)
584	>	return 0;
585
586		strlcpy(request->name, hostbuf, HOSTLEN + 1);
587	<
704	<	return(1);
587	>	return 1;
588		break;
589	<	case T_CNAME: /* first check we already havent started looking
590	<	into a cname */
591	<	if (request->type != T_PTR)
709	<	return(0);
589	>	case T_CNAME:  /* First check we already haven't started looking into a cname */
590	>	if (request->type != T_PTR)
591	>	return 0;
592
593		if (request->state == REQ_CNAME)
594		{
#	Line 714 | Line 596 | proc_answer(struct reslist *request, HEA
596		current, hostbuf, sizeof(hostbuf));
597
598		if (n < 0)
599	<	return(0);
600	<	return(1);
599	>	return 0;
600	>	return 1;
601		}
602
603		request->state = REQ_CNAME;
604		current += rd_length;
605		break;
606	<
606	>
607		default:
608		/* XXX I'd rather just throw away the entire bogus thing
609		* but its possible its just a broken nameserver with still
610		* valid answers. But lets do some rudimentary logging for now...
611		*/
612	<	ilog(L_ERROR, "irc_res.c bogus type %d", type);
612	>	ilog(LOG_TYPE_IRCD, "irc_res.c bogus type %d", type);
613		break;
614		}
615		}
616
617	<	return(1);
617	>	return 1;
618		}
619
620		/*
#	Line 741 | Line 623 | proc_answer(struct reslist *request, HEA
623		static void
624		res_readreply(fde_t *fd, void *data)
625		{
626	<	char buf[sizeof(HEADER) + MAXPACKET]
745	<	/* Sparc and alpha need 16bit-alignment for accessing header->id
746	<	* (which is uint16_t). Because of the header = (HEADER*) buf;
747	<	* lateron, this is neeeded. --FaUl
748	<	*/
749	<	#if defined(__sparc__) || defined(__alpha__)
750	<	__attribute__((aligned (16)))
751	<	#endif
752	<	;
626	>	char buf[sizeof(HEADER) + MAXPACKET];
627		HEADER *header;
628		struct reslist *request = NULL;
629	<	int rc;
756	<	int answer_count;
629	>	ssize_t rc = 0;
630		socklen_t len = sizeof(struct irc_ssaddr);
631		struct irc_ssaddr lsin;
632
633		rc = recvfrom(fd->fd, buf, sizeof(buf), 0, (struct sockaddr *)&lsin, &len);
634
635	<	/* Re-schedule a read *after* recvfrom, or we'll be registering
635	>	/*
636	>	* Re-schedule a read *after* recvfrom, or we'll be registering
637		* interest where it'll instantly be ready for read :-) -- adrian
638		*/
639		comm_setselect(fd, COMM_SELECT_READ, res_readreply, NULL, 0);
640
641	<	/* Better to cast the sizeof instead of rc */
642	<	if (rc <= (int)(sizeof(HEADER)))
641	>	if (rc <= (ssize_t)sizeof(HEADER))
642	>	return;
643	>
644	>	/*
645	>	* Check against possibly fake replies
646	>	*/
647	>	if (!res_ourserver(&lsin))
648		return;
649
650		/*
651	<	* convert DNS reply reader from Network byte order to CPU byte order.
651	>	* Convert DNS reply reader from Network byte order to CPU byte order.
652		*/
653		header = (HEADER *)buf;
654		header->ancount = ntohs(header->ancount);
#	Line 778 | Line 657 | res_readreply(fde_t *fd, void *data)
657		header->arcount = ntohs(header->arcount);
658
659		/*
660	<	* response for an id which we have already received an answer for
660	>	* Response for an id which we have already received an answer for
661		* just ignore this response.
662		*/
663	<	if (0 == (request = find_id(header->id)))
785	<	return;
786	<
787	<	/*
788	<	* check against possibly fake replies
789	<	*/
790	<	if (!res_ourserver(&lsin))
663	>	if ((request = find_id(header->id)) == NULL)
664		return;
665
666		if ((header->rcode != NO_ERRORS) || (header->ancount == 0))
#	Line 804 | Line 677 | res_readreply(fde_t *fd, void *data)
677		#ifdef IPV6
678		else
679		{
680	<	/*
681	<	* If we havent already tried this, and we're looking up AAAA, try A
809	<	* now
680	>	/*
681	>	* If we havent already tried this, and we're looking up AAAA, try A now.
682		*/
683		if (request->state == REQ_AAAA && request->type == T_AAAA)
684		{
#	Line 820 | Line 692 | res_readreply(fde_t *fd, void *data)
692		}
693
694		/*
695	<	* If this fails there was an error decoding the received packet,
695	>	* If this fails there was an error decoding the received packet,
696		* try it again and hope it works the next time.
697		*/
698	<	answer_count = proc_answer(request, header, buf, buf + rc);
827	<
828	<	if (answer_count)
698	>	if (proc_answer(request, header, buf, buf + rc))
699		{
700		if (request->type == T_PTR)
701		{
702		if (request->name == NULL)
703		{
704		/*
705	<	* got a PTR response with no name, something bogus is happening
705	>	* Got a PTR response with no name, something bogus is happening
706		* don't bother trying again, the client address doesn't resolve
707		*/
708		(*request->callback)(request->callback_ctx, NULL, NULL);
#	Line 841 | Line 711 | res_readreply(fde_t *fd, void *data)
711		}
712
713		/*
714	<	* Lookup the 'authoritative' name that we were given for the
845	<	* ip#.
846	<	*
714	>	* Lookup the 'authoritative' name that we were given for the ip#.
715		*/
716		#ifdef IPV6
717		if (request->addr.ss.ss_family == AF_INET6)
#	Line 856 | Line 724 | res_readreply(fde_t *fd, void *data)
724		else
725		{
726		/*
727	<	* got a name and address response, client resolved
727	>	* Got a name and address response, client resolved
728		*/
729		(*request->callback)(request->callback_ctx, &request->addr, request->name);
730		rem_request(request);
#	Line 869 | Line 737 | res_readreply(fde_t *fd, void *data)
737		*/
738		assert(0);
739
740	+	(*request->callback)(request->callback_ctx, NULL, NULL);
741		/* XXX don't leak it */
742		rem_request(request);
743		}
#	Line 877 | Line 746 | res_readreply(fde_t *fd, void *data)
746		void
747		report_dns_servers(struct Client *source_p)
748		{
749	<	int i;
750	<	char ipaddr[HOSTIPLEN + 1];
749	>	char ipaddr[HOSTIPLEN + 1] = "";
750	>
751	>	for (unsigned int i = 0; i < irc_nscount; ++i)
752	>	{
753	>	getnameinfo((struct sockaddr *)&(irc_nsaddr_list[i]),
754	>	irc_nsaddr_list[i].ss_len, ipaddr,
755	>	sizeof(ipaddr), NULL, 0, NI_NUMERICHOST);
756	>	sendto_one_numeric(source_p, &me, RPL_STATSALINE, ipaddr);
757	>	}
758	>	}
759	>
760	>	/*
761	>	* timeout_query_list - Remove queries from the list which have been
762	>	* there too long without being resolved.
763	>	*/
764	>	static time_t
765	>	timeout_query_list(void)
766	>	{
767	>	dlink_node *ptr = NULL, *ptr_next = NULL;
768	>	struct reslist *request = NULL;
769	>	time_t next_time = 0;
770	>	time_t timeout   = 0;
771
772	<	for (i = 0; i < irc_nscount; i++)
772	>	DLINK_FOREACH_SAFE(ptr, ptr_next, request_list.head)
773		{
774	<	irc_getnameinfo((struct sockaddr *)&(irc_nsaddr_list[i]),
775	<	irc_nsaddr_list[i].ss_len, ipaddr,
776	<	sizeof(ipaddr), NULL, 0, NI_NUMERICHOST);
777	<	sendto_one(source_p, form_str(RPL_STATSALINE),
778	<	me.name, source_p->name, ipaddr);
774	>	request = ptr->data;
775	>	timeout = request->sentat + request->timeout;
776	>
777	>	if (CurrentTime >= timeout)
778	>	{
779	>	if (--request->retries <= 0)
780	>	{
781	>	(*request->callback)(request->callback_ctx, NULL, NULL);
782	>	rem_request(request);
783	>	continue;
784	>	}
785	>	else
786	>	{
787	>	request->sentat = CurrentTime;
788	>	request->timeout += request->timeout;
789	>	resend_query(request);
790	>	}
791	>	}
792	>
793	>	if (next_time == 0 || timeout < next_time)
794	>	next_time = timeout;
795		}
796	+
797	+	return (next_time > CurrentTime) ? next_time : (CurrentTime + AR_TTL);
798	+	}
799	+
800	+	/*
801	+	* timeout_resolver - check request list
802	+	*/
803	+	static void
804	+	timeout_resolver(void *notused)
805	+	{
806	+	timeout_query_list();
807	+	}
808	+
809	+	/*
810	+	* init_resolver - initialize resolver and resolver library
811	+	*/
812	+	void
813	+	init_resolver(void)
814	+	{
815	+	static struct event event_timeout_resolver =
816	+	{
817	+	.name = "timeout_resolver",
818	+	.handler = timeout_resolver,
819	+	.when = 1
820	+	};
821	+
822	+	dns_pool = mp_pool_new(sizeof(struct reslist), MP_CHUNK_SIZE_DNS);
823	+	memset(&ResolverFileDescriptor, 0, sizeof(fde_t));
824	+	start_resolver();
825	+
826	+	event_add(&event_timeout_resolver, NULL);
827		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)