diff --git a/src/DNS.cc b/src/DNS.cc
index 40fe832e34..a3b0b62ef3 100644
--- a/src/DNS.cc
+++ b/src/DNS.cc
@@ -766,12 +766,20 @@ int DNS_Interpreter::ParseRR_AAAA(DNS_MsgInfo* msg,
 
 		if ( len < 0 )
 			{
-			analyzer->Weird("DNS_AAAA_neg_length");
+			if ( msg->atype == TYPE_AAAA )
+				analyzer->Weird("DNS_AAAA_neg_length");
+			else
+				analyzer->Weird("DNS_A6_neg_length");
 			return 0;
 			}
 		}
 
-	if ( dns_AAAA_reply && ! msg->skip_event )
+	EventHandlerPtr event;
+	if ( msg->atype == TYPE_AAAA )
+		event = dns_AAAA_reply;
+	else
+		event = dns_A6_reply;
+	if ( event && ! msg->skip_event )
 		{
 		val_list* vl = new val_list;
 
@@ -779,7 +787,7 @@ int DNS_Interpreter::ParseRR_AAAA(DNS_MsgInfo* msg,
 		vl->append(msg->BuildHdrVal());
 		vl->append(msg->BuildAnswerVal());
 		vl->append(new AddrVal(addr));
-		analyzer->ConnectionEvent(dns_AAAA_reply, vl);
+		analyzer->ConnectionEvent(event, vl);
 		}
 
 	return 1;
diff --git a/src/DNS_Mgr.cc b/src/DNS_Mgr.cc
index 2234ccbb10..b6e7c66218 100644
--- a/src/DNS_Mgr.cc
+++ b/src/DNS_Mgr.cc
@@ -46,13 +46,13 @@ extern int select(int, fd_set *, fd_set *, fd_set *, struct timeval *);
 
 class DNS_Mgr_Request {
 public:
-	DNS_Mgr_Request(const char* h)	{ host = copy_string(h); addr = 0; }
-	DNS_Mgr_Request(uint32 a)		{ addr = a; host = 0; }
+	DNS_Mgr_Request(const char* h)	{ host = copy_string(h); }
+	DNS_Mgr_Request(const IPAddr& a)		{ addr = a; host = 0; }
 	~DNS_Mgr_Request()			{ delete [] host; }
 
 	// Returns nil if this was an address request.
 	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 RequestPending() const	{ return request_pending; }
@@ -61,7 +61,7 @@ public:
 
 protected:
 	char* host;	// if non-nil, this is a host request
-	uint32 addr;
+	IPAddr addr;
 	uint32 ttl;
 	int request_pending;
 };
@@ -77,13 +77,18 @@ int DNS_Mgr_Request::MakeRequest(nb_dns_info* nb_dns)
 	if ( host )
 		return nb_dns_host_request(nb_dns, host, (void*) this, err) >= 0;
 	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 {
 public:
 	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);
 
 	int NoMapping() const		{ return no_mapping; }
@@ -93,10 +98,10 @@ public:
 
 	// Returns nil if this was an address request.
 	const char* ReqHost() const	{ return req_host; }
-	uint32 ReqAddr() const		{ return req_addr; }
+	IPAddr ReqAddr() const		{ return req_addr; }
 	string ReqStr() const
 		{
-		return req_host ? req_host : IPAddr(IPAddr::IPv4, &req_addr, IPAddr::Network);
+		return req_host ? req_host : req_addr;
 		}
 
 	ListVal* Addrs();
@@ -123,7 +128,7 @@ protected:
 	int init_failed;
 
 	char* req_host;
-	uint32 req_addr;
+	IPAddr req_addr;
 	uint32 req_ttl;
 
 	int num_names;
@@ -131,7 +136,7 @@ protected:
 	StringVal* host_val;
 
 	int num_addrs;
-	uint32* addrs;
+	IPAddr* addrs;
 	ListVal* addrs_val;
 
 	int failed;
@@ -156,14 +161,13 @@ DNS_Mapping::DNS_Mapping(const char* host, struct hostent* h, uint32 ttl)
 	{
 	Init(h);
 	req_host = copy_string(host);
-	req_addr = 0;
 	req_ttl = ttl;
 
 	if ( names && ! names[0] )
 		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);
 	req_addr = addr;
@@ -177,7 +181,6 @@ DNS_Mapping::DNS_Mapping(FILE* f)
 	init_failed = 1;
 
 	req_host = 0;
-	req_addr = 0;
 
 	char buf[512];
 
@@ -197,12 +200,7 @@ DNS_Mapping::DNS_Mapping(FILE* f)
 	if ( is_req_host )
 		req_host = copy_string(req_buf);
 	else
-		{
-		IPAddr addr(req_buf);
-		const uint32* bytes;
-		addr.GetBytes(&bytes);
-		req_addr = *bytes; //FIXME: IPv6 support
-		}
+		req_addr = IPAddr(req_buf);
 
 	num_names = 1;
 	names = new char*[num_names];
@@ -210,7 +208,7 @@ DNS_Mapping::DNS_Mapping(FILE* f)
 
 	if ( num_addrs > 0 )
 		{
-		addrs = new uint32[num_addrs];
+		addrs = new IPAddr[num_addrs];
 
 		for ( int i = 0; i < num_addrs; ++i )
 			{
@@ -224,10 +222,7 @@ DNS_Mapping::DNS_Mapping(FILE* f)
 			if ( newline )
 				*newline = '\0';
 
-			IPAddr addr(buf);
-			const uint32* bytes;
-			addr.GetBytes(&bytes);
-			addrs[i] = *bytes; //FIXME IPv6 support
+			addrs[i] = IPAddr(buf);
 			}
 		}
 	else
@@ -290,14 +285,6 @@ StringVal* DNS_Mapping::Host()
 	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)
 	{
 	no_mapping = 0;
@@ -306,7 +293,7 @@ void DNS_Mapping::Init(struct hostent* h)
 	host_val = 0;
 	addrs_val = 0;
 
-	if ( ! h || h->h_addrtype != AF_INET || h->h_length != 4 )
+	if ( ! h )
 		{
 		Clear();
 		return;
@@ -321,10 +308,14 @@ void DNS_Mapping::Init(struct hostent* h)
 
 	if ( num_addrs > 0 )
 		{
-		addrs = new uint32[num_addrs];
+		addrs = new IPAddr[num_addrs];
 		for ( int i = 0; i < num_addrs; ++i )
-			addrs[i] = raw_bytes_to_addr(
-					(unsigned char*)h->h_addr_list[i]);
+			if ( h->h_addrtype == AF_INET )
+				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
 		addrs = 0;
@@ -346,14 +337,12 @@ void DNS_Mapping::Clear()
 void DNS_Mapping::Save(FILE* f) const
 	{
 	fprintf(f, "%.0f %d %s %d %s %d\n", creation_time, req_host != 0,
-		req_host ? req_host :
-			IPAddr(IPAddr::IPv4, &req_addr, IPAddr::Network).AsString().c_str(),
+		req_host ? req_host : req_addr.AsString().c_str(),
 		failed, (names && names[0]) ? names[0] : "*",
 		num_addrs);
 
 	for ( int i = 0; i < num_addrs; ++i )
-		fprintf(f, "%s\n",
-			IPAddr(IPAddr::IPv4, &addrs[i], IPAddr::Network).AsString().c_str());
+		fprintf(f, "%s\n", addrs[i].AsString().c_str());
 	}
 
 
@@ -487,14 +476,14 @@ TableVal* DNS_Mgr::LookupHost(const char* name)
 	}
 	}
 
-Val* DNS_Mgr::LookupAddr(uint32 addr)
+Val* DNS_Mgr::LookupAddr(const IPAddr& addr)
 	{
 	if ( ! did_init )
 		Init();
 
 	if ( mode != DNS_PRIME )
 		{
-		HashKey h(&addr, 1);
+		HashKey h(addr);
 		DNS_Mapping* d = addr_mappings.Lookup(&h);
 
 		if ( d )
@@ -503,7 +492,7 @@ Val* DNS_Mgr::LookupAddr(uint32 addr)
 				return d->Host();
 			else
 				{
-				string s = IPAddr(IPAddr::IPv4, &addr, IPAddr::Network);
+				string s(addr);
 				reporter->Warning("can't resolve IP address: %s", s.c_str());
 				return new StringVal(s.c_str());
 				}
@@ -518,7 +507,7 @@ Val* DNS_Mgr::LookupAddr(uint32 addr)
 
 	case DNS_FORCE:
 		reporter->FatalError("can't find DNS entry for %s in cache",
-		    IPAddr(IPAddr::IPv4, &addr, IPAddr::Network).AsString().c_str());
+		    addr.AsString().c_str());
 		return 0;
 
 	case DNS_DEFAULT:
@@ -707,14 +696,12 @@ void DNS_Mgr::AddResult(DNS_Mgr_Request* dr, struct nb_dns_result* r)
 	else
 		{
 		new_dm = new DNS_Mapping(dr->ReqAddr(), h, ttl);
-		uint32 tmp_addr = dr->ReqAddr();
-		HashKey k(&tmp_addr, 1);
+		HashKey k(dr->ReqAddr());
 		prev_dm = addr_mappings.Insert(&k, new_dm);
 
 		if ( new_dm->Failed() && prev_dm && prev_dm->Valid() )
 			{
-			uint32 tmp_addr = dr->ReqAddr();
-			HashKey k2(&tmp_addr, 1);
+			HashKey k2(dr->ReqAddr());
 			(void) addr_mappings.Insert(&k2, prev_dm);
 			++keep_prev;
 			}
@@ -826,8 +813,7 @@ void DNS_Mgr::LoadCache(FILE* f)
 			host_mappings.Insert(m->ReqHost(), m);
 		else
 			{
-			uint32 tmp_addr = m->ReqAddr();
-			HashKey h(&tmp_addr, 1);
+			HashKey h(m->ReqAddr());
 			addr_mappings.Insert(&h, m);
 			}
 		}
@@ -848,9 +834,9 @@ void DNS_Mgr::Save(FILE* f, PDict(DNS_Mapping)& m)
 		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);
 
 	if ( ! d )
@@ -886,7 +872,7 @@ TableVal* DNS_Mgr::LookupNameInCache(string name)
 	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 )
 		Init();
@@ -996,7 +982,7 @@ double DNS_Mgr::NextTimestamp(double* network_time)
 	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.
 
diff --git a/src/DNS_Mgr.h b/src/DNS_Mgr.h
index 91bcad4084..fb55b991cb 100644
--- a/src/DNS_Mgr.h
+++ b/src/DNS_Mgr.h
@@ -40,10 +40,6 @@ enum DNS_MgrMode {
 // Number of seconds we'll wait for a reply.
 #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 {
 public:
 	DNS_Mgr(DNS_MgrMode mode);
@@ -56,7 +52,7 @@ public:
 	// a set of addr.
 	TableVal* LookupHost(const char* host);
 
-	Val* LookupAddr(uint32 addr);
+	Val* LookupAddr(const IPAddr& addr);
 
 	// Define the directory where to store the data.
 	void SetDir(const char* arg_dir)	{ dir = copy_string(arg_dir); }
@@ -65,7 +61,7 @@ public:
 	void Resolve();
 	int Save();
 
-	const char* LookupAddrInCache(dns_mgr_addr_type addr);
+	const char* LookupAddrInCache(const IPAddr& addr);
 	TableVal* LookupNameInCache(string name);
 
 	// Support for async lookups.
@@ -79,7 +75,7 @@ public:
 		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);
 
 	struct Stats {
@@ -121,7 +117,7 @@ protected:
 
 	// Finish the request if we have a result.  If not, time it out if
 	// requested.
-	void CheckAsyncAddrRequest(dns_mgr_addr_type addr, bool timeout);
+	void CheckAsyncAddrRequest(const IPAddr& addr, bool timeout);
 	void CheckAsyncHostRequest(const char* host, bool timeout);
 
 	// Process outstanding requests.
@@ -164,7 +160,7 @@ protected:
 
 	struct AsyncRequest {
 		double time;
-		dns_mgr_addr_type host;
+		IPAddr host;
 		string name;
 		CallbackList callbacks;
 
@@ -205,7 +201,7 @@ protected:
 
 	};
 
-	typedef map<dns_mgr_addr_type, AsyncRequest*> AsyncRequestAddrMap;
+	typedef map<IPAddr, AsyncRequest*> AsyncRequestAddrMap;
 	AsyncRequestAddrMap asyncs_addrs;
 
 	typedef map<string, AsyncRequest*> AsyncRequestNameMap;
diff --git a/src/DPM.cc b/src/DPM.cc
index 2700c92933..c02db08c2f 100644
--- a/src/DPM.cc
+++ b/src/DPM.cc
@@ -17,22 +17,37 @@ ExpectedConn::ExpectedConn(const IPAddr& _orig, const IPAddr& _resp,
 	if ( _orig == IPAddr(string("0.0.0.0")) )
 		// don't use the IPv4 mapping, use the literal unspecified address
 		// to indicate a wildcard
-		orig[0] = orig[1] = orig[2] = orig[3] = 0;
+		orig = IPAddr(string("::"));
 	else
-		_orig.CopyIPv6(orig);
-	_resp.CopyIPv6(resp);
+		orig = _orig;
+	resp = _resp;
 	resp_p = _resp_p;
 	proto = _proto;
 	}
 
 ExpectedConn::ExpectedConn(const ExpectedConn& c)
 	{
-	memcpy(orig, c.orig, sizeof(orig));
-	memcpy(resp, c.resp, sizeof(resp));
+	orig = c.orig;
+	resp = c.resp;
 	resp_p = c.resp_p;
 	proto = c.proto;
 	}
 
+HashKey* ExpectedConn::GetKey() const
+	{
+	struct Key {
+		uint32 orig[4];
+		uint32 resp[4];
+		uint16 resp_p;
+		uint16 proto;
+	};
+	Key k;
+	orig.CopyIPv6(k.orig);
+	resp.CopyIPv6(k.resp);
+	k.resp_p = resp_p;
+	k.proto = proto;
+	return new HashKey(&k, sizeof(k));
+	}
 
 DPM::DPM()
 : expected_conns_queue(AssignedAnalyzer::compare)
@@ -134,23 +149,18 @@ AnalyzerTag::Tag DPM::GetExpected(int proto, const Connection* conn)
 	ExpectedConn c(conn->OrigAddr(), conn->RespAddr(),
 			ntohs(conn->RespPort()), proto);
 
-	// Can't use sizeof(c) due to potential alignment issues.
-	// FIXME: I guess this is still not portable ...
-	HashKey key(&c, sizeof(c.orig) + sizeof(c.resp) +
-				sizeof(c.resp_p) + sizeof(c.proto));
-
-	AssignedAnalyzer* a = expected_conns.Lookup(&key);
+	HashKey* key = c.GetKey();
+	AssignedAnalyzer* a = expected_conns.Lookup(key);
+	delete key;
 
 	if ( ! a )
 		{
 		// Wildcard for originator.
-		for ( int i = 0; i < 4; ++i )
-			c.orig[i] = 0;
+		c.orig = IPAddr(string("::"));
 
-		HashKey key(&c, sizeof(c.orig) + sizeof(c.resp) +
-				sizeof(c.resp_p) + sizeof(c.proto));
-
-		a = expected_conns.Lookup(&key);
+		HashKey* key = c.GetKey();
+		a = expected_conns.Lookup(key);
+		delete key;
 		}
 
 	if ( ! a )
@@ -393,11 +403,7 @@ void DPM::ExpectConnection(const IPAddr& orig, const IPAddr& resp,
 			{
 			if ( ! a->deleted )
 				{
-				HashKey* key = new HashKey(&a->conn,
-							sizeof(a->conn.orig) +
-							sizeof(a->conn.resp) +
-							sizeof(a->conn.resp_p) +
-							sizeof(a->conn.proto));
+				HashKey* key = a->conn.GetKey();
 				expected_conns.Remove(key);
 				delete key;
 				}
@@ -416,10 +422,9 @@ void DPM::ExpectConnection(const IPAddr& orig, const IPAddr& resp,
 
 	ExpectedConn c(orig, resp, resp_p, proto);
 
-	HashKey key(&c, sizeof(c.orig) + sizeof(c.resp) +
-			sizeof(c.resp_p) + sizeof(c.proto));
+	HashKey* key = c.GetKey();
 
-	AssignedAnalyzer* a = expected_conns.Lookup(&key);
+	AssignedAnalyzer* a = expected_conns.Lookup(key);
 
 	if ( a )
 		a->deleted = true;
@@ -431,8 +436,9 @@ void DPM::ExpectConnection(const IPAddr& orig, const IPAddr& resp,
 	a->timeout = network_time + timeout;
 	a->deleted = false;
 
-	expected_conns.Insert(&key, a);
+	expected_conns.Insert(key, a);
 	expected_conns_queue.push(a);
+	delete key;
 	}
 
 void DPM::Done()
@@ -443,11 +449,7 @@ void DPM::Done()
 		AssignedAnalyzer* a = expected_conns_queue.top();
 		if ( ! a->deleted )
 			{
-			HashKey* key = new HashKey(&a->conn,
-					sizeof(a->conn.orig) +
-					sizeof(a->conn.resp) +
-					sizeof(a->conn.resp_p) +
-					sizeof(a->conn.proto));
+			HashKey* key = a->conn.GetKey();
 			expected_conns.Remove(key);
 			delete key;
 			}
diff --git a/src/DPM.h b/src/DPM.h
index b3e5f8f17f..7e9150f3aa 100644
--- a/src/DPM.h
+++ b/src/DPM.h
@@ -32,8 +32,10 @@ public:
 
 	ExpectedConn(const ExpectedConn& c);
 
-	uint32 orig[4];
-	uint32 resp[4];
+	HashKey* GetKey() const;
+
+	IPAddr orig;
+	IPAddr resp;
 	uint16 resp_p;
 	uint16 proto;
 };
diff --git a/src/Expr.cc b/src/Expr.cc
index 46590493a8..a8c2fc32c9 100644
--- a/src/Expr.cc
+++ b/src/Expr.cc
@@ -835,22 +835,30 @@ Val* BinaryExpr::StringFold(Val* v1, Val* v2) const
 
 Val* BinaryExpr::AddrFold(Val* v1, Val* v2) const
 	{
-	uint32 a1[4];
-	uint32 a2[4];
-	v1->AsAddr().CopyIPv6(a1);
-	v2->AsAddr().CopyIPv6(a2);
+	IPAddr a1 = v1->AsAddr();
+	IPAddr a2 = v2->AsAddr();
 	int result = 0;
 
 	switch ( tag ) {
-#undef DO_FOLD
-#define DO_FOLD(sense) { result = memcmp(a1, a2, 16) sense 0; break; }
 
-	case EXPR_LT:		DO_FOLD(<)
-	case EXPR_LE:		DO_FOLD(<=)
-	case EXPR_EQ:		DO_FOLD(==)
-	case EXPR_NE:		DO_FOLD(!=)
-	case EXPR_GE:		DO_FOLD(>=)
-	case EXPR_GT:		DO_FOLD(>)
+	case EXPR_LT:
+		result = a1 < a2;
+		break;
+	case EXPR_LE:
+		result = a1 < a2 || a1 == a2;
+		break;
+	case EXPR_EQ:
+		result = a1 == a2;
+		break;
+	case EXPR_NE:
+		result = a1 != a2;
+		break;
+	case EXPR_GE:
+		result = ! ( a1 < a2 );
+		break;
+	case EXPR_GT:
+		result = ( ! ( a1 < a2 ) ) && ( a1 != a2 );
+		break;
 
 	default:
 		BadTag("BinaryExpr::AddrFold", expr_name(tag));
diff --git a/src/Hash.cc b/src/Hash.cc
index 7873e398c3..c8e68da429 100644
--- a/src/Hash.cc
+++ b/src/Hash.cc
@@ -103,6 +103,16 @@ HashKey::HashKey(const BroString* s)
 	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)
 	{
 	size = arg_size;
diff --git a/src/Hash.h b/src/Hash.h
index 00db53d075..2d24a05b79 100644
--- a/src/Hash.h
+++ b/src/Hash.h
@@ -6,6 +6,7 @@
 #include <stdlib.h>
 
 #include "BroString.h"
+#include "IPAddr.h"
 
 #define UHASH_KEY_SIZE 36
 
@@ -28,6 +29,7 @@ public:
 	HashKey(const void* p);
 	HashKey(const char* s);
 	HashKey(const BroString* s);
+	HashKey(const IPAddr& addr);
 	~HashKey()
 		{
 		if ( is_our_dynamic )
diff --git a/src/IP.h b/src/IP.h
index 5733f633a2..ba37fb4c69 100644
--- a/src/IP.h
+++ b/src/IP.h
@@ -10,26 +10,22 @@
 class IP_Hdr {
 public:
 	IP_Hdr(struct ip* arg_ip4)
-		: ip4(arg_ip4), ip6(0),
-		  src_addr(arg_ip4->ip_src), dst_addr(arg_ip4->ip_dst), del(1)
+		: ip4(arg_ip4), ip6(0), del(1)
 		{
 		}
 
 	IP_Hdr(const struct ip* arg_ip4)
-		: ip4(arg_ip4), ip6(0),
-		  src_addr(arg_ip4->ip_src), dst_addr(arg_ip4->ip_dst), del(0)
+		: ip4(arg_ip4), ip6(0), del(0)
 		{
 		}
 
 	IP_Hdr(struct ip6_hdr* arg_ip6)
-		: ip4(0), ip6(arg_ip6),
-		  src_addr(arg_ip6->ip6_src), dst_addr(arg_ip6->ip6_dst), del(1)
+		: ip4(0), ip6(arg_ip6), del(1)
 		{
 		}
 
 	IP_Hdr(const struct ip6_hdr* arg_ip6)
-		: ip4(0), ip6(arg_ip6),
-		  src_addr(arg_ip6->ip6_src), dst_addr(arg_ip6->ip6_dst), del(0)
+		: ip4(0), ip6(arg_ip6), del(0)
 		{
 		}
 
@@ -47,8 +43,10 @@ public:
 	const struct ip* IP4_Hdr() const	{ return ip4; }
 	const struct ip6_hdr* IP6_Hdr() const	{ return ip6; }
 
-	const IPAddr& SrcAddr() const	{ return src_addr; }
-	const IPAddr& DstAddr() const	{ return dst_addr; }
+	IPAddr SrcAddr() const
+		{ return ip4 ? IPAddr(ip4->ip_src) : IPAddr(ip6->ip6_src); }
+	IPAddr DstAddr() const
+		{ return ip4 ? IPAddr(ip4->ip_dst) : IPAddr(ip6->ip6_dst); }
 
 	//TODO: needs adapting/replacement for IPv6 support
 	uint16 ID4() const	{ return ip4 ? ip4->ip_id : 0; }
@@ -92,8 +90,6 @@ public:
 private:
 	const struct ip* ip4;
 	const struct ip6_hdr* ip6;
-	IPAddr src_addr;
-	IPAddr dst_addr;
 	int del;
 };
 
diff --git a/src/Val.cc b/src/Val.cc
index e42dfbd36e..fe7bd44481 100644
--- a/src/Val.cc
+++ b/src/Val.cc
@@ -923,7 +923,6 @@ SubNetVal::SubNetVal(const char* text, int width) : Val(TYPE_SUBNET)
 	val.subnet_val = new IPPrefix(text, width);
 	}
 
-#if 0
 SubNetVal::SubNetVal(uint32 addr, int width) : Val(TYPE_SUBNET)
 	{
 	IPAddr a(IPAddr::IPv4, &addr, IPAddr::Network);
@@ -935,7 +934,6 @@ SubNetVal::SubNetVal(const uint32* addr, int width) : Val(TYPE_SUBNET)
 	IPAddr a(IPAddr::IPv6, addr, IPAddr::Network);
 	val.subnet_val = new IPPrefix(a, width);
 	}
-#endif
 
 SubNetVal::SubNetVal(const IPAddr& addr, int width) : Val(TYPE_SUBNET)
 	{
diff --git a/src/bro.bif b/src/bro.bif
index 1d2f0674ad..bbd31ef8a6 100644
--- a/src/bro.bif
+++ b/src/bro.bif
@@ -3441,25 +3441,7 @@ function lookup_addr%(host: addr%) : string
 	frame->SetDelayed();
 	trigger->Hold();
 
-	if ( host->AsAddr().GetFamily() != IPAddr::IPv4 )
-		{
-		// 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,
+	dns_mgr->AsyncLookupAddr(host->AsAddr(),
 			new LookupHostCallback(trigger, frame->GetCall(), true));
 	return 0;
 	%}
diff --git a/src/nb_dns.c b/src/nb_dns.c
index 475ba3b8b0..d3b3c5c4de 100644
--- a/src/nb_dns.c
+++ b/src/nb_dns.c
@@ -186,7 +186,7 @@ _nb_dns_cmpsockaddr(register struct sockaddr *sa1,
 #endif
 	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);
 		return (-1);
 	}
@@ -381,7 +381,7 @@ nb_dns_addr_request2(register struct nb_dns_info *nd, char *addrp,
 			size -= i;
 			cp += i;
 		}
-		snprintf(cp, size, "ip6.int");
+		snprintf(cp, size, "ip6.arpa");
 		break;
 #endif