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.
4 * (Well, some of the function names are the same, and bits of the structs..)
5 * You can use it where it is useful, free even. Buy us a beer and stuff.
7 * The authors takes no responsibility for any damage or loss
8 * of property which results from the use of this software.
10 * $Id: res.c 3301 2007-03-28 15:04:06Z jilles $
11 * from Hybrid Id: res.c 459 2006-02-12 22:21:37Z db $
13 * July 1999 - Rewrote a bunch of stuff here. Change hostent builder code,
14 * added callbacks and reference counting of returned hostents.
15 * --Bleep (Thomas Helvey <tomh@inxpress.net>)
17 * This was all needlessly complicated for irc. Simplified. No more hostent
18 * All we really care about is the IP -> hostname mappings. Thats all.
20 * Apr 28, 2003 --cryogen and Dianora
22 * DNS server flooding lessened, AAAA-or-A lookup removed, ip6.int support
23 * removed, various robustness fixes
25 * 2006 --jilles and nenolod
29 #include "ircd_defs.h"
34 #include "irc_string.h"
35 #include "sprintf_irc.h"
37 #include "client.h" /* SNO_* */
40 #error this code needs to be able to address individual octets
43 static PF res_readreply
;
45 #define MAXPACKET 1024 /* rfc sez 512 but we expand names so ... */
46 #define RES_MAXALIASES 35 /* maximum aliases allowed */
47 #define RES_MAXADDRS 35 /* maximum addresses allowed */
48 #define AR_TTL 600 /* TTL in seconds for dns cache entries */
50 /* RFC 1104/1105 wasn't very helpful about what these fields
51 * should be named, so for now, we'll just name them this way.
52 * we probably should look at what named calls them or something.
54 #define TYPE_SIZE (size_t)2
55 #define CLASS_SIZE (size_t)2
56 #define TTL_SIZE (size_t)4
57 #define RDLENGTH_SIZE (size_t)2
58 #define ANSWER_FIXED_SIZE (TYPE_SIZE + CLASS_SIZE + TTL_SIZE + RDLENGTH_SIZE)
62 REQ_IDLE
, /* We're doing not much at all */
63 REQ_PTR
, /* Looking up a PTR */
64 REQ_A
, /* Looking up an A or AAAA */
65 REQ_CNAME
/* We got a CNAME in response, we better get a real answer next */
72 int sent
; /* number of requests sent */
73 request_state state
; /* State the resolver machine is in */
76 char queryname
[128]; /* name currently being queried */
77 char retries
; /* retry counter */
78 char sends
; /* number of sends (>1 means resent) */
79 char resend
; /* send flag. 0 == dont resend */
82 struct irc_sockaddr_storage addr
;
84 struct DNSQuery
*query
; /* query callback for this request */
88 static rb_dlink_list request_list
= { NULL
, NULL
, 0 };
90 static void rem_request(struct reslist
*request
);
91 static struct reslist
*make_request(struct DNSQuery
*query
);
92 static void do_query_name(struct DNSQuery
*query
, const char *name
, struct reslist
*request
, int);
93 static void do_query_number(struct DNSQuery
*query
, const struct irc_sockaddr_storage
*,
94 struct reslist
*request
);
95 static void query_name(struct reslist
*request
);
96 static int send_res_msg(const char *buf
, int len
, int count
);
97 static void resend_query(struct reslist
*request
);
98 static int check_question(struct reslist
*request
, HEADER
* header
, char *buf
, char *eob
);
99 static int proc_answer(struct reslist
*request
, HEADER
* header
, char *, char *);
100 static struct reslist
*find_id(int id
);
101 static struct DNSReply
*make_dnsreply(struct reslist
*request
);
103 extern struct irc_sockaddr_storage irc_nsaddr_list
[IRCD_MAXNS
];
104 extern int irc_nscount
;
105 extern char irc_domain
[HOSTLEN
+ 1];
111 * looks up "inp" in irc_nsaddr_list[]
116 * paul vixie, 29may94
117 * revised for ircd, cryogen(stu) may03
119 static int res_ourserver(const struct irc_sockaddr_storage
*inp
)
122 struct sockaddr_in6
*v6
;
123 struct sockaddr_in6
*v6in
= (struct sockaddr_in6
*)inp
;
125 struct sockaddr_in
*v4
;
126 struct sockaddr_in
*v4in
= (struct sockaddr_in
*)inp
;
129 for (ns
= 0; ns
< irc_nscount
; ns
++)
131 const struct irc_sockaddr_storage
*srv
= &irc_nsaddr_list
[ns
];
133 v6
= (struct sockaddr_in6
*)srv
;
135 v4
= (struct sockaddr_in
*)srv
;
137 /* could probably just memcmp(srv, inp, srv.ss_len) here
138 * but we'll air on the side of caution - stu
140 switch (srv
->ss_family
)
144 if (srv
->ss_family
== inp
->ss_family
)
145 if (v6
->sin6_port
== v6in
->sin6_port
)
146 if ((memcmp(&v6
->sin6_addr
.s6_addr
, &v6in
->sin6_addr
.s6_addr
,
147 sizeof(struct in6_addr
)) == 0) ||
148 (memcmp(&v6
->sin6_addr
.s6_addr
, &in6addr_any
,
149 sizeof(struct in6_addr
)) == 0))
154 if (srv
->ss_family
== inp
->ss_family
)
155 if (v4
->sin_port
== v4in
->sin_port
)
156 if ((v4
->sin_addr
.s_addr
== INADDR_ANY
)
157 || (v4
->sin_addr
.s_addr
== v4in
->sin_addr
.s_addr
))
169 * timeout_query_list - Remove queries from the list which have been
170 * there too long without being resolved.
172 static time_t timeout_query_list(time_t now
)
175 rb_dlink_node
*rb_free(;
176 struct reslist
*request
;
177 time_t next_time
= 0;
180 RB_DLINK_FOREACH_SAFE(ptr
, rb_free(, request_list
.head
)
183 timeout
= request
->sentat
+ request
->timeout
;
187 if (--request
->retries
<= 0)
189 (*request
->query
->callback
) (request
->query
->ptr
, NULL
);
190 rem_request(request
);
195 request
->sentat
= now
;
196 request
->timeout
+= request
->timeout
;
197 resend_query(request
);
201 if ((next_time
== 0) || timeout
< next_time
)
207 return (next_time
> now
) ? next_time
: (now
+ AR_TTL
);
211 * timeout_resolver - check request list
213 static void timeout_resolver(void *notused
)
215 timeout_query_list(CurrentTime
);
219 * start_resolver - do everything we need to read the resolv.conf file
220 * and initialize the resolver file descriptor if needed
222 static void start_resolver(void)
226 if (res_fd
<= 0) /* there isn't any such thing as fd 0, that's just a myth. */
228 if ((res_fd
= rb_socket(irc_nsaddr_list
[0].ss_family
, SOCK_DGRAM
, 0,
229 "UDP resolver socket")) == -1)
232 /* At the moment, the resolver FD data is global .. */
233 rb_setselect(res_fd
, FDLIST_NONE
, COMM_SELECT_READ
, res_readreply
, NULL
, 0);
234 eventAdd("timeout_resolver", timeout_resolver
, NULL
, 1);
239 * init_resolver - initialize resolver and resolver library
241 void init_resolver(void)
244 srand48(CurrentTime
);
250 * restart_resolver - reread resolv.conf, reopen socket
252 void restart_resolver(void)
256 eventDelete(timeout_resolver
, NULL
); /* -ddosen */
261 * add_local_domain - Add the domain to hostname, if it is missing
262 * (as suggested by eps@TOASTER.SFSU.EDU)
264 void add_local_domain(char *hname
, size_t size
)
266 /* try to fix up unqualified names */
267 if (strchr(hname
, '.') == NULL
)
271 size_t len
= strlen(hname
);
273 if ((strlen(irc_domain
) + len
+ 2) < size
)
276 strcpy(hname
+ len
, irc_domain
);
283 * rem_request - remove a request from the list.
284 * This must also free any memory that has been allocated for
285 * temporary storage of DNS results.
287 static void rem_request(struct reslist
*request
)
289 rb_dlinkDelete(&request
->node
, &request_list
);
290 MyFree(request
->name
);
295 * make_request - Create a DNS request record for the server.
297 static struct reslist
*make_request(struct DNSQuery
*query
)
299 struct reslist
*request
= MyMalloc(sizeof(struct reslist
));
301 request
->sentat
= CurrentTime
;
302 request
->retries
= 3;
304 request
->timeout
= 4; /* start at 4 and exponential inc. */
305 request
->query
= query
;
306 request
->state
= REQ_IDLE
;
308 rb_dlinkAdd(request
, &request
->node
, &request_list
);
314 * delete_resolver_queries - cleanup outstanding queries
315 * for which there no longer exist clients or conf lines.
317 void delete_resolver_queries(const struct DNSQuery
*query
)
320 rb_dlink_node
*rb_free(;
321 struct reslist
*request
;
323 RB_DLINK_FOREACH_SAFE(ptr
, rb_free(, request_list
.head
)
325 if ((request
= ptr
->data
) != NULL
)
327 if (query
== request
->query
)
328 rem_request(request
);
334 * send_res_msg - sends msg to all nameservers found in the "_res" structure.
335 * This should reflect /etc/resolv.conf. We will get responses
336 * which arent needed but is easier than checking to see if nameserver
337 * isnt present. Returns number of messages successfully sent to
338 * nameservers or -1 if no successful sends.
340 static int send_res_msg(const char *msg
, int len
, int rcount
)
344 int max_queries
= IRCD_MIN(irc_nscount
, rcount
);
346 /* RES_PRIMARY option is not implemented
347 * if (res.options & RES_PRIMARY || 0 == max_queries)
349 if (max_queries
== 0)
352 for (i
= 0; sent
< max_queries
&& i
< irc_nscount
; i
++)
354 if (sendto(res_fd
, msg
, len
, 0,
355 (struct sockaddr
*)&(irc_nsaddr_list
[i
]),
356 GET_SS_LEN(irc_nsaddr_list
[i
])) == len
)
364 * find_id - find a dns request id (id is determined by dn_mkquery)
366 static struct reslist
*find_id(int id
)
369 struct reslist
*request
;
371 RB_DLINK_FOREACH(ptr
, request_list
.head
)
375 if (request
->id
== id
)
383 * gethost_byname_type - get host address from name
386 void gethost_byname_type(const char *name
, struct DNSQuery
*query
, int type
)
389 do_query_name(query
, name
, NULL
, type
);
393 * gethost_byaddr - get host name from address
395 void gethost_byaddr(const struct irc_sockaddr_storage
*addr
, struct DNSQuery
*query
)
397 do_query_number(query
, addr
, NULL
);
401 * do_query_name - nameserver lookup name
403 static void do_query_name(struct DNSQuery
*query
, const char *name
, struct reslist
*request
,
406 char host_name
[HOSTLEN
+ 1];
408 strlcpy(host_name
, name
, HOSTLEN
+ 1);
409 add_local_domain(host_name
, HOSTLEN
);
413 request
= make_request(query
);
414 request
->name
= (char *)MyMalloc(strlen(host_name
) + 1);
415 strcpy(request
->name
, host_name
);
416 request
->state
= REQ_A
;
419 strlcpy(request
->queryname
, host_name
, sizeof(request
->queryname
));
420 request
->type
= type
;
425 * do_query_number - Use this to do reverse IP# lookups.
427 static void do_query_number(struct DNSQuery
*query
, const struct irc_sockaddr_storage
*addr
,
428 struct reslist
*request
)
430 const unsigned char *cp
;
434 request
= make_request(query
);
435 memcpy(&request
->addr
, addr
, sizeof(struct irc_sockaddr_storage
));
436 request
->name
= (char *)MyMalloc(HOSTLEN
+ 1);
439 if (addr
->ss_family
== AF_INET
)
441 struct sockaddr_in
*v4
= (struct sockaddr_in
*)addr
;
442 cp
= (const unsigned char *)&v4
->sin_addr
.s_addr
;
444 rb_sprintf(request
->queryname
, "%u.%u.%u.%u.in-addr.arpa", (unsigned int)(cp
[3]),
445 (unsigned int)(cp
[2]), (unsigned int)(cp
[1]), (unsigned int)(cp
[0]));
448 else if (addr
->ss_family
== AF_INET6
)
450 struct sockaddr_in6
*v6
= (struct sockaddr_in6
*)addr
;
451 cp
= (const unsigned char *)&v6
->sin6_addr
.s6_addr
;
453 (void)sprintf(request
->queryname
, "%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x."
454 "%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.ip6.arpa",
455 (unsigned int)(cp
[15] & 0xf), (unsigned int)(cp
[15] >> 4),
456 (unsigned int)(cp
[14] & 0xf), (unsigned int)(cp
[14] >> 4),
457 (unsigned int)(cp
[13] & 0xf), (unsigned int)(cp
[13] >> 4),
458 (unsigned int)(cp
[12] & 0xf), (unsigned int)(cp
[12] >> 4),
459 (unsigned int)(cp
[11] & 0xf), (unsigned int)(cp
[11] >> 4),
460 (unsigned int)(cp
[10] & 0xf), (unsigned int)(cp
[10] >> 4),
461 (unsigned int)(cp
[9] & 0xf), (unsigned int)(cp
[9] >> 4),
462 (unsigned int)(cp
[8] & 0xf), (unsigned int)(cp
[8] >> 4),
463 (unsigned int)(cp
[7] & 0xf), (unsigned int)(cp
[7] >> 4),
464 (unsigned int)(cp
[6] & 0xf), (unsigned int)(cp
[6] >> 4),
465 (unsigned int)(cp
[5] & 0xf), (unsigned int)(cp
[5] >> 4),
466 (unsigned int)(cp
[4] & 0xf), (unsigned int)(cp
[4] >> 4),
467 (unsigned int)(cp
[3] & 0xf), (unsigned int)(cp
[3] >> 4),
468 (unsigned int)(cp
[2] & 0xf), (unsigned int)(cp
[2] >> 4),
469 (unsigned int)(cp
[1] & 0xf), (unsigned int)(cp
[1] >> 4),
470 (unsigned int)(cp
[0] & 0xf), (unsigned int)(cp
[0] >> 4));
474 request
->type
= T_PTR
;
479 * query_name - generate a query based on class, type and name.
481 static void query_name(struct reslist
*request
)
486 memset(buf
, 0, sizeof(buf
));
489 irc_res_mkquery(request
->queryname
, C_IN
, request
->type
, (unsigned char *)buf
, sizeof(buf
))) > 0)
491 HEADER
*header
= (HEADER
*) buf
;
497 * generate an unique id
498 * NOTE: we don't have to worry about converting this to and from
499 * network byte order, the nameserver does not interpret this value
500 * and returns it unchanged
505 header
->id
= (header
->id
+ lrand48()) & 0xffff;
506 } while (find_id(header
->id
));
508 gettimeofday(&tv
, NULL
);
511 header
->id
= (header
->id
+ k
+ tv
.tv_usec
) & 0xffff;
513 } while (find_id(header
->id
));
514 #endif /* HAVE_LRAND48 */
515 request
->id
= header
->id
;
518 request
->sent
+= send_res_msg(buf
, request_len
, request
->sends
);
522 static void resend_query(struct reslist
*request
)
524 if (request
->resend
== 0)
527 switch (request
->type
)
530 do_query_number(NULL
, &request
->addr
, request
);
536 do_query_name(NULL
, request
->name
, request
, request
->type
);
544 * check_question - check if the reply really belongs to the
545 * name we queried (to guard against late replies from previous
546 * queries with the same id).
548 static int check_question(struct reslist
*request
, HEADER
* header
, char *buf
, char *eob
)
550 char hostbuf
[128]; /* working buffer */
551 unsigned char *current
; /* current position in buf */
552 int n
; /* temp count */
554 current
= (unsigned char *)buf
+ sizeof(HEADER
);
555 if (header
->qdcount
!= 1)
557 n
= irc_dn_expand((unsigned char *)buf
, (unsigned char *)eob
, current
, hostbuf
,
561 if (strcasecmp(hostbuf
, request
->queryname
))
567 * proc_answer - process name server reply
569 static int proc_answer(struct reslist
*request
, HEADER
* header
, char *buf
, char *eob
)
571 char hostbuf
[HOSTLEN
+ 100]; /* working buffer */
572 unsigned char *current
; /* current position in buf */
573 int query_class
; /* answer class */
574 int type
; /* answer type */
575 int n
; /* temp count */
577 struct sockaddr_in
*v4
; /* conversion */
579 struct sockaddr_in6
*v6
;
581 current
= (unsigned char *)buf
+ sizeof(HEADER
);
583 for (; header
->qdcount
> 0; --header
->qdcount
)
585 if ((n
= irc_dn_skipname(current
, (unsigned char *)eob
)) < 0)
588 current
+= (size_t) n
+ QFIXEDSZ
;
592 * process each answer sent to us blech.
594 while (header
->ancount
> 0 && (char *)current
< eob
)
598 n
= irc_dn_expand((unsigned char *)buf
, (unsigned char *)eob
, current
, hostbuf
,
611 * no more answers left
616 hostbuf
[HOSTLEN
] = '\0';
618 /* With Address arithmetic you have to be very anal
619 * this code was not working on alpha due to that
620 * (spotted by rodder/jailbird/dianora)
622 current
+= (size_t) n
;
624 if (!(((char *)current
+ ANSWER_FIXED_SIZE
) < eob
))
627 type
= irc_ns_get16(current
);
628 current
+= TYPE_SIZE
;
630 query_class
= irc_ns_get16(current
);
631 current
+= CLASS_SIZE
;
633 request
->ttl
= irc_ns_get32(current
);
636 rd_length
= irc_ns_get16(current
);
637 current
+= RDLENGTH_SIZE
;
640 * Wait to set request->type until we verify this structure
645 if (request
->type
!= T_A
)
649 * check for invalid rd_length or too many addresses
651 if (rd_length
!= sizeof(struct in_addr
))
653 v4
= (struct sockaddr_in
*)&request
->addr
;
654 SET_SS_LEN(request
->addr
, sizeof(struct sockaddr_in
));
655 v4
->sin_family
= AF_INET
;
656 memcpy(&v4
->sin_addr
, current
, sizeof(struct in_addr
));
661 if (request
->type
!= T_AAAA
)
663 if (rd_length
!= sizeof(struct in6_addr
))
665 SET_SS_LEN(request
->addr
, sizeof(struct sockaddr_in6
));
666 v6
= (struct sockaddr_in6
*)&request
->addr
;
667 v6
->sin6_family
= AF_INET6
;
668 memcpy(&v6
->sin6_addr
, current
, sizeof(struct in6_addr
));
673 if (request
->type
!= T_PTR
)
675 n
= irc_dn_expand((unsigned char *)buf
, (unsigned char *)eob
, current
,
676 hostbuf
, sizeof(hostbuf
));
678 return (0); /* broken message */
680 return (0); /* no more answers left */
682 strlcpy(request
->name
, hostbuf
, HOSTLEN
+ 1);
686 case T_CNAME
: /* first check we already havent started looking
688 if (request
->type
!= T_PTR
)
691 if (request
->state
== REQ_CNAME
)
693 n
= irc_dn_expand((unsigned char *)buf
, (unsigned char *)eob
,
694 current
, hostbuf
, sizeof(hostbuf
));
701 request
->state
= REQ_CNAME
;
702 current
+= rd_length
;
706 /* XXX I'd rather just throw away the entire bogus thing
707 * but its possible its just a broken nameserver with still
708 * valid answers. But lets do some rudimentary logging for now...
710 ilog(L_MAIN
, "irc_res.c bogus type %d", type
);
719 * res_readreply - read a dns reply from the nameserver and process it.
721 static void res_readreply(int fd
, void *data
)
723 char buf
[sizeof(HEADER
) + MAXPACKET
]
724 /* Sparc and alpha need 16bit-alignment for accessing header->id
725 * (which is uint16_t). Because of the header = (HEADER*) buf;
726 * lateron, this is neeeded. --FaUl
728 #if defined(__sparc__) || defined(__alpha__)
729 __attribute__ ((aligned(16)))
733 struct reslist
*request
= NULL
;
734 struct DNSReply
*reply
= NULL
;
737 socklen_t len
= sizeof(struct irc_sockaddr_storage
);
738 struct irc_sockaddr_storage lsin
;
740 rc
= recvfrom(fd
, buf
, sizeof(buf
), 0, (struct sockaddr
*)&lsin
, &len
);
742 /* Re-schedule a read *after* recvfrom, or we'll be registering
743 * interest where it'll instantly be ready for read :-) -- adrian
745 rb_setselect(fd
, FDLIST_NONE
, COMM_SELECT_READ
, res_readreply
, NULL
, 0);
746 /* Better to cast the sizeof instead of rc */
747 if (rc
<= (int)(sizeof(HEADER
)))
751 * convert DNS reply reader from Network byte order to CPU byte order.
753 header
= (HEADER
*) buf
;
754 header
->ancount
= ntohs(header
->ancount
);
755 header
->qdcount
= ntohs(header
->qdcount
);
756 header
->nscount
= ntohs(header
->nscount
);
757 header
->arcount
= ntohs(header
->arcount
);
760 * response for an id which we have already received an answer for
761 * just ignore this response.
763 if (0 == (request
= find_id(header
->id
)))
767 * check against possibly fake replies
769 if (!res_ourserver(&lsin
))
772 if (!check_question(request
, header
, buf
, buf
+ rc
))
775 if ((header
->rcode
!= NO_ERRORS
) || (header
->ancount
== 0))
777 if (NXDOMAIN
== header
->rcode
)
779 (*request
->query
->callback
) (request
->query
->ptr
, NULL
);
780 rem_request(request
);
785 * If a bad error was returned, we stop here and dont send
786 * send any more (no retries granted).
788 (*request
->query
->callback
) (request
->query
->ptr
, NULL
);
789 rem_request(request
);
794 * If this fails there was an error decoding the received packet,
797 answer_count
= proc_answer(request
, header
, buf
, buf
+ rc
);
801 if (request
->type
== T_PTR
)
803 if (request
->name
== NULL
)
806 * got a PTR response with no name, something bogus is happening
807 * don't bother trying again, the client address doesn't resolve
809 (*request
->query
->callback
) (request
->query
->ptr
, reply
);
810 rem_request(request
);
815 * Lookup the 'authoritative' name that we were given for the
820 if (request
->addr
.ss_family
== AF_INET6
)
821 gethost_byname_type(request
->name
, request
->query
, T_AAAA
);
824 gethost_byname_type(request
->name
, request
->query
, T_A
);
825 rem_request(request
);
830 * got a name and address response, client resolved
832 reply
= make_dnsreply(request
);
833 (*request
->query
->callback
) (request
->query
->ptr
, reply
);
835 rem_request(request
);
840 /* couldn't decode, give up -- jilles */
841 (*request
->query
->callback
) (request
->query
->ptr
, NULL
);
842 rem_request(request
);
846 static struct DNSReply
*make_dnsreply(struct reslist
*request
)
849 s_assert(request
!= 0);
851 cp
= (struct DNSReply
*)MyMalloc(sizeof(struct DNSReply
));
853 cp
->h_name
= request
->name
;
854 memcpy(&cp
->addr
, &request
->addr
, sizeof(cp
->addr
));
858 void report_dns_servers(struct Client
*source_p
)
863 for (i
= 0; i
< irc_nscount
; i
++)
865 if (!inetntop_sock((struct sockaddr
*)&(irc_nsaddr_list
[i
]),
866 ipaddr
, sizeof ipaddr
))
867 strlcpy(ipaddr
, "?", sizeof ipaddr
);
868 sendto_one_numeric(source_p
, RPL_STATSDEBUG
,