88 |
|
time_t timeout; |
89 |
|
struct irc_ssaddr addr; |
90 |
|
char *name; |
91 |
< |
struct DNSQuery *query; /* query callback for this request */ |
91 |
> |
dns_callback_fnc callback; |
92 |
> |
void *callback_ctx; |
93 |
|
}; |
94 |
|
|
95 |
|
static fde_t ResolverFileDescriptor; |
96 |
|
static dlink_list request_list = { NULL, NULL, 0 }; |
97 |
|
|
98 |
|
static void rem_request(struct reslist *request); |
99 |
< |
static struct reslist *make_request(struct DNSQuery *query); |
100 |
< |
static void do_query_name(struct DNSQuery *query, |
101 |
< |
const char* name, struct reslist *request, int); |
102 |
< |
static void do_query_number(struct DNSQuery *query, |
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, |
130 |
|
res_ourserver(const struct irc_ssaddr *inp) |
131 |
|
{ |
132 |
|
#ifdef IPV6 |
133 |
< |
struct sockaddr_in6 *v6; |
134 |
< |
struct sockaddr_in6 *v6in = (struct sockaddr_in6 *)inp; |
133 |
> |
const struct sockaddr_in6 *v6; |
134 |
> |
const struct sockaddr_in6 *v6in = (const struct sockaddr_in6 *)inp; |
135 |
|
#endif |
136 |
< |
struct sockaddr_in *v4; |
137 |
< |
struct sockaddr_in *v4in = (struct sockaddr_in *)inp; |
136 |
> |
const struct sockaddr_in *v4; |
137 |
> |
const struct sockaddr_in *v4in = (const struct sockaddr_in *)inp; |
138 |
|
int ns; |
139 |
|
|
140 |
|
for (ns = 0; ns < irc_nscount; ns++) |
141 |
|
{ |
142 |
|
const struct irc_ssaddr *srv = &irc_nsaddr_list[ns]; |
143 |
|
#ifdef IPV6 |
144 |
< |
v6 = (struct sockaddr_in6 *)srv; |
144 |
> |
v6 = (const struct sockaddr_in6 *)srv; |
145 |
|
#endif |
146 |
< |
v4 = (struct sockaddr_in *)srv; |
146 |
> |
v4 = (const struct sockaddr_in *)srv; |
147 |
|
|
148 |
|
/* could probably just memcmp(srv, inp, srv.ss_len) here |
149 |
|
* but we'll air on the side of caution - stu |
199 |
|
{ |
200 |
|
if (--request->retries <= 0) |
201 |
|
{ |
202 |
< |
(*request->query->callback)(request->query->ptr, NULL); |
202 |
> |
(*request->callback)(request->callback_ctx, NULL, NULL); |
203 |
|
rem_request(request); |
204 |
|
continue; |
205 |
|
} |
313 |
|
* make_request - Create a DNS request record for the server. |
314 |
|
*/ |
315 |
|
static struct reslist * |
316 |
< |
make_request(struct DNSQuery* query) |
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->query = query; |
327 |
< |
request->state = REQ_IDLE; |
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); |
336 |
|
* for which there no longer exist clients or conf lines. |
337 |
|
*/ |
338 |
|
void |
339 |
< |
delete_resolver_queries(const struct DNSQuery *query) |
339 |
> |
delete_resolver_queries(const void *vptr) |
340 |
|
{ |
341 |
|
dlink_node *ptr; |
342 |
|
dlink_node *next_ptr; |
346 |
|
{ |
347 |
|
if ((request = ptr->data) != NULL) |
348 |
|
{ |
349 |
< |
if (query == request->query) |
349 |
> |
if (request->callback_ctx == vptr) |
350 |
|
rem_request(request); |
351 |
|
} |
352 |
|
} |
408 |
|
* |
409 |
|
*/ |
410 |
|
void |
411 |
< |
gethost_byname_type(const char *name, struct DNSQuery *query, int type) |
411 |
> |
gethost_byname_type(dns_callback_fnc callback, void *ctx, const char *name, int type) |
412 |
|
{ |
413 |
|
assert(name != 0); |
414 |
< |
do_query_name(query, name, NULL, type); |
414 |
> |
do_query_name(callback, ctx, name, NULL, type); |
415 |
|
} |
416 |
|
|
417 |
|
/* |
418 |
|
* gethost_byname - wrapper for _type - send T_AAAA first if IPV6 supported |
419 |
|
*/ |
420 |
|
void |
421 |
< |
gethost_byname(const char *name, struct DNSQuery *query) |
421 |
> |
gethost_byname(dns_callback_fnc callback, void *ctx, const char *name) |
422 |
|
{ |
423 |
|
#ifdef IPV6 |
424 |
< |
gethost_byname_type(name, query, T_AAAA); |
424 |
> |
gethost_byname_type(callback, ctx, name, T_AAAA); |
425 |
|
#else |
426 |
< |
gethost_byname_type(name, query, T_A); |
426 |
> |
gethost_byname_type(callback, ctx, name, T_A); |
427 |
|
#endif |
428 |
|
} |
429 |
|
|
431 |
|
* gethost_byaddr - get host name from address |
432 |
|
*/ |
433 |
|
void |
434 |
< |
gethost_byaddr(const struct irc_ssaddr *addr, struct DNSQuery *query) |
434 |
> |
gethost_byaddr(dns_callback_fnc callback, void *ctx, const struct irc_ssaddr *addr) |
435 |
|
{ |
436 |
< |
do_query_number(query, addr, NULL); |
436 |
> |
do_query_number(callback, ctx, addr, NULL); |
437 |
|
} |
438 |
|
|
439 |
|
/* |
440 |
|
* do_query_name - nameserver lookup name |
441 |
|
*/ |
442 |
|
static void |
443 |
< |
do_query_name(struct DNSQuery *query, const char *name, |
443 |
> |
do_query_name(dns_callback_fnc callback, void *ctx, const char *name, |
444 |
|
struct reslist *request, int type) |
445 |
|
{ |
446 |
|
char host_name[HOSTLEN + 1]; |
450 |
|
|
451 |
|
if (request == NULL) |
452 |
|
{ |
453 |
< |
request = make_request(query); |
453 |
> |
request = make_request(callback, ctx); |
454 |
|
request->name = MyMalloc(strlen(host_name) + 1); |
455 |
|
request->type = type; |
456 |
|
strcpy(request->name, host_name); |
470 |
|
* do_query_number - Use this to do reverse IP# lookups. |
471 |
|
*/ |
472 |
|
static void |
473 |
< |
do_query_number(struct DNSQuery *query, const struct irc_ssaddr *addr, |
473 |
> |
do_query_number(dns_callback_fnc callback, void *ctx, |
474 |
> |
const struct irc_ssaddr *addr, |
475 |
|
struct reslist *request) |
476 |
|
{ |
477 |
|
char ipbuf[128]; |
479 |
|
|
480 |
|
if (addr->ss.ss_family == AF_INET) |
481 |
|
{ |
482 |
< |
struct sockaddr_in *v4 = (struct sockaddr_in *)addr; |
482 |
> |
const struct sockaddr_in *v4 = (const struct sockaddr_in *)addr; |
483 |
|
cp = (const unsigned char*)&v4->sin_addr.s_addr; |
484 |
|
|
485 |
|
ircsprintf(ipbuf, "%u.%u.%u.%u.in-addr.arpa.", |
489 |
|
#ifdef IPV6 |
490 |
|
else if (addr->ss.ss_family == AF_INET6) |
491 |
|
{ |
492 |
< |
struct sockaddr_in6 *v6 = (struct sockaddr_in6 *)addr; |
492 |
> |
const struct sockaddr_in6 *v6 = (const struct sockaddr_in6 *)addr; |
493 |
|
cp = (const unsigned char *)&v6->sin6_addr.s6_addr; |
494 |
|
|
495 |
|
sprintf(ipbuf, "%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x." |
514 |
|
#endif |
515 |
|
if (request == NULL) |
516 |
|
{ |
517 |
< |
request = make_request(query); |
517 |
> |
request = make_request(callback, ctx); |
518 |
|
request->type = T_PTR; |
519 |
|
memcpy(&request->addr, addr, sizeof(struct irc_ssaddr)); |
520 |
|
request->name = MyMalloc(HOSTLEN + 1); |
566 |
|
switch (request->type) |
567 |
|
{ |
568 |
|
case T_PTR: |
569 |
< |
do_query_number(NULL, &request->addr, request); |
569 |
> |
do_query_number(NULL, NULL, &request->addr, request); |
570 |
|
break; |
571 |
|
case T_A: |
572 |
< |
do_query_name(NULL, request->name, request, request->type); |
572 |
> |
do_query_name(NULL, NULL, request->name, request, request->type); |
573 |
|
break; |
574 |
|
#ifdef IPV6 |
575 |
|
case T_AAAA: |
576 |
|
/* didnt work, try A */ |
577 |
|
if (request->state == REQ_AAAA) |
578 |
< |
do_query_name(NULL, request->name, request, T_A); |
578 |
> |
do_query_name(NULL, NULL, request->name, request, T_A); |
579 |
|
#endif |
580 |
|
default: |
581 |
|
break; |
752 |
|
; |
753 |
|
HEADER *header; |
754 |
|
struct reslist *request = NULL; |
752 |
– |
struct DNSReply *reply = NULL; |
755 |
|
int rc; |
756 |
|
int answer_count; |
757 |
|
socklen_t len = sizeof(struct irc_ssaddr); |
798 |
|
* If a bad error was returned, stop here and don't |
799 |
|
* send any more (no retries granted). |
800 |
|
*/ |
801 |
< |
(*request->query->callback)(request->query->ptr, NULL); |
801 |
> |
(*request->callback)(request->callback_ctx, NULL, NULL); |
802 |
|
rem_request(request); |
803 |
|
} |
804 |
|
#ifdef IPV6 |
835 |
|
* got a PTR response with no name, something bogus is happening |
836 |
|
* don't bother trying again, the client address doesn't resolve |
837 |
|
*/ |
838 |
< |
(*request->query->callback)(request->query->ptr, reply); |
838 |
> |
(*request->callback)(request->callback_ctx, NULL, NULL); |
839 |
|
rem_request(request); |
840 |
|
return; |
841 |
|
} |
847 |
|
*/ |
848 |
|
#ifdef IPV6 |
849 |
|
if (request->addr.ss.ss_family == AF_INET6) |
850 |
< |
gethost_byname_type(request->name, request->query, T_AAAA); |
850 |
> |
gethost_byname_type(request->callback, request->callback_ctx, request->name, T_AAAA); |
851 |
|
else |
852 |
|
#endif |
853 |
< |
gethost_byname_type(request->name, request->query, T_A); |
853 |
> |
gethost_byname_type(request->callback, request->callback_ctx, request->name, T_A); |
854 |
|
rem_request(request); |
855 |
|
} |
856 |
|
else |
858 |
|
/* |
859 |
|
* got a name and address response, client resolved |
860 |
|
*/ |
861 |
< |
reply = make_dnsreply(request); |
860 |
< |
(*request->query->callback)(request->query->ptr, reply); |
861 |
< |
MyFree(reply); |
861 |
> |
(*request->callback)(request->callback_ctx, &request->addr, request->name); |
862 |
|
rem_request(request); |
863 |
|
} |
864 |
|
} |
874 |
|
} |
875 |
|
} |
876 |
|
|
877 |
– |
static struct DNSReply * |
878 |
– |
make_dnsreply(struct reslist *request) |
879 |
– |
{ |
880 |
– |
struct DNSReply *cp; |
881 |
– |
assert(request != 0); |
882 |
– |
|
883 |
– |
cp = (struct DNSReply *)MyMalloc(sizeof(struct DNSReply)); |
884 |
– |
|
885 |
– |
cp->h_name = request->name; |
886 |
– |
memcpy(&cp->addr, &request->addr, sizeof(cp->addr)); |
887 |
– |
return(cp); |
888 |
– |
} |
889 |
– |
|
877 |
|
void |
878 |
|
report_dns_servers(struct Client *source_p) |
879 |
|
{ |
880 |
|
int i; |
881 |
< |
char ipaddr[HOSTIPLEN]; |
881 |
> |
char ipaddr[HOSTIPLEN + 1]; |
882 |
|
|
883 |
|
for (i = 0; i < irc_nscount; i++) |
884 |
|
{ |
885 |
|
irc_getnameinfo((struct sockaddr *)&(irc_nsaddr_list[i]), |
886 |
< |
irc_nsaddr_list[i].ss_len, ipaddr, HOSTIPLEN, NULL, 0, |
887 |
< |
NI_NUMERICHOST); |
886 |
> |
irc_nsaddr_list[i].ss_len, ipaddr, |
887 |
> |
sizeof(ipaddr), NULL, 0, NI_NUMERICHOST); |
888 |
|
sendto_one(source_p, form_str(RPL_STATSALINE), |
889 |
|
me.name, source_p->name, ipaddr); |
890 |
|
} |