ouch/inspircd
2
0
Fork 0
mirror of https://github.com/inspircd/inspircd.git synced 2025-03-10 02:59:01 -04:00
Code Issues Packages Projects Releases Wiki Activity

Added nonblocking dns

Browse Source 
*** BUG BUG BUG - If dns is slow, things will go wrong!!!! do not use this on a live net without accepting the risk involved! ***
Will be fixed by next commit.


git-svn-id: http://svn.inspircd.org/repository/trunk/inspircd@938 e03df62e-2008-0410-955e-edbf42e46eb7
This commit is contained in:
brain 2005-04-01 17:08:31 +00:00
parent f326e475e3
commit ade5e94878
8 changed files with 1058 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
include/dns.h Normal file
View File

@ -0,0 +1,62 @@
/*
dns.h - dns library declarations based on firedns 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
*/
#ifndef _DNS_H
#define _DNS_H
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string>
struct dns_ip4list {
in_addr ip;
dns_ip4list *next;
};
class DNS
{
private:
char *result;
in_addr *binip;
int t,i;
void dns_init();
unsigned int fd;
void dns_init_2(const char* dnsserver);
in_addr *dns_aton4(const char * const ipstring);
char *dns_ntoa4(const in_addr * const ip);
int dns_getip4(const char * const name);
int dns_getip4list(const char * const name);
int dns_getname4(const in_addr * const ip);
char *dns_getresult(const int fd);
in_addr *dns_aton4_s(const char * const ipstring, in_addr * const ip);
char *dns_ntoa4_s(const in_addr * const ip, char * const result);
char *dns_getresult_s(const int fd, char * const result);
in_addr *dns_aton4_r(const char * const ipstring);
char *dns_ntoa4_r(const in_addr * const ip);
char *dns_getresult_r(const int fd);
public:
DNS();
DNS(std::string dnsserver);
~DNS();
bool ReverseLookup(std::string ip);
bool ForwardLookup(std::string host);
bool HasResult();
std::string GetResult();
};
#endif

5
include/dnsqueue.h Normal file
View File

@ -0,0 +1,5 @@
#include "inspircd.h"
#include "users.h"
bool lookup_dns(userrec* u);
void dns_poll();

4
include/users.h
View File

@ -155,6 +155,10 @@ class userrec : public connection
*/
char oper[NICKMAX];
/** True when DNS lookups are completed.
*/
bool dns_done;
userrec();
virtual ~userrec() { }

4
src/Makefile
View File

@ -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)

716
src/dns.cpp Normal file
View File

@ -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 "";
}
}

248
src/dnsqueue.cpp Normal file
View File

@ -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());
}
}
}

35
src/inspircd.cpp
View File

@ -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)
{

1
src/users.cpp
View File

@ -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++)
{