Index: uspace/app/ping/ping.c
===================================================================
--- uspace/app/ping/ping.c	(revision 13be2583f424e363415cb6d5be27d6fb883f8353)
+++ uspace/app/ping/ping.c	(revision f023251c3aa6327894b6d7424d62f7d2d8581485)
@@ -271,6 +271,6 @@
 	}
 	
-	uint16_t af = inet_addr_get(&dest_addr, &dest, NULL);
-	if (af != AF_INET) {
+	ip_ver_t ver = inet_addr_get(&dest_addr, &dest, NULL);
+	if (ver != ip_v4) {
 		printf("Destination '%s' is not an IPv4 address.\n",
 		    argv[optind]);
Index: uspace/app/ping6/ping6.c
===================================================================
--- uspace/app/ping6/ping6.c	(revision 13be2583f424e363415cb6d5be27d6fb883f8353)
+++ uspace/app/ping6/ping6.c	(revision f023251c3aa6327894b6d7424d62f7d2d8581485)
@@ -271,6 +271,6 @@
 	}
 	
-	uint16_t af = inet_addr_get(&dest_addr, NULL, &dest);
-	if (af != AF_INET6) {
+	ip_ver_t ver = inet_addr_get(&dest_addr, NULL, &dest);
+	if (ver != ip_v6) {
 		printf("Destination '%s' is not an IPv6 address.\n",
 		    argv[optind]);
Index: uspace/lib/c/generic/inet/addr.c
===================================================================
--- uspace/lib/c/generic/inet/addr.c	(revision 13be2583f424e363415cb6d5be27d6fb883f8353)
+++ uspace/lib/c/generic/inet/addr.c	(revision f023251c3aa6327894b6d7424d62f7d2d8581485)
@@ -33,4 +33,5 @@
  */
 
+#include <assert.h>
 #include <errno.h>
 #include <unistd.h>
@@ -59,10 +60,10 @@
 
 static const inet_addr_t inet_addr_any_addr = {
-	.family = AF_INET,
+	.version = ip_v4,
 	.addr = 0
 };
 
 static const inet_addr_t inet_addr_any_addr6 = {
-	.family = AF_INET6,
+	.version = ip_v6,
 	.addr6 = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 };
@@ -150,5 +151,5 @@
 void inet_addr(inet_addr_t *addr, uint8_t a, uint8_t b, uint8_t c, uint8_t d)
 {
-	addr->family = AF_INET;
+	addr->version = ip_v4;
 	addr->addr = ((addr32_t) a << 24) | ((addr32_t) b << 16) |
 	    ((addr32_t) c << 8) | ((addr32_t) d);
@@ -158,5 +159,5 @@
     uint8_t prefix)
 {
-	naddr->family = AF_INET;
+	naddr->version = ip_v4;
 	naddr->addr = ((addr32_t) a << 24) | ((addr32_t) b << 16) |
 	    ((addr32_t) c << 8) | ((addr32_t) d);
@@ -167,5 +168,5 @@
     uint16_t d, uint16_t e, uint16_t f, uint16_t g, uint16_t h)
 {
-	addr->family = AF_INET6;
+	addr->version = ip_v6;
 	addr->addr6[0] = (a >> 8) & 0xff;
 	addr->addr6[1] = a & 0xff;
@@ -189,5 +190,5 @@
     uint16_t d, uint16_t e, uint16_t f, uint16_t g, uint16_t h, uint8_t prefix)
 {
-	naddr->family = AF_INET6;
+	naddr->version = ip_v6;
 	naddr->addr6[0] = (a >> 8) & 0xff;
 	naddr->addr6[1] = a & 0xff;
@@ -209,32 +210,47 @@
 }
 
-/** Parse network address family.
- *
- * @param text Network address in common notation.
- * @param af   Place to store network address family.
+/** Determine address version.
+ *
+ * @param text Address in common notation.
+ * @param af   Place to store address version.
  *
  * @return EOK on success, EINVAL if input is not in valid format.
  *
  */
-int inet_addr_family(const char *text, uint16_t *af)
+static int inet_addr_version(const char *text, ip_ver_t *ver)
 {
 	char *dot = str_chr(text, '.');
 	if (dot != NULL) {
-		*af = AF_INET;
+		*ver = ip_v4;
 		return EOK;
 	}
-	
+
 	char *collon = str_chr(text, ':');
 	if (collon != NULL) {
-		*af = AF_INET6;
+		*ver = ip_v6;
 		return EOK;
 	}
-	
+
 	return EINVAL;
 }
 
+static int ipver_af(ip_ver_t ver)
+{
+	switch (ver) {
+	case ip_any:
+		return AF_NONE;
+	case ip_v4:
+		return AF_INET;
+	case ip_v6:
+		return AF_INET6;
+	default:
+		assert(false);
+		return EINVAL;
+	}
+}
+
 void inet_naddr_addr(const inet_naddr_t *naddr, inet_addr_t *addr)
 {
-	addr->family = naddr->family;
+	addr->version = naddr->version;
 	memcpy(addr->addr6, naddr->addr6, 16);
 }
@@ -243,5 +259,5 @@
     inet_naddr_t *naddr)
 {
-	naddr->family = addr->family;
+	naddr->version = addr->version;
 	memcpy(naddr->addr6, addr->addr6, 16);
 	naddr->prefix = prefix;
@@ -250,5 +266,5 @@
 void inet_addr_any(inet_addr_t *addr)
 {
-	addr->family = AF_NONE;
+	addr->version = ip_any;
 	memset(addr->addr6, 0, 16);
 }
@@ -256,5 +272,5 @@
 void inet_naddr_any(inet_naddr_t *naddr)
 {
-	naddr->family = AF_NONE;
+	naddr->version = ip_any;
 	memset(naddr->addr6, 0, 16);
 	naddr->prefix = 0;
@@ -263,11 +279,11 @@
 int inet_addr_compare(const inet_addr_t *a, const inet_addr_t *b)
 {
-	if (a->family != b->family)
+	if (a->version != b->version)
 		return 0;
-	
-	switch (a->family) {
-	case AF_INET:
+
+	switch (a->version) {
+	case ip_v4:
 		return (a->addr == b->addr);
-	case AF_INET6:
+	case ip_v6:
 		return addr128_compare(a->addr6, b->addr6);
 	default:
@@ -278,5 +294,5 @@
 int inet_addr_is_any(const inet_addr_t *addr)
 {
-	return ((addr->family == 0) ||
+	return ((addr->version == ip_any) ||
 	    (inet_addr_compare(addr, &inet_addr_any_addr)) ||
 	    (inet_addr_compare(addr, &inet_addr_any_addr6)));
@@ -285,11 +301,11 @@
 int inet_naddr_compare(const inet_naddr_t *naddr, const inet_addr_t *addr)
 {
-	if (naddr->family != addr->family)
+	if (naddr->version != addr->version)
 		return 0;
 	
-	switch (naddr->family) {
-	case AF_INET:
+	switch (naddr->version) {
+	case ip_v4:
 		return (naddr->addr == addr->addr);
-	case AF_INET6:
+	case ip_v6:
 		return addr128_compare(naddr->addr6, addr->addr6);
 	default:
@@ -300,16 +316,16 @@
 int inet_naddr_compare_mask(const inet_naddr_t *naddr, const inet_addr_t *addr)
 {
-	if (naddr->family != addr->family)
+	if (naddr->version != addr->version)
 		return 0;
-	
-	switch (naddr->family) {
-	case AF_INET:
+
+	switch (naddr->version) {
+	case ip_v4:
 		if (naddr->prefix > 32)
 			return 0;
-		
+
 		addr32_t mask =
 		    BIT_RANGE(addr32_t, 31, 31 - (naddr->prefix - 1));
 		return ((naddr->addr & mask) == (addr->addr & mask));
-	case AF_INET6:
+	case ip_v6:
 		if (naddr->prefix > 128)
 			return 0;
@@ -352,19 +368,19 @@
 int inet_addr_parse(const char *text, inet_addr_t *addr)
 {
-	int rc = inet_addr_family(text, &addr->family);
+	int rc = inet_addr_version(text, &addr->version);
 	if (rc != EOK)
 		return rc;
 	
 	uint8_t buf[16];
-	rc = inet_pton(addr->family, text, buf);
+	rc = inet_pton(ipver_af(addr->version), text, buf);
 	if (rc != EOK)
 		return rc;
 	
-	switch (addr->family) {
-	case AF_INET:
+	switch (addr->version) {
+	case ip_v4:
 		addr->addr = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) |
 		    buf[3];
 		break;
-	case AF_INET6:
+	case ip_v6:
 		memcpy(addr->addr6, buf, 16);
 		break;
@@ -392,10 +408,10 @@
 	*slash = 0;
 	
-	int rc = inet_addr_family(text, &naddr->family);
+	int rc = inet_addr_version(text, &naddr->version);
 	if (rc != EOK)
 		return rc;
 	
 	uint8_t buf[16];
-	rc = inet_pton(naddr->family, text, buf);
+	rc = inet_pton(ipver_af(naddr->version), text, buf);
 	*slash = '/';
 	
@@ -406,6 +422,6 @@
 	uint8_t prefix;
 	
-	switch (naddr->family) {
-	case AF_INET:
+	switch (naddr->version) {
+	case ip_v4:
 		prefix = strtoul(slash, &slash, 10);
 		if (prefix > 32)
@@ -417,5 +433,5 @@
 		
 		break;
-	case AF_INET6:
+	case ip_v6:
 		prefix = strtoul(slash, &slash, 10);
 		if (prefix > 128)
@@ -447,14 +463,14 @@
 	int rc = 0;
 	
-	switch (addr->family) {
-	case AF_NONE:
+	switch (addr->version) {
+	case ip_any:
 		rc = asprintf(bufp, "none");
 		break;
-	case AF_INET:
+	case ip_v4:
 		rc = asprintf(bufp, "%u.%u.%u.%u", (addr->addr >> 24) & 0xff,
 		    (addr->addr >> 16) & 0xff, (addr->addr >> 8) & 0xff,
 		    addr->addr & 0xff);
 		break;
-	case AF_INET6:
+	case ip_v6:
 		*bufp = (char *) malloc(INET6_ADDRSTRLEN);
 		if (*bufp == NULL)
@@ -487,9 +503,9 @@
 	char prefix[INET_PREFIXSTRSIZE];
 	
-	switch (naddr->family) {
-	case AF_NONE:
+	switch (naddr->version) {
+	case ip_any:
 		rc = asprintf(bufp, "none");
 		break;
-	case AF_INET:
+	case ip_v4:
 		rc = asprintf(bufp, "%" PRIu8 ".%" PRIu8 ".%" PRIu8 ".%" PRIu8
 		    "/%" PRIu8, (naddr->addr >> 24) & 0xff,
@@ -497,5 +513,5 @@
 		    naddr->addr & 0xff, naddr->prefix);
 		break;
-	case AF_INET6:
+	case ip_v6:
 		*bufp = (char *) malloc(INET6_ADDRSTRLEN + INET_PREFIXSTRSIZE);
 		if (*bufp == NULL)
@@ -529,50 +545,50 @@
 }
 
-uint16_t inet_addr_get(const inet_addr_t *addr, addr32_t *v4, addr128_t *v6)
-{
-	switch (addr->family) {
-	case AF_INET:
+ip_ver_t inet_addr_get(const inet_addr_t *addr, addr32_t *v4, addr128_t *v6)
+{
+	switch (addr->version) {
+	case ip_v4:
 		if (v4 != NULL)
 			*v4 = addr->addr;
-		
-		break;
-	case AF_INET6:
+		break;
+	case ip_v6:
 		if (v6 != NULL)
 			memcpy(*v6, addr->addr6, 16);
-		
-		break;
-	}
-	
-	return addr->family;
-}
-
-uint16_t inet_naddr_get(const inet_naddr_t *naddr, addr32_t *v4, addr128_t *v6,
+		break;
+	default:
+		assert(false);
+		break;
+	}
+
+	return addr->version;
+}
+
+ip_ver_t inet_naddr_get(const inet_naddr_t *naddr, addr32_t *v4, addr128_t *v6,
     uint8_t *prefix)
 {
-	switch (naddr->family) {
-	case AF_INET:
+	switch (naddr->version) {
+	case ip_v4:
 		if (v4 != NULL)
 			*v4 = naddr->addr;
-		
 		if (prefix != NULL)
 			*prefix = naddr->prefix;
-		
-		break;
-	case AF_INET6:
+		break;
+	case ip_v6:
 		if (v6 != NULL)
 			memcpy(*v6, naddr->addr6, 16);
-		
 		if (prefix != NULL)
 			*prefix = naddr->prefix;
-		
-		break;
-	}
-	
-	return naddr->family;
+		break;
+	default:
+		assert(false);
+		break;
+	}
+
+	return naddr->version;
 }
 
 void inet_addr_set(addr32_t v4, inet_addr_t *addr)
 {
-	addr->family = AF_INET;
+	addr->version = ip_v4;
 	addr->addr = v4;
 }
@@ -580,5 +596,5 @@
 void inet_naddr_set(addr32_t v4, uint8_t prefix, inet_naddr_t *naddr)
 {
-	naddr->family = AF_INET;
+	naddr->version = ip_v4;
 	naddr->addr = v4;
 	naddr->prefix = prefix;
@@ -587,5 +603,5 @@
 void inet_sockaddr_in_addr(const sockaddr_in_t *sockaddr_in, inet_addr_t *addr)
 {
-	addr->family = AF_INET;
+	addr->version = ip_v4;
 	addr->addr = uint32_t_be2host(sockaddr_in->sin_addr.s_addr);
 }
@@ -593,5 +609,5 @@
 void inet_addr_set6(addr128_t v6, inet_addr_t *addr)
 {
-	addr->family = AF_INET6;
+	addr->version = ip_v6;
 	memcpy(addr->addr6, v6, 16);
 }
@@ -599,5 +615,5 @@
 void inet_naddr_set6(addr128_t v6, uint8_t prefix, inet_naddr_t *naddr)
 {
-	naddr->family = AF_INET6;
+	naddr->version = ip_v6;
 	memcpy(naddr->addr6, v6, 16);
 	naddr->prefix = prefix;
@@ -607,5 +623,5 @@
     inet_addr_t *addr)
 {
-	addr->family = AF_INET6;
+	addr->version = ip_v6;
 	addr128_t_be2host(sockaddr_in6->sin6_addr.s6_addr, addr->addr6);
 }
@@ -614,22 +630,23 @@
     sockaddr_in_t *sockaddr_in, sockaddr_in6_t *sockaddr_in6)
 {
-	switch (addr->family) {
-	case AF_INET:
+	switch (addr->version) {
+	case ip_v4:
 		if (sockaddr_in != NULL) {
 			sockaddr_in->sin_family = AF_INET;
 			sockaddr_in->sin_addr.s_addr = host2uint32_t_be(addr->addr);
 		}
-		
-		break;
-	case AF_INET6:
+		break;
+	case ip_v6:
 		if (sockaddr_in6 != NULL) {
 			sockaddr_in6->sin6_family = AF_INET6;
 			host2addr128_t_be(addr->addr6, sockaddr_in6->sin6_addr.s6_addr);
 		}
-		
-		break;
-	}
-	
-	return addr->family;
+		break;
+	default:
+		assert(false);
+		break;
+	}
+
+	return ipver_af(addr->version);
 }
 
Index: uspace/lib/c/include/inet/addr.h
===================================================================
--- uspace/lib/c/include/inet/addr.h	(revision 13be2583f424e363415cb6d5be27d6fb883f8353)
+++ uspace/lib/c/include/inet/addr.h	(revision f023251c3aa6327894b6d7424d62f7d2d8581485)
@@ -44,7 +44,17 @@
 typedef uint8_t addr128_t[16];
 
+typedef enum {
+	/** Any IP protocol version */
+	ip_any,
+	/** IPv4 */
+	ip_v4,
+	/** IPv6 */
+	ip_v6
+} ip_ver_t;
+
 /** Node address */
 typedef struct {
-	uint16_t family;
+	/** IP version */
+	ip_ver_t version;
 	union {
 		addr32_t addr;
@@ -55,6 +65,6 @@
 /** Network address */
 typedef struct {
-	/** Address family */
-	uint16_t family;
+	/** IP version */
+	ip_ver_t version;
 	
 	/** Address */
@@ -91,5 +101,4 @@
     uint16_t, uint16_t, uint16_t, uint16_t, uint8_t);
 
-extern int inet_addr_family(const char *, uint16_t *);
 extern void inet_naddr_addr(const inet_naddr_t *, inet_addr_t *);
 extern void inet_addr_naddr(const inet_addr_t *, uint8_t, inet_naddr_t *);
@@ -110,6 +119,6 @@
 extern int inet_naddr_format(const inet_naddr_t *, char **);
 
-extern uint16_t inet_addr_get(const inet_addr_t *, addr32_t *, addr128_t *);
-extern uint16_t inet_naddr_get(const inet_naddr_t *, addr32_t *, addr128_t *,
+extern ip_ver_t inet_addr_get(const inet_addr_t *, addr32_t *, addr128_t *);
+extern ip_ver_t inet_naddr_get(const inet_naddr_t *, addr32_t *, addr128_t *,
     uint8_t *);
 
Index: uspace/srv/net/dhcp/dhcp.c
===================================================================
--- uspace/srv/net/dhcp/dhcp.c	(revision 13be2583f424e363415cb6d5be27d6fb883f8353)
+++ uspace/srv/net/dhcp/dhcp.c	(revision f023251c3aa6327894b6d7424d62f7d2d8581485)
@@ -231,6 +231,5 @@
 	memset(offer, 0, sizeof(*offer));
 
-	yiaddr.family = AF_INET;
-	yiaddr.addr = uint32_t_be2host(hdr->yiaddr);
+	inet_addr_set(uint32_t_be2host(hdr->yiaddr), &yiaddr);
 	rc = inet_addr_format(&yiaddr, &saddr);
 	if (rc != EOK)
@@ -240,6 +239,5 @@
 	free(saddr);
 
-	siaddr.family = AF_INET;
-	siaddr.addr = uint32_t_be2host(hdr->siaddr);
+	inet_addr_set(uint32_t_be2host(hdr->siaddr), &siaddr);
 	rc = inet_addr_format(&siaddr, &saddr);
 	if (rc != EOK)
@@ -249,6 +247,5 @@
 	free(saddr);
 
-	giaddr.family = AF_INET;
-	giaddr.addr = uint32_t_be2host(hdr->giaddr);
+	inet_addr_set(uint32_t_be2host(hdr->giaddr), &giaddr);
 	rc = inet_addr_format(&giaddr, &saddr);
 	if (rc != EOK)
@@ -258,6 +255,5 @@
 	free(saddr);
 
-	offer->oaddr.family = AF_INET;
-	offer->oaddr.addr = yiaddr.addr;
+	inet_naddr_set(yiaddr.addr, 0, &offer->oaddr);
 
 	msgb = (uint8_t *)msg;
@@ -299,6 +295,6 @@
 			if (opt_len != 4)
 				return EINVAL;
-			offer->srv_addr.family = AF_INET;
-			offer->srv_addr.addr = dhcp_uint32_decode(&msgb[i]);
+			inet_addr_set(dhcp_uint32_decode(&msgb[i]),
+			    &offer->srv_addr);
 			have_server_id = true;
 			break;
@@ -306,12 +302,12 @@
 			if (opt_len != 4)
 				return EINVAL;
-			offer->router.family = AF_INET;
-			offer->router.addr = dhcp_uint32_decode(&msgb[i]);
+			inet_addr_set(dhcp_uint32_decode(&msgb[i]),
+			    &offer->router);
 			break;
 		case opt_dns_server:
 			if (opt_len != 4)
 				return EINVAL;
-			offer->dns_server.family = AF_INET;
-			offer->dns_server.addr = dhcp_uint32_decode(&msgb[i]);
+			inet_addr_set(dhcp_uint32_decode(&msgb[i]),
+			    &offer->dns_server);
 			break;
 		case opt_end:
@@ -379,7 +375,5 @@
 
 	if (offer->router.addr != 0) {
-		defr.family = AF_INET;
-		defr.addr = 0;
-		defr.prefix = 0;
+		inet_naddr_set(0, 0, &defr);
 
 		rc = inetcfg_sroute_create("dhcpdef", &defr, &offer->router, &sroute_id);
Index: uspace/srv/net/ethip/arp.c
===================================================================
--- uspace/srv/net/ethip/arp.c	(revision 13be2583f424e363415cb6d5be27d6fb883f8353)
+++ uspace/srv/net/ethip/arp.c	(revision f023251c3aa6327894b6d7424d62f7d2d8581485)
@@ -73,6 +73,6 @@
 	
 	addr32_t laddr_v4;
-	uint16_t laddr_af = inet_addr_get(&laddr->addr, &laddr_v4, NULL);
-	if (laddr_af != AF_INET)
+	ip_ver_t laddr_ver = inet_addr_get(&laddr->addr, &laddr_v4, NULL);
+	if (laddr_ver != ip_v4)
 		return;
 	
Index: uspace/srv/net/ethip/ethip_nic.c
===================================================================
--- uspace/srv/net/ethip/ethip_nic.c	(revision 13be2583f424e363415cb6d5be27d6fb883f8353)
+++ uspace/srv/net/ethip/ethip_nic.c	(revision f023251c3aa6327894b6d7424d62f7d2d8581485)
@@ -354,6 +354,6 @@
 	
 	list_foreach(nic->addr_list, link, ethip_link_addr_t, laddr) {
-		uint16_t af = inet_addr_get(&laddr->addr, NULL, NULL);
-		if (af == AF_INET6)
+		ip_ver_t ver = inet_addr_get(&laddr->addr, NULL, NULL);
+		if (ver == ip_v6)
 			count++;
 	}
@@ -373,6 +373,6 @@
 	list_foreach(nic->addr_list, link, ethip_link_addr_t, laddr) {
 		addr128_t v6;
-		uint16_t af = inet_addr_get(&laddr->addr, NULL, &v6);
-		if (af != AF_INET6)
+		ip_ver_t ver = inet_addr_get(&laddr->addr, NULL, &v6);
+		if (ver != ip_v6)
 			continue;
 		
Index: uspace/srv/net/inetsrv/addrobj.c
===================================================================
--- uspace/srv/net/inetsrv/addrobj.c	(revision 13be2583f424e363415cb6d5be27d6fb883f8353)
+++ uspace/srv/net/inetsrv/addrobj.c	(revision f023251c3aa6327894b6d7424d62f7d2d8581485)
@@ -218,24 +218,24 @@
 	inet_addr_t lsrc_addr;
 	inet_naddr_addr(&addr->naddr, &lsrc_addr);
-	
+
 	addr32_t lsrc_v4;
 	addr128_t lsrc_v6;
-	uint16_t lsrc_af = inet_addr_get(&lsrc_addr, &lsrc_v4, &lsrc_v6);
-	
+	ip_ver_t lsrc_ver = inet_addr_get(&lsrc_addr, &lsrc_v4, &lsrc_v6);
+
 	addr32_t ldest_v4;
 	addr128_t ldest_v6;
-	uint16_t ldest_af = inet_addr_get(ldest, &ldest_v4, &ldest_v6);
-	
-	if (lsrc_af != ldest_af)
+	ip_ver_t ldest_ver = inet_addr_get(ldest, &ldest_v4, &ldest_v6);
+
+	if (lsrc_ver != ldest_ver)
 		return EINVAL;
-	
+
 	int rc;
 	addr48_t ldest_mac;
-	
-	switch (ldest_af) {
-	case AF_INET:
+
+	switch (ldest_ver) {
+	case ip_v4:
 		return inet_link_send_dgram(addr->ilink, lsrc_v4, ldest_v4,
 		    dgram, proto, ttl, df);
-	case AF_INET6:
+	case ip_v6:
 		/*
 		 * Translate local destination IPv6 address.
@@ -244,9 +244,12 @@
 		if (rc != EOK)
 			return rc;
-		
+
 		return inet_link_send_dgram6(addr->ilink, ldest_mac, dgram,
 		    proto, ttl, df);
-	}
-	
+	default:
+		assert(false);
+		break;
+	}
+
 	return ENOTSUP;
 }
Index: uspace/srv/net/inetsrv/icmp.c
===================================================================
--- uspace/srv/net/inetsrv/icmp.c	(revision 13be2583f424e363415cb6d5be27d6fb883f8353)
+++ uspace/srv/net/inetsrv/icmp.c	(revision f023251c3aa6327894b6d7424d62f7d2d8581485)
@@ -123,24 +123,24 @@
 {
 	log_msg(LOG_DEFAULT, LVL_DEBUG, "icmp_recv_echo_reply()");
-	
+
 	if (dgram->size < sizeof(icmp_echo_t))
 		return EINVAL;
-	
+
 	icmp_echo_t *reply = (icmp_echo_t *) dgram->data;
-	
+
 	inetping_sdu_t sdu;
-	
-	uint16_t family = inet_addr_get(&dgram->src, &sdu.src, NULL);
-	if (family != AF_INET)
+
+	ip_ver_t ver = inet_addr_get(&dgram->src, &sdu.src, NULL);
+	if (ver != ip_v4)
 		return EINVAL;
-	
-	family = inet_addr_get(&dgram->dest, &sdu.dest, NULL);
-	if (family != AF_INET)
+
+	ver = inet_addr_get(&dgram->dest, &sdu.dest, NULL);
+	if (ver != ip_v4)
 		return EINVAL;
-	
+
 	sdu.seq_no = uint16_t_be2host(reply->seq_no);
 	sdu.data = reply + sizeof(icmp_echo_t);
 	sdu.size = dgram->size - sizeof(icmp_echo_t);
-	
+
 	uint16_t ident = uint16_t_be2host(reply->ident);
 
@@ -154,7 +154,7 @@
 	if (rdata == NULL)
 		return ENOMEM;
-	
+
 	icmp_echo_t *request = (icmp_echo_t *) rdata;
-	
+
 	request->type = ICMP_ECHO_REQUEST;
 	request->code = 0;
@@ -162,22 +162,22 @@
 	request->ident = host2uint16_t_be(ident);
 	request->seq_no = host2uint16_t_be(sdu->seq_no);
-	
+
 	memcpy(rdata + sizeof(icmp_echo_t), sdu->data, sdu->size);
-	
+
 	uint16_t checksum = inet_checksum_calc(INET_CHECKSUM_INIT, rdata, rsize);
 	request->checksum = host2uint16_t_be(checksum);
-	
+
 	inet_dgram_t dgram;
-	
+
 	inet_addr_set(sdu->src, &dgram.src);
 	inet_addr_set(sdu->dest, &dgram.dest);
-	
+
 	dgram.iplink = 0;
 	dgram.tos = ICMP_TOS;
 	dgram.data = rdata;
 	dgram.size = rsize;
-	
+
 	int rc = inet_route_packet(&dgram, IP_PROTO_ICMP, INET_TTL_MAX, 0);
-	
+
 	free(rdata);
 	return rc;
Index: uspace/srv/net/inetsrv/icmpv6.c
===================================================================
--- uspace/srv/net/inetsrv/icmpv6.c	(revision 13be2583f424e363415cb6d5be27d6fb883f8353)
+++ uspace/srv/net/inetsrv/icmpv6.c	(revision f023251c3aa6327894b6d7424d62f7d2d8581485)
@@ -59,10 +59,10 @@
 	
 	addr128_t src_v6;
-	uint16_t src_af = inet_addr_get(&dgram->src, NULL, &src_v6);
+	ip_ver_t src_ver = inet_addr_get(&dgram->src, NULL, &src_v6);
 	
 	addr128_t dest_v6;
-	uint16_t dest_af = inet_addr_get(&dgram->dest, NULL, &dest_v6);
-	
-	if ((src_af != dest_af) || (src_af != AF_INET6))
+	ip_ver_t dest_ver = inet_addr_get(&dgram->dest, NULL, &dest_v6);
+	
+	if ((src_ver != dest_ver) || (src_ver != ip_v6))
 		return EINVAL;
 	
@@ -118,8 +118,8 @@
 	inetping6_sdu_t sdu;
 	
-	uint16_t src_af = inet_addr_get(&dgram->src, NULL, &sdu.src);
-	uint16_t dest_af = inet_addr_get(&dgram->dest, NULL, &sdu.dest);
-	
-	if ((src_af != dest_af) || (src_af != AF_INET6))
+	ip_ver_t src_ver = inet_addr_get(&dgram->src, NULL, &sdu.src);
+	ip_ver_t dest_ver = inet_addr_get(&dgram->dest, NULL, &sdu.dest);
+	
+	if ((src_ver != dest_ver) || (src_ver != ip_v6))
 		return EINVAL;
 	
Index: uspace/srv/net/inetsrv/inet_link.c
===================================================================
--- uspace/srv/net/inetsrv/inet_link.c	(revision 13be2583f424e363415cb6d5be27d6fb883f8353)
+++ uspace/srv/net/inetsrv/inet_link.c	(revision f023251c3aa6327894b6d7424d62f7d2d8581485)
@@ -294,11 +294,11 @@
 {
 	addr32_t src_v4;
-	uint16_t src_af = inet_addr_get(&dgram->src, &src_v4, NULL);
-	if (src_af != AF_INET)
+	ip_ver_t src_ver = inet_addr_get(&dgram->src, &src_v4, NULL);
+	if (src_ver != ip_v4)
 		return EINVAL;
 	
 	addr32_t dest_v4;
-	uint16_t dest_af = inet_addr_get(&dgram->dest, &dest_v4, NULL);
-	if (dest_af != AF_INET)
+	ip_ver_t dest_ver = inet_addr_get(&dgram->dest, &dest_v4, NULL);
+	if (dest_ver != ip_v4)
 		return EINVAL;
 	
@@ -369,11 +369,11 @@
 {
 	addr128_t src_v6;
-	uint16_t src_af = inet_addr_get(&dgram->src, NULL, &src_v6);
-	if (src_af != AF_INET6)
+	ip_ver_t src_ver = inet_addr_get(&dgram->src, NULL, &src_v6);
+	if (src_ver != ip_v6)
 		return EINVAL;
 	
 	addr128_t dest_v6;
-	uint16_t dest_af = inet_addr_get(&dgram->dest, NULL, &dest_v6);
-	if (dest_af != AF_INET6)
+	ip_ver_t dest_ver = inet_addr_get(&dgram->dest, NULL, &dest_v6);
+	if (dest_ver != ip_v6)
 		return EINVAL;
 	
Index: uspace/srv/net/inetsrv/inetping.c
===================================================================
--- uspace/srv/net/inetsrv/inetping.c	(revision 13be2583f424e363415cb6d5be27d6fb883f8353)
+++ uspace/srv/net/inetsrv/inetping.c	(revision f023251c3aa6327894b6d7424d62f7d2d8581485)
@@ -72,6 +72,6 @@
 		return rc;
 	
-	uint16_t family = inet_addr_get(&local_addr, local, NULL);
-	if (family != AF_INET)
+	ip_ver_t ver = inet_addr_get(&local_addr, local, NULL);
+	if (ver != ip_v4)
 		return EINVAL;
 	
Index: uspace/srv/net/inetsrv/inetping6.c
===================================================================
--- uspace/srv/net/inetsrv/inetping6.c	(revision 13be2583f424e363415cb6d5be27d6fb883f8353)
+++ uspace/srv/net/inetsrv/inetping6.c	(revision f023251c3aa6327894b6d7424d62f7d2d8581485)
@@ -72,6 +72,6 @@
 		return rc;
 	
-	uint16_t family = inet_addr_get(&local_addr, NULL, local);
-	if (family != AF_INET6)
+	ip_ver_t ver = inet_addr_get(&local_addr, NULL, local);
+	if (ver != ip_v6)
 		return EINVAL;
 	
Index: uspace/srv/net/inetsrv/inetsrv.c
===================================================================
--- uspace/srv/net/inetsrv/inetsrv.c	(revision 13be2583f424e363415cb6d5be27d6fb883f8353)
+++ uspace/srv/net/inetsrv/inetsrv.c	(revision f023251c3aa6327894b6d7424d62f7d2d8581485)
@@ -63,5 +63,5 @@
 
 static inet_naddr_t solicited_node_mask = {
-	.family = AF_INET6,
+	.version = ip_v6,
 	.addr6 = {0xff, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01, 0xff, 0, 0, 0},
 	.prefix = 104
@@ -69,10 +69,10 @@
 
 static inet_addr_t broadcast4_all_hosts = {
-	.family = AF_INET,
+	.version = ip_v4,
 	.addr = 0xffffffff
 };
 
 static inet_addr_t multicast_all_nodes = {
-	.family = AF_INET6,
+	.version = ip_v6,
 	.addr6 = {0xff, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01}
 };
@@ -180,4 +180,5 @@
 
 	if (dgram->iplink != 0) {
+		/* XXX TODO - IPv6 */
 		log_msg(LOG_DEFAULT, LVL_DEBUG, "dgram directly to iplink %zu",
 		    dgram->iplink);
@@ -187,6 +188,6 @@
 			return ENOENT;
 
-		if (dgram->src.family != AF_INET ||
-			dgram->dest.family != AF_INET)
+		if (dgram->src.version != ip_v4 ||
+			dgram->dest.version != ip_v4)
 			return EINVAL;
 
@@ -225,9 +226,11 @@
 
 	/* Take source address from the address object */
-	if (remote->family == AF_INET && remote->addr == 0xffffffff) {
-		local->family = AF_INET;
+	if (remote->version == ip_v4 && remote->addr == 0xffffffff) {
+		/* XXX TODO - IPv6 */
+		local->version = ip_v4;
 		local->addr = 0;
 		return EOK;
 	}
+
 	inet_naddr_addr(&dir.aobj->naddr, local);
 	return EOK;
Index: uspace/srv/net/inetsrv/pdu.c
===================================================================
--- uspace/srv/net/inetsrv/pdu.c	(revision 13be2583f424e363415cb6d5be27d6fb883f8353)
+++ uspace/srv/net/inetsrv/pdu.c	(revision f023251c3aa6327894b6d7424d62f7d2d8581485)
@@ -533,7 +533,7 @@
 int ndp_pdu_decode(inet_dgram_t *dgram, ndp_packet_t *ndp)
 {
-	uint16_t src_af = inet_addr_get(&dgram->src, NULL,
+	ip_ver_t src_ver = inet_addr_get(&dgram->src, NULL,
 	    &ndp->sender_proto_addr);
-	if (src_af != AF_INET6)
+	if (src_ver != ip_v6)
 		return EINVAL;
 	
Index: uspace/srv/net/inetsrv/sroute.c
===================================================================
--- uspace/srv/net/inetsrv/sroute.c	(revision 13be2583f424e363415cb6d5be27d6fb883f8353)
+++ uspace/srv/net/inetsrv/sroute.c	(revision f023251c3aa6327894b6d7424d62f7d2d8581485)
@@ -95,5 +95,5 @@
 inet_sroute_t *inet_sroute_find(inet_addr_t *addr)
 {
-	uint16_t addr_af = inet_addr_get(addr, NULL, NULL);
+	ip_ver_t addr_ver = inet_addr_get(addr, NULL, NULL);
 	
 	inet_sroute_t *best = NULL;
@@ -104,9 +104,9 @@
 	list_foreach(sroute_list, sroute_list, inet_sroute_t, sroute) {
 		uint8_t dest_bits;
-		uint16_t dest_af = inet_naddr_get(&sroute->dest, NULL, NULL,
+		ip_ver_t dest_ver = inet_naddr_get(&sroute->dest, NULL, NULL,
 		    &dest_bits);
 		
 		/* Skip comparison with different address family */
-		if (addr_af != dest_af)
+		if (addr_ver != dest_ver)
 			continue;
 		
Index: uspace/srv/net/tcp/pdu.c
===================================================================
--- uspace/srv/net/tcp/pdu.c	(revision 13be2583f424e363415cb6d5be27d6fb883f8353)
+++ uspace/srv/net/tcp/pdu.c	(revision f023251c3aa6327894b6d7424d62f7d2d8581485)
@@ -145,19 +145,19 @@
 }
 
-static uint16_t tcp_phdr_setup(tcp_pdu_t *pdu, tcp_phdr_t *phdr,
+static ip_ver_t tcp_phdr_setup(tcp_pdu_t *pdu, tcp_phdr_t *phdr,
     tcp_phdr6_t *phdr6)
 {
 	addr32_t src_v4;
 	addr128_t src_v6;
-	uint16_t src_af = inet_addr_get(&pdu->src, &src_v4, &src_v6);
-	
+	uint16_t src_ver = inet_addr_get(&pdu->src, &src_v4, &src_v6);
+
 	addr32_t dest_v4;
 	addr128_t dest_v6;
-	uint16_t dest_af = inet_addr_get(&pdu->dest, &dest_v4, &dest_v6);
-	
-	assert(src_af == dest_af);
-	
-	switch (src_af) {
-	case AF_INET:
+	uint16_t dest_ver = inet_addr_get(&pdu->dest, &dest_v4, &dest_v6);
+
+	assert(src_ver == dest_ver);
+
+	switch (src_ver) {
+	case ip_v4:
 		phdr->src = host2uint32_t_be(src_v4);
 		phdr->dest = host2uint32_t_be(dest_v4);
@@ -167,5 +167,5 @@
 		    host2uint16_t_be(pdu->header_size + pdu->text_size);
 		break;
-	case AF_INET6:
+	case ip_v6:
 		host2addr128_t_be(src_v6, phdr6->src);
 		host2addr128_t_be(dest_v6, phdr6->dest);
@@ -178,6 +178,6 @@
 		assert(false);
 	}
-	
-	return src_af;
+
+	return src_ver;
 }
 
@@ -266,12 +266,12 @@
 	tcp_phdr_t phdr;
 	tcp_phdr6_t phdr6;
-	
-	uint16_t af = tcp_phdr_setup(pdu, &phdr, &phdr6);
-	switch (af) {
-	case AF_INET:
+
+	ip_ver_t ver = tcp_phdr_setup(pdu, &phdr, &phdr6);
+	switch (ver) {
+	case ip_v4:
 		cs_phdr = tcp_checksum_calc(TCP_CHECKSUM_INIT, (void *) &phdr,
 		    sizeof(tcp_phdr_t));
 		break;
-	case AF_INET6:
+	case ip_v6:
 		cs_phdr = tcp_checksum_calc(TCP_CHECKSUM_INIT, (void *) &phdr6,
 		    sizeof(tcp_phdr6_t));
@@ -280,5 +280,5 @@
 		assert(false);
 	}
-	
+
 	cs_headers = tcp_checksum_calc(cs_phdr, pdu->header, pdu->header_size);
 	return tcp_checksum_calc(cs_headers, pdu->text, pdu->text_size);
Index: uspace/srv/net/udp/pdu.c
===================================================================
--- uspace/srv/net/udp/pdu.c	(revision 13be2583f424e363415cb6d5be27d6fb883f8353)
+++ uspace/srv/net/udp/pdu.c	(revision f023251c3aa6327894b6d7424d62f7d2d8581485)
@@ -85,19 +85,19 @@
 }
 
-static uint16_t udp_phdr_setup(udp_pdu_t *pdu, udp_phdr_t *phdr,
+static ip_ver_t udp_phdr_setup(udp_pdu_t *pdu, udp_phdr_t *phdr,
     udp_phdr6_t *phdr6)
 {
 	addr32_t src_v4;
 	addr128_t src_v6;
-	uint16_t src_af = inet_addr_get(&pdu->src, &src_v4, &src_v6);
-	
+	ip_ver_t src_ver = inet_addr_get(&pdu->src, &src_v4, &src_v6);
+
 	addr32_t dest_v4;
 	addr128_t dest_v6;
-	uint16_t dest_af = inet_addr_get(&pdu->dest, &dest_v4, &dest_v6);
-	
-	assert(src_af == dest_af);
-	
-	switch (src_af) {
-	case AF_INET:
+	ip_ver_t dest_ver = inet_addr_get(&pdu->dest, &dest_v4, &dest_v6);
+
+	assert(src_ver == dest_ver);
+
+	switch (src_ver) {
+	case ip_v4:
 		phdr->src_addr = host2uint32_t_be(src_v4);
 		phdr->dest_addr = host2uint32_t_be(dest_v4);
@@ -106,5 +106,5 @@
 		phdr->udp_length = host2uint16_t_be(pdu->data_size);
 		break;
-	case AF_INET6:
+	case ip_v6:
 		host2addr128_t_be(src_v6, phdr6->src_addr);
 		host2addr128_t_be(dest_v6, phdr6->dest_addr);
@@ -116,6 +116,6 @@
 		assert(false);
 	}
-	
-	return src_af;
+
+	return src_ver;
 }
 
@@ -136,12 +136,12 @@
 	udp_phdr_t phdr;
 	udp_phdr6_t phdr6;
-	
-	uint16_t af = udp_phdr_setup(pdu, &phdr, &phdr6);
-	switch (af) {
-	case AF_INET:
+
+	ip_ver_t ver = udp_phdr_setup(pdu, &phdr, &phdr6);
+	switch (ver) {
+	case ip_v4:
 		cs_phdr = udp_checksum_calc(UDP_CHECKSUM_INIT, (void *) &phdr,
 		    sizeof(udp_phdr_t));
 		break;
-	case AF_INET6:
+	case ip_v6:
 		cs_phdr = udp_checksum_calc(UDP_CHECKSUM_INIT, (void *) &phdr6,
 		    sizeof(udp_phdr6_t));
@@ -150,5 +150,5 @@
 		assert(false);
 	}
-	
+
 	return udp_checksum_calc(cs_phdr, pdu->data, pdu->data_size);
 }