Mirror/zeek
1
0
Fork 0
mirror of https://github.com/zeek/zeek.git synced 2025-10-02 14:48:21 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Port DNS_Mgr to use new IPAddr class, enable lookups on IPv6 addrs.

Browse source 
Host lookups still need to be changed to also do AAAA queries.
This commit is contained in:
Jon Siwek 2012-02-13 15:57:59 -06:00
parent c0f05f57a7
commit 0f207c243c
6 changed files with 61 additions and 84 deletions
Download patch file Download diff file Expand all files Collapse all files

93
src/DNS_Mgr.cc
View file

@ -46,13 +46,13 @@ extern int select(int, fd_set *, fd_set *, fd_set *, struct timeval *);
class DNS_Mgr_Request { class DNS_Mgr_Request {
public: public:
DNS_Mgr_Request(const char* h) { host = copy_string(h); addr = 0; } DNS_Mgr_Request(const char* h) { host = copy_string(h); }
DNS_Mgr_Request(uint32 a) { addr = a; host = 0; } DNS_Mgr_Request(const IPAddr& a) { addr = a; host = 0; }
~DNS_Mgr_Request() { delete [] host; } ~DNS_Mgr_Request() { delete [] host; }
// Returns nil if this was an address request. // Returns nil if this was an address request.
const char* ReqHost() const { return host; } const char* ReqHost() const { return host; }
uint32 ReqAddr() const { return addr; } const IPAddr& ReqAddr() const { return addr; }
int MakeRequest(nb_dns_info* nb_dns); int MakeRequest(nb_dns_info* nb_dns);
int RequestPending() const { return request_pending; } int RequestPending() const { return request_pending; }
@ -61,7 +61,7 @@ public:
protected: protected:
char* host; // if non-nil, this is a host request char* host; // if non-nil, this is a host request
uint32 addr; IPAddr addr;
uint32 ttl; uint32 ttl;
int request_pending; int request_pending;
}; };
@ -77,13 +77,18 @@ int DNS_Mgr_Request::MakeRequest(nb_dns_info* nb_dns)
if ( host ) if ( host )
return nb_dns_host_request(nb_dns, host, (void*) this, err) >= 0; return nb_dns_host_request(nb_dns, host, (void*) this, err) >= 0;
else else
return nb_dns_addr_request(nb_dns, addr, (void*) this, err) >= 0; {
const uint32* bytes;
int len = addr.GetBytes(&bytes);
return nb_dns_addr_request2(nb_dns, (char*) bytes,
len == 1 ? AF_INET : AF_INET6, (void*) this, err) >= 0;
}
} }
class DNS_Mapping { class DNS_Mapping {
public: public:
DNS_Mapping(const char* host, struct hostent* h, uint32 ttl); DNS_Mapping(const char* host, struct hostent* h, uint32 ttl);
DNS_Mapping(uint32 addr, struct hostent* h, uint32 ttl); DNS_Mapping(const IPAddr& addr, struct hostent* h, uint32 ttl);
DNS_Mapping(FILE* f); DNS_Mapping(FILE* f);
int NoMapping() const { return no_mapping; } int NoMapping() const { return no_mapping; }
@ -93,11 +98,10 @@ public:
// Returns nil if this was an address request. // Returns nil if this was an address request.
const char* ReqHost() const { return req_host; } const char* ReqHost() const { return req_host; }
uint32 ReqAddr() const { return req_addr; } const IPAddr& ReqAddr() const { return req_addr; }
const char* ReqStr() const const char* ReqStr() const
{ {
return req_host ? req_host : return req_host ? req_host : string(req_addr).c_str();
string(IPAddr(IPAddr::IPv4, &req_addr, IPAddr::Network)).c_str();
} }
ListVal* Addrs(); ListVal* Addrs();
@ -124,7 +128,7 @@ protected:
int init_failed; int init_failed;
char* req_host; char* req_host;
uint32 req_addr; IPAddr req_addr;
uint32 req_ttl; uint32 req_ttl;
int num_names; int num_names;
@ -132,7 +136,7 @@ protected:
StringVal* host_val; StringVal* host_val;
int num_addrs; int num_addrs;
uint32* addrs; IPAddr* addrs;
ListVal* addrs_val; ListVal* addrs_val;
int failed; int failed;
@ -157,14 +161,13 @@ DNS_Mapping::DNS_Mapping(const char* host, struct hostent* h, uint32 ttl)
{ {
Init(h); Init(h);
req_host = copy_string(host); req_host = copy_string(host);
req_addr = 0;
req_ttl = ttl; req_ttl = ttl;
if ( names && ! names[0] ) if ( names && ! names[0] )
names[0] = copy_string(host); names[0] = copy_string(host);
} }
DNS_Mapping::DNS_Mapping(uint32 addr, struct hostent* h, uint32 ttl) DNS_Mapping::DNS_Mapping(const IPAddr& addr, struct hostent* h, uint32 ttl)
{ {
Init(h); Init(h);
req_addr = addr; req_addr = addr;
@ -178,7 +181,6 @@ DNS_Mapping::DNS_Mapping(FILE* f)
init_failed = 1; init_failed = 1;
req_host = 0; req_host = 0;
req_addr = 0;
char buf[512]; char buf[512];
@ -200,10 +202,7 @@ DNS_Mapping::DNS_Mapping(FILE* f)
else else
{ {
string s(req_buf); string s(req_buf);
IPAddr addr(s); req_addr = IPAddr(s);
const uint32* bytes;
addr.GetBytes(&bytes);
req_addr = *bytes; //FIXME: IPv6 support
} }
num_names = 1; num_names = 1;
@ -212,7 +211,7 @@ DNS_Mapping::DNS_Mapping(FILE* f)
if ( num_addrs > 0 ) if ( num_addrs > 0 )
{ {
addrs = new uint32[num_addrs]; addrs = new IPAddr[num_addrs];
for ( int i = 0; i < num_addrs; ++i ) for ( int i = 0; i < num_addrs; ++i )
{ {
@ -227,10 +226,7 @@ DNS_Mapping::DNS_Mapping(FILE* f)
*newline = '\0'; *newline = '\0';
string s(buf); string s(buf);
IPAddr addr(s); addrs[i] = IPAddr(s);
const uint32* bytes;
addr.GetBytes(&bytes);
addrs[i] = *bytes; //FIXME IPv6 support
} }
} }
else else
@ -293,14 +289,6 @@ StringVal* DNS_Mapping::Host()
return host_val; return host_val;
} }
// Converts an array of 4 bytes in network order to the corresponding
// 32-bit network long.
static uint32 raw_bytes_to_addr(const unsigned char b[4])
{
uint32 l = (b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3];
return uint32(htonl(l));
}
void DNS_Mapping::Init(struct hostent* h) void DNS_Mapping::Init(struct hostent* h)
{ {
no_mapping = 0; no_mapping = 0;
@ -309,7 +297,7 @@ void DNS_Mapping::Init(struct hostent* h)
host_val = 0; host_val = 0;
addrs_val = 0; addrs_val = 0;
if ( ! h || h->h_addrtype != AF_INET || h->h_length != 4 ) if ( ! h )
{ {
Clear(); Clear();
return; return;
@ -324,10 +312,14 @@ void DNS_Mapping::Init(struct hostent* h)
if ( num_addrs > 0 ) if ( num_addrs > 0 )
{ {
addrs = new uint32[num_addrs]; addrs = new IPAddr[num_addrs];
for ( int i = 0; i < num_addrs; ++i ) for ( int i = 0; i < num_addrs; ++i )
addrs[i] = raw_bytes_to_addr( if ( h->h_addrtype == AF_INET )
(unsigned char*)h->h_addr_list[i]); addrs[i] = IPAddr(IPAddr::IPv4, (uint32*)h->h_addr_list[i],
IPAddr::Network);
else if ( h->h_addrtype == AF_INET6 )
addrs[i] = IPAddr(IPAddr::IPv6, (uint32*)h->h_addr_list[i],
IPAddr::Network);
} }
else else
addrs = 0; addrs = 0;
@ -349,14 +341,12 @@ void DNS_Mapping::Clear()
void DNS_Mapping::Save(FILE* f) const void DNS_Mapping::Save(FILE* f) const
{ {
fprintf(f, "%.0f %d %s %d %s %d\n", creation_time, req_host != 0, fprintf(f, "%.0f %d %s %d %s %d\n", creation_time, req_host != 0,
req_host ? req_host : req_host ? req_host : string(req_addr).c_str(),
string(IPAddr(IPAddr::IPv4, &req_addr, IPAddr::Network)).c_str(),
failed, (names && names[0]) ? names[0] : "*", failed, (names && names[0]) ? names[0] : "*",
num_addrs); num_addrs);
for ( int i = 0; i < num_addrs; ++i ) for ( int i = 0; i < num_addrs; ++i )
fprintf(f, "%s\n", fprintf(f, "%s\n", string(addrs[i]).c_str());
string(IPAddr(IPAddr::IPv4, &addrs[i], IPAddr::Network)).c_str());
} }
@ -490,14 +480,14 @@ TableVal* DNS_Mgr::LookupHost(const char* name)
} }
} }
Val* DNS_Mgr::LookupAddr(uint32 addr) Val* DNS_Mgr::LookupAddr(const IPAddr& addr)
{ {
if ( ! did_init ) if ( ! did_init )
Init(); Init();
if ( mode != DNS_PRIME ) if ( mode != DNS_PRIME )
{ {
HashKey h(&addr, 1); HashKey h(addr);
DNS_Mapping* d = addr_mappings.Lookup(&h); DNS_Mapping* d = addr_mappings.Lookup(&h);
if ( d ) if ( d )
@ -506,7 +496,7 @@ Val* DNS_Mgr::LookupAddr(uint32 addr)
return d->Host(); return d->Host();
else else
{ {
string s = IPAddr(IPAddr::IPv4, &addr, IPAddr::Network); string s(addr);
reporter->Warning("can't resolve IP address: %s", s.c_str()); reporter->Warning("can't resolve IP address: %s", s.c_str());
return new StringVal(s.c_str()); return new StringVal(s.c_str());
} }
@ -521,7 +511,7 @@ Val* DNS_Mgr::LookupAddr(uint32 addr)
case DNS_FORCE: case DNS_FORCE:
reporter->FatalError("can't find DNS entry for %s in cache", reporter->FatalError("can't find DNS entry for %s in cache",
string(IPAddr(IPAddr::IPv4, &addr, IPAddr::Network)).c_str()); string(addr).c_str());
return 0; return 0;
case DNS_DEFAULT: case DNS_DEFAULT:
@ -710,14 +700,12 @@ void DNS_Mgr::AddResult(DNS_Mgr_Request* dr, struct nb_dns_result* r)
else else
{ {
new_dm = new DNS_Mapping(dr->ReqAddr(), h, ttl); new_dm = new DNS_Mapping(dr->ReqAddr(), h, ttl);
uint32 tmp_addr = dr->ReqAddr(); HashKey k(dr->ReqAddr());
HashKey k(&tmp_addr, 1);
prev_dm = addr_mappings.Insert(&k, new_dm); prev_dm = addr_mappings.Insert(&k, new_dm);
if ( new_dm->Failed() && prev_dm && prev_dm->Valid() ) if ( new_dm->Failed() && prev_dm && prev_dm->Valid() )
{ {
uint32 tmp_addr = dr->ReqAddr(); HashKey k2(dr->ReqAddr());
HashKey k2(&tmp_addr, 1);
(void) addr_mappings.Insert(&k2, prev_dm); (void) addr_mappings.Insert(&k2, prev_dm);
++keep_prev; ++keep_prev;
} }
@ -829,8 +817,7 @@ void DNS_Mgr::LoadCache(FILE* f)
host_mappings.Insert(m->ReqHost(), m); host_mappings.Insert(m->ReqHost(), m);
else else
{ {
uint32 tmp_addr = m->ReqAddr(); HashKey h(m->ReqAddr());
HashKey h(&tmp_addr, 1);
addr_mappings.Insert(&h, m); addr_mappings.Insert(&h, m);
} }
} }
@ -851,9 +838,9 @@ void DNS_Mgr::Save(FILE* f, PDict(DNS_Mapping)& m)
dm->Save(f); dm->Save(f);
} }
const char* DNS_Mgr::LookupAddrInCache(dns_mgr_addr_type addr) const char* DNS_Mgr::LookupAddrInCache(const IPAddr& addr)
{ {
HashKey h(&addr, 1); HashKey h(addr);
DNS_Mapping* d = dns_mgr->addr_mappings.Lookup(&h); DNS_Mapping* d = dns_mgr->addr_mappings.Lookup(&h);
if ( ! d ) if ( ! d )
@ -889,7 +876,7 @@ TableVal* DNS_Mgr::LookupNameInCache(string name)
return d->AddrsSet(); return d->AddrsSet();
} }
void DNS_Mgr::AsyncLookupAddr(dns_mgr_addr_type host, LookupCallback* callback) void DNS_Mgr::AsyncLookupAddr(const IPAddr& host, LookupCallback* callback)
{ {
if ( ! did_init ) if ( ! did_init )
Init(); Init();
@ -999,7 +986,7 @@ double DNS_Mgr::NextTimestamp(double* network_time)
return asyncs_timeouts.size() ? timer_mgr->Time() : -1.0; return asyncs_timeouts.size() ? timer_mgr->Time() : -1.0;
} }
void DNS_Mgr::CheckAsyncAddrRequest(dns_mgr_addr_type addr, bool timeout) void DNS_Mgr::CheckAsyncAddrRequest(const IPAddr& addr, bool timeout)
{ {
// Note that this code is a mirror of that for CheckAsyncHostRequest. // Note that this code is a mirror of that for CheckAsyncHostRequest.

16
src/DNS_Mgr.h
View file

@ -40,10 +40,6 @@ enum DNS_MgrMode {
// Number of seconds we'll wait for a reply. // Number of seconds we'll wait for a reply.
#define DNS_TIMEOUT 5 #define DNS_TIMEOUT 5
// ### For now, we don't support IPv6 lookups. When we do, this
// should become addr_type.
typedef uint32 dns_mgr_addr_type;
class DNS_Mgr : public IOSource { class DNS_Mgr : public IOSource {
public: public:
DNS_Mgr(DNS_MgrMode mode); DNS_Mgr(DNS_MgrMode mode);
@ -56,7 +52,7 @@ public:
// a set of addr. // a set of addr.
TableVal* LookupHost(const char* host); TableVal* LookupHost(const char* host);
Val* LookupAddr(uint32 addr); Val* LookupAddr(const IPAddr& addr);
// Define the directory where to store the data. // Define the directory where to store the data.
void SetDir(const char* arg_dir) { dir = copy_string(arg_dir); } void SetDir(const char* arg_dir) { dir = copy_string(arg_dir); }
@ -65,7 +61,7 @@ public:
void Resolve(); void Resolve();
int Save(); int Save();
const char* LookupAddrInCache(dns_mgr_addr_type addr); const char* LookupAddrInCache(const IPAddr& addr);
TableVal* LookupNameInCache(string name); TableVal* LookupNameInCache(string name);
// Support for async lookups. // Support for async lookups.
@ -79,7 +75,7 @@ public:
virtual void Timeout() = 0; virtual void Timeout() = 0;
}; };
void AsyncLookupAddr(dns_mgr_addr_type host, LookupCallback* callback); void AsyncLookupAddr(const IPAddr& host, LookupCallback* callback);
void AsyncLookupName(string name, LookupCallback* callback); void AsyncLookupName(string name, LookupCallback* callback);
struct Stats { struct Stats {
@ -121,7 +117,7 @@ protected:
// Finish the request if we have a result. If not, time it out if // Finish the request if we have a result. If not, time it out if
// requested. // requested.
void CheckAsyncAddrRequest(dns_mgr_addr_type addr, bool timeout); void CheckAsyncAddrRequest(const IPAddr& addr, bool timeout);
void CheckAsyncHostRequest(const char* host, bool timeout); void CheckAsyncHostRequest(const char* host, bool timeout);
// Process outstanding requests. // Process outstanding requests.
@ -164,7 +160,7 @@ protected:
struct AsyncRequest { struct AsyncRequest {
double time; double time;
dns_mgr_addr_type host; IPAddr host;
string name; string name;
CallbackList callbacks; CallbackList callbacks;
@ -205,7 +201,7 @@ protected:
}; };
typedef map<dns_mgr_addr_type, AsyncRequest*> AsyncRequestAddrMap; typedef map<IPAddr, AsyncRequest*> AsyncRequestAddrMap;
AsyncRequestAddrMap asyncs_addrs; AsyncRequestAddrMap asyncs_addrs;
typedef map<string, AsyncRequest*> AsyncRequestNameMap; typedef map<string, AsyncRequest*> AsyncRequestNameMap;

10
src/Hash.cc
View file

@ -103,6 +103,16 @@ HashKey::HashKey(const BroString* s)
is_our_dynamic = 0; is_our_dynamic = 0;
} }
HashKey::HashKey(const IPAddr& addr)
{
const uint32* bytes;
int len = addr.GetBytes(&bytes);
size = len * sizeof(uint32);
key = CopyKey(bytes, size);
is_our_dynamic = 1;
hash = HashBytes(key, size);
}
HashKey::HashKey(int copy_key, void* arg_key, int arg_size) HashKey::HashKey(int copy_key, void* arg_key, int arg_size)
{ {
size = arg_size; size = arg_size;

2
src/Hash.h
View file

@ -6,6 +6,7 @@
#include <stdlib.h> #include <stdlib.h>
#include "BroString.h" #include "BroString.h"
#include "IPAddr.h"
#define UHASH_KEY_SIZE 36 #define UHASH_KEY_SIZE 36
@ -28,6 +29,7 @@ public:
HashKey(const void* p); HashKey(const void* p);
HashKey(const char* s); HashKey(const char* s);
HashKey(const BroString* s); HashKey(const BroString* s);
HashKey(const IPAddr& addr);
~HashKey() ~HashKey()
{ {
if ( is_our_dynamic ) if ( is_our_dynamic )

20
src/bro.bif
View file

@ -3432,25 +3432,7 @@ function lookup_addr%(host: addr%) : string
frame->SetDelayed(); frame->SetDelayed();
trigger->Hold(); trigger->Hold();
if ( host->AsAddr()->family() != IPAddr::IPv4 ) dns_mgr->AsyncLookupAddr(*host->AsAddr(),
{
// FIXME: This is a temporary work-around until we get this
// fixed. We warn the user once, and always trigger a timeout.
// Ticket #355 records the problem.
static bool warned = false;
if ( ! warned )
{
reporter->Warning("lookup_addr() only supports IPv4 addresses currently");
warned = true;
}
trigger->Timeout();
return 0;
}
const uint32* bytes;
host->AsAddr()->GetBytes(&bytes);
dns_mgr->AsyncLookupAddr(*bytes,
new LookupHostCallback(trigger, frame->GetCall(), true)); new LookupHostCallback(trigger, frame->GetCall(), true));
return 0; return 0;
%} %}

4
src/nb_dns.c
View file

@ -186,7 +186,7 @@ _nb_dns_cmpsockaddr(register struct sockaddr *sa1,
#endif #endif
static const char serr[] = "answer from wrong nameserver (%d)"; static const char serr[] = "answer from wrong nameserver (%d)";
if (sa1->sa_family != sa1->sa_family) { if (sa1->sa_family != sa2->sa_family) {
snprintf(errstr, NB_DNS_ERRSIZE, serr, 1); snprintf(errstr, NB_DNS_ERRSIZE, serr, 1);
return (-1); return (-1);
} }
@ -381,7 +381,7 @@ nb_dns_addr_request2(register struct nb_dns_info *nd, char *addrp,
size -= i; size -= i;
cp += i; cp += i;
} }
snprintf(cp, size, "ip6.int"); snprintf(cp, size, "ip6.arpa");
break; break;
#endif #endif