diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/Makefile | 4 | ||||
| -rw-r--r-- | src/dns.cpp | 716 | ||||
| -rw-r--r-- | src/dnsqueue.cpp | 248 | ||||
| -rw-r--r-- | src/inspircd.cpp | 35 | ||||
| -rw-r--r-- | src/users.cpp | 1 |
5 files changed, 987 insertions, 17 deletions
diff --git a/src/Makefile b/src/Makefile index 47b7c99bf..adeab47e0 100644 --- a/src/Makefile +++ b/src/Makefile @@ -7,8 +7,8 @@ CC = im a cheezeball -SRC_1 = base.cpp inspircd.cpp inspircd_util.cpp inspircd_io.cpp connection.cpp message.cpp commands.cpp -SRC_2 = dynamic.cpp users.cpp modules.cpp wildcard.cpp servers.cpp channels.cpp mode.cpp xline.cpp inspstring.cpp +SRC_1 = base.cpp inspircd.cpp inspircd_util.cpp inspircd_io.cpp connection.cpp message.cpp commands.cpp dnsqueue.cpp +SRC_2 = dynamic.cpp users.cpp modules.cpp wildcard.cpp servers.cpp channels.cpp mode.cpp xline.cpp inspstring.cpp dns.cpp SRC = $(SRC_1) $(SRC_2) OBJS = $(SRC:.cpp=.o) diff --git a/src/dns.cpp b/src/dns.cpp new file mode 100644 index 000000000..ffde3f2a1 --- /dev/null +++ b/src/dns.cpp @@ -0,0 +1,716 @@ +/* +dns.cpp - based on the dns library Copyright (C) 2002 Ian Gulliver + +This program is free software; you can redistribute it and/or modify +it under the terms of version 2 of the GNU General Public License as +published by the Free Software Foundation. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +*/ + +#define _DNS_C + +#include <string> +#include <stdlib.h> +#include <time.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/time.h> +#include <string.h> +#include <unistd.h> +#include <stdio.h> +#include <errno.h> +#include <fcntl.h> +#include "dns.h" + +static const char tagstring[] = "$Id$"; + +#define max(a,b) (a > b ? a : b) +#define DNS_MAX 8 /* max number of nameservers used */ +#define DNS_CONFIG_FBCK "/etc/resolv.conf" /* fallback config file */ +#define DNS_PORT 53 /* DNS well known port */ +#define DNS_QRY_A 1 /* name to IP address */ +#define DNS_QRY_AAAA 28 /* name to IP6 address */ +#define DNS_QRY_PTR 12 /* IP address to name */ +#define DNS_QRY_MX 15 /* name to MX */ +#define DNS_QRY_TXT 16 /* name to TXT */ +#define DNS_QRY_CNAME 5 + +#define DNS_ALIGN (sizeof(void *) > sizeof(long) ? sizeof(void *) : sizeof(long)) +#define DNS_TRIES 3 +#define RESULTSIZE 1024 +#define min(a,b) (a < b ? a : b) + +static struct in_addr servers4[DNS_MAX]; /* up to DNS_MAX nameservers; populated by dns_init() */ +static int i4; /* actual count of nameservers; set by dns_init() */ + +static int initdone = 0; /* to ensure dns_init() only runs once (on the first call) */ +static int wantclose = 0; +static int lastcreate = -1; + +struct s_connection { /* open DNS query */ + struct s_connection *next; /* next in list */ + unsigned char id[2]; + unsigned int _class; + unsigned int type; + int want_list; + int fd; /* file descriptor returned from sockets */ +}; + +struct s_rr_middle { + unsigned int type; + unsigned int _class; + unsigned long ttl; + unsigned int rdlength; +}; + +#define DNS_POINTER_VALUE 0xc000 + +static s_connection *connection_head = NULL; /* linked list of open DNS queries; populated by dns_add_query(), decimated by dns_getresult_s() */ + +struct s_header { /* DNS query header */ + unsigned char id[2]; + unsigned int flags1; +#define FLAGS1_MASK_QR 0x80 +#define FLAGS1_MASK_OPCODE 0x78 /* bitshift right 3 */ +#define FLAGS1_MASK_AA 0x04 +#define FLAGS1_MASK_TC 0x02 +#define FLAGS1_MASK_RD 0x01 + unsigned int flags2; +#define FLAGS2_MASK_RA 0x80 +#define FLAGS2_MASK_Z 0x70 +#define FLAGS2_MASK_RCODE 0x0f + unsigned int qdcount; + unsigned int ancount; + unsigned int nscount; + unsigned int arcount; + unsigned char payload[512]; /* DNS question, populated by dns_build_query_payload() */ +}; + +void *dns_align(void *inp) { + char *p = (char*)inp; + int offby = ((char *)p - (char *)0) % DNS_ALIGN; + if (offby != 0) + return p + (DNS_ALIGN - offby); + else + return p; +} + +/* + * These little hacks are here to avoid alignment and type sizing issues completely by doing manual copies + */ +void dns_fill_rr(s_rr_middle* rr, const unsigned char *input) { + rr->type = input[0] * 256 + input[1]; + rr->_class = input[2] * 256 + input[3]; + rr->ttl = input[4] * 16777216 + input[5] * 65536 + input[6] * 256 + input[7]; + rr->rdlength = input[8] * 256 + input[9]; +} + +void dns_fill_header(s_header *header, const unsigned char *input, const int l) { + header->id[0] = input[0]; + header->id[1] = input[1]; + header->flags1 = input[2]; + header->flags2 = input[3]; + header->qdcount = input[4] * 256 + input[5]; + header->ancount = input[6] * 256 + input[7]; + header->nscount = input[8] * 256 + input[9]; + header->arcount = input[10] * 256 + input[11]; + memcpy(header->payload,&input[12],l); +} + +void dns_empty_header(unsigned char *output, const s_header *header, const int l) { + output[0] = header->id[0]; + output[1] = header->id[1]; + output[2] = header->flags1; + output[3] = header->flags2; + output[4] = header->qdcount / 256; + output[5] = header->qdcount % 256; + output[6] = header->ancount / 256; + output[7] = header->ancount % 256; + output[8] = header->nscount / 256; + output[9] = header->nscount % 256; + output[10] = header->arcount / 256; + output[11] = header->arcount % 256; + memcpy(&output[12],header->payload,l); +} + +void dns_close(int fd) { /* close query */ + if (fd == lastcreate) { + wantclose = 1; + return; + } + close(fd); + return; +} + +void DNS::dns_init() { /* on first call only: populates servers4 struct with up to DNS_MAX nameserver IP addresses from /etc/resolv.conf */ + FILE *f; + int i; + in_addr addr4; + char buf[1024]; + if (initdone == 1) + return; + i4 = 0; + + initdone = 1; + srand((unsigned int) time(NULL)); + memset(servers4,'\0',sizeof(in_addr) * DNS_MAX); + f = fopen(DNS_CONFIG_FBCK,"r"); + if (f == NULL) + return; + while (fgets(buf,1024,f) != NULL) { + if (strncmp(buf,"nameserver",10) == 0) { + i = 10; + while (buf[i] == ' ' || buf[i] == '\t') + i++; + if (i4 < DNS_MAX) { + if (dns_aton4_s(&buf[i],&addr4) != NULL) + memcpy(&servers4[i4++],&addr4,sizeof(in_addr)); + } + } + } + fclose(f); + +} + +void DNS::dns_init_2(const char* dnsserver) { /* populates servers4 struct with address from the given parameter */ + FILE *f; + int i; + in_addr addr4; + char buf[1024]; + if (initdone == 1) + return; + i4 = 0; + + initdone = 1; + srand((unsigned int) time(NULL)); + memset(servers4,'\0',sizeof(in_addr) * DNS_MAX); + if (dns_aton4_s(dnsserver,&addr4) != NULL) + memcpy(&servers4[i4++],&addr4,sizeof(in_addr)); +} + + +static int dns_send_requests(const s_header *h, const s_connection *s, const int l) { /* send DNS query */ + int i; + sockaddr_in addr4; + unsigned char payload[sizeof(s_header)]; + + dns_empty_header(payload,h,l); + + + for (i = 0; i < i4; i++) { + /* otherwise send via standard ipv4 boringness */ + memset(&addr4,0,sizeof(addr4)); + memcpy(&addr4.sin_addr,&servers4[i],sizeof(addr4.sin_addr)); + addr4.sin_family = AF_INET; + addr4.sin_port = htons(DNS_PORT); + sendto(s->fd, payload, l + 12, 0, (sockaddr *) &addr4, sizeof(addr4)); + } + + return 0; +} + +static s_connection *dns_add_query(s_header *h) { /* build DNS query, add to list */ + s_connection * s; + + s = new s_connection; + + /* set header flags */ + h->id[0] = s->id[0] = rand() % 255; /* verified by dns_getresult_s() */ + h->id[1] = s->id[1] = rand() % 255; + h->flags1 = 0 | FLAGS1_MASK_RD; + h->flags2 = 0; + h->qdcount = 1; + h->ancount = 0; + h->nscount = 0; + h->arcount = 0; + + /* turn off want_list by default */ + s->want_list = 0; + + /* try to create ipv6 or ipv4 socket */ + s->fd = socket(PF_INET, SOCK_DGRAM, 0); + if (s->fd != -1) { + if (fcntl(s->fd, F_SETFL, O_NONBLOCK) != 0) { + close(s->fd); + s->fd = -1; + } + } + if (s->fd != -1) { + sockaddr_in addr; + memset(&addr,0,sizeof(addr)); + addr.sin_family = AF_INET; + addr.sin_port = 0; + addr.sin_addr.s_addr = INADDR_ANY; + if (bind(s->fd,(sockaddr *)&addr,sizeof(addr)) != 0) { + close(s->fd); + s->fd = -1; + } + } + if (s->fd == -1) { + free(s); + return NULL; + } + /* create new connection object, add to linked list */ + s->next = connection_head; + connection_head = s; + + if (wantclose == 1) { + close(lastcreate); + wantclose = 0; + } + lastcreate = s->fd; + return s; +} + +static int dns_build_query_payload(const char * const name, const unsigned short rr, const unsigned short _class, unsigned char * const payload) { + short payloadpos; + const char * tempchr, * tempchr2; + unsigned short l; + + payloadpos = 0; + tempchr2 = name; + + /* split name up into labels, create query */ + while ((tempchr = strchr(tempchr2,'.')) != NULL) { + l = tempchr - tempchr2; + if (payloadpos + l + 1 > 507) + return -1; + payload[payloadpos++] = l; + memcpy(&payload[payloadpos],tempchr2,l); + payloadpos += l; + tempchr2 = &tempchr[1]; + } + l = strlen(tempchr2); + if (l) { + if (payloadpos + l + 2 > 507) + return -1; + payload[payloadpos++] = l; + memcpy(&payload[payloadpos],tempchr2,l); + payloadpos += l; + payload[payloadpos++] = '\0'; + } + if (payloadpos > 508) + return -1; + l = htons(rr); + memcpy(&payload[payloadpos],&l,2); + l = htons(_class); + memcpy(&payload[payloadpos + 2],&l,2); + return payloadpos + 4; +} + +in_addr* DNS::dns_aton4(const char * const ipstring) { /* ascii to numeric: convert string to static 4part IP addr struct */ + in_addr ip; + return dns_aton4_s(ipstring,&ip); +} + +in_addr* DNS::dns_aton4_r(const char *ipstring) { /* ascii to numeric (reentrant): convert string to new 4part IP addr struct */ + in_addr* ip; + ip = new in_addr; + if(dns_aton4_s(ipstring,ip) == NULL) { + free(ip); + return NULL; + } + return ip; +} + +in_addr* DNS::dns_aton4_s(const char *ipstring, in_addr *ip) { /* ascii to numeric (buffered): convert string to given 4part IP addr struct */ + unsigned char *myip; + int i,part = 0; + myip = (unsigned char *)ip; + + memset(myip,'\0',4); + for (i = 0; i < 16; i++) { + switch (ipstring[i]) { + case '\0': + if (part != 3) + return NULL; + return ip; + break; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (myip[part] > 25) + return NULL; + myip[part] *= 10; + if (myip[part] == 250 && ipstring[i] - '0' > 6) + return NULL; + myip[part] += ipstring[i] - '0'; + break; + case '.': + if (part == 3) + return ip; + else + part++; + break; + default: + if (part == 3) + return ip; + else + return NULL; + break; + } + } + if (part == 3) + return ip; + else + return NULL; +} + +int DNS::dns_getip4(const char *name) { /* build, add and send A query; retrieve result with dns_getresult() */ + s_header h; + s_connection *s; + int l; + + dns_init(); + + + l = dns_build_query_payload(name,DNS_QRY_A,1,(unsigned char *)&h.payload); + if (l == -1) + return -1; + s = dns_add_query(&h); + if (s == NULL) + return -1; + s->_class = 1; + s->type = DNS_QRY_A; + if (dns_send_requests(&h,s,l) == -1) + return -1; + + return s->fd; +} + +int DNS::dns_getip4list(const char *name) { /* build, add and send A query; retrieve result with dns_getresult() */ + s_header h; + s_connection *s; + int l; + + dns_init(); + + + l = dns_build_query_payload(name,DNS_QRY_A,1,(unsigned char *)&h.payload); + if (l == -1) + return -1; + s = dns_add_query(&h); + if (s == NULL) + return -1; + s->_class = 1; + s->type = DNS_QRY_A; + s->want_list = 1; + if (dns_send_requests(&h,s,l) == -1) + return -1; + + return s->fd; +} + +int DNS::dns_getname4(const in_addr *ip) { /* build, add and send PTR query; retrieve result with dns_getresult() */ + char query[512]; + s_header h; + s_connection * s; + unsigned char *c; + int l; + + dns_init(); + + c = (unsigned char *)&ip->s_addr; + + sprintf(query,"%d.%d.%d.%d.in-addr.arpa",c[3],c[2],c[1],c[0]); + + l = dns_build_query_payload(query,DNS_QRY_PTR,1,(unsigned char *)&h.payload); + if (l == -1) + return -1; + s = dns_add_query(&h); + if (s == NULL) + return -1; + s->_class = 1; + s->type = DNS_QRY_PTR; + if (dns_send_requests(&h,s,l) == -1) + return -1; + + return s->fd; +} + +char* DNS::dns_ntoa4(const in_addr * const ip) { /* numeric to ascii: convert 4part IP addr struct to static string */ + static char result[256]; + return dns_ntoa4_s(ip,result); +} + +char* DNS::dns_ntoa4_r(const in_addr *ip) { /* numeric to ascii (reentrant): convert 4part IP addr struct to new string */ + char *result; + result = new char[256]; + return dns_ntoa4_s(ip,result); +} + +char* DNS::dns_ntoa4_s(const in_addr *ip, char *result) { /* numeric to ascii (buffered): convert 4part IP addr struct to given string */ + unsigned char *m; + m = (unsigned char *)&ip->s_addr; + sprintf(result,"%d.%d.%d.%d",m[0],m[1],m[2],m[3]); + return result; +} + +char* DNS::dns_getresult(const int fd) { /* retrieve result of DNS query */ + static char result[RESULTSIZE]; + return dns_getresult_s(fd,result); +} + +char* DNS::dns_getresult_r(const int fd) { /* retrieve result of DNS query (reentrant) */ + char *result; + result = new char[RESULTSIZE]; + if(dns_getresult_s(fd,result) == NULL) { + free(result); + return NULL; + } + return result; +} + +char* DNS::dns_getresult_s(const int fd, char *result) { /* retrieve result of DNS query (buffered) */ + s_header h; + s_connection *c, *prev; + int l,i,q,curanswer,o; + s_rr_middle rr; + unsigned char buffer[sizeof(s_header)]; + unsigned short p; + + prev = NULL; + c = connection_head; + while (c != NULL) { /* find query in list of open queries */ + if (c->fd == fd) + break; + prev = c; + c = c->next; + } + if (c == NULL) { + return NULL; /* query not found */ + } + /* query found-- pull from list: */ + if (prev != NULL) + prev->next = c->next; + else + connection_head = c->next; + + l = recv(c->fd,buffer,sizeof(s_header),0); + dns_close(c->fd); + if (l < 12) { + free(c); + return NULL; + } + dns_fill_header(&h,buffer,l - 12); + if (c->id[0] != h.id[0] || c->id[1] != h.id[1]) { + free(c); + return NULL; /* ID mismatch */ + } + if ((h.flags1 & FLAGS1_MASK_QR) == 0) { + free(c); + return NULL; + } + if ((h.flags1 & FLAGS1_MASK_OPCODE) != 0) { + free(c); + return NULL; + } + if ((h.flags2 & FLAGS2_MASK_RCODE) != 0) { + free(c); + return NULL; + } + if (h.ancount < 1) { /* no sense going on if we don't have any answers */ + free(c); + return NULL; + } + /* skip queries */ + i = 0; + q = 0; + l -= 12; + while (q < h.qdcount && i < l) { + if (h.payload[i] > 63) { /* pointer */ + i += 6; /* skip pointer, _class and type */ + q++; + } else { /* label */ + if (h.payload[i] == 0) { + q++; + i += 5; /* skip nil, _class and type */ + } else + i += h.payload[i] + 1; /* skip length and label */ + } + } + /* &h.payload[i] should now be the start of the first response */ + curanswer = 0; + while (curanswer < h.ancount) { + q = 0; + while (q == 0 && i < l) { + if (h.payload[i] > 63) { /* pointer */ + i += 2; /* skip pointer */ + q = 1; + } else { /* label */ + if (h.payload[i] == 0) { + i++; + q = 1; + } else + i += h.payload[i] + 1; /* skip length and label */ + } + } + if (l - i < 10) { + free(c); + return NULL; + } + dns_fill_rr(&rr,&h.payload[i]); + i += 10; + if (rr.type != c->type) { + curanswer++; + i += rr.rdlength; + continue; + } + if (rr._class != c->_class) { + curanswer++; + i += rr.rdlength; + continue; + } + break; + } + if (curanswer == h.ancount) + return NULL; + if (i + rr.rdlength > l) + return NULL; + if (rr.rdlength > 1023) + return NULL; + + switch (rr.type) { + case DNS_QRY_PTR: + o = 0; + q = 0; + while (q == 0 && i < l && o + 256 < 1023) { + if (h.payload[i] > 63) { /* pointer */ + memcpy(&p,&h.payload[i],2); + i = ntohs(p) - DNS_POINTER_VALUE - 12; + } else { /* label */ + if (h.payload[i] == 0) + q = 1; + else { + result[o] = '\0'; + if (o != 0) + result[o++] = '.'; + memcpy(&result[o],&h.payload[i + 1],h.payload[i]); + o += h.payload[i]; + i += h.payload[i] + 1; + } + } + } + result[o] = '\0'; + break; + case DNS_QRY_A: + if (c->want_list) { + dns_ip4list *alist = (dns_ip4list *) result; /* we have to trust that this is aligned */ + while ((char *)alist - (char *)result < 700) { + if (rr.type != DNS_QRY_A) + break; + if (rr._class != 1) + break; + if (rr.rdlength != 4) { + free(c); + return NULL; + } + memcpy(&alist->ip,&h.payload[i],4); + if (++curanswer >= h.ancount) + break; + i += rr.rdlength; + { + /* skip next name */ + q = 0; + while (q == 0 && i < l) { + if (h.payload[i] > 63) { /* pointer */ + i += 2; /* skip pointer */ + q = 1; + } else { /* label */ + if (h.payload[i] == 0) { + i++; + q = 1; + } else + i += h.payload[i] + 1; /* skip length and label */ + } + } + } + if (l - i < 10) { + free(c); + return NULL; + } + dns_fill_rr(&rr,&h.payload[i]); + i += 10; + alist->next = (dns_ip4list *) dns_align(((char *) alist) + sizeof(dns_ip4list)); + alist = alist->next; + alist->next = NULL; + } + alist->next = NULL; + break; + } + goto defaultcase; + break; + default: + defaultcase: + memcpy(result,&h.payload[i],rr.rdlength); + result[rr.rdlength] = '\0'; + break; + } + free(c); + return result; +} + +DNS::DNS() +{ + dns_init(); +} + +DNS::DNS(std::string dnsserver) +{ + dns_init_2(dnsserver.c_str()); +} + +DNS::~DNS() +{ +} + +bool DNS::ReverseLookup(std::string ip) +{ + binip = dns_aton4(ip.c_str()); + if (binip == NULL) { + fprintf(stderr,"invalid IP address.\n"); + return 2; + } + this->fd = dns_getname4(binip); +} + +bool DNS::ForwardLookup(std::string host) +{ +} + +bool DNS::HasResult() +{ + fd_set fds; + FD_ZERO(&fds); + FD_SET(this->fd,&fds); + timeval tvs; + tvs.tv_usec = 0; + tvs.tv_sec = 0; + int result = select(this->fd+1, &fds, NULL, NULL, &tvs); + return (result > 0); +} + +std::string DNS::GetResult() +{ + result = dns_getresult(this->fd); + if (result) { + return result; + } else { + return ""; + } +} diff --git a/src/dnsqueue.cpp b/src/dnsqueue.cpp new file mode 100644 index 000000000..ac521f091 --- /dev/null +++ b/src/dnsqueue.cpp @@ -0,0 +1,248 @@ +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * Inspire is copyright (C) 2002-2004 ChatSpike-Dev. + * E-mail: + * <brain@chatspike.net> + * <Craig@chatspike.net> + * + * Written by Craig Edwards, Craig McLure, and others. + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +/* Now with added unF! ;) */ + +using namespace std; + +#include "inspircd.h" +#include "inspircd_io.h" +#include "inspircd_util.h" +#include "inspircd_config.h" +#include <unistd.h> +#include <fcntl.h> +#include <sys/errno.h> +#include <sys/ioctl.h> +#include <sys/utsname.h> +#include <cstdio> +#include <time.h> +#include <string> +#ifdef GCC3 +#include <ext/hash_map> +#else +#include <hash_map> +#endif +#include <map> +#include <sstream> +#include <vector> +#include <errno.h> +#include <deque> +#include <errno.h> +#include <unistd.h> +#include <sched.h> +#include "connection.h" +#include "users.h" +#include "servers.h" +#include "ctables.h" +#include "globals.h" +#include "modules.h" +#include "dynamic.h" +#include "wildcard.h" +#include "message.h" +#include "mode.h" +#include "commands.h" +#include "xline.h" +#include "inspstring.h" +#include "dnsqueue.h" +#include <stdlib.h> +#include <time.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/poll.h> +#include <sys/time.h> +#include <netinet/in.h> +#include <string.h> +#include <unistd.h> +#include <stdio.h> +#include <errno.h> +#include <fcntl.h> +#include "dns.h" + +#ifdef GCC3 +#define nspace __gnu_cxx +#else +#define nspace std +#endif + +extern int MaxWhoResults; + +extern std::vector<Module*> modules; +extern std::vector<std::string> module_names; +extern std::vector<ircd_module*> factory; +extern std::vector<int> fd_reap; + +extern int MODCOUNT; + +namespace nspace +{ +#ifdef GCC34 + template<> struct hash<in_addr> +#else + template<> struct nspace::hash<in_addr> +#endif + { + size_t operator()(const struct in_addr &a) const + { + size_t q; + memcpy(&q,&a,sizeof(size_t)); + return q; + } + }; +#ifdef GCC34 + template<> struct hash<string> +#else + template<> struct nspace::hash<string> +#endif + { + size_t operator()(const string &s) const + { + char a[MAXBUF]; + static struct hash<const char *> strhash; + strlcpy(a,s.c_str(),MAXBUF); + strlower(a); + return strhash(a); + } + }; +} + + +struct StrHashComp +{ + + bool operator()(const string& s1, const string& s2) const + { + char a[MAXBUF],b[MAXBUF]; + strlcpy(a,s1.c_str(),MAXBUF); + strlcpy(b,s2.c_str(),MAXBUF); + return (strcasecmp(a,b) == 0); + } + +}; + +struct InAddr_HashComp +{ + + bool operator()(const in_addr &s1, const in_addr &s2) const + { + size_t q; + size_t p; + + memcpy(&q,&s1,sizeof(size_t)); + memcpy(&p,&s2,sizeof(size_t)); + + return (q == p); + } + +}; + + +typedef nspace::hash_map<std::string, userrec*, nspace::hash<string>, StrHashComp> user_hash; +typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, StrHashComp> chan_hash; +typedef nspace::hash_map<in_addr,string*, nspace::hash<in_addr>, InAddr_HashComp> address_cache; +typedef std::deque<command_t> command_table; + +extern user_hash clientlist; +extern chan_hash chanlist; +extern user_hash whowas; +extern command_table cmdlist; +extern address_cache IP; + +extern ClassVector Classes; + +extern char DNSServer[MAXBUF]; + +class Lookup { +private: + DNS* resolver; + userrec* u; +public: + Lookup() + { + u = NULL; + resolver = NULL; + } + + ~Lookup() + { + if (resolver) + delete resolver; + } + + Lookup(userrec* user) + { + u = user; + log(DEBUG,"New Lookup class with DNSServer set to '%s'",DNSServer); + resolver = new DNS(std::string(DNSServer)); + resolver->ReverseLookup(std::string(user->host)); + } + + bool Done() + { + if (resolver->HasResult()) + { + log(DEBUG,"DNS Result available!"); + std::string hostname = resolver->GetResult(); + if (u) + { + log(DEBUG,"Applying hostname lookup to %s: %s",u->nick,hostname.c_str()); + if (hostname != "") + strlcpy(u->host,hostname.c_str(),MAXBUF); + u->dns_done = true; + return true; + } + } + return false; + } + + int GetFD() + { + if (u) + { + return u->fd; + } + else return 0; + } +}; + +typedef std::vector<Lookup> dns_queue; + +dns_queue dnsq; + +bool lookup_dns(userrec* u) +{ + // place a new user into the queue... + log(DEBUG,"Queueing DNS lookup for %s",u->nick); + Lookup L(u); + dnsq.push_back(L); + return true; +} + +void dns_poll() +{ + // do we have items in the queue? + if (dnsq.size()) + { + log(DEBUG,"DNS items pending..."); + // are any ready, or stale? + if (dnsq[0].Done() || (!dnsq[0].GetFD())) + { + // if they are take them out... + log(DEBUG,"****** DNS lookup for fd %d is complete. ******",dnsq[0].GetFD()); + dnsq.erase(dnsq.begin()); + } + } +} + diff --git a/src/inspircd.cpp b/src/inspircd.cpp index 6fd3ab500..491c67cd2 100644 --- a/src/inspircd.cpp +++ b/src/inspircd.cpp @@ -56,6 +56,7 @@ using namespace std; #include "commands.h" #include "xline.h" #include "inspstring.h" +#include "dnsqueue.h" #ifdef GCC3 #define nspace __gnu_cxx @@ -77,6 +78,7 @@ char rules[MAXBUF]; char list[MAXBUF]; char PrefixQuit[MAXBUF]; char DieValue[MAXBUF]; +char DNSServer[MAXBUF]; int debugging = 0; int WHOWAS_STALE = 48; // default WHOWAS Entries last 2 days before they go 'stale' int WHOWAS_MAX = 100; // default 100 people maximum in the WHOWAS list @@ -369,6 +371,7 @@ void ReadConfig(bool bail, userrec* user) ConfValue("options","allowhalfop",0,AH,&config_f); ConfValue("options","allowprotect",0,AP,&config_f); ConfValue("options","allowfounder",0,AF,&config_f); + ConfValue("dns","server",0,DNSServer,&config_f); NetBufferSize = atoi(NB); MaxWhoResults = atoi(MW); AllowHalfop = ((!strcasecmp(AH,"true")) || (!strcasecmp(AH,"1")) || (!strcasecmp(AH,"yes"))); @@ -2211,6 +2214,8 @@ void AddClient(int socket, char* host, int port, bool iscached, char* ip) WriteServ(socket,"NOTICE Auth :Looking up your hostname..."); } + lookup_dns(clientlist[tempnick]); + // set the registration timeout for this user unsigned long class_regtimeout = 90; for (ClassVector::iterator i = Classes.begin(); i != Classes.end(); i++) @@ -3401,6 +3406,9 @@ int InspIRCd(void) timeval tval; FD_ZERO(&sfd); + // poll dns queue + dns_poll(); + user_hash::iterator count2 = clientlist.begin(); // *FIX* Instead of closing sockets in kill_link when they receive the ERROR :blah line, we should queue @@ -3690,26 +3698,23 @@ int InspIRCd(void) length = sizeof (client); incomingSockfd = accept (openSockfd[count], (struct sockaddr *) &client, &length); - address_cache::iterator iter = IP.find(client.sin_addr); + //address_cache::iterator iter = IP.find(client.sin_addr); bool iscached = false; - if (iter == IP.end()) - { + //if (iter == IP.end()) + //{ /* ip isn't in cache, add it */ strlcpy (target, (char *) inet_ntoa (client.sin_addr), MAXBUF); - if(CleanAndResolve(resolved, target) != TRUE) - { - strlcpy(resolved,target,MAXBUF); - } + strlcpy (resolved, target, MAXBUF); /* hostname now in 'target' */ - IP[client.sin_addr] = new string(resolved); + //IP[client.sin_addr] = new string(resolved); /* hostname in cache */ - } - else - { - /* found ip (cached) */ - strlcpy(resolved, iter->second->c_str(), MAXBUF); - iscached = true; - } + //} + //else + //{ + // /* found ip (cached) */ + // strlcpy(resolved, iter->second->c_str(), MAXBUF); + // iscached = true; + //} if (incomingSockfd < 0) { diff --git a/src/users.cpp b/src/users.cpp index 9b97eff05..9f82a04d6 100644 --- a/src/users.cpp +++ b/src/users.cpp @@ -41,6 +41,7 @@ userrec::userrec() fd = lastping = signon = idle_lastmsg = nping = registered = 0; flood = port = bytes_in = bytes_out = cmds_in = cmds_out = 0; haspassed = false; + dns_done = false; strcpy(result,""); for (int i = 0; i < MAXCHANS; i++) { |