2 dns.cpp - based on the firedns library Copyright (C) 2002 Ian Gulliver
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of version 2 of the GNU General Public License as
6 published by the Free Software Foundation.
8 This program is distributed in the hope that it will be useful,
9 but WITHOUT ANY WARRANTY; without even the implied warranty of
10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 GNU General Public License for more details.
13 You should have received a copy of the GNU General Public License
14 along with this program; if not, write to the Free Software
15 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 #include <sys/types.h>
26 #include <sys/socket.h>
34 #include <sys/types.h>
35 #include <sys/socket.h>
36 #include <netinet/in.h>
37 #include <arpa/inet.h>
40 #include "helperfuncs.h"
41 #include "socketengine.h"
43 extern InspIRCd* ServerInstance;
44 extern ServerConfig* Config;
46 #define max(a,b) (a > b ? a : b)
47 #define DNS_MAX 8 /* max number of nameservers used */
48 #define DNS_CONFIG_FBCK "/etc/resolv.conf" /* fallback config file */
49 #define DNS_PORT 53 /* DNS well known port */
50 #define DNS_QRY_A 1 /* name to IP address */
51 #define DNS_QRY_AAAA 28 /* name to IP6 address */
52 #define DNS_QRY_PTR 12 /* IP address to name */
53 #define DNS_QRY_MX 15 /* name to MX */
54 #define DNS_QRY_TXT 16 /* name to TXT */
55 #define DNS_QRY_CNAME 5
57 #define DNS_ALIGN (sizeof(void *) > sizeof(long) ? sizeof(void *) : sizeof(long))
59 #define RESULTSIZE 1024
60 #define min(a,b) (a < b ? a : b)
62 static struct in_addr servers4[DNS_MAX]; /* up to DNS_MAX nameservers; populated by dns_init() */
63 static int i4; /* actual count of nameservers; set by dns_init() */
65 static int initdone = 0; /* to ensure dns_init() only runs once (on the first call) */
66 static int wantclose = 0;
67 static int lastcreate = -1;
69 struct s_connection { /* open DNS query */
70 struct s_connection *next; /* next in list */
75 int fd; /* file descriptor returned from sockets */
82 unsigned int rdlength;
85 #define DNS_POINTER_VALUE 0xc000
87 static s_connection *connection_head = NULL; /* linked list of open DNS queries; populated by dns_add_query(), decimated by dns_getresult_s() */
89 struct s_header { /* DNS query header */
92 #define FLAGS1_MASK_QR 0x80
93 #define FLAGS1_MASK_OPCODE 0x78 /* bitshift right 3 */
94 #define FLAGS1_MASK_AA 0x04
95 #define FLAGS1_MASK_TC 0x02
96 #define FLAGS1_MASK_RD 0x01
98 #define FLAGS2_MASK_RA 0x80
99 #define FLAGS2_MASK_Z 0x70
100 #define FLAGS2_MASK_RCODE 0x0f
101 unsigned int qdcount;
102 unsigned int ancount;
103 unsigned int nscount;
104 unsigned int arcount;
105 unsigned char payload[512]; /* DNS question, populated by dns_build_query_payload() */
110 void *dns_align(void *inp) {
111 char *p = (char*)inp;
112 int offby = ((char *)p - (char *)0) % DNS_ALIGN;
114 return p + (DNS_ALIGN - offby);
120 * These little hacks are here to avoid alignment and type sizing issues completely by doing manual copies
122 void dns_fill_rr(s_rr_middle* rr, const unsigned char *input) {
123 rr->type = input[0] * 256 + input[1];
124 rr->_class = input[2] * 256 + input[3];
125 rr->ttl = input[4] * 16777216 + input[5] * 65536 + input[6] * 256 + input[7];
126 rr->rdlength = input[8] * 256 + input[9];
129 void dns_fill_header(s_header *header, const unsigned char *input, const int l) {
130 header->id[0] = input[0];
131 header->id[1] = input[1];
132 header->flags1 = input[2];
133 header->flags2 = input[3];
134 header->qdcount = input[4] * 256 + input[5];
135 header->ancount = input[6] * 256 + input[7];
136 header->nscount = input[8] * 256 + input[9];
137 header->arcount = input[10] * 256 + input[11];
138 memcpy(header->payload,&input[12],l);
141 void dns_empty_header(unsigned char *output, const s_header *header, const int l) {
142 output[0] = header->id[0];
143 output[1] = header->id[1];
144 output[2] = header->flags1;
145 output[3] = header->flags2;
146 output[4] = header->qdcount / 256;
147 output[5] = header->qdcount % 256;
148 output[6] = header->ancount / 256;
149 output[7] = header->ancount % 256;
150 output[8] = header->nscount / 256;
151 output[9] = header->nscount % 256;
152 output[10] = header->arcount / 256;
153 output[11] = header->arcount % 256;
154 memcpy(&output[12],header->payload,l);
157 void dns_close(int fd) { /* close query */
159 ServerInstance->SE->DelFd(fd);
161 log(DEBUG,"DNS: dns_close on fd %d",fd);
162 if (fd == lastcreate) {
171 void DNS::dns_init() { /* on first call only: populates servers4 struct with up to DNS_MAX nameserver IP addresses from /etc/resolv.conf */
181 srand((unsigned int) TIME);
182 memset(servers4,'\0',sizeof(in_addr) * DNS_MAX);
183 f = fopen(DNS_CONFIG_FBCK,"r");
186 while (fgets(buf,1024,f) != NULL) {
187 if (strncmp(buf,"nameserver",10) == 0) {
189 while (buf[i] == ' ' || buf[i] == '\t')
192 if (dns_aton4_s(&buf[i],&addr4) != NULL)
193 memcpy(&servers4[i4++],&addr4,sizeof(in_addr));
200 void DNS::dns_init_2(const char* dnsserver)
204 srand((unsigned int) TIME);
205 memset(servers4,'\0',sizeof(in_addr) * DNS_MAX);
206 if (dns_aton4_s(dnsserver,&addr4) != NULL)
207 memcpy(&servers4[i4++],&addr4,sizeof(in_addr));
211 static int dns_send_requests(const s_header *h, const s_connection *s, const int l)
215 unsigned char payload[sizeof(s_header)];
217 dns_empty_header(payload,h,l);
222 /* otherwise send via standard ipv4 boringness */
223 memset(&addr4,0,sizeof(addr4));
224 memcpy(&addr4.sin_addr,&servers4[i],sizeof(addr4.sin_addr));
225 addr4.sin_family = AF_INET;
226 addr4.sin_port = htons(DNS_PORT);
227 if (sendto(s->fd, payload, l + 12, 0, (sockaddr *) &addr4, sizeof(addr4)) == -1)
235 static s_connection *dns_add_query(s_header *h) { /* build DNS query, add to list */
238 s = new s_connection;
240 /* set header flags */
241 h->id[0] = s->id[0] = rand() % 255; /* verified by dns_getresult_s() */
242 h->id[1] = s->id[1] = rand() % 255;
243 h->flags1 = 0 | FLAGS1_MASK_RD;
250 /* turn off want_list by default */
253 /* try to create ipv6 or ipv4 socket */
254 s->fd = socket(PF_INET, SOCK_DGRAM, 0);
256 if (fcntl(s->fd, F_SETFL, O_NONBLOCK) != 0) {
264 memset(&addr,0,sizeof(addr));
265 addr.sin_family = AF_INET;
267 addr.sin_addr.s_addr = INADDR_ANY;
268 if (bind(s->fd,(sockaddr *)&addr,sizeof(addr)) != 0) {
278 /* create new connection object, add to linked list */
279 s->next = connection_head;
282 if (wantclose == 1) {
283 shutdown(lastcreate,2);
291 static int dns_build_query_payload(const char * const name, const unsigned short rr, const unsigned short _class, unsigned char * const payload) {
293 const char * tempchr, * tempchr2;
299 /* split name up into labels, create query */
300 while ((tempchr = strchr(tempchr2,'.')) != NULL) {
301 l = tempchr - tempchr2;
302 if (payloadpos + l + 1 > 507)
304 payload[payloadpos++] = l;
305 memcpy(&payload[payloadpos],tempchr2,l);
307 tempchr2 = &tempchr[1];
309 l = strlen(tempchr2);
311 if (payloadpos + l + 2 > 507)
313 payload[payloadpos++] = l;
314 memcpy(&payload[payloadpos],tempchr2,l);
316 payload[payloadpos++] = '\0';
318 if (payloadpos > 508)
321 memcpy(&payload[payloadpos],&l,2);
323 memcpy(&payload[payloadpos + 2],&l,2);
324 return payloadpos + 4;
327 in_addr* DNS::dns_aton4(const char * const ipstring) { /* ascii to numeric: convert string to static 4part IP addr struct */
329 return dns_aton4_s(ipstring,&ip);
332 in_addr* DNS::dns_aton4_r(const char *ipstring) { /* ascii to numeric (reentrant): convert string to new 4part IP addr struct */
335 if(dns_aton4_s(ipstring,ip) == NULL) {
342 in_addr* DNS::dns_aton4_s(const char *ipstring, in_addr *ip) { /* ascii to numeric (buffered): convert string to given 4part IP addr struct */
343 inet_aton(ipstring,ip);
347 int DNS::dns_getip4(const char *name) { /* build, add and send A query; retrieve result with dns_getresult() */
355 l = dns_build_query_payload(name,DNS_QRY_A,1,(unsigned char *)&h.payload);
358 s = dns_add_query(&h);
363 if (dns_send_requests(&h,s,l) == -1)
369 int DNS::dns_getip4list(const char *name) { /* build, add and send A query; retrieve result with dns_getresult() */
377 l = dns_build_query_payload(name,DNS_QRY_A,1,(unsigned char *)&h.payload);
380 s = dns_add_query(&h);
386 if (dns_send_requests(&h,s,l) == -1)
392 int DNS::dns_getname4(const in_addr *ip) { /* build, add and send PTR query; retrieve result with dns_getresult() */
399 c = (unsigned char *)&ip->s_addr;
401 sprintf(query,"%d.%d.%d.%d.in-addr.arpa",c[3],c[2],c[1],c[0]);
403 l = dns_build_query_payload(query,DNS_QRY_PTR,1,(unsigned char *)&h.payload);
406 s = dns_add_query(&h);
410 s->type = DNS_QRY_PTR;
411 if (dns_send_requests(&h,s,l) == -1)
417 char* DNS::dns_ntoa4(const in_addr * const ip) { /* numeric to ascii: convert 4part IP addr struct to static string */
419 return dns_ntoa4_s(ip,r);
422 char* DNS::dns_ntoa4_s(const in_addr *ip, char *r) { /* numeric to ascii (buffered): convert 4part IP addr struct to given string */
424 m = (unsigned char *)&ip->s_addr;
425 sprintf(r,"%d.%d.%d.%d",m[0],m[1],m[2],m[3]);
429 char* DNS::dns_getresult(const int cfd) { /* retrieve result of DNS query */
430 log(DEBUG,"DNS: dns_getresult with cfd=%d",cfd);
431 return dns_getresult_s(cfd,this->localbuf);
434 char* DNS::dns_getresult_s(const int cfd, char *res) { /* retrieve result of DNS query (buffered) */
436 s_connection *c, *prev;
437 int l,i,q,curanswer,o;
439 unsigned char buffer[sizeof(s_header)];
449 while (c != NULL) { /* find query in list of open queries */
456 log(DEBUG,"DNS: got a response for a query we didnt send with fd=%d",cfd);
457 return NULL; /* query not found */
459 /* query found-- pull from list: */
461 prev->next = c->next;
463 connection_head = c->next;
465 l = recv(c->fd,buffer,sizeof(s_header),0);
471 dns_fill_header(&h,buffer,l - 12);
472 if (c->id[0] != h.id[0] || c->id[1] != h.id[1]) {
473 log(DEBUG,"DNS: id mismatch on query");
475 return NULL; /* ID mismatch */
477 if ((h.flags1 & FLAGS1_MASK_QR) == 0) {
478 log(DEBUG,"DNS: didnt get a query result");
482 if ((h.flags1 & FLAGS1_MASK_OPCODE) != 0) {
483 log(DEBUG,"DNS: got an OPCODE and didnt want one");
487 if ((h.flags2 & FLAGS2_MASK_RCODE) != 0) {
488 log(DEBUG,"DNS lookup failed due to SERVFAIL");
492 if (h.ancount < 1) { /* no sense going on if we don't have any answers */
493 log(DEBUG,"DNS: no answers!");
501 while ((unsigned)q < h.qdcount && i < l) {
502 if (h.payload[i] > 63) { /* pointer */
503 i += 6; /* skip pointer, _class and type */
506 if (h.payload[i] == 0) {
508 i += 5; /* skip nil, _class and type */
510 i += h.payload[i] + 1; /* skip length and label */
513 /* &h.payload[i] should now be the start of the first response */
515 while ((unsigned)curanswer < h.ancount) {
517 while (q == 0 && i < l) {
518 if (h.payload[i] > 63) { /* pointer */
519 i += 2; /* skip pointer */
522 if (h.payload[i] == 0) {
526 i += h.payload[i] + 1; /* skip length and label */
533 dns_fill_rr(&rr,&h.payload[i]);
535 if (rr.type != c->type) {
540 if (rr._class != c->_class) {
547 if ((unsigned)curanswer == h.ancount)
549 if ((unsigned)i + rr.rdlength > (unsigned)l)
551 if (rr.rdlength > 1023)
556 log(DEBUG,"DNS: got a result of type DNS_QRY_PTR");
559 while (q == 0 && i < l && o + 256 < 1023) {
560 if (h.payload[i] > 63) { /* pointer */
561 memcpy(&p,&h.payload[i],2);
562 i = ntohs(p) - DNS_POINTER_VALUE - 12;
564 if (h.payload[i] == 0)
570 memcpy(&res[o],&h.payload[i + 1],h.payload[i]);
572 i += h.payload[i] + 1;
579 log(DEBUG,"DNS: got a result of type DNS_QRY_A");
581 dns_ip4list *alist = (dns_ip4list *) res; /* we have to trust that this is aligned */
582 while ((char *)alist - (char *)res < 700) {
583 if (rr.type != DNS_QRY_A)
587 if (rr.rdlength != 4) {
591 memcpy(&alist->ip,&h.payload[i],4);
592 if ((unsigned)++curanswer >= h.ancount)
598 while (q == 0 && i < l) {
599 if (h.payload[i] > 63) { /* pointer */
600 i += 2; /* skip pointer */
603 if (h.payload[i] == 0) {
607 i += h.payload[i] + 1; /* skip length and label */
615 dns_fill_rr(&rr,&h.payload[i]);
617 alist->next = (dns_ip4list *) dns_align(((char *) alist) + sizeof(dns_ip4list));
628 log(DEBUG,"DNS: doing something with result 'default'");
629 memcpy(res,&h.payload[i],rr.rdlength);
630 res[rr.rdlength] = '\0';
640 log(DEBUG,"Create blank DNS");
643 DNS::DNS(std::string dnsserver)
645 dns_init_2(dnsserver.c_str());
646 log(DEBUG,"Create DNS");
649 void DNS::SetNS(std::string dnsserver)
651 dns_init_2(dnsserver.c_str());
659 bool DNS::ReverseLookup(std::string ip)
661 ServerInstance->stats->statsDns++;
662 binip = dns_aton4(ip.c_str());
667 this->myfd = dns_getname4(binip);
668 if (this->myfd == -1)
672 log(DEBUG,"DNS: ReverseLookup, fd=%d",this->myfd);
674 ServerInstance->SE->AddFd(this->myfd,true,X_ESTAB_DNS);
679 bool DNS::ForwardLookup(std::string host)
681 ServerInstance->stats->statsDns++;
682 this->myfd = dns_getip4(host.c_str());
683 if (this->myfd == -1)
687 log(DEBUG,"DNS: ForwardLookup, fd=%d",this->myfd);
689 ServerInstance->SE->AddFd(this->myfd,true,X_ESTAB_DNS);
694 bool DNS::HasResult(int fd)
696 return (fd == this->myfd);
699 /* Only the multithreaded dns uses this poll() based
700 * check now. As its in another thread we dont have
701 * to worry about its performance that much.
703 bool DNS::HasResult()
705 log(DEBUG,"DNS: HasResult, fd=%d",this->myfd);
707 polls.fd = this->myfd;
708 polls.events = POLLIN;
709 int ret = poll(&polls,1,1);
710 log(DEBUG,"DNS: Hasresult returning %d",ret);
719 std::string DNS::GetResult()
721 log(DEBUG,"DNS: GetResult()");
722 result = dns_getresult(this->myfd);
724 ServerInstance->stats->statsDnsGood++;
725 dns_close(this->myfd);
728 ServerInstance->stats->statsDnsBad++;
729 if (this->myfd != -1)
731 dns_close(this->myfd);
737 std::string DNS::GetResultIP()
740 log(DEBUG,"DNS: GetResultIP()");
741 result = dns_getresult(this->myfd);
742 if (this->myfd != -1)
744 dns_close(this->myfd);
748 ServerInstance->stats->statsDnsGood++;
749 unsigned char a = (unsigned)result[0];
750 unsigned char b = (unsigned)result[1];
751 unsigned char c = (unsigned)result[2];
752 unsigned char d = (unsigned)result[3];
753 snprintf(r,1024,"%u.%u.%u.%u",a,b,c,d);
758 ServerInstance->stats->statsDnsBad++;
759 log(DEBUG,"DANGER WILL ROBINSON! NXDOMAIN for forward lookup, but we got a reverse lookup!");
767 void* dns_task(void* arg)
769 userrec* u = (userrec*)arg;
770 log(DEBUG,"DNS thread for user %s",u->nick);
775 if (dns1.ReverseLookup(u->ip))
777 while (!dns1.HasResult())
781 host = dns1.GetResult();
784 if (dns2.ForwardLookup(host))
786 while (!dns2.HasResult())
790 ip = dns2.GetResultIP();
791 if (ip == std::string(u->ip))
793 if (host.length() < 160)
795 strcpy(u->host,host.c_str());
796 strcpy(u->dhost,host.c_str());