X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fdns.cpp;h=d65ec8c88cc7e31d394ba1709b39a1bb8092aaf0;hb=c80508b28be5947648f59710e6653f793a73bd76;hp=f6bba28daf7a35f53aa7c3bd8280a1925809da47;hpb=c36a817fa143a7919fb8e2c617937f9883fafd4f;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/dns.cpp b/src/dns.cpp index f6bba28da..d65ec8c88 100644 --- a/src/dns.cpp +++ b/src/dns.cpp @@ -49,11 +49,18 @@ using namespace std; #include "dns.h" #include "inspircd.h" #include "helperfuncs.h" +#include "inspircd_config.h" #include "socketengine.h" +#include "configreader.h" + +#ifdef THREADED_DNS +pthread_mutex_t connmap_lock = PTHREAD_MUTEX_INITIALIZER; +#endif extern InspIRCd* ServerInstance; extern ServerConfig* Config; extern time_t TIME; +extern userrec* fd_ref_table[MAX_DESCRIPTORS]; enum QueryType { DNS_QRY_A = 1, DNS_QRY_PTR = 12 }; enum QueryFlags1 { FLAGS1_MASK_RD = 0x01, FLAGS1_MASK_TC = 0x02, FLAGS1_MASK_AA = 0x04, FLAGS1_MASK_OPCODE = 0x78, FLAGS1_MASK_QR = 0x80 }; @@ -65,10 +72,11 @@ typedef std::map connlist; typedef connlist::iterator connlist_iter; connlist connections; -struct in_addr servers4[8]; +Resolver* dns_classes[MAX_DESCRIPTORS]; + +insp_inaddr servers4[8]; int i4; int initdone = 0; -int wantclose = 0; int lastcreate = -1; class s_connection @@ -162,14 +170,10 @@ inline void dns_empty_header(unsigned char *output, const s_header *header, cons void dns_close(int fd) { #ifndef THREADED_DNS - ServerInstance->SE->DelFd(fd); + if (ServerInstance && ServerInstance->SE) + ServerInstance->SE->DelFd(fd); #endif log(DEBUG,"DNS: dns_close on fd %d",fd); - if (fd == lastcreate) - { - wantclose = 1; - return; - } shutdown(fd,2); close(fd); return; @@ -179,7 +183,7 @@ void DNS::dns_init() { FILE *f; int i; - in_addr addr4; + insp_inaddr addr4; char buf[1024]; if (initdone == 1) return; @@ -187,7 +191,7 @@ void DNS::dns_init() initdone = 1; srand((unsigned int) TIME); - memset(servers4,'\0',sizeof(in_addr) * 8); + memset(servers4,'\0',sizeof(insp_inaddr) * 8); f = fopen("/etc/resolv.conf","r"); if (f == NULL) return; @@ -200,7 +204,7 @@ void DNS::dns_init() if (i4 < 8) { if (dns_aton4_s(&buf[i],&addr4) != NULL) - memcpy(&servers4[i4++],&addr4,sizeof(in_addr)); + memcpy(&servers4[i4++],&addr4,sizeof(insp_inaddr)); } } } @@ -209,19 +213,19 @@ void DNS::dns_init() void DNS::dns_init_2(const char* dnsserver) { - in_addr addr4; - i4 = 0; - srand((unsigned int) TIME); - memset(servers4,'\0',sizeof(in_addr) * 8); - if (dns_aton4_s(dnsserver,&addr4) != NULL) - memcpy(&servers4[i4++],&addr4,sizeof(in_addr)); + insp_inaddr addr4; + i4 = 0; + srand((unsigned int) TIME); + memset(servers4,'\0',sizeof(insp_inaddr) * 8); + if (dns_aton4_s(dnsserver,&addr4) != NULL) + memcpy(&servers4[i4++],&addr4,sizeof(insp_inaddr)); } int dns_send_requests(const s_header *h, const s_connection *s, const int l) { int i; - sockaddr_in addr4; + insp_sockaddr addr4; unsigned char payload[sizeof(s_header)]; dns_empty_header(payload,h,l); @@ -270,7 +274,7 @@ s_connection *dns_add_query(s_header *h) } if (s->fd != -1) { - sockaddr_in addr; + insp_sockaddr addr; memset(&addr,0,sizeof(addr)); addr.sin_family = AF_INET; addr.sin_port = 0; @@ -284,20 +288,19 @@ s_connection *dns_add_query(s_header *h) } if (s->fd == -1) { - delete s; + DELETE(s); return NULL; } /* create new connection object, add to linked list */ +#ifdef THREADED_DNS + pthread_mutex_lock(&connmap_lock); +#endif if (connections.find(s->fd) == connections.end()) connections[s->fd] = s; +#ifdef THREADED_DNS + pthread_mutex_unlock(&connmap_lock); +#endif - if (wantclose == 1) - { - shutdown(lastcreate,2); - close(lastcreate); - wantclose = 0; - } - lastcreate = s->fd; return s; } @@ -340,24 +343,24 @@ int dns_build_query_payload(const char * const name, const unsigned short rr, co return payloadpos + 4; } -in_addr* DNS::dns_aton4(const char * const ipstring) +insp_inaddr* DNS::dns_aton4(const char * const ipstring) { - static in_addr ip; + static insp_inaddr 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; +insp_inaddr* DNS::dns_aton4_r(const char *ipstring) { /* ascii to numeric (reentrant): convert string to new 4part IP addr struct */ + insp_inaddr* ip; + ip = new insp_inaddr; if(dns_aton4_s(ipstring,ip) == NULL) { - delete ip; + DELETE(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 */ +insp_inaddr* DNS::dns_aton4_s(const char *ipstring, insp_inaddr *ip) { /* ascii to numeric (buffered): convert string to given 4part IP addr struct */ inet_aton(ipstring,ip); return ip; } @@ -406,7 +409,7 @@ int DNS::dns_getip4list(const char *name) { /* build, add and send A query; retr return s->fd; } -int DNS::dns_getname4(const in_addr *ip) { /* build, add and send PTR query; retrieve result with dns_getresult() */ +int DNS::dns_getname4(const insp_inaddr *ip) { /* build, add and send PTR query; retrieve result with dns_getresult() */ char query[512]; s_header h; s_connection * s; @@ -431,12 +434,12 @@ int DNS::dns_getname4(const in_addr *ip) { /* build, add and send PTR query; ret return s->fd; } -char* DNS::dns_ntoa4(const in_addr * const ip) { /* numeric to ascii: convert 4part IP addr struct to static string */ +char* DNS::dns_ntoa4(const insp_inaddr * const ip) { /* numeric to ascii: convert 4part IP addr struct to static string */ static char r[256]; return dns_ntoa4_s(ip,r); } -char* DNS::dns_ntoa4_s(const in_addr *ip, char *r) { /* numeric to ascii (buffered): convert 4part IP addr struct to given string */ +char* DNS::dns_ntoa4_s(const insp_inaddr *ip, char *r) { /* numeric to ascii (buffered): convert 4part IP addr struct to given string */ unsigned char *m; m = (unsigned char *)&ip->s_addr; sprintf(r,"%d.%d.%d.%d",m[0],m[1],m[2],m[3]); @@ -460,10 +463,21 @@ char* DNS::dns_getresult_s(const int cfd, char *res) { /* retrieve result of DNS *res = 0; /* FireDNS used a linked list for this. How ugly (and slow). */ + +#ifdef THREADED_DNS + /* XXX: STL really does NOT like being poked and prodded in more than + * one orifice by threaded apps. Make sure we remain nice to it, and + * lock a mutex around any access to the std::map. + */ + pthread_mutex_lock(&connmap_lock); +#endif connlist_iter n_iter = connections.find(cfd); if (n_iter == connections.end()) { log(DEBUG,"DNS: got a response for a query we didnt send with fd=%d",cfd); +#ifdef THREADED_DNS + pthread_mutex_unlock(&connmap_lock); +#endif return NULL; } else @@ -473,43 +487,46 @@ char* DNS::dns_getresult_s(const int cfd, char *res) { /* retrieve result of DNS /* We don't delete c here, because its done later when needed */ connections.erase(n_iter); } +#ifdef THREADED_DNS + pthread_mutex_unlock(&connmap_lock); +#endif l = recv(c->fd,buffer,sizeof(s_header),0); dns_close(c->fd); if (l < 12) { - delete c; + DELETE(c); return NULL; } dns_fill_header(&h,buffer,l - 12); if (c->id[0] != h.id[0] || c->id[1] != h.id[1]) { log(DEBUG,"DNS: id mismatch on query"); - delete c; + DELETE(c); return NULL; /* ID mismatch */ } if ((h.flags1 & FLAGS1_MASK_QR) == 0) { log(DEBUG,"DNS: didnt get a query result"); - delete c; + DELETE(c); return NULL; } if ((h.flags1 & FLAGS1_MASK_OPCODE) != 0) { log(DEBUG,"DNS: got an OPCODE and didnt want one"); - delete c; + DELETE(c); return NULL; } if ((h.flags2 & FLAGS2_MASK_RCODE) != 0) { log(DEBUG,"DNS lookup failed due to SERVFAIL"); - delete c; + DELETE(c); return NULL; } if (h.ancount < 1) { log(DEBUG,"DNS: no answers!"); - delete c; + DELETE(c); return NULL; } i = 0; @@ -555,7 +572,7 @@ char* DNS::dns_getresult_s(const int cfd, char *res) { /* retrieve result of DNS } if (l - i < 10) { - delete c; + DELETE(c); return NULL; } dns_fill_rr(&rr,&h.payload[i]); @@ -591,6 +608,7 @@ char* DNS::dns_getresult_s(const int cfd, char *res) { /* retrieve result of DNS { if (h.payload[i] > 63) { + log(DEBUG,"DNS: h.payload[i] > 63"); memcpy(&p,&h.payload[i],2); i = ntohs(p) - 0xC000 - 12; } @@ -626,7 +644,7 @@ char* DNS::dns_getresult_s(const int cfd, char *res) { /* retrieve result of DNS break; if (rr.rdlength != 4) { - delete c; + DELETE(c); return NULL; } memcpy(&alist->ip,&h.payload[i],4); @@ -653,7 +671,7 @@ char* DNS::dns_getresult_s(const int cfd, char *res) { /* retrieve result of DNS } if (l - i < 10) { - delete c; + DELETE(c); return NULL; } dns_fill_rr(&rr,&h.payload[i]); @@ -673,7 +691,7 @@ char* DNS::dns_getresult_s(const int cfd, char *res) { /* retrieve result of DNS res[rr.rdlength] = '\0'; break; } - delete c; + DELETE(c); return res; } @@ -683,13 +701,13 @@ DNS::DNS() log(DEBUG,"Create blank DNS"); } -DNS::DNS(std::string dnsserver) +DNS::DNS(const std::string &dnsserver) { dns_init_2(dnsserver.c_str()); - log(DEBUG,"Create DNS"); + log(DEBUG,"Create DNS with server '%s'",dnsserver.c_str()); } -void DNS::SetNS(std::string dnsserver) +void DNS::SetNS(const std::string &dnsserver) { dns_init_2(dnsserver.c_str()); log(DEBUG,"Set NS"); @@ -699,30 +717,36 @@ DNS::~DNS() { } -bool DNS::ReverseLookup(std::string ip) +bool DNS::ReverseLookup(const std::string &ip, bool ins) { - ServerInstance->stats->statsDns++; - binip = dns_aton4(ip.c_str()); - if (binip == NULL) + if (ServerInstance && ServerInstance->stats) + ServerInstance->stats->statsDns++; + binip = dns_aton4(ip.c_str()); + if (binip == NULL) { - return false; - } + return false; + } - this->myfd = dns_getname4(binip); + this->myfd = dns_getname4(binip); if (this->myfd == -1) { return false; } log(DEBUG,"DNS: ReverseLookup, fd=%d",this->myfd); #ifndef THREADED_DNS - ServerInstance->SE->AddFd(this->myfd,true,X_ESTAB_DNS); + if (ins) + { + if (ServerInstance && ServerInstance->SE) + ServerInstance->SE->AddFd(this->myfd,true,X_ESTAB_DNS); + } #endif return true; } -bool DNS::ForwardLookup(std::string host) +bool DNS::ForwardLookup(const std::string &host, bool ins) { - ServerInstance->stats->statsDns++; + if (ServerInstance && ServerInstance->stats) + ServerInstance->stats->statsDns++; this->myfd = dns_getip4(host.c_str()); if (this->myfd == -1) { @@ -730,11 +754,31 @@ bool DNS::ForwardLookup(std::string host) } log(DEBUG,"DNS: ForwardLookup, fd=%d",this->myfd); #ifndef THREADED_DNS - ServerInstance->SE->AddFd(this->myfd,true,X_ESTAB_DNS); + if (ins) + { + if (ServerInstance && ServerInstance->SE) + ServerInstance->SE->AddFd(this->myfd,true,X_ESTAB_DNS); + } #endif return true; } +bool DNS::ForwardLookupWithFD(const std::string &host, int &fd) +{ + if (ServerInstance && ServerInstance->stats) + ServerInstance->stats->statsDns++; + this->myfd = dns_getip4(host.c_str()); + fd = this->myfd; + if (this->myfd == -1) + { + return false; + } + log(DEBUG,"DNS: ForwardLookupWithFD, fd=%d",this->myfd); + if (ServerInstance && ServerInstance->SE) + ServerInstance->SE->AddFd(this->myfd,true,X_ESTAB_MODULE); + return true; +} + bool DNS::HasResult(int fd) { return (fd == this->myfd); @@ -763,19 +807,23 @@ int DNS::GetFD() std::string DNS::GetResult() { log(DEBUG,"DNS: GetResult()"); - result = dns_getresult(this->myfd); - if (result) + result = dns_getresult(this->myfd); + if (result) { - ServerInstance->stats->statsDnsGood++; + if (ServerInstance && ServerInstance->stats) + ServerInstance->stats->statsDnsGood++; dns_close(this->myfd); + this->myfd = -1; return result; - } + } else { - ServerInstance->stats->statsDnsBad++; + if (ServerInstance && ServerInstance->stats) + ServerInstance->stats->statsDnsBad++; if (this->myfd != -1) { dns_close(this->myfd); + this->myfd = -1; } return ""; } @@ -789,10 +837,12 @@ std::string DNS::GetResultIP() if (this->myfd != -1) { dns_close(this->myfd); + this->myfd = -1; } if (result) { - ServerInstance->stats->statsDnsGood++; + if (ServerInstance && ServerInstance->stats) + ServerInstance->stats->statsDnsGood++; unsigned char a = (unsigned)result[0]; unsigned char b = (unsigned)result[1]; unsigned char c = (unsigned)result[2]; @@ -802,7 +852,8 @@ std::string DNS::GetResultIP() } else { - ServerInstance->stats->statsDnsBad++; + if (ServerInstance && ServerInstance->stats) + ServerInstance->stats->statsDnsBad++; log(DEBUG,"DANGER WILL ROBINSON! NXDOMAIN for forward lookup, but we got a reverse lookup!"); return ""; } @@ -811,42 +862,217 @@ std::string DNS::GetResultIP() #ifdef THREADED_DNS + +/* This function is a thread function which can be thought of as a lightweight process + * to all you non-threaded people. In actuality its so much more, and pretty damn cool. + * With threaded dns enabled, each user which connects gets a thread attached to their + * user record when their DNS lookup starts. This function starts in parallel, and + * commences a blocking dns lookup. Because its a seperate thread, this occurs without + * actually blocking the main application. Once the dns lookup is completed, the thread + * checks if the user is still around by checking their fd against the reference table, + * and if they are, writes the hostname into the struct and terminates, after setting + * userrec::dns_done to true. Because this is multi-threaded it can make proper use of + * SMP setups (like the one i have here *grin*). + * This is in comparison to the non-threaded dns, which must monitor the thread sockets + * in a nonblocking fashion, consuming more resources to do so. + * + * NB: Yes this does scale, thank you. Even with large numbers of connecting clients + * in any one timeframe, they wont all connect *at the same time* therefore any argument + * of "but there will be thousands of threads it'll blow up" is moot, ive tested this and + * there will only ever be somewhere around the listen backlog in number of pending + * lookups at any one time. This is significant on any modern SMP system. + */ void* dns_task(void* arg) { - userrec* u = (userrec*)arg; - log(DEBUG,"DNS thread for user %s",u->nick); - DNS dns1; - DNS dns2; - std::string host; - std::string ip; - if (dns1.ReverseLookup((char*)inet_ntoa(dest->ip4))) - { - while (!dns1.HasResult()) - { - usleep(100); - } - host = dns1.GetResult(); - if (host != "") - { - if (dns2.ForwardLookup(host)) - { - while (!dns2.HasResult()) - { - usleep(100); - } - ip = dns2.GetResultIP(); - if (ip == std::string((char*)inet_ntoa(dest->ip4))) - { - if (host.length() < 160) - { - strcpy(u->host,host.c_str()); - strcpy(u->dhost,host.c_str()); - } - } - } - } - } - u->dns_done = true; - return NULL; + userrec* u = (userrec*)arg; + int thisfd = u->fd; + + log(DEBUG,"DNS thread for user %s",u->nick); + DNS dns1(Config->DNSServer); + DNS dns2(Config->DNSServer); + std::string host; + std::string ip; + int iterations = 0; + + if (dns1.ReverseLookup(inet_ntoa(u->ip4),false)) + { + /* FIX: Dont make these infinite! */ + while ((!dns1.HasResult()) && (++iterations < 20)) + usleep(100); + + if (iterations < 20) + { + if (dns1.GetFD() != -1) + { + host = dns1.GetResult(); + if (host != "") + { + if (dns2.ForwardLookup(host, false)) + { + iterations = 0; + while ((!dns2.HasResult()) && (++iterations < 20)) + usleep(100); + + if (iterations < 20) + { + if (dns2.GetFD() != -1) + { + ip = dns2.GetResultIP(); + if (ip == std::string(inet_ntoa(u->ip4))) + { + if (host.length() < 65) + { + if ((fd_ref_table[thisfd] == u) && (fd_ref_table[thisfd])) + { + if (!u->dns_done) + { + strcpy(u->host,host.c_str()); + if ((fd_ref_table[thisfd] == u) && (fd_ref_table[thisfd])) + { + strcpy(u->dhost,host.c_str()); + } + } + } + } + } + } + } + } + } + } + } + } + if ((fd_ref_table[thisfd] == u) && (fd_ref_table[thisfd])) + u->dns_done = true; + log(DEBUG,"THREAD EXIT"); + return NULL; } #endif + +Resolver::Resolver(const std::string &source, bool forward, const std::string &dnsserver = "") : input(source), fwd(forward), server(dnsserver) +{ + if (this->server != "") + Query.SetNS(this->server); + else + Query.SetNS(Config->DNSServer); + + if (forward) + { + Query.ForwardLookup(input.c_str(), false); + this->fd = Query.GetFD(); + } + else + { + Query.ReverseLookup(input.c_str(), false); + this->fd = Query.GetFD(); + } + if (fd < 0) + { + log(DEBUG,"Resolver::Resolver: RESOLVER_NSDOWN"); + this->OnError(RESOLVER_NSDOWN); + ModuleException e("Resolver: Nameserver is down"); + throw e; + /* We shouldnt get here really */ + return; + } + + if (ServerInstance && ServerInstance->SE) + { + log(DEBUG,"Resolver::Resolver: this->fd=%d",this->fd); + ServerInstance->SE->AddFd(this->fd,true,X_ESTAB_CLASSDNS); + } + else + { + log(DEBUG,"Resolver::Resolver: RESOLVER_NOTREADY"); + this->OnError(RESOLVER_NOTREADY); + ModuleException e("Resolver: Core not initialized yet"); + throw e; + /* We shouldnt get here really */ + return; + } +} + +Resolver::~Resolver() +{ + log(DEBUG,"Resolver::~Resolver"); + if (ServerInstance && ServerInstance->SE) + ServerInstance->SE->DelFd(this->fd); +} + +int Resolver::GetFd() +{ + return this->fd; +} + +bool Resolver::ProcessResult() +{ + log(DEBUG,"Resolver::ProcessResult"); + if (this->fwd) + result = Query.GetResultIP(); + else + result = Query.GetResult(); + + if (result != "") + { + log(DEBUG,"Resolver::OnLookupComplete(%s)",result.c_str()); + this->OnLookupComplete(result); + return true; + } + else + { + log(DEBUG,"Resolver::OnError(RESOLVER_NXDOMAIN)"); + this->OnError(RESOLVER_NXDOMAIN); + return false; + } +} + +void Resolver::OnLookupComplete(const std::string &result) +{ +} + +void Resolver::OnError(ResolverError e) +{ +} + +void dns_deal_with_classes(int fd) +{ + log(DEBUG,"dns_deal_with_classes(%d)",fd); + if ((fd > -1) && (dns_classes[fd])) + { + log(DEBUG,"Valid fd %d",fd); + dns_classes[fd]->ProcessResult(); + delete dns_classes[fd]; + dns_classes[fd] = NULL; + } +} + +bool dns_add_class(Resolver* r) +{ + log(DEBUG,"dns_add_class"); + if ((r) && (r->GetFd() > -1)) + { + if (!dns_classes[r->GetFd()]) + { + log(DEBUG,"dns_add_class: added class"); + dns_classes[r->GetFd()] = r; + return true; + } + else + { + log(DEBUG,"Space occupied!"); + return false; + } + } + else + { + log(DEBUG,"Bad class"); + delete r; + return true; + } +} + +void init_dns() +{ + memset(dns_classes,0,sizeof(dns_classes)); +} +