ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/branches/8.2.x/src/res.c
Revision: 4447
Committed: Sat Aug 9 19:19:58 2014 UTC (9 years, 7 months ago) by michael
Content type: text/x-csrc
File size: 22565 byte(s)
Log Message:
- res.c:start_resolver(): made /stats F more descriptive about the resolver socket

File Contents

# User Rev Content
1 adx 30 /*
2 michael 2916 * 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 michael 3322 /*! \file res.c
23 michael 2916 * \brief ircd resolver functions
24     * \version $Id$
25     */
26    
27     /*
28 michael 4312 * 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 adx 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     *
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 michael 4312 * All we really care about is the IP -> hostname mappings. That's all.
42 adx 30 *
43     * Apr 28, 2003 --cryogen and Dianora
44     */
45    
46     #include "stdinc.h"
47 michael 1011 #include "list.h"
48 adx 30 #include "client.h"
49     #include "event.h"
50     #include "irc_string.h"
51     #include "ircd.h"
52     #include "numeric.h"
53 michael 982 #include "rng_mt.h"
54 adx 30 #include "fdlist.h"
55     #include "s_bsd.h"
56 michael 1309 #include "log.h"
57 michael 3347 #include "misc.h"
58 adx 30 #include "send.h"
59     #include "memory.h"
60 michael 1654 #include "mempool.h"
61 michael 3322 #include "res.h"
62     #include "reslib.h"
63 adx 30
64     #if (CHAR_BIT != 8)
65 michael 2916 #error this code needs to be able to address individual octets
66 adx 30 #endif
67    
68     static PF res_readreply;
69    
70 michael 4312 #define MAXPACKET 1024 /**< rfc says 512 but we expand names so ... */
71     #define AR_TTL 600 /**< TTL in seconds for dns cache entries */
72 adx 30
73 michael 4312 /*
74     * RFC 1104/1105 wasn't very helpful about what these fields
75 adx 30 * should be named, so for now, we'll just name them this way.
76 michael 4312 * We probably should look at what named calls them or something.
77 adx 30 */
78     #define TYPE_SIZE (size_t)2
79     #define CLASS_SIZE (size_t)2
80     #define TTL_SIZE (size_t)4
81     #define RDLENGTH_SIZE (size_t)2
82     #define ANSWER_FIXED_SIZE (TYPE_SIZE + CLASS_SIZE + TTL_SIZE + RDLENGTH_SIZE)
83    
84 michael 2916 typedef enum
85 adx 30 {
86 michael 4312 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     REQ_AAAA, /**< Looking up an AAAA */
90     REQ_CNAME /**< We got a CNAME in response, we better get a real answer next */
91 adx 30 } request_state;
92    
93 michael 2916 struct reslist
94 adx 30 {
95 michael 4422 dlink_node node; /**< Doubly linked list node. */
96     int id; /**< Request ID (from request header). */
97     int sent; /**< Number of requests sent */
98     request_state state; /**< State the resolver machine is in */
99     char type; /**< Current request type. */
100     char retries; /**< Retry counter */
101     unsigned int sends; /**< Number of sends (>1 means resent). */
102     char resend; /**< Send flag; 0 == don't resend. */
103     time_t sentat; /**< Timestamp we last sent this request. */
104     time_t timeout; /**< When this request times out. */
105     struct irc_ssaddr addr; /**< Address for this request. */
106     char name[RFC1035_MAX_DOMAIN_LENGTH + 1]; /**< Hostname for this request. */
107     size_t namelength; /**< Actual hostname length. */
108     dns_callback_fnc callback; /**< Callback function on completion. */
109     void *callback_ctx; /**< Context pointer for callback. */
110 adx 30 };
111    
112     static fde_t ResolverFileDescriptor;
113 michael 3235 static dlink_list request_list;
114     static mp_pool_t *dns_pool;
115 adx 30
116    
117 michael 4312 /*
118     * rem_request - remove a request from the list.
119     * This must also free any memory that has been allocated for
120     * temporary storage of DNS results.
121     */
122     static void
123     rem_request(struct reslist *request)
124     {
125     dlinkDelete(&request->node, &request_list);
126     mp_pool_release(request);
127     }
128    
129 adx 30 /*
130 michael 4312 * make_request - Create a DNS request record for the server.
131     */
132     static struct reslist *
133     make_request(dns_callback_fnc callback, void *ctx)
134     {
135     struct reslist *request = mp_pool_get(dns_pool);
136    
137     request->sentat = CurrentTime;
138     request->retries = 2;
139     request->resend = 1;
140     request->timeout = 4; /* Start at 4 and exponential inc. */
141     request->state = REQ_IDLE;
142     request->callback = callback;
143     request->callback_ctx = ctx;
144    
145     dlinkAdd(request, &request->node, &request_list);
146     return request;
147     }
148    
149     /*
150 adx 30 * int
151     * res_ourserver(inp)
152     * looks up "inp" in irc_nsaddr_list[]
153     * returns:
154     * 0 : not found
155     * >0 : found
156     * author:
157     * paul vixie, 29may94
158     * revised for ircd, cryogen(stu) may03
159     */
160     static int
161 michael 2916 res_ourserver(const struct irc_ssaddr *inp)
162 adx 30 {
163 michael 992 const struct sockaddr_in6 *v6;
164     const struct sockaddr_in6 *v6in = (const struct sockaddr_in6 *)inp;
165     const struct sockaddr_in *v4;
166 michael 2916 const struct sockaddr_in *v4in = (const struct sockaddr_in *)inp;
167 adx 30
168 michael 3297 for (unsigned int i = 0; i < irc_nscount; ++i)
169 adx 30 {
170 michael 3235 const struct irc_ssaddr *srv = &irc_nsaddr_list[i];
171 michael 992 v6 = (const struct sockaddr_in6 *)srv;
172     v4 = (const struct sockaddr_in *)srv;
173 adx 30
174 michael 4312 /*
175     * Could probably just memcmp(srv, inp, srv.ss_len) here
176 adx 30 * but we'll air on the side of caution - stu
177     */
178     switch (srv->ss.ss_family)
179     {
180     case AF_INET6:
181     if (srv->ss.ss_family == inp->ss.ss_family)
182     if (v6->sin6_port == v6in->sin6_port)
183 michael 1346 if (!memcmp(&v6->sin6_addr.s6_addr, &v6in->sin6_addr.s6_addr,
184     sizeof(struct in6_addr)))
185 michael 1124 return 1;
186 adx 30 break;
187     case AF_INET:
188     if (srv->ss.ss_family == inp->ss.ss_family)
189     if (v4->sin_port == v4in->sin_port)
190 michael 1346 if (v4->sin_addr.s_addr == v4in->sin_addr.s_addr)
191 michael 1124 return 1;
192 adx 30 break;
193     default:
194     break;
195     }
196     }
197    
198 michael 1124 return 0;
199 adx 30 }
200    
201     /*
202     * start_resolver - do everything we need to read the resolv.conf file
203     * and initialize the resolver file descriptor if needed
204     */
205     static void
206     start_resolver(void)
207     {
208     irc_res_init();
209    
210     if (!ResolverFileDescriptor.flags.open)
211     {
212     if (comm_open(&ResolverFileDescriptor, irc_nsaddr_list[0].ss.ss_family,
213 michael 4447 SOCK_DGRAM, 0, "UDP resolver socket") == -1)
214 adx 30 return;
215    
216     /* At the moment, the resolver FD data is global .. */
217 michael 3298 comm_setselect(&ResolverFileDescriptor, COMM_SELECT_READ, res_readreply, NULL, 0);
218 adx 30 }
219     }
220    
221     /*
222     * restart_resolver - reread resolv.conf, reopen socket
223     */
224     void
225     restart_resolver(void)
226     {
227     fd_close(&ResolverFileDescriptor);
228     start_resolver();
229     }
230    
231     /*
232 michael 2916 * delete_resolver_queries - cleanup outstanding queries
233 adx 30 * for which there no longer exist clients or conf lines.
234     */
235     void
236 michael 992 delete_resolver_queries(const void *vptr)
237 adx 30 {
238 michael 3235 dlink_node *ptr = NULL, *ptr_next = NULL;
239 adx 30
240 michael 3235 DLINK_FOREACH_SAFE(ptr, ptr_next, request_list.head)
241 adx 30 {
242 michael 997 struct reslist *request = ptr->data;
243    
244     if (request->callback_ctx == vptr)
245     rem_request(request);
246 adx 30 }
247     }
248    
249     /*
250     * send_res_msg - sends msg to all nameservers found in the "_res" structure.
251     * This should reflect /etc/resolv.conf. We will get responses
252     * which arent needed but is easier than checking to see if nameserver
253 michael 4299 * isn't present. Returns number of messages successfully sent to
254 adx 30 * nameservers or -1 if no successful sends.
255     */
256     static int
257 michael 3297 send_res_msg(const char *msg, int len, unsigned int rcount)
258 adx 30 {
259     int sent = 0;
260 michael 3297 unsigned int max_queries = IRCD_MIN(irc_nscount, rcount);
261 adx 30
262     /* RES_PRIMARY option is not implemented
263     * if (res.options & RES_PRIMARY || 0 == max_queries)
264     */
265     if (max_queries == 0)
266     max_queries = 1;
267    
268 michael 3297 for (unsigned int i = 0; i < max_queries; ++i)
269 adx 30 {
270 michael 2916 if (sendto(ResolverFileDescriptor.fd, msg, len, 0,
271     (struct sockaddr*)&(irc_nsaddr_list[i]),
272     irc_nsaddr_list[i].ss_len) == len)
273 adx 30 ++sent;
274     }
275    
276 michael 1124 return sent;
277 adx 30 }
278    
279     /*
280     * find_id - find a dns request id (id is determined by dn_mkquery)
281     */
282     static struct reslist *
283     find_id(int id)
284     {
285 michael 1124 dlink_node *ptr = NULL;
286 adx 30
287     DLINK_FOREACH(ptr, request_list.head)
288     {
289 michael 1124 struct reslist *request = ptr->data;
290 adx 30
291     if (request->id == id)
292 michael 1124 return request;
293 adx 30 }
294    
295 michael 1124 return NULL;
296 adx 30 }
297    
298 michael 2916 /*
299 michael 4312 * query_name - generate a query based on class, type and name.
300 adx 30 */
301 michael 4312 static void
302     query_name(const char *name, int query_class, int type,
303     struct reslist *request)
304 adx 30 {
305 michael 4312 char buf[MAXPACKET];
306     int request_len = 0;
307 adx 30
308 michael 4312 memset(buf, 0, sizeof(buf));
309 adx 30
310 michael 4312 if ((request_len = irc_res_mkquery(name, query_class, type,
311     (unsigned char *)buf, sizeof(buf))) > 0)
312     {
313     HEADER *header = (HEADER *)buf;
314    
315     /*
316     * Generate an unique id.
317     * NOTE: we don't have to worry about converting this to and from
318     * network byte order, the nameserver does not interpret this value
319     * and returns it unchanged.
320     */
321     do
322     header->id = (header->id + genrand_int32()) & 0xFFFF;
323     while (find_id(header->id));
324    
325     request->id = header->id;
326     ++request->sends;
327    
328     request->sent += send_res_msg(buf, request_len, request->sends);
329     }
330 adx 30 }
331    
332     /*
333     * do_query_name - nameserver lookup name
334     */
335     static void
336 michael 992 do_query_name(dns_callback_fnc callback, void *ctx, const char *name,
337 adx 30 struct reslist *request, int type)
338     {
339 michael 4409 char host_name[RFC1035_MAX_DOMAIN_LENGTH + 1];
340 adx 30
341 michael 998 strlcpy(host_name, name, sizeof(host_name));
342 adx 30
343     if (request == NULL)
344     {
345 michael 4409 request = make_request(callback, ctx);
346     request->type = type;
347     request->namelength = strlcpy(request->name, host_name, sizeof(request->name));
348 michael 4414
349 michael 984 if (type != T_A)
350     request->state = REQ_AAAA;
351 adx 30 else
352 michael 4414 request->state = REQ_A;
353 adx 30 }
354    
355     request->type = type;
356     query_name(host_name, C_IN, type, request);
357     }
358    
359     /*
360     * do_query_number - Use this to do reverse IP# lookups.
361     */
362     static void
363 michael 992 do_query_number(dns_callback_fnc callback, void *ctx,
364     const struct irc_ssaddr *addr,
365 adx 30 struct reslist *request)
366     {
367 michael 3298 char ipbuf[128] = "";
368 michael 985
369 adx 30 if (addr->ss.ss_family == AF_INET)
370     {
371 michael 992 const struct sockaddr_in *v4 = (const struct sockaddr_in *)addr;
372 michael 3298 const unsigned char *cp = (const unsigned char *)&v4->sin_addr.s_addr;
373 adx 30
374 michael 1124 snprintf(ipbuf, sizeof(ipbuf), "%u.%u.%u.%u.in-addr.arpa.",
375     (unsigned int)(cp[3]), (unsigned int)(cp[2]),
376     (unsigned int)(cp[1]), (unsigned int)(cp[0]));
377 adx 30 }
378     else if (addr->ss.ss_family == AF_INET6)
379     {
380 michael 992 const struct sockaddr_in6 *v6 = (const struct sockaddr_in6 *)addr;
381 michael 3298 const unsigned char *cp = (const unsigned char *)&v6->sin6_addr.s6_addr;
382 adx 30
383 michael 1124 snprintf(ipbuf, sizeof(ipbuf),
384     "%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x."
385     "%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.ip6.arpa.",
386     (unsigned int)(cp[15] & 0xf), (unsigned int)(cp[15] >> 4),
387     (unsigned int)(cp[14] & 0xf), (unsigned int)(cp[14] >> 4),
388     (unsigned int)(cp[13] & 0xf), (unsigned int)(cp[13] >> 4),
389     (unsigned int)(cp[12] & 0xf), (unsigned int)(cp[12] >> 4),
390     (unsigned int)(cp[11] & 0xf), (unsigned int)(cp[11] >> 4),
391     (unsigned int)(cp[10] & 0xf), (unsigned int)(cp[10] >> 4),
392     (unsigned int)(cp[9] & 0xf), (unsigned int)(cp[9] >> 4),
393     (unsigned int)(cp[8] & 0xf), (unsigned int)(cp[8] >> 4),
394     (unsigned int)(cp[7] & 0xf), (unsigned int)(cp[7] >> 4),
395     (unsigned int)(cp[6] & 0xf), (unsigned int)(cp[6] >> 4),
396     (unsigned int)(cp[5] & 0xf), (unsigned int)(cp[5] >> 4),
397     (unsigned int)(cp[4] & 0xf), (unsigned int)(cp[4] >> 4),
398     (unsigned int)(cp[3] & 0xf), (unsigned int)(cp[3] >> 4),
399     (unsigned int)(cp[2] & 0xf), (unsigned int)(cp[2] >> 4),
400     (unsigned int)(cp[1] & 0xf), (unsigned int)(cp[1] >> 4),
401     (unsigned int)(cp[0] & 0xf), (unsigned int)(cp[0] >> 4));
402 adx 30 }
403 michael 4414
404 adx 30 if (request == NULL)
405     {
406 michael 992 request = make_request(callback, ctx);
407 adx 30 request->type = T_PTR;
408     memcpy(&request->addr, addr, sizeof(struct irc_ssaddr));
409     }
410    
411     query_name(ipbuf, C_IN, T_PTR, request);
412     }
413    
414     /*
415 michael 4312 * gethost_byname_type - get host address from name
416     *
417 adx 30 */
418 michael 4312 void
419     gethost_byname_type(dns_callback_fnc callback, void *ctx, const char *name, int type)
420 adx 30 {
421 michael 4312 assert(name);
422     do_query_name(callback, ctx, name, NULL, type);
423     }
424 adx 30
425 michael 4312 /*
426     * gethost_byname - wrapper for _type - send T_AAAA first if IPV6 supported
427     */
428     void
429     gethost_byname(dns_callback_fnc callback, void *ctx, const char *name)
430     {
431     gethost_byname_type(callback, ctx, name, T_AAAA);
432     }
433 adx 30
434 michael 4312 /*
435     * gethost_byaddr - get host name from address
436     */
437     void
438     gethost_byaddr(dns_callback_fnc callback, void *ctx, const struct irc_ssaddr *addr)
439     {
440     do_query_number(callback, ctx, addr, NULL);
441 adx 30 }
442    
443     static void
444     resend_query(struct reslist *request)
445     {
446     if (request->resend == 0)
447     return;
448    
449 michael 982 switch (request->type)
450 adx 30 {
451     case T_PTR:
452 michael 992 do_query_number(NULL, NULL, &request->addr, request);
453 adx 30 break;
454     case T_A:
455 michael 992 do_query_name(NULL, NULL, request->name, request, request->type);
456 adx 30 break;
457 michael 4299 case T_AAAA: /* Didn't work, try A */
458 adx 30 if (request->state == REQ_AAAA)
459 michael 992 do_query_name(NULL, NULL, request->name, request, T_A);
460 adx 30 default:
461     break;
462     }
463     }
464    
465     /*
466     * proc_answer - process name server reply
467     */
468     static int
469 michael 1124 proc_answer(struct reslist *request, HEADER *header, char *buf, char *eob)
470 adx 30 {
471 michael 4409 char hostbuf[RFC1035_MAX_DOMAIN_LENGTH + 100]; /* working buffer */
472 adx 30 unsigned char *current; /* current position in buf */
473     int type; /* answer type */
474     int n; /* temp count */
475     int rd_length;
476     struct sockaddr_in *v4; /* conversion */
477     struct sockaddr_in6 *v6;
478 michael 4414
479 adx 30 current = (unsigned char *)buf + sizeof(HEADER);
480    
481     for (; header->qdcount > 0; --header->qdcount)
482     {
483     if ((n = irc_dn_skipname(current, (unsigned char *)eob)) < 0)
484     break;
485    
486 michael 1124 current += (size_t)n + QFIXEDSZ;
487 adx 30 }
488    
489     /*
490 michael 4299 * Process each answer sent to us blech.
491 adx 30 */
492     while (header->ancount > 0 && (char *)current < eob)
493     {
494     header->ancount--;
495    
496     n = irc_dn_expand((unsigned char *)buf, (unsigned char *)eob, current,
497     hostbuf, sizeof(hostbuf));
498    
499 michael 4299 if (n < 0 /* Broken message */ || n == 0 /* No more answers left */)
500 michael 1124 return 0;
501 adx 30
502 michael 4409 hostbuf[RFC1035_MAX_DOMAIN_LENGTH] = '\0';
503 adx 30
504 michael 4299 /*
505     * With Address arithmetic you have to be very anal
506 adx 30 * this code was not working on alpha due to that
507     * (spotted by rodder/jailbird/dianora)
508     */
509 michael 3298 current += (size_t)n;
510 adx 30
511     if (!(((char *)current + ANSWER_FIXED_SIZE) < eob))
512     break;
513    
514     type = irc_ns_get16(current);
515     current += TYPE_SIZE;
516     current += CLASS_SIZE;
517     current += TTL_SIZE;
518     rd_length = irc_ns_get16(current);
519     current += RDLENGTH_SIZE;
520    
521 michael 2916 /*
522     * Wait to set request->type until we verify this structure
523 adx 30 */
524     switch (type)
525     {
526     case T_A:
527     if (request->type != T_A)
528 michael 1124 return 0;
529 adx 30
530     /*
531 michael 3298 * Check for invalid rd_length or too many addresses
532 adx 30 */
533     if (rd_length != sizeof(struct in_addr))
534 michael 1124 return 0;
535    
536 adx 30 v4 = (struct sockaddr_in *)&request->addr;
537     request->addr.ss_len = sizeof(struct sockaddr_in);
538     v4->sin_family = AF_INET;
539     memcpy(&v4->sin_addr, current, sizeof(struct in_addr));
540 michael 1124 return 1;
541 adx 30 break;
542     case T_AAAA:
543     if (request->type != T_AAAA)
544 michael 1124 return 0;
545    
546 adx 30 if (rd_length != sizeof(struct in6_addr))
547 michael 1124 return 0;
548    
549 adx 30 request->addr.ss_len = sizeof(struct sockaddr_in6);
550     v6 = (struct sockaddr_in6 *)&request->addr;
551     v6->sin6_family = AF_INET6;
552     memcpy(&v6->sin6_addr, current, sizeof(struct in6_addr));
553 michael 1124 return 1;
554 adx 30 break;
555     case T_PTR:
556     if (request->type != T_PTR)
557 michael 1124 return 0;
558    
559 adx 30 n = irc_dn_expand((unsigned char *)buf, (unsigned char *)eob,
560 michael 3298 current, hostbuf, sizeof(hostbuf));
561 michael 4299 if (n < 0 /* Broken message */ || n == 0 /* No more answers left */)
562 michael 1124 return 0;
563 adx 30
564 michael 4409 request->namelength = strlcpy(request->name, hostbuf, sizeof(request->name));
565 michael 1124 return 1;
566 adx 30 break;
567 michael 4299 case T_CNAME: /* First check we already haven't started looking into a cname */
568 michael 2916 if (request->type != T_PTR)
569 michael 1124 return 0;
570 adx 30
571     if (request->state == REQ_CNAME)
572     {
573     n = irc_dn_expand((unsigned char *)buf, (unsigned char *)eob,
574     current, hostbuf, sizeof(hostbuf));
575    
576     if (n < 0)
577 michael 1124 return 0;
578     return 1;
579 adx 30 }
580    
581     request->state = REQ_CNAME;
582     current += rd_length;
583     break;
584 michael 2916
585 adx 30 default:
586     /* XXX I'd rather just throw away the entire bogus thing
587     * but its possible its just a broken nameserver with still
588     * valid answers. But lets do some rudimentary logging for now...
589     */
590 michael 1247 ilog(LOG_TYPE_IRCD, "irc_res.c bogus type %d", type);
591 adx 30 break;
592     }
593     }
594    
595 michael 1124 return 1;
596 adx 30 }
597    
598     /*
599     * res_readreply - read a dns reply from the nameserver and process it.
600     */
601     static void
602     res_readreply(fde_t *fd, void *data)
603     {
604 michael 4239 char buf[sizeof(HEADER) + MAXPACKET];
605 adx 30 HEADER *header;
606     struct reslist *request = NULL;
607 michael 4302 ssize_t rc = 0;
608 adx 30 socklen_t len = sizeof(struct irc_ssaddr);
609     struct irc_ssaddr lsin;
610    
611 michael 4318 while ((rc = recvfrom(fd->fd, buf, sizeof(buf), 0, (struct sockaddr *)&lsin, &len)) != -1)
612     {
613     if (rc <= (ssize_t)sizeof(HEADER))
614     continue;
615 adx 30
616 michael 4318 /*
617     * Check against possibly fake replies
618     */
619     if (!res_ourserver(&lsin))
620     continue;
621 michael 984
622 michael 4318 /*
623     * Convert DNS reply reader from Network byte order to CPU byte order.
624     */
625     header = (HEADER *)buf;
626     header->ancount = ntohs(header->ancount);
627     header->qdcount = ntohs(header->qdcount);
628     header->nscount = ntohs(header->nscount);
629     header->arcount = ntohs(header->arcount);
630 adx 30
631 michael 4318 /*
632     * Response for an id which we have already received an answer for
633     * just ignore this response.
634     */
635     if ((request = find_id(header->id)) == NULL)
636     continue;
637 michael 4238
638 michael 4318 if ((header->rcode != NO_ERRORS) || (header->ancount == 0))
639     {
640     if (header->rcode == SERVFAIL || header->rcode == NXDOMAIN)
641     {
642     /*
643     * If a bad error was returned, stop here and don't
644     * send any more (no retries granted).
645     */
646 michael 4409 (*request->callback)(request->callback_ctx, NULL, NULL, 0);
647 michael 4318 rem_request(request);
648     }
649     else
650     {
651     /*
652     * If we havent already tried this, and we're looking up AAAA, try A now.
653     */
654     if (request->state == REQ_AAAA && request->type == T_AAAA)
655     {
656     request->timeout += 4;
657     resend_query(request);
658     }
659     }
660 michael 4414
661 michael 4318 continue;
662     }
663 adx 30
664 michael 4318 /*
665     * If this fails there was an error decoding the received packet.
666     * We only give it one shot. If it fails, just leave the client
667     * unresolved.
668     */
669     if (!proc_answer(request, header, buf, buf + rc))
670 db 155 {
671 michael 4409 (*request->callback)(request->callback_ctx, NULL, NULL, 0);
672 michael 984 rem_request(request);
673 michael 4318 continue;
674 michael 984 }
675 michael 4318
676     if (request->type == T_PTR)
677 michael 984 {
678 michael 4409 if (request->namelength == 0)
679 michael 4318 {
680     /*
681     * Got a PTR response with no name, something bogus is happening
682     * don't bother trying again, the client address doesn't resolve
683     */
684 michael 4409 (*request->callback)(request->callback_ctx, NULL, NULL, 0);
685 michael 4318 rem_request(request);
686     continue;
687     }
688    
689 michael 2916 /*
690 michael 4318 * Lookup the 'authoritative' name that we were given for the ip#.
691 adx 30 */
692 michael 4318 if (request->addr.ss.ss_family == AF_INET6)
693     gethost_byname_type(request->callback, request->callback_ctx, request->name, T_AAAA);
694     else
695 michael 4414 gethost_byname_type(request->callback, request->callback_ctx, request->name, T_A);
696 michael 4318 rem_request(request);
697 michael 984 }
698 michael 4318 else
699 adx 30 {
700     /*
701 michael 4318 * Got a name and address response, client resolved
702 adx 30 */
703 michael 4409 (*request->callback)(request->callback_ctx, &request->addr, request->name, request->namelength);
704 adx 30 rem_request(request);
705     }
706 michael 4315
707 michael 4318 continue;
708 adx 30 }
709 michael 4318
710     comm_setselect(fd, COMM_SELECT_READ, res_readreply, NULL, 0);
711 adx 30 }
712    
713     void
714     report_dns_servers(struct Client *source_p)
715     {
716 michael 3235 char ipaddr[HOSTIPLEN + 1] = "";
717 adx 30
718 michael 3297 for (unsigned int i = 0; i < irc_nscount; ++i)
719 adx 30 {
720 michael 1123 getnameinfo((struct sockaddr *)&(irc_nsaddr_list[i]),
721     irc_nsaddr_list[i].ss_len, ipaddr,
722     sizeof(ipaddr), NULL, 0, NI_NUMERICHOST);
723 michael 3109 sendto_one_numeric(source_p, &me, RPL_STATSALINE, ipaddr);
724 adx 30 }
725     }
726 michael 4312
727     /*
728     * timeout_query_list - Remove queries from the list which have been
729     * there too long without being resolved.
730     */
731     static time_t
732     timeout_query_list(void)
733     {
734     dlink_node *ptr = NULL, *ptr_next = NULL;
735     struct reslist *request = NULL;
736     time_t next_time = 0;
737     time_t timeout = 0;
738    
739     DLINK_FOREACH_SAFE(ptr, ptr_next, request_list.head)
740     {
741     request = ptr->data;
742     timeout = request->sentat + request->timeout;
743    
744     if (CurrentTime >= timeout)
745     {
746     if (--request->retries <= 0)
747     {
748 michael 4409 (*request->callback)(request->callback_ctx, NULL, NULL, 0);
749 michael 4312 rem_request(request);
750     continue;
751     }
752     else
753     {
754     request->sentat = CurrentTime;
755     request->timeout += request->timeout;
756     resend_query(request);
757     }
758     }
759    
760     if (next_time == 0 || timeout < next_time)
761     next_time = timeout;
762     }
763    
764     return (next_time > CurrentTime) ? next_time : (CurrentTime + AR_TTL);
765     }
766    
767     /*
768     * timeout_resolver - check request list
769     */
770     static void
771 michael 4438 timeout_resolver(void *unused)
772 michael 4312 {
773     timeout_query_list();
774     }
775    
776     /*
777     * init_resolver - initialize resolver and resolver library
778     */
779     void
780     init_resolver(void)
781     {
782     static struct event event_timeout_resolver =
783     {
784     .name = "timeout_resolver",
785     .handler = timeout_resolver,
786     .when = 1
787     };
788    
789     dns_pool = mp_pool_new(sizeof(struct reslist), MP_CHUNK_SIZE_DNS);
790 michael 4421
791 michael 4312 start_resolver();
792     event_add(&event_timeout_resolver, NULL);
793     }

Properties

Name Value
svn:eol-style native
svn:keywords Id Revision