[PATCH 0/6] iptraf-ng: sockaddr (v2, rebased)

[Vitezslav Samel]

Right now we pass to some functions IPv4 and IPv6 address combo, but
we always use only one of them. There exists struct sockaddr_storage,
which can hold any kind of address, which this patch series make use.

So change these functions to pass pointer to struct sockaddr_storage
only instead of IPv4 address AND IPv6 address.

Many functions don't bother which kind of address it operates on,
only passes it to the lower layer of functions, so this is welcomed
simplification of source code. Later, when new protocol arives, we
only change sockaddr_* functions and (almost) all is done.

The first and the second patch are cleanups, the rest implements
sockaddr_storage helpers, the last one cleans up.

v2:
  - added the clean up (the 6th patch)
v1:
  - initial version

Vitezslav Samel (6):
  revname(): explicitly pass size of target space
  use inet_ntop() instead of deprecated inet_ntoa() (take 2)
  sockaddr.c: new helpers ...
  use sockaddr_*() helpers for addresses
  use port inside struct sockaddr_(sin,sin6) instead of explicitly
    defined one
  merge the same statements in the if() {} else {} clauses

 Makefile       |    4 ++
 src/itrafmon.c |   63 +++++++---------------
 src/othptab.c  |   59 ++++++++++----------
 src/othptab.h  |   12 ++---
 src/revname.c  |   46 ++++------------
 src/revname.h  |    4 +-
 src/rvnamed.c  |  100 +++++++----------------------------
 src/rvnamed.h  |    3 +-
 src/serv.c     |    2 +-
 src/servname.c |   10 ++--
 src/servname.h |    2 +-
 src/sockaddr.c |  161 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 src/sockaddr.h |   16 ++++++
 src/tcptable.c |  151 +++++++++++++++++++++-------------------------------
 src/tcptable.h |   24 ++++-----
 15 files changed, 346 insertions(+), 311 deletions(-)
 create mode 100644 src/sockaddr.c
 create mode 100644 src/sockaddr.h

-- 
1.7.8.4

[PATCH 1/6] revname(): explicitly pass size of target space

[Vitezslav Samel]

Signed-off-by: Vitezslav Samel <vitezslav(a)samel.cz&gt;
---
 src/othptab.c  |    6 ++++--
 src/revname.c  |   20 ++++++++++----------
 src/revname.h  |    2 +-
 src/tcptable.c |   10 ++++++----
 4 files changed, 21 insertions(+), 17 deletions(-)

diff --git a/src/othptab.c b/src/othptab.c
index 1d223ce..ef5587b 100644
--- a/src/othptab.c
+++ b/src/othptab.c
@@ -204,8 +204,10 @@ struct othptabent *add_othp_entry(struct othptable *table, struct
pkt_hdr *pkt,
 		else
 			memset(&new_entry->s6addr, 0, 16);
 
-		revname(rev_lookup, &isaddr, s6addr, new_entry->s_fqdn, rvnfd);
-		revname(rev_lookup, &idaddr, d6addr, new_entry->d_fqdn, rvnfd);
+		revname(rev_lookup, &isaddr, s6addr, new_entry->s_fqdn,
+			sizeof(new_entry->s_fqdn), rvnfd);
+		revname(rev_lookup, &idaddr, d6addr, new_entry->d_fqdn,
+			sizeof(new_entry->d_fqdn), rvnfd);
 
 		if (!fragment) {
 			if (protocol == IPPROTO_ICMP) {
diff --git a/src/revname.c b/src/revname.c
index 627b00d..28a1b68 100644
--- a/src/revname.c
+++ b/src/revname.c
@@ -134,7 +134,7 @@ void close_rvn_socket(int fd)
 }
 
 int revname(int *lookup, struct in_addr *saddr, struct in6_addr *s6addr,
-	    char *target, int rvnfd)
+	    char *target, size_t target_size, int rvnfd)
 {
 	struct hostent *he;
 	struct rvn rpkt;
@@ -145,7 +145,7 @@ int revname(int *lookup, struct in_addr *saddr, struct in6_addr
*s6addr,
 	struct timeval tv;
 	int sstat = 0;
 
-	memset(target, 0, 45);
+	memset(target, 0, target_size);
 	if (*lookup) {
 		if (rvnfd > 0) {
 			su.sun_family = AF_UNIX;
@@ -189,14 +189,14 @@ int revname(int *lookup, struct in_addr *saddr, struct in6_addr
*s6addr,
 
 			if (br < 0) {
 				if (saddr->s_addr != 0)
-					inet_ntop(AF_INET, saddr, target, 44);
+					inet_ntop(AF_INET, saddr, target, target_size - 1);
 				else
-					inet_ntop(AF_INET6, s6addr, target, 44);
+					inet_ntop(AF_INET6, s6addr, target, target_size - 1);
 				printipcerr();
 				*lookup = 0;
 				return RESOLVED;
 			}
-			strncpy(target, rpkt.fqdn, 44);
+			strncpy(target, rpkt.fqdn, target_size - 1);
 			return (rpkt.ready);
 		} else {
 			if (saddr->s_addr != 0)
@@ -210,20 +210,20 @@ int revname(int *lookup, struct in_addr *saddr, struct in6_addr
*s6addr,
 
 			if (he == NULL) {
 				if (saddr->s_addr != 0)
-					inet_ntop(AF_INET, saddr, target, 44);
+					inet_ntop(AF_INET, saddr, target, target_size - 1);
 				else
-					inet_ntop(AF_INET6, s6addr, target, 44);
+					inet_ntop(AF_INET6, s6addr, target, target_size - 1);
 			} else {
-				strncpy(target, he->h_name, 44);
+				strncpy(target, he->h_name, target_size - 1);
 			}
 
 			return RESOLVED;
 		}
 	} else {
 		if (saddr->s_addr != 0 || s6addr == NULL)
-			inet_ntop(AF_INET, saddr, target, 44);
+			inet_ntop(AF_INET, saddr, target, target_size - 1);
 		else
-			inet_ntop(AF_INET6, s6addr, target, 44);
+			inet_ntop(AF_INET6, s6addr, target, target_size - 1);
 
 		return RESOLVED;
 	}
diff --git a/src/revname.h b/src/revname.h
index 63dceb1..9a994da 100644
--- a/src/revname.h
+++ b/src/revname.h
@@ -13,6 +13,6 @@ void open_rvn_socket(int *fd);
 void close_rvn_socket(int fd);
 
 int revname(int *lookup, struct in_addr *saddr, struct in6_addr *s6addr,
-	    char *target, int rvnfd);
+	    char *target, size_t target_size, int rvnfd);
 
 #endif	/* IPTRAF_NG_REVNAME_H */
diff --git a/src/tcptable.c b/src/tcptable.c
index ff85c9b..5a19cb5 100644
--- a/src/tcptable.c
+++ b/src/tcptable.c
@@ -352,11 +352,11 @@ struct tcptableent *addentry(struct tcptable *table, unsigned long
int saddr,
 
 	new_entry->s_fstat =
 	    revname(rev_lookup, &(new_entry->saddr), &new_entry->s6addr,
-		    new_entry->s_fqdn, rvnfd);
+		    new_entry->s_fqdn, sizeof(new_entry->s_fqdn), rvnfd);
 
 	new_entry->d_fstat =
 	    revname(rev_lookup, &(new_entry->daddr), &new_entry->d6addr,
-		    new_entry->d_fqdn, rvnfd);
+		    new_entry->d_fqdn, sizeof(new_entry->d_fqdn), rvnfd);
 
 	/*
 	 * Set port service names (where applicable)
@@ -600,14 +600,16 @@ void updateentry(struct tcptable *table, struct tcptableent
*tableentry,
 	if (tableentry->s_fstat != RESOLVED) {
 		tableentry->s_fstat =
 		    revname(revlook, &(tableentry->saddr),
-			    &(tableentry->s6addr), tableentry->s_fqdn, rvnfd);
+			    &(tableentry->s6addr), tableentry->s_fqdn,
+			    sizeof(tableentry->s_fqdn), rvnfd);
 		strcpy(tableentry->oth_connection->d_fqdn, tableentry->s_fqdn);
 		tableentry->oth_connection->d_fstat = tableentry->s_fstat;
 	}
 	if (tableentry->d_fstat != RESOLVED) {
 		tableentry->d_fstat =
 		    revname(revlook, &(tableentry->daddr),
-			    &(tableentry->d6addr), tableentry->d_fqdn, rvnfd);
+			    &(tableentry->d6addr), tableentry->d_fqdn,
+			    sizeof(tableentry->d_fqdn), rvnfd);
 		strcpy(tableentry->oth_connection->s_fqdn, tableentry->d_fqdn);
 		tableentry->oth_connection->s_fstat = tableentry->d_fstat;
 	}
-- 
1.7.8.4

[PATCH 2/6] use inet_ntop() instead of deprecated inet_ntoa() (take 2)

[Vitezslav Samel]

Signed-off-by: Vitezslav Samel <vitezslav(a)samel.cz&gt;
---
 src/othptab.c |    9 +++++----
 src/rvnamed.c |   21 +++++++++------------
 2 files changed, 14 insertions(+), 16 deletions(-)

diff --git a/src/othptab.c b/src/othptab.c
index ef5587b..6b77336 100644
--- a/src/othptab.c
+++ b/src/othptab.c
@@ -235,9 +235,10 @@ struct othptabent *add_othp_entry(struct othptable *table, struct
pkt_hdr *pkt,
 				new_entry->un.ospf.area =
 				    ntohl(((struct ospfhdr *) packet2)->
 					  ospf_areaid.s_addr);
-				strcpy(new_entry->un.ospf.routerid,
-				       inet_ntoa(((struct ospfhdr *)
-						  packet2)->ospf_routerid));
+				inet_ntop(AF_INET,
+					  &((struct ospfhdr *)packet2)->ospf_routerid,
+					  new_entry->un.ospf.routerid,
+					  sizeof(new_entry->un.ospf.routerid));
 			}
 		}
 	} else {
@@ -400,7 +401,7 @@ void printothpentry(struct othptable *table, struct othptabent
*entry,
 				break;
 			}
 
-			sprintf(scratchpad, inet_ntoa(saddr));
+			inet_ntop(AF_INET, &saddr, scratchpad, sizeof(scratchpad));
 			strcat(msgstring, scratchpad);
 			wattrset(table->othpwin, ARPATTR);
 			break;
diff --git a/src/rvnamed.c b/src/rvnamed.c
index a0a4f5f..a663b85 100644
--- a/src/rvnamed.c
+++ b/src/rvnamed.c
@@ -97,7 +97,8 @@ static void process_rvn_packet(struct rvn *rvnpacket)
 
 	if (he == NULL) {
 		if (rvnpacket->saddr.s_addr != 0)
-			strcpy(rvnpacket->fqdn, inet_ntoa(rvnpacket->saddr));
+			inet_ntop(AF_INET, &rvnpacket->saddr,
+				  rvnpacket->fqdn, sizeof(rvnpacket->fqdn));
 		else
 			inet_ntop(AF_INET6, &(rvnpacket->s6addr),
 				  rvnpacket->fqdn, sizeof(rvnpacket->fqdn));
@@ -506,19 +507,15 @@ int main(void)
 						rvnpacket.type = RVN_REPLY;
 						memset(rvnpacket.fqdn, 0, sizeof(rvnpacket.fqdn));
 						if (rvnpacket.saddr.s_addr != 0)
-							strcpy(rvnpacket.fqdn,
-							       inet_ntoa
-							       (rvnpacket.
-								saddr));
+							inet_ntop(AF_INET,
+								  &rvnpacket.saddr,
+								  rvnpacket.fqdn,
+								  sizeof(rvnpacket.fqdn));
 						else
 							inet_ntop(AF_INET6,
-								  &rvnpacket.
-								  s6addr,
-								  rvnpacket.
-								  fqdn,
-								  sizeof
-								  (rvnpacket.
-								   fqdn));
+								  &rvnpacket.s6addr,
+								  rvnpacket.fqdn,
+								  sizeof(rvnpacket.fqdn));
 						rvnpacket.ready = RESOLVING;
 
 						br = sendto(ifd, &rvnpacket,
-- 
1.7.8.4

[PATCH 3/6] sockaddr.c: new helpers ...

[Vitezslav Samel]

... which can make lot of functions address family agnostic.

Signed-off-by: Vitezslav Samel <vitezslav(a)samel.cz&gt;
---
 Makefile       |    4 ++
 src/sockaddr.c |  129 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 src/sockaddr.h |   14 ++++++
 3 files changed, 147 insertions(+), 0 deletions(-)
 create mode 100644 src/sockaddr.c
 create mode 100644 src/sockaddr.h

diff --git a/Makefile b/Makefile
index a533b0f..c72ff7a 100644
--- a/Makefile
+++ b/Makefile
@@ -115,6 +115,7 @@ iptraf-h += src/list.h
 iptraf-h += src/counters.h
 iptraf-h += src/rate.h
 iptraf-h += src/built-in.h
+iptraf-h += src/sockaddr.h
 
 iptraf-o += src/tui/input.o
 iptraf-o += src/tui/labels.o
@@ -157,9 +158,12 @@ iptraf-o += src/cidr.o
 iptraf-o += src/counters.o
 iptraf-o += src/rate.o
 iptraf-o += src/capture-pkt.o
+iptraf-o += src/sockaddr.o
 
 rvnamed-o += src/rvnamed.o
 rvnamed-o += src/getpath.o
+rvnamed-o += src/sockaddr.o
+rvnamed-o += src/usage.o
 
 -include config.mak.autogen
 -include config.mak
diff --git a/src/sockaddr.c b/src/sockaddr.c
new file mode 100644
index 0000000..b86ec5c
--- /dev/null
+++ b/src/sockaddr.c
@@ -0,0 +1,129 @@
+/* For terms of usage/redistribution/modification see the LICENSE file */
+/* For authors and contributors see the AUTHORS file */
+
+#include "iptraf-ng-compat.h"
+
+void sockaddr_make_ipv4(struct sockaddr_storage *sockaddr,
+			u_int32_t addr)
+{
+	if (!sockaddr)
+		die("%s(): sockaddr == NULL", __FUNCTION__);
+
+	memset(sockaddr, 0, sizeof(*sockaddr));
+	struct sockaddr_in *sockaddr_in = (struct sockaddr_in *)sockaddr;
+	sockaddr_in->sin_family = AF_INET;
+	sockaddr_in->sin_port = 0;
+	sockaddr_in->sin_addr.s_addr = addr;
+}
+
+void sockaddr_make_ipv6(struct sockaddr_storage *sockaddr,
+			struct in6_addr *addr)
+{
+	if (!sockaddr)
+		die("%s(): sockaddr == NULL", __FUNCTION__);
+	if (!addr)
+		die("%s(): addr == NULL", __FUNCTION__);
+
+	memset(sockaddr, 0, sizeof(*sockaddr));
+	struct sockaddr_in6 *sockaddr_in6 = (struct sockaddr_in6 *)sockaddr;
+	sockaddr_in6->sin6_family = AF_INET6;
+	sockaddr_in6->sin6_port = 0;
+	sockaddr_in6->sin6_addr = *addr;
+	sockaddr_in6->sin6_flowinfo = 0;
+	sockaddr_in6->sin6_scope_id = 0;
+}
+
+int sockaddr_is_equal(struct sockaddr_storage *addr1,
+		      struct sockaddr_storage *addr2)
+{
+	if (!addr1)
+		die("%s(): addr1 == NULL", __FUNCTION__);
+	if (!addr2)
+		die("%s(): addr2 == NULL", __FUNCTION__);
+
+	if (addr1->ss_family != addr2->ss_family)
+		return 0;
+
+	switch (addr1->ss_family) {
+	case AF_INET: {
+		struct sockaddr_in *sa1 = (struct sockaddr_in *)addr1;
+		struct sockaddr_in *sa2 = (struct sockaddr_in *)addr2;
+
+		if ((sa1->sin_addr.s_addr == sa2->sin_addr.s_addr)
+		    && (sa1->sin_port == sa2->sin_port))
+			return 1;
+		else
+			return 0;
+		}
+	case AF_INET6: {
+		struct sockaddr_in6 *sa1 = (struct sockaddr_in6 *)addr1;
+		struct sockaddr_in6 *sa2 = (struct sockaddr_in6 *)addr2;
+
+		if ((sa1->sin6_port == sa2->sin6_port)
+		    && (sa1->sin6_flowinfo == sa2->sin6_flowinfo)
+		    && (sa1->sin6_scope_id == sa2->sin6_scope_id)
+		    && (memcmp(&sa1->sin6_addr, &sa2->sin6_addr,
sizeof(sa1->sin6_addr)) == 0))
+			return 1;
+		else
+			return 0;
+	       }
+	default:
+		die("%s(): Unknown address family", __FUNCTION__);
+	}
+}
+
+void sockaddr_ntop(struct sockaddr_storage *addr, char *buf, size_t buflen)
+{
+	if(!addr)
+		die("%s(): addr == NULL", __FUNCTION__);
+
+	const char *ret;
+	size_t minlen;
+
+	memset(buf, 0, buflen);
+	switch (addr->ss_family) {
+	case AF_INET:
+		minlen = INET_ADDRSTRLEN;
+		ret = inet_ntop(AF_INET, &((struct sockaddr_in *)addr)->sin_addr, buf, buflen -
1);
+		break;
+	case AF_INET6:
+		minlen = INET6_ADDRSTRLEN;
+		ret = inet_ntop(AF_INET6, &((struct sockaddr_in6 *)addr)->sin6_addr, buf, buflen
- 1);
+		break;
+	default:
+		die("%s(): Unknown address family", __FUNCTION__);
+	}
+	if (ret == NULL) {
+		switch (errno) {
+		case ENOSPC:
+			die("%s(): buffer too small (must be at least %u bytes)", __FUNCTION__,
minlen);
+		case EAFNOSUPPORT:
+			die("%s(): Unknown address family", __FUNCTION__);
+		}
+	}
+}
+
+struct hostent *sockaddr_gethostbyaddr(struct sockaddr_storage *addr)
+{
+	if(!addr)
+		die("%s(): addr == NULL", __FUNCTION__);
+
+	switch (addr->ss_family) {
+	case AF_INET:
+		return gethostbyaddr(&((struct sockaddr_in *)addr)->sin_addr, sizeof(struct
in_addr), AF_INET);
+	case AF_INET6:
+		return gethostbyaddr(&((struct sockaddr_in6 *)addr)->sin6_addr, sizeof(struct
in6_addr), AF_INET6);
+	default:
+		die("%s(): Unknown address family", __FUNCTION__);
+	}
+}
+
+void sockaddr_copy(struct sockaddr_storage *dest, struct sockaddr_storage *src)
+{
+	if (!src)
+		die("%s(): src == NULL", __FUNCTION__);
+	if (!dest)
+		die("%s(): dest == NULL", __FUNCTION__);
+
+	memcpy(dest, src, sizeof(struct sockaddr_storage));
+}
diff --git a/src/sockaddr.h b/src/sockaddr.h
new file mode 100644
index 0000000..83648c5
--- /dev/null
+++ b/src/sockaddr.h
@@ -0,0 +1,14 @@
+#ifndef IPTRAF_NG_SOCKADDR_H
+#define IPTRAF_NG_SOCKADDR_H
+
+void sockaddr_make_ipv4(struct sockaddr_storage *sockaddr,
+			u_int32_t addr);
+void sockaddr_make_ipv6(struct sockaddr_storage *sockaddr,
+			struct in6_addr *addr);
+int sockaddr_is_equal(struct sockaddr_storage *addr1,
+		      struct sockaddr_storage *addr2);
+void sockaddr_ntop(struct sockaddr_storage *addr, char *buf, size_t buflen);
+struct hostent *sockaddr_gethostbyaddr(struct sockaddr_storage *addr);
+void sockaddr_copy(struct sockaddr_storage *dest, struct sockaddr_storage *src);
+
+#endif	/* IPTRAF_NG_SOCKADDR_H */
-- 
1.7.8.4

[PATCH 4/6] use sockaddr_*() helpers for addresses

[Vitezslav Samel]

convert some functions using sockaddr_*() helpers to be address
family agnostic.

Signed-off-by: Vitezslav Samel <vitezslav(a)samel.cz&gt;
---
 src/itrafmon.c |   42 ++++++++----------
 src/othptab.c  |   40 +++++++----------
 src/othptab.h  |   12 ++---
 src/revname.c  |   38 +++-------------
 src/revname.h  |    2 +-
 src/rvnamed.c  |   97 ++++++++----------------------------------
 src/rvnamed.h  |    3 +-
 src/tcptable.c |  129 +++++++++++++++++++++++++-------------------------------
 src/tcptable.h |   24 +++++-----
 9 files changed, 138 insertions(+), 249 deletions(-)

diff --git a/src/itrafmon.c b/src/itrafmon.c
index 4c64cac..d28d988 100644
--- a/src/itrafmon.c
+++ b/src/itrafmon.c
@@ -32,6 +32,7 @@ itrafmon.c - the IP traffic monitor module
 #include "instances.h"
 #include "logvars.h"
 #include "itrafmon.h"
+#include "sockaddr.h"
 
 #define SCROLLUP 0
 #define SCROLLDOWN 1
@@ -1011,16 +1012,21 @@ void ipmon(struct OPTIONS *options, struct filterstate *ofilter,
 			ifname = ifnamebuf;
 		}
 
+		struct sockaddr_storage saddr, daddr;
 		switch(pkt.pkt_protocol) {
 		case ETH_P_IP:
 			frag_off = pkt.iphdr->frag_off;
+			sockaddr_make_ipv4(&saddr, pkt.iphdr->saddr);
+			sockaddr_make_ipv4(&daddr, pkt.iphdr->daddr);
 			break;
 		case ETH_P_IPV6:
 			frag_off = 0;
+			sockaddr_make_ipv6(&saddr, &pkt.ip6_hdr->ip6_src);
+			sockaddr_make_ipv6(&daddr, &pkt.ip6_hdr->ip6_dst);
 			break;
 		default:
-			add_othp_entry(&othptbl, &pkt, 0, 0, NULL,
-				       NULL, NOT_IP,
+			add_othp_entry(&othptbl, &pkt, NULL, NULL,
+				       NOT_IP,
 				       pkt.pkt_protocol,
 				       pkt.pkt_payload, ifname, 0,
 				       0, logging, logfile,
@@ -1036,21 +1042,14 @@ void ipmon(struct OPTIONS *options, struct filterstate *ofilter,
 		if (ip_protocol == IPPROTO_TCP) {
 			if (pkt.iphdr) {
 				tcpentry =
-					in_table(&table,
-						 pkt.iphdr->saddr,
-						 pkt.iphdr->daddr,
-						 NULL, NULL,
+					in_table(&table, &saddr, &daddr,
 						 ntohs(sport),
 						 ntohs(dport),
 						 ifname, logging,
 						 logfile, options);
 			} else {
 				tcpentry =
-					in_table(&table, 0, 0,
-						 (uint8_t *) &pkt.ip6_hdr->
-						 ip6_src.s6_addr,
-						 (uint8_t *) &pkt.ip6_hdr->
-						 ip6_dst.s6_addr,
+					in_table(&table, &saddr, &daddr,
 						 ntohs(sport), ntohs(dport),
 						 ifname, logging, logfile, options);
 			}
@@ -1071,19 +1070,16 @@ void ipmon(struct OPTIONS *options, struct filterstate *ofilter,
 				wasempty = (table.head == NULL);
 				if (pkt.iphdr)
 					tcpentry =
-						addentry(&table,
-							 (unsigned long) pkt.iphdr->saddr,
-							 (unsigned long) pkt.iphdr->daddr,
-							 NULL, NULL, sport, dport,
+						addentry(&table, &saddr, &daddr,
+							 sport, dport,
 							 pkt_ip_protocol(&pkt),
 							 ifname, &revlook, rvnfd,
 							 options->servnames);
 				else
 					tcpentry =
-						addentry(&table, 0, 0,
-							 (uint8_t *) &pkt.ip6_hdr->ip6_src.s6_addr,
-							 (uint8_t *) &pkt.ip6_hdr->ip6_dst.s6_addr,
-							 sport, dport, pkt_ip_protocol(&pkt),
+						addentry(&table, &saddr, &daddr,
+							 sport, dport,
+							 pkt_ip_protocol(&pkt),
 							 ifname, &revlook, rvnfd,
 							 options->servnames);
 				if (tcpentry != NULL) {
@@ -1192,9 +1188,8 @@ void ipmon(struct OPTIONS *options, struct filterstate *ofilter,
 					process_dest_unreach(&table, (char *) transpacket,
 							     ifname);
 			}
-			add_othp_entry(&othptbl, &pkt, pkt.iphdr->saddr,
-				       pkt.iphdr->daddr, NULL, NULL, IS_IP,
-				       pkt_ip_protocol(&pkt),
+			add_othp_entry(&othptbl, &pkt, &saddr, &daddr,
+				       IS_IP, pkt_ip_protocol(&pkt),
 				       (char *) transpacket,
 				       ifname, &revlook, rvnfd,
 				       logging, logfile,
@@ -1206,8 +1201,7 @@ void ipmon(struct OPTIONS *options, struct filterstate *ofilter,
 				process_dest_unreach(&table, (char *) transpacket,
 						     ifname);
 
-			add_othp_entry(&othptbl, &pkt, 0, 0,
-				       &pkt.ip6_hdr->ip6_src, &pkt.ip6_hdr->ip6_dst,
+			add_othp_entry(&othptbl, &pkt, &saddr, &daddr,
 				       IS_IP, pkt_ip_protocol(&pkt),
 				       (char *) transpacket, ifname,
 				       &revlook, rvnfd,
diff --git a/src/othptab.c b/src/othptab.c
index 6b77336..592ee09 100644
--- a/src/othptab.c
+++ b/src/othptab.c
@@ -24,6 +24,7 @@ othptab.c - non-TCP protocol display module
 #include "addproto.h"
 #include "packet.h"
 #include "hostmon.h"
+#include "sockaddr.h"
 
 #define MSGSTRING_MAX	240
 #define SHORTSTRING_MAX	40
@@ -141,18 +142,22 @@ void process_dest_unreach(struct tcptable *table, char *packet, char
*ifname)
 		if (ip6->ip6_nxt != IPPROTO_TCP)
 			return;
 		tcp = (struct tcphdr *) (packet + 48);
+		struct sockaddr_storage saddr, daddr;
+		sockaddr_make_ipv6(&saddr, &ip6->ip6_src);
+		sockaddr_make_ipv6(&daddr, &ip6->ip6_dst);
 		tcpentry =
-		    in_table(table, 0, 0, ip6->ip6_src.s6_addr,
-			     ip6->ip6_dst.s6_addr, ntohs(tcp->source),
+		    in_table(table, &saddr, &daddr, ntohs(tcp->source),
 			     ntohs(tcp->dest), ifname, 0, NULL, NULL);
 	} else {
 		if (ip->protocol != IPPROTO_TCP)
 			return;
 		tcp = (struct tcphdr *) (packet + 8 + (ip->ihl * 4));
+		struct sockaddr_storage saddr, daddr;
+		sockaddr_make_ipv4(&saddr, ip->saddr);
+		sockaddr_make_ipv4(&daddr, ip->daddr);
 		tcpentry =
-		    in_table(table, ip->saddr, ip->daddr, NULL, NULL,
-			     ntohs(tcp->source), ntohs(tcp->dest), ifname, 0,
-			     NULL, NULL);
+		    in_table(table, &saddr, &daddr, ntohs(tcp->source),
+			     ntohs(tcp->dest), ifname, 0, NULL, NULL);
 	}
 
 	if (tcpentry != NULL) {
@@ -162,9 +167,9 @@ void process_dest_unreach(struct tcptable *table, char *packet, char
*ifname)
 }
 
 struct othptabent *add_othp_entry(struct othptable *table, struct pkt_hdr *pkt,
-				  unsigned long saddr,
-				  unsigned long daddr, struct in6_addr *s6addr,
-				  struct in6_addr *d6addr, int is_ip,
+				  struct sockaddr_storage *saddr,
+				  struct sockaddr_storage *daddr,
+				  int is_ip,
 				  int protocol,
 				  char *packet2,
 				  char *ifname, int *rev_lookup, int rvnfd,
@@ -173,7 +178,6 @@ struct othptabent *add_othp_entry(struct othptable *table, struct
pkt_hdr *pkt,
 {
 	struct othptabent *new_entry;
 	struct othptabent *temp;
-	struct in_addr isaddr, idaddr;
 
 	new_entry = xmallocz(sizeof(struct othptabent));
 
@@ -191,22 +195,12 @@ struct othptabent *add_othp_entry(struct othptable *table, struct
pkt_hdr *pkt,
 	}
 
 	if (is_ip) {
-		new_entry->saddr = isaddr.s_addr = saddr;
-		new_entry->daddr = idaddr.s_addr = daddr;
-
-		if (s6addr != NULL)
-			memcpy(&new_entry->s6addr, s6addr, 16);
-		else
-			memset(&new_entry->s6addr, 0, 16);
-
-		if (d6addr != NULL)
-			memcpy(&new_entry->d6addr, d6addr, 16);
-		else
-			memset(&new_entry->s6addr, 0, 16);
+		sockaddr_copy(&new_entry->saddr, saddr);
+		sockaddr_copy(&new_entry->daddr, daddr);
 
-		revname(rev_lookup, &isaddr, s6addr, new_entry->s_fqdn,
+		revname(rev_lookup, saddr, new_entry->s_fqdn,
 			sizeof(new_entry->s_fqdn), rvnfd);
-		revname(rev_lookup, &idaddr, d6addr, new_entry->d_fqdn,
+		revname(rev_lookup, daddr, new_entry->d_fqdn,
 			sizeof(new_entry->d_fqdn), rvnfd);
 
 		if (!fragment) {
diff --git a/src/othptab.h b/src/othptab.h
index fbd9456..153d013 100644
--- a/src/othptab.h
+++ b/src/othptab.h
@@ -20,10 +20,8 @@ othptab.h - header file for the non-TCP routines
 #define VSCRL_OFFSET	60	/* Characters to vertically scroll */
 
 struct othptabent {
-	unsigned long int saddr;
-	unsigned long int daddr;
-	struct in6_addr s6addr;
-	struct in6_addr d6addr;
+	struct sockaddr_storage saddr;
+	struct sockaddr_storage daddr;
 	char smacaddr[18];	/* FIXME: use dynamicly allocated space */
 	char dmacaddr[18];
 	unsigned short linkproto;
@@ -124,9 +122,9 @@ void init_othp_table(struct othptable *table, int mac);
 void process_dest_unreach(struct tcptable *table, char *packet, char *ifname);
 
 struct othptabent *add_othp_entry(struct othptable *table, struct pkt_hdr *pkt,
-				  unsigned long saddr,
-				  unsigned long daddr, struct in6_addr *s6addr,
-				  struct in6_addr *d6addr, int is_ip,
+				  struct sockaddr_storage *saddr,
+				  struct sockaddr_storage *daddr,
+				  int is_ip,
 				  int protocol,
 				  char *packet2,
 				  char *ifname, int *rev_lookup, int rvnamedon,
diff --git a/src/revname.c b/src/revname.c
index 28a1b68..8188789 100644
--- a/src/revname.c
+++ b/src/revname.c
@@ -16,6 +16,7 @@ interim IP addresses in the meantime.
 #include "getpath.h"
 #include "revname.h"
 #include "rvnamed.h"
+#include "sockaddr.h"
 
 char revname_socket[80];
 
@@ -133,10 +134,9 @@ void close_rvn_socket(int fd)
 	}
 }
 
-int revname(int *lookup, struct in_addr *saddr, struct in6_addr *s6addr,
+int revname(int *lookup, struct sockaddr_storage *addr,
 	    char *target, size_t target_size, int rvnfd)
 {
-	struct hostent *he;
 	struct rvn rpkt;
 	int br;
 	struct sockaddr_un su;
@@ -152,13 +152,7 @@ int revname(int *lookup, struct in_addr *saddr, struct in6_addr
*s6addr,
 			strcpy(su.sun_path, IPTSOCKNAME);
 
 			rpkt.type = RVN_REQUEST;
-			rpkt.saddr.s_addr = saddr->s_addr;
-
-			if (s6addr != NULL)
-				memcpy(rpkt.s6addr.s6_addr, s6addr->s6_addr,
-				       16);
-			else
-				memset(rpkt.s6addr.s6_addr, 0, 4);
+			sockaddr_copy(&rpkt.addr, addr);
 
 			sendto(rvnfd, &rpkt, sizeof(struct rvn), 0,
 			       (struct sockaddr *) &su,
@@ -188,10 +182,7 @@ int revname(int *lookup, struct in_addr *saddr, struct in6_addr
*s6addr,
 			} while ((br < 0) && (errno == EINTR));
 
 			if (br < 0) {
-				if (saddr->s_addr != 0)
-					inet_ntop(AF_INET, saddr, target, target_size - 1);
-				else
-					inet_ntop(AF_INET6, s6addr, target, target_size - 1);
+				sockaddr_ntop(addr, target, target_size);
 				printipcerr();
 				*lookup = 0;
 				return RESOLVED;
@@ -199,20 +190,9 @@ int revname(int *lookup, struct in_addr *saddr, struct in6_addr
*s6addr,
 			strncpy(target, rpkt.fqdn, target_size - 1);
 			return (rpkt.ready);
 		} else {
-			if (saddr->s_addr != 0)
-				he = gethostbyaddr((char *) saddr,
-						   sizeof(struct in_addr),
-						   AF_INET);
-			else
-				he = gethostbyaddr((char *) s6addr,
-						   sizeof(struct in6_addr),
-						   AF_INET6);
-
+			struct hostent *he = sockaddr_gethostbyaddr(addr);
 			if (he == NULL) {
-				if (saddr->s_addr != 0)
-					inet_ntop(AF_INET, saddr, target, target_size - 1);
-				else
-					inet_ntop(AF_INET6, s6addr, target, target_size - 1);
+				sockaddr_ntop(addr, target, target_size);
 			} else {
 				strncpy(target, he->h_name, target_size - 1);
 			}
@@ -220,11 +200,7 @@ int revname(int *lookup, struct in_addr *saddr, struct in6_addr
*s6addr,
 			return RESOLVED;
 		}
 	} else {
-		if (saddr->s_addr != 0 || s6addr == NULL)
-			inet_ntop(AF_INET, saddr, target, target_size - 1);
-		else
-			inet_ntop(AF_INET6, s6addr, target, target_size - 1);
-
+		sockaddr_ntop(addr, target, target_size);
 		return RESOLVED;
 	}
 	return NOTRESOLVED;
diff --git a/src/revname.h b/src/revname.h
index 9a994da..847d832 100644
--- a/src/revname.h
+++ b/src/revname.h
@@ -12,7 +12,7 @@ void killrvnamed(void);
 void open_rvn_socket(int *fd);
 void close_rvn_socket(int fd);
 
-int revname(int *lookup, struct in_addr *saddr, struct in6_addr *s6addr,
+int revname(int *lookup, struct sockaddr_storage *addr,
 	    char *target, size_t target_size, int rvnfd);
 
 #endif	/* IPTRAF_NG_REVNAME_H */
diff --git a/src/rvnamed.c b/src/rvnamed.c
index a663b85..2ad1fd4 100644
--- a/src/rvnamed.c
+++ b/src/rvnamed.c
@@ -42,6 +42,7 @@ socket protocol.
 #include <sys/wait.h>
 #include "rvnamed.h"
 #include "dirs.h"
+#include "sockaddr.h"
 
 #define NUM_CACHE_ENTRIES 2048
 #define TIME_TARGET_MAX 30
@@ -49,8 +50,7 @@ socket protocol.
 #define __unused __attribute__((unused))
 
 struct hosts {
-	unsigned long addr;
-	uint8_t addr6[16];
+	struct sockaddr_storage addr;
 	char fqdn[45];
 	int ready;
 };
@@ -88,23 +88,14 @@ static void process_rvn_packet(struct rvn *rvnpacket)
 
 	ccfd = socket(PF_UNIX, SOCK_DGRAM, 0);
 
-	if (rvnpacket->saddr.s_addr != 0)
-		he = gethostbyaddr((char *) &(rvnpacket->saddr),
-				   sizeof(struct in_addr), AF_INET);
-	else
-		he = gethostbyaddr((char *) &(rvnpacket->s6addr),
-				   sizeof(struct in6_addr), AF_INET6);
-
+	he = sockaddr_gethostbyaddr(&rvnpacket->addr);
 	if (he == NULL) {
-		if (rvnpacket->saddr.s_addr != 0)
-			inet_ntop(AF_INET, &rvnpacket->saddr,
-				  rvnpacket->fqdn, sizeof(rvnpacket->fqdn));
-		else
-			inet_ntop(AF_INET6, &(rvnpacket->s6addr),
-				  rvnpacket->fqdn, sizeof(rvnpacket->fqdn));
+		sockaddr_ntop(&rvnpacket->addr, rvnpacket->fqdn,
+			      sizeof(rvnpacket->fqdn));
 	} else {
 		memset(rvnpacket->fqdn, 0, sizeof(rvnpacket->fqdn));
-		strncpy(rvnpacket->fqdn, he->h_name, sizeof(rvnpacket->fqdn)-1);
+		strncpy(rvnpacket->fqdn, he->h_name,
+			sizeof(rvnpacket->fqdn) - 1);
 	}
 
 	ccsa.sun_family = AF_UNIX;
@@ -124,17 +115,9 @@ static int name_resolved(struct rvn *rvnpacket, struct hosts
*hostlist,
 			 unsigned int lastfree)
 {
 	for (unsigned int i = 0; i != lastfree; i++)
-		if (hostlist[i].ready == RESOLVED) {
-			if (rvnpacket->saddr.s_addr != 0) {
-				if (rvnpacket->saddr.s_addr == hostlist[i].addr)
-					return i;
-			} else {
-				if (!memcmp(rvnpacket->s6addr.s6_addr,
-					    hostlist[i].addr6,
-					    sizeof(hostlist[i].addr6)))
-					return i;
-			}
-		}
+		if ((hostlist[i].ready == RESOLVED)
+		    && sockaddr_is_equal(&rvnpacket->addr, &hostlist[i].addr))
+			return i;
 
 	return -1;
 }
@@ -147,15 +130,10 @@ static int name_resolved(struct rvn *rvnpacket, struct hosts
*hostlist,
 static int addrstat(struct rvn *rvnpacket, struct hosts *hostlist,
 		    unsigned int lastfree)
 {
-	for (unsigned int i = 0; i != lastfree; i++) {
-		if (rvnpacket->saddr.s_addr != 0) {
-			if (rvnpacket->saddr.s_addr == hostlist[i].addr)
-				return hostlist[i].ready;
-		} else if (!memcmp(&rvnpacket->s6addr.s6_addr,
-				   &hostlist[i].addr6,
-				   sizeof(hostlist[i].addr6)))
+	for (unsigned int i = 0; i != lastfree; i++)
+		if (sockaddr_is_equal(&rvnpacket->addr, &hostlist[i].addr))
 			return hostlist[i].ready;
-	}
+
 	return NOTRESOLVED;
 }
 
@@ -302,12 +280,7 @@ int main(void)
 				hi = 0;
 
 				while (hi <= lastfree) {
-					if ((hostlist[hi].addr ==
-					     rvnpacket.saddr.s_addr)
-					    && !memcmp(rvnpacket.s6addr.s6_addr,
-						       hostlist[hi].addr6,
-						       sizeof(hostlist[hi].
-							      addr6)))
+					if (sockaddr_is_equal(&hostlist[hi].addr, &rvnpacket.addr))
 						break;
 					hi++;
 				}
@@ -320,13 +293,9 @@ int main(void)
 					if (hostindex == NUM_CACHE_ENTRIES)
 						hostindex = 0;
 
-					hostlist[hi].addr =
-					    rvnpacket.saddr.s_addr;
-					memcpy(hostlist[hi].addr6,
-					       rvnpacket.s6addr.s6_addr,
-					       sizeof(hostlist[hi].addr6));
+					sockaddr_copy(&hostlist[hi].addr, &rvnpacket.addr);
 				}
-				strncpy(hostlist[hi].fqdn, rvnpacket.fqdn, 44);
+				strncpy(hostlist[hi].fqdn, rvnpacket.fqdn, sizeof(hostlist[hi].fqdn) - 1);
 
 				hostlist[hi].ready = RESOLVED;
 			}
@@ -423,26 +392,8 @@ int main(void)
 								 * address is RESOLVING.
 								 *
 								 */
-								hostlist
-								    [hostindex].
-								    addr =
-								    rvnpacket.
-								    saddr.
-								    s_addr;
-								memcpy(hostlist
-								       [hostindex].
-								       addr6,
-								       rvnpacket.
-								       s6addr.
-								       s6_addr,
-								       sizeof
-								       (hostlist
-									[hostindex].
-									addr6));
-								hostlist
-								    [hostindex].
-								    ready =
-								    RESOLVING;
+								sockaddr_copy(&hostlist[hostindex].addr, &rvnpacket.addr);
+								hostlist[hostindex].ready = RESOLVING;
 
 								maxlogged = 0;
 								fr = fork();
@@ -505,17 +456,7 @@ int main(void)
 							}
 						}
 						rvnpacket.type = RVN_REPLY;
-						memset(rvnpacket.fqdn, 0, sizeof(rvnpacket.fqdn));
-						if (rvnpacket.saddr.s_addr != 0)
-							inet_ntop(AF_INET,
-								  &rvnpacket.saddr,
-								  rvnpacket.fqdn,
-								  sizeof(rvnpacket.fqdn));
-						else
-							inet_ntop(AF_INET6,
-								  &rvnpacket.s6addr,
-								  rvnpacket.fqdn,
-								  sizeof(rvnpacket.fqdn));
+						sockaddr_ntop(&rvnpacket.addr, rvnpacket.fqdn, sizeof(rvnpacket.fqdn));
 						rvnpacket.ready = RESOLVING;
 
 						br = sendto(ifd, &rvnpacket,
diff --git a/src/rvnamed.h b/src/rvnamed.h
index 91442d6..6155493 100644
--- a/src/rvnamed.h
+++ b/src/rvnamed.h
@@ -24,8 +24,7 @@
 struct rvn {
 	int type;
 	int ready;
-	struct in_addr saddr;
-	struct in6_addr s6addr;
+	struct sockaddr_storage addr;
 	char fqdn[45];
 };
 
diff --git a/src/tcptable.c b/src/tcptable.c
index 5a19cb5..1167b10 100644
--- a/src/tcptable.c
+++ b/src/tcptable.c
@@ -20,6 +20,7 @@ tcptable.c - table manipulation routines for the IP monitor
 #include "rvnamed.h"
 #include "servname.h"
 #include "hostmon.h"
+#include "sockaddr.h"
 
 #define MSGSTRING_MAX	320
 
@@ -50,26 +51,47 @@ static void setlabels(WINDOW *win, int mode)
  * The hash function for the TCP hash table
  */
 
-static unsigned int tcp_hash(unsigned long saddr, uint32_t *s6addr,
-			     unsigned int sport, unsigned long daddr,
-			     uint32_t *d6addr, unsigned int dport,
+static unsigned int tcp_hash(struct sockaddr_storage *saddr, unsigned int sport,
+			     struct sockaddr_storage *daddr, unsigned int dport,
 			     char *ifname)
 {
 	size_t i;
-	int ifsum = 0;
+	unsigned int ifsum = 0;
 
 	for (i = 0; i <= strlen(ifname) - 1; i++)
 		ifsum += ifname[i];
 
-	if (s6addr != 0 && d6addr != 0) {
-		for (i = 0; i < 4; i++) {
-			saddr ^= s6addr[i];
-			daddr ^= d6addr[i];
-		}
+	switch (saddr->ss_family) {
+	case AF_INET:
+		ifsum += 4 * ((struct sockaddr_in *)saddr)->sin_addr.s_addr;
+		ifsum += 3 * sport;
+		break;
+	case AF_INET6: {
+		unsigned int ip6sum = 0;
+		for (i = 0; i < 4; i++)
+			ip6sum ^= ((struct sockaddr_in6 *)saddr)->sin6_addr.s6_addr32[i];
+		ifsum += 4 * ip6sum;
+		ifsum += 3 * sport;
+		break; }
+	default:
+		die("%s(): saddr: unknown address family", __FUNCTION__);
 	}
-
-	return ((ifsum + (4 * saddr) + (3 * sport) + (2 * daddr) +
-		 dport) % ENTRIES_IN_HASH_TABLE);
+	switch (daddr->ss_family) {
+	case AF_INET:
+		ifsum += 2 * ((struct sockaddr_in *)daddr)->sin_addr.s_addr;
+		ifsum += dport;
+		break;
+	case AF_INET6: {
+		unsigned int ip6sum = 0;
+		for (i = 0; i < 4; i++)
+			ip6sum ^= ((struct sockaddr_in6 *)daddr)->sin6_addr.s6_addr32[i];
+		ifsum += 2 * ip6sum;
+		ifsum += dport;
+		break; }
+	default:
+		die("%s(): daddr: unknown address family", __FUNCTION__);
+	}
+	return (ifsum % ENTRIES_IN_HASH_TABLE);
 }
 
 static void print_tcp_num_entries(struct tcptable *table)
@@ -138,10 +160,8 @@ static void add_tcp_hash_entry(struct tcptable *table, struct
tcptableent *entry
 	unsigned int hp;	/* hash position in table */
 	struct tcp_hashentry *ptmp;
 
-	hp = tcp_hash(entry->saddr.s_addr, entry->s6addr.s6_addr32,
-		      entry->sport, entry->daddr.s_addr,
-		      entry->d6addr.s6_addr32, entry->dport, entry->ifname);
-
+	hp = tcp_hash(&entry->saddr, entry->sport,
+		      &entry->daddr, entry->dport, entry->ifname);
 	ptmp = xmallocz(sizeof(struct tcp_hashentry));
 	/*
 	 * Add backpointer from screen node to hash node for deletion later
@@ -205,10 +225,11 @@ static void del_tcp_hash_node(struct tcptable *table, struct
tcptableent *entry)
  * Add a new entry to the TCP screen table
  */
 
-struct tcptableent *addentry(struct tcptable *table, unsigned long int saddr,
-			     unsigned long int daddr, uint8_t * s6addr,
-			     uint8_t * d6addr, unsigned int sport,
-			     unsigned int dport, int protocol, char *ifname,
+struct tcptableent *addentry(struct tcptable *table,
+			     struct sockaddr_storage *saddr,
+			     struct sockaddr_storage *daddr,
+			     unsigned int sport, unsigned int dport,
+			     int protocol, char *ifname,
 			     int *rev_lookup, int rvnfd, int servnames)
 {
 	struct tcptableent *new_entry;
@@ -296,24 +317,10 @@ struct tcptableent *addentry(struct tcptable *table, unsigned long
int saddr,
 	 * Fill in address fields with raw IP addresses
 	 */
 
-	new_entry->saddr.s_addr = new_entry->oth_connection->daddr.s_addr =
-	    saddr;
-	if (s6addr == NULL) {
-		memset(&new_entry->s6addr, 0, 16);
-		memset(&new_entry->oth_connection->d6addr, 0, 16);
-	} else {
-		memcpy(&new_entry->s6addr, s6addr, 16);
-		memcpy(&new_entry->oth_connection->d6addr, s6addr, 16);
-	}
-	new_entry->daddr.s_addr = new_entry->oth_connection->saddr.s_addr =
-	    daddr;
-	if (d6addr == NULL) {
-		memset(&new_entry->d6addr, 0, 16);
-		memset(&new_entry->oth_connection->s6addr, 0, 16);
-	} else {
-		memcpy(&new_entry->d6addr, d6addr, 16);
-		memcpy(&new_entry->oth_connection->s6addr, d6addr, 16);
-	}
+	sockaddr_copy(&new_entry->saddr, saddr);
+	sockaddr_copy(&new_entry->oth_connection->daddr, saddr);
+	sockaddr_copy(&new_entry->daddr, daddr);
+	sockaddr_copy(&new_entry->oth_connection->saddr, daddr);
 	new_entry->protocol = protocol;
 
 	/*
@@ -351,11 +358,11 @@ struct tcptableent *addentry(struct tcptable *table, unsigned long
int saddr,
 	new_entry->stat = new_entry->oth_connection->stat = 0;
 
 	new_entry->s_fstat =
-	    revname(rev_lookup, &(new_entry->saddr), &new_entry->s6addr,
+	    revname(rev_lookup, &new_entry->saddr,
 		    new_entry->s_fqdn, sizeof(new_entry->s_fqdn), rvnfd);
 
 	new_entry->d_fstat =
-	    revname(rev_lookup, &(new_entry->daddr), &new_entry->d6addr,
+	    revname(rev_lookup, &new_entry->daddr,
 		    new_entry->d_fqdn, sizeof(new_entry->d_fqdn), rvnfd);
 
 	/*
@@ -492,11 +499,12 @@ void write_timeout_log(int logging, FILE * logfile, struct
tcptableent *tcpnode,
 	}
 }
 
-struct tcptableent *in_table(struct tcptable *table, unsigned long saddr,
-			     unsigned long daddr, uint8_t * s6addr,
-			     uint8_t * d6addr, unsigned int sport,
-			     unsigned int dport, char *ifname, int logging,
-			     FILE * logfile, struct OPTIONS *opts)
+struct tcptableent *in_table(struct tcptable *table,
+			     struct sockaddr_storage *saddr,
+			     struct sockaddr_storage *daddr,
+			     unsigned int sport, unsigned int dport,
+			     char *ifname, int logging,
+			     FILE *logfile, struct OPTIONS *opts)
 {
 	struct tcp_hashentry *hashptr;
 	unsigned int hp;
@@ -504,9 +512,6 @@ struct tcptableent *in_table(struct tcptable *table, unsigned long
saddr,
 	time_t now;
 	time_t timeout;
 
-	int sfree = 0;
-	int dfree = 0;
-
 	if (opts != NULL)
 		timeout = opts->timeout;
 	else
@@ -519,23 +524,12 @@ struct tcptableent *in_table(struct tcptable *table, unsigned long
saddr,
 	 * Determine hash table index for this set of addresses and ports
 	 */
 
-	hp = tcp_hash(saddr, (uint32_t *) s6addr, sport, daddr,
-		      (uint32_t *) d6addr, dport, ifname);
+	hp = tcp_hash(saddr, sport, daddr, dport, ifname);
 	hashptr = table->hash_table[hp];
 
-	if (s6addr == NULL) {
-		s6addr = xmallocz(sizeof(struct in6_addr));
-		sfree = 1;
-	}
-	if (d6addr == NULL) {
-		d6addr = xmallocz(sizeof(struct in6_addr));
-		dfree = 1;
-	}
 	while (hashptr != NULL) {
-		if ((hashptr->tcpnode->saddr.s_addr == saddr)
-		    && (!memcmp(&hashptr->tcpnode->s6addr.s6_addr, s6addr, 16))
-		    && (hashptr->tcpnode->daddr.s_addr == daddr)
-		    && (!memcmp(&hashptr->tcpnode->d6addr.s6_addr, d6addr, 16))
+		if (sockaddr_is_equal(&hashptr->tcpnode->saddr, saddr)
+		    && sockaddr_is_equal(&hashptr->tcpnode->daddr, daddr)
 		    && (hashptr->tcpnode->sport == sport)
 		    && (hashptr->tcpnode->dport == dport)
 		    && (strcmp(hashptr->tcpnode->ifname, ifname) == 0))
@@ -562,11 +556,6 @@ struct tcptableent *in_table(struct tcptable *table, unsigned long
saddr,
 		hashptr = hashptr->next_entry;
 	}
 
-	if (sfree)
-		free(s6addr);
-	if (dfree)
-		free(d6addr);
-
 	if (hashptr != NULL) {	/* needed to avoid SIGSEGV */
 		if ((((hashptr->tcpnode->finsent == 2)
 		      && (hashptr->tcpnode->oth_connection->finsent == 2)))
@@ -599,16 +588,14 @@ void updateentry(struct tcptable *table, struct tcptableent
*tableentry,
 
 	if (tableentry->s_fstat != RESOLVED) {
 		tableentry->s_fstat =
-		    revname(revlook, &(tableentry->saddr),
-			    &(tableentry->s6addr), tableentry->s_fqdn,
+		    revname(revlook, &tableentry->saddr, tableentry->s_fqdn,
 			    sizeof(tableentry->s_fqdn), rvnfd);
 		strcpy(tableentry->oth_connection->d_fqdn, tableentry->s_fqdn);
 		tableentry->oth_connection->d_fstat = tableentry->s_fstat;
 	}
 	if (tableentry->d_fstat != RESOLVED) {
 		tableentry->d_fstat =
-		    revname(revlook, &(tableentry->daddr),
-			    &(tableentry->d6addr), tableentry->d_fqdn,
+		    revname(revlook, &tableentry->daddr, tableentry->d_fqdn,
 			    sizeof(tableentry->d_fqdn), rvnfd);
 		strcpy(tableentry->oth_connection->s_fqdn, tableentry->d_fqdn);
 		tableentry->oth_connection->s_fstat = tableentry->d_fstat;
diff --git a/src/tcptable.h b/src/tcptable.h
index 8b3b931..cc2d0c0 100644
--- a/src/tcptable.h
+++ b/src/tcptable.h
@@ -22,10 +22,8 @@
 #define ENTRIES_IN_HASH_TABLE	1543
 
 struct tcptableent {
-	struct in_addr saddr;
-	struct in_addr daddr;
-	struct in6_addr s6addr;
-	struct in6_addr d6addr;
+	struct sockaddr_storage saddr;
+	struct sockaddr_storage daddr;
 	char s_fqdn[45];	/* fully-qualified domain names */
 	char d_fqdn[45];
 	int s_fstat;
@@ -98,16 +96,18 @@ struct tcptable {
 
 void init_tcp_table(struct tcptable *table);
 
-struct tcptableent *addentry(struct tcptable *table, unsigned long int saddr,
-			     unsigned long int daddr, uint8_t * s6addr,
-			     uint8_t * d6addr, unsigned int sport,
-			     unsigned int dport, int protocol, char *ifname,
+struct tcptableent *addentry(struct tcptable *table,
+			     struct sockaddr_storage *saddr,
+			     struct sockaddr_storage *daddr,
+			     unsigned int sport, unsigned int dport,
+			     int protocol, char *ifname,
 			     int *rev_lookup, int rvnamedon, int servnames);
 
-struct tcptableent *in_table(struct tcptable *table, unsigned long saddr,
-			     unsigned long daddr, uint8_t * s6addr,
-			     uint8_t * d6addr, unsigned int sport,
-			     unsigned int dport, char *ifname, int logging,
+struct tcptableent *in_table(struct tcptable *table,
+			     struct sockaddr_storage *saddr,
+			     struct sockaddr_storage *daddr,
+			     unsigned int sport, unsigned int dport,
+			     char *ifname, int logging,
 			     FILE * logfile, struct OPTIONS *opts);
 
 void updateentry(struct tcptable *table, struct tcptableent *tableentry,
-- 
1.7.8.4

[PATCH 5/6] use port inside struct sockaddr_(sin, sin6) instead of explicitly defined one

[Vitezslav Samel]

Signed-off-by: Vitezslav Samel <vitezslav(a)samel.cz&gt;
---
 src/itrafmon.c |    7 ++-----
 src/othptab.c  |   14 ++++++++------
 src/serv.c     |    2 +-
 src/servname.c |   10 +++++-----
 src/servname.h |    2 +-
 src/sockaddr.c |   32 ++++++++++++++++++++++++++++++++
 src/sockaddr.h |    2 ++
 src/tcptable.c |   38 +++++++++++---------------------------
 src/tcptable.h |    4 ----
 9 files changed, 62 insertions(+), 49 deletions(-)

diff --git a/src/itrafmon.c b/src/itrafmon.c
index d28d988..4ea57f4 100644
--- a/src/itrafmon.c
+++ b/src/itrafmon.c
@@ -1040,17 +1040,16 @@ void ipmon(struct OPTIONS *options, struct filterstate *ofilter,
 
 		__u8 ip_protocol = pkt_ip_protocol(&pkt);
 		if (ip_protocol == IPPROTO_TCP) {
+			sockaddr_set_port(&saddr, ntohs(sport));
+			sockaddr_set_port(&daddr, ntohs(dport));
 			if (pkt.iphdr) {
 				tcpentry =
 					in_table(&table, &saddr, &daddr,
-						 ntohs(sport),
-						 ntohs(dport),
 						 ifname, logging,
 						 logfile, options);
 			} else {
 				tcpentry =
 					in_table(&table, &saddr, &daddr,
-						 ntohs(sport), ntohs(dport),
 						 ifname, logging, logfile, options);
 			}
 
@@ -1071,14 +1070,12 @@ void ipmon(struct OPTIONS *options, struct filterstate *ofilter,
 				if (pkt.iphdr)
 					tcpentry =
 						addentry(&table, &saddr, &daddr,
-							 sport, dport,
 							 pkt_ip_protocol(&pkt),
 							 ifname, &revlook, rvnfd,
 							 options->servnames);
 				else
 					tcpentry =
 						addentry(&table, &saddr, &daddr,
-							 sport, dport,
 							 pkt_ip_protocol(&pkt),
 							 ifname, &revlook, rvnfd,
 							 options->servnames);
diff --git a/src/othptab.c b/src/othptab.c
index 592ee09..dc4d7a9 100644
--- a/src/othptab.c
+++ b/src/othptab.c
@@ -144,20 +144,22 @@ void process_dest_unreach(struct tcptable *table, char *packet, char
*ifname)
 		tcp = (struct tcphdr *) (packet + 48);
 		struct sockaddr_storage saddr, daddr;
 		sockaddr_make_ipv6(&saddr, &ip6->ip6_src);
+		sockaddr_set_port(&saddr, ntohs(tcp->source));
 		sockaddr_make_ipv6(&daddr, &ip6->ip6_dst);
+		sockaddr_set_port(&daddr, ntohs(tcp->dest));
 		tcpentry =
-		    in_table(table, &saddr, &daddr, ntohs(tcp->source),
-			     ntohs(tcp->dest), ifname, 0, NULL, NULL);
+		    in_table(table, &saddr, &daddr, ifname, 0, NULL, NULL);
 	} else {
 		if (ip->protocol != IPPROTO_TCP)
 			return;
 		tcp = (struct tcphdr *) (packet + 8 + (ip->ihl * 4));
 		struct sockaddr_storage saddr, daddr;
 		sockaddr_make_ipv4(&saddr, ip->saddr);
+		sockaddr_set_port(&saddr, ntohs(tcp->source));
 		sockaddr_make_ipv4(&daddr, ip->daddr);
+		sockaddr_set_port(&daddr, ntohs(tcp->dest));
 		tcpentry =
-		    in_table(table, &saddr, &daddr, ntohs(tcp->source),
-			     ntohs(tcp->dest), ifname, 0, NULL, NULL);
+		    in_table(table, &saddr, &daddr, ifname, 0, NULL, NULL);
 	}
 
 	if (tcpentry != NULL) {
@@ -216,11 +218,11 @@ struct othptabent *add_othp_entry(struct othptable *table, struct
pkt_hdr *pkt,
 				    ((struct icmp6_hdr *) packet2)->icmp6_code;
 			} else if (protocol == IPPROTO_UDP) {
 				servlook(servnames,
-					 ((struct udphdr *) packet2)->source,
+					 ntohs(((struct udphdr *) packet2)->source),
 					 IPPROTO_UDP, new_entry->un.udp.s_sname,
 					 10);
 				servlook(servnames,
-					 ((struct udphdr *) packet2)->dest,
+					 ntohs(((struct udphdr *) packet2)->dest),
 					 IPPROTO_UDP, new_entry->un.udp.d_sname,
 					 10);
 			} else if (protocol == IPPROTO_OSPFIGP) {
diff --git a/src/serv.c b/src/serv.c
index c6a5521..f2470b4 100644
--- a/src/serv.c
+++ b/src/serv.c
@@ -219,7 +219,7 @@ static struct portlistent *addtoportlist(struct portlist *list,
 	 * Obtain appropriate service name
 	 */
 
-	servlook(servnames, htons(port), protocol, ptemp->servname, 10);
+	servlook(servnames, port, protocol, ptemp->servname, 10);
 
 	memset(&ptemp->serv_count, 0, sizeof(ptemp->serv_count));
 
diff --git a/src/servname.c b/src/servname.c
index c7285ee..658a1c0 100644
--- a/src/servname.c
+++ b/src/servname.c
@@ -10,7 +10,7 @@ servname.c	- lookup module for TCP and UDP service names based on
 
 #include "iptraf-ng-compat.h"
 
-void servlook(int servnames, unsigned int port, unsigned int protocol,
+void servlook(int servnames, in_port_t port, unsigned int protocol,
 	      char *target, int maxlen)
 {
 	static struct servent *sve;
@@ -19,16 +19,16 @@ void servlook(int servnames, unsigned int port, unsigned int
protocol,
 
 	if (servnames) {
 		if (protocol == IPPROTO_TCP)
-			sve = getservbyport(port, "tcp");
+			sve = getservbyport(htons(port), "tcp");
 		else
-			sve = getservbyport(port, "udp");
+			sve = getservbyport(htons(port), "udp");
 
 		if (sve != NULL) {
 			strncpy(target, sve->s_name, maxlen);
 		} else {
-			sprintf(target, "%u", ntohs(port));
+			sprintf(target, "%u", port);
 		}
 	} else {
-		sprintf(target, "%u", ntohs(port));
+		sprintf(target, "%u", port);
 	}
 }
diff --git a/src/servname.h b/src/servname.h
index 55de3ae..7fc4fed 100644
--- a/src/servname.h
+++ b/src/servname.h
@@ -7,7 +7,7 @@ servname.h - function prototype for service lookup
 
 ***/
 
-void servlook(int servnames, unsigned int port, unsigned int protocol,
+void servlook(int servnames, in_port_t port, unsigned int protocol,
 	      char *target, int maxlen);
 
 #endif	/* IPTRAF_NG_SERVNAME_H */
diff --git a/src/sockaddr.c b/src/sockaddr.c
index b86ec5c..6ffc989 100644
--- a/src/sockaddr.c
+++ b/src/sockaddr.c
@@ -33,6 +33,38 @@ void sockaddr_make_ipv6(struct sockaddr_storage *sockaddr,
 	sockaddr_in6->sin6_scope_id = 0;
 }
 
+in_port_t sockaddr_get_port(struct sockaddr_storage *sockaddr)
+{
+	if (!sockaddr)
+		die("%s(): sockaddr == NULL", __FUNCTION__);
+
+	switch (sockaddr->ss_family) {
+	case AF_INET:
+		return ((struct sockaddr_in *)sockaddr)->sin_port;
+	case AF_INET6:
+		return ((struct sockaddr_in6 *)sockaddr)->sin6_port;
+	default:
+		die("%s(): Unknown address family", __FUNCTION__);
+	}
+}
+
+void sockaddr_set_port(struct sockaddr_storage *sockaddr, in_port_t port)
+{
+	if (!sockaddr)
+		die("%s(): sockaddr == NULL", __FUNCTION__);
+
+	switch (sockaddr->ss_family) {
+	case AF_INET:
+		((struct sockaddr_in *)sockaddr)->sin_port = port;
+		break;
+	case AF_INET6:
+		((struct sockaddr_in6 *)sockaddr)->sin6_port = port;
+		break;
+	default:
+		die("%s(): Unknown address family", __FUNCTION__);
+	}
+}
+
 int sockaddr_is_equal(struct sockaddr_storage *addr1,
 		      struct sockaddr_storage *addr2)
 {
diff --git a/src/sockaddr.h b/src/sockaddr.h
index 83648c5..b9727e8 100644
--- a/src/sockaddr.h
+++ b/src/sockaddr.h
@@ -5,6 +5,8 @@ void sockaddr_make_ipv4(struct sockaddr_storage *sockaddr,
 			u_int32_t addr);
 void sockaddr_make_ipv6(struct sockaddr_storage *sockaddr,
 			struct in6_addr *addr);
+in_port_t sockaddr_get_port(struct sockaddr_storage *sockaddr);
+void sockaddr_set_port(struct sockaddr_storage *sockaddr, in_port_t port);
 int sockaddr_is_equal(struct sockaddr_storage *addr1,
 		      struct sockaddr_storage *addr2);
 void sockaddr_ntop(struct sockaddr_storage *addr, char *buf, size_t buflen);
diff --git a/src/tcptable.c b/src/tcptable.c
index 1167b10..6979505 100644
--- a/src/tcptable.c
+++ b/src/tcptable.c
@@ -51,8 +51,8 @@ static void setlabels(WINDOW *win, int mode)
  * The hash function for the TCP hash table
  */
 
-static unsigned int tcp_hash(struct sockaddr_storage *saddr, unsigned int sport,
-			     struct sockaddr_storage *daddr, unsigned int dport,
+static unsigned int tcp_hash(struct sockaddr_storage *saddr,
+			     struct sockaddr_storage *daddr,
 			     char *ifname)
 {
 	size_t i;
@@ -64,14 +64,14 @@ static unsigned int tcp_hash(struct sockaddr_storage *saddr, unsigned
int sport,
 	switch (saddr->ss_family) {
 	case AF_INET:
 		ifsum += 4 * ((struct sockaddr_in *)saddr)->sin_addr.s_addr;
-		ifsum += 3 * sport;
+		ifsum += 3 * ((struct sockaddr_in *)saddr)->sin_port;
 		break;
 	case AF_INET6: {
 		unsigned int ip6sum = 0;
 		for (i = 0; i < 4; i++)
 			ip6sum ^= ((struct sockaddr_in6 *)saddr)->sin6_addr.s6_addr32[i];
 		ifsum += 4 * ip6sum;
-		ifsum += 3 * sport;
+		ifsum += 3 * ((struct sockaddr_in6 *)saddr)->sin6_port;
 		break; }
 	default:
 		die("%s(): saddr: unknown address family", __FUNCTION__);
@@ -79,14 +79,14 @@ static unsigned int tcp_hash(struct sockaddr_storage *saddr, unsigned
int sport,
 	switch (daddr->ss_family) {
 	case AF_INET:
 		ifsum += 2 * ((struct sockaddr_in *)daddr)->sin_addr.s_addr;
-		ifsum += dport;
+		ifsum +=     ((struct sockaddr_in *)daddr)->sin_port;
 		break;
 	case AF_INET6: {
 		unsigned int ip6sum = 0;
 		for (i = 0; i < 4; i++)
 			ip6sum ^= ((struct sockaddr_in6 *)daddr)->sin6_addr.s6_addr32[i];
 		ifsum += 2 * ip6sum;
-		ifsum += dport;
+		ifsum +=     ((struct sockaddr_in6 *)daddr)->sin6_port;
 		break; }
 	default:
 		die("%s(): daddr: unknown address family", __FUNCTION__);
@@ -100,7 +100,6 @@ static void print_tcp_num_entries(struct tcptable *table)
 		  table->count);
 }
 
-
 void init_tcp_table(struct tcptable *table)
 {
 	int i;
@@ -160,8 +159,7 @@ static void add_tcp_hash_entry(struct tcptable *table, struct
tcptableent *entry
 	unsigned int hp;	/* hash position in table */
 	struct tcp_hashentry *ptmp;
 
-	hp = tcp_hash(&entry->saddr, entry->sport,
-		      &entry->daddr, entry->dport, entry->ifname);
+	hp = tcp_hash(&entry->saddr, &entry->daddr, entry->ifname);
 	ptmp = xmallocz(sizeof(struct tcp_hashentry));
 	/*
 	 * Add backpointer from screen node to hash node for deletion later
@@ -228,7 +226,6 @@ static void del_tcp_hash_node(struct tcptable *table, struct
tcptableent *entry)
 struct tcptableent *addentry(struct tcptable *table,
 			     struct sockaddr_storage *saddr,
 			     struct sockaddr_storage *daddr,
-			     unsigned int sport, unsigned int dport,
 			     int protocol, char *ifname,
 			     int *rev_lookup, int rvnfd, int servnames)
 {
@@ -348,13 +345,6 @@ struct tcptableent *addentry(struct tcptable *table,
 	memset(new_entry->smacaddr, 0, sizeof(new_entry->smacaddr));
 	memset(new_entry->oth_connection->smacaddr, 0,
sizeof(new_entry->oth_connection->smacaddr));
 
-	/*
-	 * Set raw port numbers
-	 */
-
-	new_entry->sport = new_entry->oth_connection->dport = ntohs(sport);
-	new_entry->dport = new_entry->oth_connection->sport = ntohs(dport);
-
 	new_entry->stat = new_entry->oth_connection->stat = 0;
 
 	new_entry->s_fstat =
@@ -365,12 +355,9 @@ struct tcptableent *addentry(struct tcptable *table,
 	    revname(rev_lookup, &new_entry->daddr,
 		    new_entry->d_fqdn, sizeof(new_entry->d_fqdn), rvnfd);
 
-	/*
-	 * Set port service names (where applicable)
-	 */
-
-	servlook(servnames, sport, IPPROTO_TCP, new_entry->s_sname, 10);
-	servlook(servnames, dport, IPPROTO_TCP, new_entry->d_sname, 10);
+	/* set port service names (where applicable) */
+	servlook(servnames, sockaddr_get_port(saddr), IPPROTO_TCP, new_entry->s_sname, 10);
+	servlook(servnames, sockaddr_get_port(daddr), IPPROTO_TCP, new_entry->d_sname, 10);
 
 	strcpy(new_entry->oth_connection->s_sname, new_entry->d_sname);
 	strcpy(new_entry->oth_connection->d_sname, new_entry->s_sname);
@@ -502,7 +489,6 @@ void write_timeout_log(int logging, FILE * logfile, struct tcptableent
*tcpnode,
 struct tcptableent *in_table(struct tcptable *table,
 			     struct sockaddr_storage *saddr,
 			     struct sockaddr_storage *daddr,
-			     unsigned int sport, unsigned int dport,
 			     char *ifname, int logging,
 			     FILE *logfile, struct OPTIONS *opts)
 {
@@ -524,14 +510,12 @@ struct tcptableent *in_table(struct tcptable *table,
 	 * Determine hash table index for this set of addresses and ports
 	 */
 
-	hp = tcp_hash(saddr, sport, daddr, dport, ifname);
+	hp = tcp_hash(saddr, daddr, ifname);
 	hashptr = table->hash_table[hp];
 
 	while (hashptr != NULL) {
 		if (sockaddr_is_equal(&hashptr->tcpnode->saddr, saddr)
 		    && sockaddr_is_equal(&hashptr->tcpnode->daddr, daddr)
-		    && (hashptr->tcpnode->sport == sport)
-		    && (hashptr->tcpnode->dport == dport)
 		    && (strcmp(hashptr->tcpnode->ifname, ifname) == 0))
 			break;
 
diff --git a/src/tcptable.h b/src/tcptable.h
index cc2d0c0..5cfa746 100644
--- a/src/tcptable.h
+++ b/src/tcptable.h
@@ -28,8 +28,6 @@ struct tcptableent {
 	char d_fqdn[45];
 	int s_fstat;
 	int d_fstat;
-	unsigned int sport;
-	unsigned int dport;
 	char smacaddr[18];
 	char s_sname[11];	/* Service names, maxlen=10 */
 	char d_sname[11];
@@ -99,14 +97,12 @@ void init_tcp_table(struct tcptable *table);
 struct tcptableent *addentry(struct tcptable *table,
 			     struct sockaddr_storage *saddr,
 			     struct sockaddr_storage *daddr,
-			     unsigned int sport, unsigned int dport,
 			     int protocol, char *ifname,
 			     int *rev_lookup, int rvnamedon, int servnames);
 
 struct tcptableent *in_table(struct tcptable *table,
 			     struct sockaddr_storage *saddr,
 			     struct sockaddr_storage *daddr,
-			     unsigned int sport, unsigned int dport,
 			     char *ifname, int logging,
 			     FILE * logfile, struct OPTIONS *opts);
 
-- 
1.7.8.4

[PATCH 6/6] merge the same statements in the if() {} else {} clauses

[Vitezslav Samel]

Signed-off-by: Vitezslav Samel <vitezslav(a)samel.cz&gt;
---
 src/itrafmon.c |   28 ++++++----------------------
 1 files changed, 6 insertions(+), 22 deletions(-)

diff --git a/src/itrafmon.c b/src/itrafmon.c
index 4ea57f4..3fe2a51 100644
--- a/src/itrafmon.c
+++ b/src/itrafmon.c
@@ -1042,16 +1042,8 @@ void ipmon(struct OPTIONS *options, struct filterstate *ofilter,
 		if (ip_protocol == IPPROTO_TCP) {
 			sockaddr_set_port(&saddr, ntohs(sport));
 			sockaddr_set_port(&daddr, ntohs(dport));
-			if (pkt.iphdr) {
-				tcpentry =
-					in_table(&table, &saddr, &daddr,
-						 ifname, logging,
-						 logfile, options);
-			} else {
-				tcpentry =
-					in_table(&table, &saddr, &daddr,
-						 ifname, logging, logfile, options);
-			}
+			tcpentry = in_table(&table, &saddr, &daddr, ifname,
+					    logging, logfile, options);
 
 			/*
 			 * Add a new entry if it doesn't exist, and,
@@ -1067,18 +1059,10 @@ void ipmon(struct OPTIONS *options, struct filterstate *ofilter,
 				 * is not yet closed, or if it is a SYN packet.
 				 */
 				wasempty = (table.head == NULL);
-				if (pkt.iphdr)
-					tcpentry =
-						addentry(&table, &saddr, &daddr,
-							 pkt_ip_protocol(&pkt),
-							 ifname, &revlook, rvnfd,
-							 options->servnames);
-				else
-					tcpentry =
-						addentry(&table, &saddr, &daddr,
-							 pkt_ip_protocol(&pkt),
-							 ifname, &revlook, rvnfd,
-							 options->servnames);
+				tcpentry = addentry(&table, &saddr, &daddr,
+						    pkt_ip_protocol(&pkt),
+						    ifname, &revlook, rvnfd,
+						    options->servnames);
 				if (tcpentry != NULL) {
 					printentry(&table, tcpentry->oth_connection, screen_idx,
 						   mode);
-- 
1.7.8.4