Merge branch 'saleyn/uds/PR-612/OTP-13572'

* saleyn/uds/PR-612/OTP-13572:
  Rewrite inet* for address family 'local'
  Rewrite inet_drv for AF_LOCAL
  Assign externally open fd to gen_tcp (UDS support)

Conflicts:
	erts/preloaded/ebin/prim_inet.beam
	lib/kernel/doc/src/gen_tcp.xml
	lib/kernel/doc/src/gen_udp.xml
	lib/kernel/src/inet6_sctp.erl
	lib/kernel/test/inet_SUITE.erl

4 files changed, 513 insertions, 182 deletions

diff --git a/erts/configure.in b/erts/configure.in
index a34dfc6dbd..ac2fae70ce 100644
--- a/erts/configure.in
+++ b/erts/configure.in
@@ -2116,7 +2116,7 @@ fi
 dnl Need by run_erl.
 AC_CHECK_FUNCS([openpty])
 
-AC_CHECK_HEADERS(net/if_dl.h ifaddrs.h netpacket/packet.h)
+AC_CHECK_HEADERS(net/if_dl.h ifaddrs.h netpacket/packet.h sys/un.h)
 AC_CHECK_FUNCS([getifaddrs])
 
 dnl Checks for variables in6addr_any and in6addr_loopback,
diff --git a/erts/emulator/drivers/common/inet_drv.c b/erts/emulator/drivers/common/inet_drv.c
index e87d141ddb..1967b27906 100644
--- a/erts/emulator/drivers/common/inet_drv.c
+++ b/erts/emulator/drivers/common/inet_drv.c
@@ -34,6 +34,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <stddef.h>
 #include <ctype.h>
 #include <sys/types.h>
 #include <errno.h>
@@ -58,6 +59,9 @@
 #ifdef HAVE_NETPACKET_PACKET_H
 #include <netpacket/packet.h>
 #endif
+#ifdef HAVE_SYS_UN_H
+#include <sys/un.h>
+#endif
 
 /* All platforms fail on malloc errors. */
 #define FATAL_MALLOC
@@ -573,7 +577,7 @@ static int my_strncasecmp(const char *s1, const char *s2, size_t n)
 #ifdef HAVE_SOCKLEN_T
 #  define SOCKLEN_T socklen_t
 #else
-#  define SOCKLEN_T int
+#  define SOCKLEN_T size_t
 #endif
 
 #include "packet_parser.h"
@@ -587,6 +591,22 @@ static int my_strncasecmp(const char *s1, const char *s2, size_t n)
 			     (((unsigned char*) (s))[1] << 8) | \
 			     (((unsigned char*) (s))[0]))
 
+/* strnlen doesn't exist everywhere */
+static size_t my_strnlen(const char *s, size_t maxlen)
+{
+    size_t i = 0;
+    while (i < maxlen && s[i] != '\0')
+        i++;
+    return i;
+}
+
+/* Check that some character in the buffer != '\0' */
+static int is_nonzero(const char *s, size_t n)
+{
+    size_t i;
+    for (i = 0;  i < n;  i++) if (s[i] != '\0') return !0;
+    return 0;
+}
 
 #ifdef VALGRIND
 #  include <valgrind/memcheck.h>   
@@ -611,6 +631,8 @@ static int my_strncasecmp(const char *s1, const char *s2, size_t n)
 #define INET_AF_INET6       2
 #define INET_AF_ANY         3 /* INADDR_ANY or IN6ADDR_ANY_INIT */
 #define INET_AF_LOOPBACK    4 /* INADDR_LOOPBACK or IN6ADDR_LOOPBACK_INIT */
+#define INET_AF_LOCAL       5
+#define INET_AF_UNDEFINED   6 /* Unknown */
 
 /* open and INET_REQ_GETTYPE enumeration */
 #define INET_TYPE_STREAM    1
@@ -896,19 +918,35 @@ typedef union {
 #ifdef HAVE_IN6
     struct sockaddr_in6 sai6;
 #endif
+#ifdef HAVE_SYS_UN_H
+    struct sockaddr_un sal;
+#endif
 } inet_address;
 
 
-/* for AF_INET & AF_INET6 */
-#define inet_address_port(x) ((x)->sai.sin_port)
+#define inet_address_port(x)			\
+  ((((x)->sai.sin_family == AF_INET) ||		\
+    ((x)->sai.sin_family == AF_INET6)) ?	\
+   ((x)->sai.sin_port) : -1)
+
+#ifdef HAVE_SYS_UN_H
+#define localaddrlen(data)				\
+  ((((unsigned char*)(data))[0] == INET_AF_LOCAL) ?	\
+   (1 + 1 + ((unsigned char*)(data))[1]) : 1)
+#else
+#define localaddrlen(data) (1)
+#endif
 
 #if defined(HAVE_IN6) && defined(AF_INET6)
-#define addrlen(family) \
-   ((family == AF_INET) ? sizeof(struct in_addr) : \
-    ((family == AF_INET6) ? sizeof(struct in6_addr) : 0))
+#define addrlen(data)					\
+    ((((unsigned char*)(data))[0] == INET_AF_INET) ?	\
+     (1 + 2 + 4) :					\
+     ((((unsigned char*)(data))[0] == INET_AF_INET6) ?	\
+      (1 + 2 + 16) : localaddrlen(data)))
 #else
-#define addrlen(family) \
-   ((family == AF_INET) ? sizeof(struct in_addr) : 0)
+#define addrlen(data)					\
+    ((((unsigned char*)(data))[0] == INET_AF_INET) ?	\
+     (1 + 2 + 4) : localaddrlen(data))
 #endif
 
 typedef struct _multi_timer_data {
@@ -999,8 +1037,10 @@ typedef struct {
     inet_address peer_addr;     /* fake peer address */
     inet_address name_addr;     /* fake local address */
 
-    inet_address* peer_ptr;    /* fake peername or NULL */
-    inet_address* name_ptr;    /* fake sockname or NULL */
+    inet_address* peer_ptr;     /* fake peername or NULL */
+    inet_address* name_ptr;     /* fake sockname or NULL */
+    SOCKLEN_T peer_addr_len;    /* fake peername size */
+    SOCKLEN_T name_addr_len;    /* fake sockname size */
 
     int   bufsz;                /* minimum buffer constraint */
     unsigned int hsz;           /* the list header size, -1 is large !!! */
@@ -1246,6 +1286,7 @@ static int async_ref = 0;          /* async reference id generator */
     } while (0)
 
 static ErlDrvTermData am_ok;
+static ErlDrvTermData am_undefined;
 static ErlDrvTermData am_tcp;
 static ErlDrvTermData am_error;
 static ErlDrvTermData am_einval;
@@ -1262,6 +1303,7 @@ static ErlDrvTermData am_ssl_tls;
 static ErlDrvTermData am_udp;
 static ErlDrvTermData am_udp_passive;
 static ErlDrvTermData am_udp_error;
+static ErlDrvTermData am_local;
 #endif
 #ifdef HAVE_SCTP
 static ErlDrvTermData am_sctp;
@@ -1471,40 +1513,59 @@ static void *realloc_wrapper(void *current, ErlDrvSizeT size){
 #endif
 
 #ifdef HAVE_UDP
-static int load_ip_port(ErlDrvTermData* spec, int i, char* buf)
-{
-    spec[i++] = ERL_DRV_INT;
-    spec[i++] = (ErlDrvTermData) get_int16(buf);
-    return i;
-}
-
-static int load_ip_address(ErlDrvTermData* spec, int i, int family, char* buf)
+static int load_address(ErlDrvTermData* spec, int i, char* buf)
 {
     int n;
-    if (family == AF_INET) {
-	for (n = 0;  n < 4;  n++) {
+    switch (*buf++) { /* Family */
+    case INET_AF_INET: {
+        for (n = 2;  n < 2+4;  n++) {
 	    spec[i++] = ERL_DRV_INT;
 	    spec[i++] = (ErlDrvTermData) ((unsigned char)buf[n]);
 	}
 	spec[i++] = ERL_DRV_TUPLE;
 	spec[i++] = 4;
+	spec[i++] = ERL_DRV_INT;
+	spec[i++] = (ErlDrvTermData) get_int16(buf);
+	break;
     }
 #if defined(HAVE_IN6) && defined(AF_INET6)
-    else if (family == AF_INET6) {
-	for (n = 0;  n < 16;  n += 2) {
+    case INET_AF_INET6: {
+	for (n = 2;  n < 2+16;  n += 2) {
 	    spec[i++] = ERL_DRV_INT;
 	    spec[i++] = (ErlDrvTermData) get_int16(buf+n);
 	}
 	spec[i++] = ERL_DRV_TUPLE;
 	spec[i++] = 8;
+	spec[i++] = ERL_DRV_INT;
+	spec[i++] = (ErlDrvTermData) get_int16(buf);
+	break;
     }
 #endif
-    else {
+#ifdef HAVE_SYS_UN_H
+    case INET_AF_LOCAL: {
+	int len = *(unsigned char*)buf++;
+	i = LOAD_ATOM(spec, i, am_local);
+	i = LOAD_BUF2BINARY(spec, i, buf, len);
+	spec[i++] = ERL_DRV_TUPLE;
+	spec[i++] = 2;
+	spec[i++] = ERL_DRV_INT;
+	spec[i++] = 0;
+	break;
+    }
+#endif
+    default: { /* INET_AF_UNDEFINED */
+        i = LOAD_ATOM(spec, i, am_undefined);
+	spec[i++] = ERL_DRV_INT;
+	spec[i++] = 0;
 	spec[i++] = ERL_DRV_TUPLE;
+	spec[i++] = 2;
+	spec[i++] = ERL_DRV_INT;
 	spec[i++] = 0;
+	break;
+    }
     }
     return i;
-}
+ }
 #endif
 
 
@@ -1512,10 +1573,13 @@ static int load_ip_address(ErlDrvTermData* spec, int i, int family, char* buf)
 /* For SCTP, we often need to return {IP, Port} tuples: */
 static int inet_get_address(char* dst, inet_address* src, unsigned int* len);
 
-#define LOAD_IP_AND_PORT_CNT                                              \
+/* Max of {{int()*8},int()} | {{int()*4},int()} |
+ *        {{'local',binary()},int()}
+ */
+#define LOAD_INET_GET_ADDRESS_CNT					\
         (8*LOAD_INT_CNT + LOAD_TUPLE_CNT + LOAD_INT_CNT + LOAD_TUPLE_CNT)
                            
-static int load_ip_and_port
+static int load_inet_get_address
            (ErlDrvTermData* spec,    int i, inet_descriptor* desc,
 	    struct sockaddr_storage* addr)
 {
@@ -1533,8 +1597,7 @@ static int load_ip_and_port
     /* NB: the following functions are safe to use, as they create tuples
        of copied Ints on the "spec", and do not install any String pts --
        a ptr to "abuf" would be dangling upon exiting this function:   */
-    i = load_ip_address(spec, i, desc->sfamily, abuf+3);
-    i = load_ip_port   (spec, i, abuf+1);
+    i = load_address(spec, i, abuf);  /* IP,Port | Family,Addr */
     i = LOAD_TUPLE     (spec, i, 2);
     return i;
 }
@@ -2226,7 +2289,6 @@ static ErlDrvTermData am_http_error;
 static ErlDrvTermData am_abs_path;
 static ErlDrvTermData am_absoluteURI;
 static ErlDrvTermData am_star;
-static ErlDrvTermData am_undefined;
 static ErlDrvTermData am_http;
 static ErlDrvTermData am_https;
 static ErlDrvTermData am_scheme;
@@ -2917,7 +2979,7 @@ static int sctp_parse_async_event
 	    ASSERT(sptr->spc_length <= sz);  /* No buffer overrun */
 
 	    i = LOAD_ATOM	(spec, i, am_sctp_paddr_change);
-	    i = load_ip_and_port(spec, i, desc, &sptr->spc_aaddr);
+	    i = load_inet_get_address(spec, i, desc, &sptr->spc_aaddr);
 
 	    switch (sptr->spc_state)
 	    {
@@ -3344,10 +3406,11 @@ static int tcp_error_message(tcp_descriptor* desc, int err)
 #ifdef HAVE_UDP
 /* 
 ** active mode message:
-**        {udp,  S, IP, Port, [H1,...Hsz | Data]} or
-**	  {sctp, S, IP, Port, {[AncilData],  Event_or_Data}}
+**    {udp,  S, IP, Port, [H1,...Hsz | Data]} or
+**    {sctp, S, IP, Port, {[AncilData],  Event_or_Data}}
 ** where
 ** 	  [H1,...,HSz] are msg headers (without IP/Port, UDP only),
+**    [AddrLen, H2,...,HSz] are msg headers for UDP AF_LOCAL only
 **	  Data  : List() | Binary()
 */
 static int packet_binary_message
@@ -3357,6 +3420,7 @@ static int packet_binary_message
     ErlDrvTermData spec [PACKET_ERL_DRV_TERM_DATA_LEN];
     int i = 0;
     int alen;
+    char* data = bin->orig_bytes+offs;
 
     DEBUGF(("packet_binary_message(%ld): len = %d\r\n",
 	   (long)desc->port, len));
@@ -3366,13 +3430,12 @@ static int packet_binary_message
     i = LOAD_ATOM(spec, i, am_udp );			      /* UDP only */
 #   endif
     i = LOAD_PORT(spec, i, desc->dport);   		      /* S	  */
-    
-    alen = addrlen(desc->sfamily);
-    i = load_ip_address(spec, i, desc->sfamily, bin->orig_bytes+offs+3);
-    i = load_ip_port(spec, i, bin->orig_bytes+offs+1);	      /* IP, Port */
-    
-    offs += (alen + 3);
-    len  -= (alen + 3);
+
+    alen = addrlen(data);
+    i = load_address(spec, i, data);     /* IP,Port | Family,Addr */
+
+    offs += alen;
+    len  -= alen;
 
 #   ifdef HAVE_SCTP
     if (!IS_SCTP(desc))
@@ -3759,6 +3822,7 @@ static int inet_init()
 #   endif
 
     INIT_ATOM(ok);
+    INIT_ATOM(undefined);
     INIT_ATOM(tcp);
 #ifdef HAVE_UDP
     INIT_ATOM(udp);
@@ -3775,6 +3839,7 @@ static int inet_init()
 #ifdef HAVE_UDP
     INIT_ATOM(udp_passive);
     INIT_ATOM(udp_error);
+    INIT_ATOM(local);
 #endif
     INIT_ATOM(empty_out_q);
     INIT_ATOM(ssl_tls);
@@ -3787,7 +3852,6 @@ static int inet_init()
     INIT_ATOM(abs_path);
     INIT_ATOM(absoluteURI);
     am_star = driver_mk_atom("*");
-    INIT_ATOM(undefined);
     INIT_ATOM(http);
     INIT_ATOM(https);
     INIT_ATOM(scheme);
@@ -3883,7 +3947,7 @@ static int inet_init()
 
 
 /*
-** Set a inaddr structure:
+** Set an inaddr structure:
 **  src = [P1,P0,X1,X2,.....]
 **  dst points to a structure large enugh to keep any kind
 **  of inaddr.
@@ -3923,6 +3987,18 @@ static char* inet_set_address(int family, inet_address* dst,
 	return src + 2+16;
     }
 #endif
+#ifdef HAVE_SYS_UN_H
+    else if ((family == AF_LOCAL) && (*len >= 1)) {
+	int n = *((unsigned char*)src);
+	if ((*len < 1+n) || (sizeof(dst->sal.sun_path) < n+1))
+	  return NULL;
+	sys_memzero((char*)dst, sizeof(struct sockaddr_un));
+	dst->sal.sun_family = family;
+	sys_memcpy(dst->sal.sun_path, src+1, n);
+	*len = offsetof(struct sockaddr_un, sun_path) + n;
+	return src + 1 + n;
+    }
+#endif
     return NULL;
 }
 
@@ -3931,7 +4007,7 @@ static char* inet_set_address(int family, inet_address* dst,
 ** or from argument if source data specifies constant address.
 ** 
 ** src = [TAG,P1,P0]           when TAG = INET_AF_ANY  | INET_AF_LOOPBACK
-** src = [TAG,P1,P0,X1,X2,...] when TAG = INET_AF_INET | INET_AF_INET6
+** src = [TAG,P1,P0,X1,X2,...] when TAG = INET_AF_INET | INET_AF_INET6 | INET_AF_LOCAL
 */
 static char *inet_set_faddress(int family, inet_address* dst,
 			       char *src, ErlDrvSizeT* len) {
@@ -3949,6 +4025,12 @@ static char *inet_set_faddress(int family, inet_address* dst,
 	family = AF_INET6;
 	break;
 #   endif
+#   ifdef HAVE_SYS_UN_H
+    case INET_AF_LOCAL: {
+        family = AF_LOCAL;
+        break;
+    }
+#   endif
     case INET_AF_ANY:
     case INET_AF_LOOPBACK: {
 	int port;
@@ -4012,7 +4094,6 @@ static char *inet_set_faddress(int family, inet_address* dst,
     return inet_set_address(family, dst, src, len);
 }
 
-
 /* Get a inaddr structure
 ** src = inaddr structure
 ** *len is the lenght of structure
@@ -4023,6 +4104,7 @@ static char *inet_set_faddress(int family, inet_address* dst,
 */
 static int inet_get_address(char* dst, inet_address* src, unsigned int* len)
 {
+    /* Compare the code with inet_address_to_erlang() */
     int family;
     short port;
 
@@ -4045,6 +4127,32 @@ static int inet_get_address(char* dst, inet_address* src, unsigned int* len)
 	return 0;
     }
 #endif
+#ifdef HAVE_SYS_UN_H
+    else if (family == AF_LOCAL) {
+        size_t n, m;
+        if (*len < offsetof(struct sockaddr_un, sun_path)) return -1;
+        n = *len - offsetof(struct sockaddr_un, sun_path);
+        if (255 < n) return -1;
+	/* Portability fix: Assume that the address is a zero terminated
+	 * string, except when the first byte is \0 i.e the
+	 * string length is 0.  Then use the reported length instead.
+	 * This fix handles Linux's abstract socket address
+	 * nonportable extension.
+	 */
+        m = my_strnlen(src->sal.sun_path, n);
+	if ((m == 0) && is_nonzero(src->sal.sun_path, n))
+	    m = n;
+        dst[0] = INET_AF_LOCAL;
+        dst[1] = (char) ((unsigned char) m);
+        sys_memcpy(dst+2, src->sal.sun_path, m);
+        *len = 1 + 1 + m;
+        return 0;
+      }
+#endif
+    else {
+        dst[0] = INET_AF_UNDEFINED;
+	*len = 1;
+    }
     return -1;
 }
 
@@ -4053,7 +4161,9 @@ static int inet_get_address(char* dst, inet_address* src, unsigned int* len)
 ** according to the size of the current,
 ** and return the resulting encoded size
 */
-static int inet_address_to_erlang(char *dst, inet_address **src) {
+static int
+inet_address_to_erlang(char *dst, inet_address **src, SOCKLEN_T sz) {
+    /* Compare the code with inet_get_address() */
     short port;
 
     switch ((*src)->sa.sa_family) {
@@ -4078,6 +4188,30 @@ static int inet_address_to_erlang(char *dst, inet_address **src) {
 	(*src) = (inet_address *) (&(*src)->sai6 + 1);
 	return 1 + 2 + 16;
 #endif
+#ifdef HAVE_SYS_UN_H
+    case AF_LOCAL: {
+        size_t n, m;
+	if (sz < offsetof(struct sockaddr_un, sun_path)) return -1;
+	n = sz - offsetof(struct sockaddr_un, sun_path);
+	if (255 < n) return -1;
+	/* Portability fix: Assume that the address is a zero terminated
+	 * string, except when the first byte is \0 i.e the
+	 * string length is 0.  Then use the reported length instead.
+	 * This fix handles Linux's abstract socket address
+	 * nonportable extension.
+	 */
+        m = my_strnlen((*src)->sal.sun_path, n);
+	if ((m == 0) && is_nonzero((*src)->sal.sun_path, n))
+	    m = n;
+	if (dst) {
+	    dst[0] = INET_AF_LOCAL;
+	    dst[1] = (char) ((unsigned char) m);
+            sys_memcpy(dst+2, (*src)->sal.sun_path, m);
+	}
+	(*src) = (inet_address *) (&(*src)->sal + 1);
+	return 1 + 1 + m;
+    }
+#endif
     default:
 	return -1;
     }
@@ -4086,7 +4220,7 @@ static int inet_address_to_erlang(char *dst, inet_address **src) {
 /* Encode n encoded addresses from addrs in the result buffer
 */
 static ErlDrvSizeT reply_inet_addrs
-(int n, inet_address *addrs, char **rbuf, ErlDrvSizeT rsize) {
+(int n, inet_address *addrs, char **rbuf, ErlDrvSizeT rsize, SOCKLEN_T sz) {
     inet_address *ia;
     int i, s;
     ErlDrvSizeT rlen;
@@ -4094,11 +4228,19 @@ static ErlDrvSizeT reply_inet_addrs
     if (IS_SOCKET_ERROR(n)) return ctl_error(sock_errno(), rbuf, rsize);
     if (n == 0) return ctl_reply(INET_REP_OK, NULL, 0, rbuf, rsize);
 
+    /* The sz argument is only used when we have got an actual size
+     * of addrs[0] from e.g getsockname() and then n == 1
+     * so we will loop over 1 element below.  Otherwise sz
+     * would be expected to differ between addresses but that
+     * can only happen for AF_LOCAL and we will only be called with
+     * n > 1 for SCTP and that will never (?) happen with AF_LOCAL
+     */
+
     /* Calculate result length */
     rlen = 1;
     ia = addrs;
     for (i = 0;  i < n;  i++) {
-	s = inet_address_to_erlang(NULL, &ia);
+        s = inet_address_to_erlang(NULL, &ia, sz);
 	if (s < 0) break;
 	rlen += s;
     }
@@ -4109,7 +4251,7 @@ static ErlDrvSizeT reply_inet_addrs
     rlen = 1;
     ia = addrs;
     for (i = 0;  i < n;  i++) {
-	s = inet_address_to_erlang((*rbuf)+rlen, &ia);
+        s = inet_address_to_erlang((*rbuf)+rlen, &ia, sz);
 	if (s < 0) break;
 	rlen += s;
     }
@@ -4180,6 +4322,7 @@ static ErlDrvSSizeT inet_ctl_open(inet_descriptor* desc, int domain, int type,
 				  char** rbuf, ErlDrvSizeT rsize)
 {
     int save_errno;
+    int protocol;
 #ifdef HAVE_SETNS
     int current_ns, new_ns;
     current_ns = new_ns = 0;
@@ -4218,7 +4361,11 @@ static ErlDrvSSizeT inet_ctl_open(inet_descriptor* desc, int domain, int type,
 	}
     }
 #endif
-    if ((desc->s = sock_open(domain, type, desc->sprotocol)) == INVALID_SOCKET)
+    protocol = desc->sprotocol;
+#ifdef HAVE_SYS_UN_H
+    if (domain == AF_LOCAL) protocol = 0;
+#endif
+    if ((desc->s = sock_open(domain, type, protocol)) == INVALID_SOCKET)
 	save_errno = sock_errno();
 #ifdef HAVE_SETNS
     if (desc->netns != NULL) {
@@ -7119,14 +7266,14 @@ static ErlDrvSSizeT inet_fill_opts(inet_descriptor* desc,
 
 #ifdef HAVE_SCTP
 #define LOAD_PADDRINFO_CNT                                            \
-        (2*LOAD_ATOM_CNT + LOAD_ASSOC_ID_CNT + LOAD_IP_AND_PORT_CNT + \
+        (2*LOAD_ATOM_CNT + LOAD_ASSOC_ID_CNT + LOAD_INET_GET_ADDRESS_CNT + \
 	 4*LOAD_INT_CNT + LOAD_TUPLE_CNT)
 static int load_paddrinfo (ErlDrvTermData * spec, int i,
 			   inet_descriptor* desc, struct sctp_paddrinfo* pai)
 {
     i = LOAD_ATOM	(spec, i, am_sctp_paddrinfo);
     i = LOAD_ASSOC_ID	(spec, i, pai->spinfo_assoc_id);
-    i = load_ip_and_port(spec, i, desc, &pai->spinfo_address);
+    i = load_inet_get_address(spec, i, desc, &pai->spinfo_address);
     switch(pai->spinfo_state)
     {
     case SCTP_ACTIVE:
@@ -7542,7 +7689,7 @@ static ErlDrvSSizeT sctp_fill_opts(inet_descriptor* desc,
 	    /* Fill in the response: */
 	    PLACE_FOR(spec, i, 
 		      2*LOAD_ATOM_CNT + LOAD_ASSOC_ID_CNT + 
-		      LOAD_IP_AND_PORT_CNT + 2*LOAD_TUPLE_CNT);
+		      LOAD_INET_GET_ADDRESS_CNT + 2*LOAD_TUPLE_CNT);
 	    switch (eopt) {
 	    case SCTP_OPT_PRIMARY_ADDR:
 		i = LOAD_ATOM(spec, i, am_sctp_primary_addr);
@@ -7556,7 +7703,7 @@ static ErlDrvSSizeT sctp_fill_opts(inet_descriptor* desc,
 		ASSERT(0);
 	    }
 	    i = LOAD_ASSOC_ID	(spec, i, sp.sspp_assoc_id);
-	    i = load_ip_and_port(spec, i, desc, &sp.sspp_addr);
+	    i = load_inet_get_address(spec, i, desc, &sp.sspp_addr);
 	    i = LOAD_TUPLE	(spec, i, 3);
 	    i = LOAD_TUPLE	(spec, i, 2);
 	    break;
@@ -7603,11 +7750,11 @@ static ErlDrvSSizeT sctp_fill_opts(inet_descriptor* desc,
 	    /* Fill in the response: */
 	    PLACE_FOR(spec, i, 
 		      2*LOAD_ATOM_CNT + LOAD_ASSOC_ID_CNT + 
-		      LOAD_IP_AND_PORT_CNT + 4*LOAD_INT_CNT);
+		      LOAD_INET_GET_ADDRESS_CNT + 4*LOAD_INT_CNT);
 	    i = LOAD_ATOM	(spec, i, am_sctp_peer_addr_params);
 	    i = LOAD_ATOM	(spec, i, am_sctp_paddrparams);
 	    i = LOAD_ASSOC_ID	(spec, i, ap.spp_assoc_id);
-	    i = load_ip_and_port(spec, i, desc, &ap.spp_address);
+	    i = load_inet_get_address(spec, i, desc, &ap.spp_address);
 	    i = LOAD_INT	(spec, i, ap.spp_hbinterval);
 	    i = LOAD_INT	(spec, i, ap.spp_pathmaxrxt);
 	    
@@ -8248,6 +8395,11 @@ static ErlDrvSSizeT inet_ctl(inet_descriptor* desc, int cmd, char* buf,
 	    put_int32(INET_AF_INET6, &tbuf[0]);
 	}
 #endif
+#ifdef HAVE_SYS_UN_H
+	else if (desc->sfamily == AF_LOCAL) {
+	    put_int32(INET_AF_LOCAL, &tbuf[0]);
+	}
+#endif
 	else
 	    return ctl_error(EINVAL, rbuf, rsize);
 
@@ -8307,19 +8459,19 @@ static ErlDrvSSizeT inet_ctl(inet_descriptor* desc, int cmd, char* buf,
 
 	    assoc_id = get_int32(buf);
 	    n = p_sctp_getpaddrs(desc->s, assoc_id, &sa);
-	    rlen = reply_inet_addrs(n, (inet_address *) sa, rbuf, rsize);
+	    rlen = reply_inet_addrs(n, (inet_address *) sa, rbuf, rsize, 0);
 	    if (n > 0) p_sctp_freepaddrs(sa);
 	    return rlen;
 	}
 #endif
 	{ /* Fallback to sock_peer */
 	    inet_address addr;
-	    unsigned int sz;
+	    SOCKLEN_T sz;
 	    int i;
 
 	    sz = sizeof(addr);
 	    i = sock_peer(desc->s, (struct sockaddr *) &addr, &sz);
-	    return reply_inet_addrs(i >= 0 ? 1 : i, &addr, rbuf, rsize);
+	    return reply_inet_addrs(i >= 0 ? 1 : i, &addr, rbuf, rsize, sz);
 	}
     }
 
@@ -8327,15 +8479,21 @@ static ErlDrvSSizeT inet_ctl(inet_descriptor* desc, int cmd, char* buf,
 	char tbuf[sizeof(inet_address)];
 	inet_address peer;
 	inet_address* ptr;
-	unsigned int sz = sizeof(peer);
+	unsigned int sz;
 
 	DEBUGF(("inet_ctl(%ld): PEER\r\n", (long)desc->port)); 
 
 	if (!(desc->state & INET_F_ACTIVE))
 	    return ctl_error(ENOTCONN, rbuf, rsize);
-	if ((ptr = desc->peer_ptr) == NULL) {
+	if ((ptr = desc->peer_ptr) != NULL) {
+	    sz = desc->peer_addr_len;
+	}
+	else {
 	    ptr = &peer;
-	    if (IS_SOCKET_ERROR(sock_peer(desc->s, (struct sockaddr*)ptr,&sz)))
+            sz = sizeof(peer);
+	    if (IS_SOCKET_ERROR
+		(sock_peer
+		 (desc->s, (struct sockaddr*)ptr, &sz)))
 		return ctl_error(sock_errno(), rbuf, rsize);
 	}
 	if (inet_get_address(tbuf, ptr, &sz) < 0)
@@ -8350,11 +8508,12 @@ static ErlDrvSSizeT inet_ctl(inet_descriptor* desc, int cmd, char* buf,
 	}
 	else if (len < 2)
 	    return ctl_error(EINVAL, rbuf, rsize);	    
-	else if (inet_set_address(desc->sfamily, &desc->peer_addr,
-				  buf, &len) == NULL)
+	else if (inet_set_faddress
+		 (desc->sfamily, &desc->peer_addr, buf, &len) == NULL)
 	    return ctl_error(EINVAL, rbuf, rsize);
 	else {
 	    desc->peer_ptr = &desc->peer_addr;
+	    desc->peer_addr_len = (SOCKLEN_T) len;
 	    return ctl_reply(INET_REP_OK, NULL, 0, rbuf, rsize);	    
 	}
     }
@@ -8376,19 +8535,19 @@ static ErlDrvSSizeT inet_ctl(inet_descriptor* desc, int cmd, char* buf,
 
 	    assoc_id = get_int32(buf);
 	    n = p_sctp_getladdrs(desc->s, assoc_id, &sa);
-	    rlen = reply_inet_addrs(n, (inet_address *) sa, rbuf, rsize);
+	    rlen = reply_inet_addrs(n, (inet_address *) sa, rbuf, rsize, 0);
 	    if (n > 0) p_sctp_freeladdrs(sa);
 	    return rlen;
 	}
 #endif
 	{ /* Fallback to sock_name */
 	    inet_address addr;
-	    unsigned int sz;
+	    SOCKLEN_T sz;
 	    int i;
 
 	    sz = sizeof(addr);
 	    i = sock_name(desc->s, (struct sockaddr *) &addr, &sz);
-	    return reply_inet_addrs(i >= 0 ? 1 : i, &addr, rbuf, rsize);
+	    return reply_inet_addrs(i >= 0 ? 1 : i, &addr, rbuf, rsize, sz);
 	}
     }
 
@@ -8396,16 +8555,21 @@ static ErlDrvSSizeT inet_ctl(inet_descriptor* desc, int cmd, char* buf,
 	char tbuf[sizeof(inet_address)];
 	inet_address name;
 	inet_address* ptr;
-	unsigned int sz = sizeof(name);
+	unsigned int sz;
 
 	DEBUGF(("inet_ctl(%ld): NAME\r\n", (long)desc->port)); 
 
 	if (!IS_BOUND(desc))
 	    return ctl_error(EINVAL, rbuf, rsize); /* address is not valid */
 
-	if ((ptr = desc->name_ptr) == NULL) {
+	if ((ptr = desc->name_ptr) != NULL) {
+	    sz = desc->name_addr_len;
+	}
+	else {
 	    ptr = &name;
-	    if (IS_SOCKET_ERROR(sock_name(desc->s, (struct sockaddr*)ptr, &sz)))
+	    sz = sizeof(name);
+	    if (IS_SOCKET_ERROR
+		(sock_name(desc->s, (struct sockaddr*)ptr, &sz)))
 		return ctl_error(sock_errno(), rbuf, rsize);
 	}
 	if (inet_get_address(tbuf, ptr, &sz) < 0)
@@ -8413,18 +8577,19 @@ static ErlDrvSSizeT inet_ctl(inet_descriptor* desc, int cmd, char* buf,
 	return ctl_reply(INET_REP_OK, tbuf, sz, rbuf, rsize);
     }
 
-    case INET_REQ_SETNAME: { /* set fake peername Port Address */
+    case INET_REQ_SETNAME: { /* set fake sockname Port Address */
 	if (len == 0) {
 	    desc->name_ptr = NULL;
 	    return ctl_reply(INET_REP_OK, NULL, 0, rbuf, rsize);
 	}
 	else if (len < 2)
 	    return ctl_error(EINVAL, rbuf, rsize);	    
-	else if (inet_set_address(desc->sfamily, &desc->name_addr,
-				  buf, &len) == NULL)
+	else if (inet_set_faddress
+		 (desc->sfamily, &desc->name_addr, buf, &len) == NULL)
 	    return ctl_error(EINVAL, rbuf, rsize);
 	else {
 	    desc->name_ptr = &desc->name_addr;
+	    desc->name_addr_len = (SOCKLEN_T) len;
 	    return ctl_reply(INET_REP_OK, NULL, 0, rbuf, rsize);	    
 	}
     }
@@ -8432,7 +8597,7 @@ static ErlDrvSSizeT inet_ctl(inet_descriptor* desc, int cmd, char* buf,
     case INET_REQ_BIND:  {      /* bind socket */
 	char tbuf[2];
 	inet_address local;
-	short port;
+	int port;
 
 	DEBUGF(("inet_ctl(%ld): BIND\r\n", (long)desc->port)); 
 
@@ -8449,13 +8614,14 @@ static ErlDrvSSizeT inet_ctl(inet_descriptor* desc, int cmd, char* buf,
 
 	desc->state = INET_STATE_BOUND;
 
-	if ((port = inet_address_port(&local)) == 0) {
+	port = inet_address_port(&local);
+	if (port == 0) {
 	    SOCKLEN_T adrlen = sizeof(local);
 	    sock_name(desc->s, &local.sa, &adrlen);
 	    port = inet_address_port(&local);
 	}
-	port = sock_ntohs(port);
-	put_int16(port, tbuf);
+        else if (port == -1) port = 0;
+	put_int16(sock_ntohs((Uint16) port), tbuf);
 	return ctl_reply(INET_REP_OK, tbuf, 2, rbuf, rsize);
     }
 
@@ -8912,6 +9078,11 @@ static ErlDrvSSizeT tcp_inet_ctl(ErlDrvData e, unsigned int cmd,
 	    return ctl_xerror("eafnosupport", rbuf, rsize);
 	    break;
 #endif
+#ifdef HAVE_SYS_UN_H
+	case INET_AF_LOCAL:
+	    domain = AF_LOCAL;
+	    break;
+#endif
 	default:
 	    return ctl_error(EINVAL, rbuf, rsize);
 	}
@@ -8938,6 +9109,11 @@ static ErlDrvSSizeT tcp_inet_ctl(ErlDrvData e, unsigned int cmd,
 	    return ctl_xerror("eafnosupport", rbuf, rsize);
 	    break;
 #endif
+#ifdef HAVE_SYS_UN_H
+	case INET_AF_LOCAL:
+	    domain = AF_LOCAL;
+	    break;
+#endif
 	default:
 	    return ctl_error(EINVAL, rbuf, rsize);
 	}
@@ -8993,8 +9169,8 @@ static ErlDrvSSizeT tcp_inet_ctl(ErlDrvData e, unsigned int cmd,
 	timeout = get_int32(buf);
 	buf += 4;
 	len -= 4;
-	if (inet_set_address(desc->inet.sfamily, &desc->inet.remote,
-			     buf, &len) == NULL)
+	if (inet_set_faddress
+	    (desc->inet.sfamily, &desc->inet.remote, buf, &len) == NULL)
 	    return ctl_error(EINVAL, rbuf, rsize);
 	
 	code = sock_connect(desc->inet.s, 
@@ -10777,6 +10953,9 @@ static ErlDrvSSizeT packet_inet_ctl(ErlDrvData e, unsigned int cmd, char* buf,
 	    return ctl_xerror("eafnosupport", rbuf, rsize);
 	    break;
 #endif
+#ifdef HAVE_SYS_UN_H
+	case INET_AF_LOCAL: af = AF_LOCAL; break;
+#endif
 	default:
 	    return ctl_error(EINVAL, rbuf, rsize);
 	}
@@ -10827,6 +11006,9 @@ static ErlDrvSSizeT packet_inet_ctl(ErlDrvData e, unsigned int cmd, char* buf,
 	    return ctl_xerror("eafnosupport", rbuf, rsize);
 	    break;
 #endif
+#ifdef HAVE_SYS_UN_H
+	case INET_AF_LOCAL: af = AF_LOCAL; break;
+#endif
 	default:
 	    return ctl_error(EINVAL, rbuf, rsize);
 	}
@@ -10909,7 +11091,7 @@ static ErlDrvSSizeT packet_inet_ctl(ErlDrvData e, unsigned int cmd, char* buf,
 
 	    /* For SCTP, we do not set the peer's addr in desc->remote, as
 	       multiple peers are possible: */
-	    if (inet_set_address(desc->sfamily, &remote, buf, &len) == NULL)
+	    if (inet_set_faddress(desc->sfamily, &remote, buf, &len) == NULL)
 		return ctl_error(EINVAL, rbuf, rsize);
 	
 	    sock_select(desc, FD_CONNECT, 1);
@@ -10949,8 +11131,8 @@ static ErlDrvSSizeT packet_inet_ctl(ErlDrvData e, unsigned int cmd, char* buf,
 	    /* Ignore timeout */
 	    buf += 4;
 	    len -= 4;
-	    if (inet_set_address(desc->sfamily, 
-				 &desc->remote, buf, &len) == NULL)
+	    if (inet_set_faddress
+		(desc->sfamily, &desc->remote, buf, &len) == NULL)
 		return ctl_error(EINVAL, rbuf, rsize);
 	    
 	    code = sock_connect(desc->s,
@@ -11130,12 +11312,12 @@ static void packet_inet_timeout(ErlDrvData e)
 
 
 /* THIS IS A "send*" REQUEST; on the Erlang side: "port_command".
-** input should be: P1 P0 Address buffer .
+** input should be: Family Address buffer .
 ** For UDP,  buffer (after Address) is just data to be sent.
 ** For SCTP, buffer contains a list representing 2 items:
 **   (1) 6 parms for sctp_sndrcvinfo, as in sctp_get_sendparams();
 **   (2) 0+ real data bytes.
-** There is no destination address -- SCTYP send is performed over
+** There is no destination address -- SCTP send is performed over
 ** an existing association, using "sctp_sndrcvinfo" specified.
 */
 static void packet_inet_command(ErlDrvData e, char* buf, ErlDrvSizeT len)
@@ -11210,7 +11392,7 @@ static void packet_inet_command(ErlDrvData e, char* buf, ErlDrvSizeT len)
     /* UDP socket. Even if it is connected, there is an address prefix
        here -- ignored for connected sockets: */
     sz = len;
-    qtr = inet_set_address(desc->sfamily, &other, ptr, &sz);
+    qtr = inet_set_faddress(desc->sfamily, &other, ptr, &sz);
     if (qtr == NULL) {
 	inet_reply_error(desc, EINVAL);
 	return;
@@ -11809,9 +11991,8 @@ int erts_sock_connect(erts_sock_t socket, byte *ip_addr, int len, Uint16 port)
     if (!inet_set_address(AF_INET, &addr, buf, &blen))
 	return 0;
 
-    if (IS_SOCKET_ERROR(sock_connect(s,
-				     (struct sockaddr *) &addr,
-				     sizeof(struct sockaddr_in))))
+    if (IS_SOCKET_ERROR
+	(sock_connect(s, (struct sockaddr *) &addr, blen)))
 	return 0;
     return 1;
 }
diff --git a/erts/preloaded/ebin/prim_inet.beam b/erts/preloaded/ebin/prim_inet.beam
index 0521060e34..876f4892a4 100644
--- a/erts/preloaded/ebin/prim_inet.beam
+++ b/erts/preloaded/ebin/prim_inet.beam
diff --git a/erts/preloaded/src/prim_inet.erl b/erts/preloaded/src/prim_inet.erl
index 4872ffd00c..c6434fd83b 100644
--- a/erts/preloaded/src/prim_inet.erl
+++ b/erts/preloaded/src/prim_inet.erl
@@ -70,11 +70,13 @@ open(Protocol, Family, Type) ->
 open(Protocol, Family, Type, Opts) ->
     open(Protocol, Family, Type, Opts, ?INET_REQ_OPEN, []).
 
+%% FDOPEN(tcp|udp|sctp, inet|inet6|local, stream|dgram|seqpacket, integer())
+
 fdopen(Protocol, Family, Type, Fd) when is_integer(Fd) ->
     fdopen(Protocol, Family, Type, Fd, true).
 
 fdopen(Protocol, Family, Type, Fd, Bound)
-  when is_integer(Fd), Bound == true orelse Bound == false ->
+  when is_integer(Fd), is_boolean(Bound) ->
     open(Protocol, Family, Type, [], ?INET_REQ_FDOPEN,
          [?int32(Fd), enc_value_2(bool, Bound)]).
 
@@ -104,8 +106,9 @@ open(Protocol, Family, Type, Opts, Req, Data) ->
 	error:system_limit -> {error, system_limit}
     end.
 
-enc_family(inet) -> ?INET_AF_INET;
-enc_family(inet6) -> ?INET_AF_INET6.
+enc_family(inet)  -> ?INET_AF_INET;
+enc_family(inet6) -> ?INET_AF_INET6;
+enc_family(local) -> ?INET_AF_LOCAL.
 
 enc_type(stream) -> ?INET_TYPE_STREAM;
 enc_type(dgram) -> ?INET_TYPE_DGRAM;
@@ -189,41 +192,52 @@ close_port(S) ->
 %%
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
-bind(S,IP,Port) when is_port(S), is_integer(Port), Port >= 0, Port =< 65535 ->
-    case ctl_cmd(S,?INET_REQ_BIND,enc_value(set, addr, {IP,Port})) of
-	{ok, [P1,P0]} -> {ok, ?u16(P1, P0)};
-	{error,_}=Error -> Error
-    end;
-
 %% Multi-homed "bind": sctp_bindx(). The Op is 'add' or 'remove'.
 %% If no addrs are specified, it just does nothing.
 %% Function returns {ok, S} on success, unlike TCP/UDP "bind":
-bind(S, Op, Addrs) when is_port(S), is_list(Addrs) ->
-    case Op of
-	add ->
-	    bindx(S, 1, Addrs);
-	remove ->
-	    bindx(S, 0, Addrs);
-	_ -> {error, einval}
+bind(S, add, Addrs) when is_port(S), is_list(Addrs) ->
+    bindx(S, 1, Addrs);
+bind(S, remove, Addrs) when is_port(S), is_list(Addrs) ->
+    bindx(S, 0, Addrs);
+bind(S, Addr, _) when is_port(S), tuple_size(Addr) =:= 2 ->
+    case type_value(set, addr, Addr) of
+	true ->
+	    case ctl_cmd(S,?INET_REQ_BIND,enc_value(set, addr, Addr)) of
+		{ok, [P1,P0]} -> {ok, ?u16(P1, P0)};
+		{error, _} = Error -> Error
+	    end;
+	false ->
+	    {error, einval}
     end;
-bind(_, _, _) -> {error, einval}.
+bind(S, IP, Port) ->
+    bind(S, {IP, Port}, 0).
 
 bindx(S, AddFlag, Addrs) ->
     case getprotocol(S) of
 	sctp ->
-	    %% Really multi-homed "bindx". Stringified args:
-	    %% [AddFlag, (AddrBytes see enc_value_2(addr,X))+]:
-	    Args =
-		[?int8(AddFlag)|
-		 [enc_value(set, addr, {IP,Port}) ||
-		     {IP, Port} <- Addrs]],
-	    case ctl_cmd(S, ?SCTP_REQ_BINDX, Args) of
-		{ok,_} -> {ok, S};
-		{error,_}=Error  -> Error
+	    case bindx_check_addrs(Addrs) of
+		true ->
+		    %% Really multi-homed "bindx". Stringified args:
+		    %% [AddFlag, (AddrBytes see enc_value_2(addr,X))+]:
+		    Args =
+			[?int8(AddFlag)|
+			 [enc_value(set, addr, Addr) || Addr <- Addrs]],
+		    case ctl_cmd(S, ?SCTP_REQ_BINDX, Args) of
+			{ok, _} -> {ok, S};
+			{error, _}=Error  -> Error
+		    end;
+		false ->
+		    {error, einval}
 	    end;
-	_ -> {error, einval}
+	_ ->
+	    {error, einval}
     end.
 
+bindx_check_addrs([Addr|Addrs]) ->
+    type_value(set, addr, Addr) andalso bindx_check_addrs(Addrs);
+bindx_check_addrs([]) ->
+    true.
+
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%
 %% CONNECT(insock(), IP, Port [,Timeout]) -> ok | {error, Reason}
@@ -242,14 +256,24 @@ bindx(S, AddFlag, Addrs) ->
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %% For TCP, UDP or SCTP sockets.
 %%
-connect(S, IP, Port) -> connect0(S, IP, Port, -1).
 
-connect(S, IP, Port, infinity) -> connect0(S, IP, Port, -1);
-connect(S, IP, Port, Time)     -> connect0(S, IP, Port, Time).
+connect(S, IP, Port) ->
+    connect(S, IP, Port, infinity).
+%%
+connect(S, Addr, _, Time) when is_port(S), tuple_size(Addr) =:= 2 ->
+    case type_value(set, addr, Addr) of
+	true when Time =:= infinity ->
+	    connect0(S, Addr, -1);
+	true when is_integer(Time) ->
+	    connect0(S, Addr, Time);
+	false ->
+	    {error, einval}
+    end;
+connect(S, IP, Port, Time) ->
+    connect(S, {IP, Port}, 0, Time).
 
-connect0(S, IP, Port, Time) when is_port(S), Port > 0, Port =< 65535,
-				 is_integer(Time) ->
-    case async_connect(S, IP, Port, Time) of
+connect0(S, Addr, Time) ->
+    case async_connect0(S, Addr, Time) of
 	{ok, S, Ref} ->
 	    receive
 		{inet_async, S, Ref, Status} ->
@@ -258,11 +282,27 @@ connect0(S, IP, Port, Time) when is_port(S), Port > 0, Port =< 65535,
 	Error -> Error
     end.
 
+
+async_connect(S, Addr, _, Time) when is_port(S), tuple_size(Addr) =:= 2 ->
+    case type_value(set, addr, Addr) of
+	true when Time =:= infinity ->
+	    async_connect0(S, Addr, -1);
+	true when is_integer(Time) ->
+	    async_connect0(S, Addr, Time);
+	false ->
+	    {error, einval}
+    end;
+%%
 async_connect(S, IP, Port, Time) ->
-    case ctl_cmd(S, ?INET_REQ_CONNECT,
-		 [enc_time(Time),?int16(Port),ip_to_bytes(IP)]) of
+    async_connect(S, {IP, Port}, 0, Time).
+
+async_connect0(S, Addr, Time) ->
+    case ctl_cmd(
+	   S, ?INET_REQ_CONNECT,
+	   [enc_time(Time),enc_value(set, addr, Addr)])
+    of
 	{ok, [R1,R0]} -> {ok, S, ?u16(R1,R0)};
-	{error,_}=Error -> Error
+	{error, _}=Error -> Error
     end.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -400,20 +440,34 @@ send(S, Data) ->
 %% "sendto" is for UDP. IP and Port are set by the caller to 0 if the socket
 %% is known to be connected.
 
-sendto(S, IP, Port, Data) when is_port(S), Port >= 0, Port =< 65535 ->
-    ?DBG_FORMAT("prim_inet:sendto(~p, ~p, ~p, ~p)~n", [S,IP,Port,Data]),
-    try erlang:port_command(S, [?int16(Port),ip_to_bytes(IP),Data]) of
-	true -> 
-	    receive
-		{inet_reply,S,Reply} ->
-		    ?DBG_FORMAT("prim_inet:sendto() -> ~p~n", [Reply]),
-		     Reply
-	    end
-    catch
-	error:_ ->
-	    ?DBG_FORMAT("prim_inet:sendto() -> {error,einval}~n", []),
-	     {error,einval}
-    end.
+sendto(S, Addr, _, Data) when is_port(S), tuple_size(Addr) =:= 2 ->
+    case type_value(set, addr, Addr) of
+	true ->
+	    ?DBG_FORMAT("prim_inet:sendto(~p, ~p, ~p)~n", [S,Addr,Data]),
+	    try
+		erlang:port_command(S, [enc_value(set, addr, Addr),Data])
+	    of
+		true ->
+		    receive
+			{inet_reply,S,Reply} ->
+			    ?DBG_FORMAT(
+			       "prim_inet:sendto() -> ~p~n", [Reply]),
+			    Reply
+		    end
+	    catch
+		error:_ ->
+		    ?DBG_FORMAT(
+		       "prim_inet:sendto() -> {error,einval}~n", []),
+		    {error,einval}
+	    end;
+	false ->
+	    ?DBG_FORMAT(
+	       "prim_inet:sendto() -> {error,einval}~n", []),
+	    {error,einval}
+    end;
+sendto(S, IP, Port, Data) ->
+    sendto(S, {IP, Port}, 0, Data).
+
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%
@@ -484,29 +538,37 @@ async_recv(S, Length, Time) ->
 %% oriented: preserved here only for API compatibility.
 %%
 recvfrom(S, Length) ->
-    recvfrom0(S, Length, -1).
+    recvfrom(S, Length, infinity).
 
-recvfrom(S, Length, infinity) ->
+recvfrom(S, Length, infinity) when is_port(S) ->
     recvfrom0(S, Length, -1);
-recvfrom(S, Length, Time) when is_integer(Time), Time < 16#ffffffff ->
-    recvfrom0(S, Length, Time);
-recvfrom(_, _, _) -> {error,einval}.
+recvfrom(S, Length, Time) when is_port(S) ->
+    if
+	is_integer(Time), 0 =< Time, Time < 16#ffffffff ->
+	    recvfrom0(S, Length, Time);
+	true ->
+	    {error, einval}
+    end.
 
 recvfrom0(S, Length, Time)
-  when is_port(S), is_integer(Length), Length >= 0, Length =< 16#ffffffff ->
+  when is_integer(Length), 0 =< Length, Length =< 16#ffffffff ->
     case ctl_cmd(S, ?PACKET_REQ_RECV,[enc_time(Time),?int32(Length)]) of
 	{ok,[R1,R0]} ->
 	    Ref = ?u16(R1,R0),
 	    receive
 		% Success, UDP:
-		{inet_async, S, Ref, {ok, [F,P1,P0 | AddrData]}} ->
-		    {IP,Data} = get_ip(F, AddrData),
-		    {ok, {IP, ?u16(P1,P0), Data}};
+		{inet_async, S, Ref, {ok, [F | AddrData]}} ->
+		    case get_addr(F, AddrData) of
+			{{Family, _} = Addr, Data} when is_atom(Family) ->
+			    {ok, {Addr, 0, Data}};
+			{{IP, Port}, Data} ->
+			    {ok, {IP, Port, Data}}
+		    end;
 
 		% Success, SCTP:
 		{inet_async, S, Ref, {ok, {[F,P1,P0 | Addr], AncData, DE}}} ->
-		    {IP, _}   = get_ip(F, Addr),
-		    {ok, {IP, ?u16(P1,P0), AncData, DE}};
+		    {IP, _} = get_ip(F, Addr),
+		    {ok, {IP, ?u16(P1, P0), AncData, DE}};
 
 		% Back-end error:
 		{inet_async, S, Ref, Error={error, _}} ->
@@ -525,21 +587,26 @@ recvfrom0(_, _, _) -> {error,einval}.
 
 peername(S) when is_port(S) ->
     case ctl_cmd(S, ?INET_REQ_PEER, []) of
-	{ok, [F, P1,P0 | Addr]} ->
-	    {IP, _} = get_ip(F, Addr),
-	    {ok, { IP, ?u16(P1, P0) }};
-	{error,_}=Error -> Error
+	{ok, [F | Addr]} ->
+	    {A, _} = get_addr(F, Addr),
+	    {ok, A};
+	{error, _} = Error -> Error
     end.
 
-setpeername(S, {IP,Port}) when is_port(S) ->
-    case ctl_cmd(S, ?INET_REQ_SETPEER, [?int16(Port),ip_to_bytes(IP)]) of
-	{ok,[]} -> ok;
-	{error,_}=Error -> Error
-    end;
 setpeername(S, undefined) when is_port(S) ->
     case ctl_cmd(S, ?INET_REQ_SETPEER, []) of
-	{ok,[]} -> ok;
-	{error,_}=Error -> Error
+	{ok, []} -> ok;
+	{error, _} = Error -> Error
+    end;
+setpeername(S, Addr) when is_port(S) ->
+    case type_value(set, addr, Addr) of
+	true ->
+	    case ctl_cmd(S, ?INET_REQ_SETPEER, enc_value(set, addr, Addr)) of
+		{ok, []} -> ok;
+		{error, _} = Error -> Error
+	    end;
+	false ->
+	    {error, einval}
     end.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -580,21 +647,28 @@ peernames(S, AssocId)
 
 sockname(S) when is_port(S) ->
     case ctl_cmd(S, ?INET_REQ_NAME, []) of
-	{ok, [F, P1, P0 | Addr]} ->
-	    {IP, _} = get_ip(F, Addr),
-	    {ok, { IP, ?u16(P1, P0) }};
-	{error,_}=Error -> Error
+	{ok, [F | Addr]} ->
+	    {A, _} = get_addr(F, Addr),
+	    {ok, A};
+	{error, _} = Error -> Error
     end.
 
-setsockname(S, {IP,Port}) when is_port(S) ->
-    case ctl_cmd(S, ?INET_REQ_SETNAME, [?int16(Port),ip_to_bytes(IP)]) of
-	{ok,[]} -> ok;
-	{error,_}=Error -> Error
-    end;
 setsockname(S, undefined) when is_port(S) ->
     case ctl_cmd(S, ?INET_REQ_SETNAME, []) of
-	{ok,[]} -> ok;
-	{error,_}=Error -> Error
+	{ok, []} -> ok;
+	{error, _} = Error -> Error
+    end;
+setsockname(S, Addr) when is_port(S) ->
+    case type_value(set, addr, Addr) of
+	true ->
+	    case
+		ctl_cmd(S, ?INET_REQ_SETNAME, enc_value(set, addr, Addr))
+	    of
+		{ok, []} -> ok;
+		{error, _} = Error -> Error
+	    end;
+	false ->
+	    {error, einval}
     end.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -1496,14 +1570,49 @@ type_value_2(uint8, X)  when X band 16#ff =:= X       -> true;
 type_value_2(time, infinity)                          -> true;
 type_value_2(time, X) when is_integer(X), X >= 0      -> true;
 type_value_2(ip,{A,B,C,D}) when ?ip(A,B,C,D)          -> true;
+%%
 type_value_2(addr, {any,Port}) ->
     type_value_2(uint16, Port);
 type_value_2(addr, {loopback,Port}) ->
     type_value_2(uint16, Port);
-type_value_2(addr, {{A,B,C,D},Port}) when ?ip(A,B,C,D) ->
+type_value_2(addr, {IP,_} = Addr) when tuple_size(IP) =:= 4 ->
+    type_value_2(addr, {inet,Addr});
+type_value_2(addr, {IP,_} = Addr) when tuple_size(IP) =:= 8 ->
+    type_value_2(addr, {inet6,Addr});
+type_value_2(addr, {Local,_}) when is_list(Local); is_binary(Local) ->
+    type_value_2(addr, {local,Local});
+%%
+type_value_2(addr, {Family,{Tag,Port}})
+  when (Family =:= inet orelse Family =:= inet6) andalso
+       (Tag =:= any orelse Tag =:= loopback) ->
+    type_value_2(uint16, Port);
+type_value_2(addr, {inet,{{A,B,C,D},Port}})
+  when ?ip(A,B,C,D) ->
     type_value_2(uint16, Port);
-type_value_2(addr, {{A,B,C,D,E,F,G,H},Port}) when ?ip6(A,B,C,D,E,F,G,H) ->
+type_value_2(addr, {inet6,{{A,B,C,D,E,F,G,H},Port}})
+  when ?ip6(A,B,C,D,E,F,G,H) ->
     type_value_2(uint16, Port);
+type_value_2(addr, {local,Addr}) ->
+    if
+	is_binary(Addr) ->
+	    byte_size(Addr) =< 255;
+	true ->
+	    try
+		%% We either get a badarg from byte_size
+		%% or from characters_to_binary
+		byte_size(
+		  unicode:characters_to_binary(
+		    Addr, file:native_name_encoding()))
+	    of
+		N when N =< 255 ->
+		    true;
+		_ ->
+		    false
+	    catch error:badarg ->
+		    false
+	    end
+    end;
+%%
 type_value_2(ether,[X1,X2,X3,X4,X5,X6])
   when ?ether(X1,X2,X3,X4,X5,X6)                    -> true;
 type_value_2({enum,List}, Enum) -> 
@@ -1611,6 +1720,7 @@ enc_value_2(time, Val)      -> ?int32(Val);
 enc_value_2(ip,{A,B,C,D})   -> [A,B,C,D];
 enc_value_2(ip, any)        -> [0,0,0,0];
 enc_value_2(ip, loopback)   -> [127,0,0,1];
+%%
 enc_value_2(addr, {any,Port}) ->
     [?INET_AF_ANY|?int16(Port)];
 enc_value_2(addr, {loopback,Port}) ->
@@ -1619,6 +1729,35 @@ enc_value_2(addr, {IP,Port}) when tuple_size(IP) =:= 4 ->
     [?INET_AF_INET,?int16(Port)|ip4_to_bytes(IP)];
 enc_value_2(addr, {IP,Port}) when tuple_size(IP) =:= 8 ->
     [?INET_AF_INET6,?int16(Port)|ip6_to_bytes(IP)];
+enc_value_2(addr, {File,_}) when is_list(File); is_binary(File) ->
+    [?INET_AF_LOCAL,iolist_size(File)|File];
+%%
+enc_value_2(addr, {inet,{any,Port}}) ->
+    [?INET_AF_INET,?int16(Port),0,0,0,0];
+enc_value_2(addr, {inet,{loopback,Port}}) ->
+    [?INET_AF_INET,?int16(Port),127,0,0,1];
+enc_value_2(addr, {inet,{IP,Port}}) ->
+    [?INET_AF_INET,?int16(Port)|ip4_to_bytes(IP)];
+enc_value_2(addr, {inet6,{any,Port}}) ->
+    [?INET_AF_INET6,?int16(Port),0,0,0,0,0,0,0,0];
+enc_value_2(addr, {inet6,{loopback,Port}}) ->
+    [?INET_AF_INET6,?int16(Port),0,0,0,0,0,0,0,1];
+enc_value_2(addr, {inet6,{IP,Port}}) ->
+    [?INET_AF_INET6,?int16(Port)|ip6_to_bytes(IP)];
+enc_value_2(addr, {local,Addr}) ->
+    %% A binary is passed as is, but anything else will be
+    %% regarded as a filename and therefore UTF-8 encoded
+    %% if the system filename encoding flag so dictates.
+    Bin =
+	if
+	    is_binary(Addr) ->
+		Addr;
+	    true ->
+		unicode:characters_to_binary(
+		  Addr, file:native_name_encoding())
+	end,
+    [?INET_AF_LOCAL,byte_size(Bin)|Bin];
+%%
 enc_value_2(ether, [_,_,_,_,_,_]=Xs) -> Xs;
 enc_value_2(sockaddr, any) ->
     [?INET_AF_ANY];
@@ -2249,9 +2388,6 @@ utf8_to_characters(Bs, U, 0) ->
 utf8_to_characters([B|Bs], U, N) when ((B band 16#3F) bor 16#80) =:= B ->
     utf8_to_characters(Bs, (U bsl 6) bor (B band 16#3F), N-1).
 
-ip_to_bytes(IP) when tuple_size(IP) =:= 4 -> ip4_to_bytes(IP);
-ip_to_bytes(IP) when tuple_size(IP) =:= 8 -> ip6_to_bytes(IP).
-
 ip4_to_bytes({A,B,C,D}) ->
     [A band 16#ff, B band 16#ff, C band 16#ff, D band 16#ff].
 
@@ -2261,18 +2397,32 @@ ip6_to_bytes({A,B,C,D,E,F,G,H}) ->
 
 get_addrs([]) ->
     [];
-get_addrs([F,P1,P0|Addr]) ->
-    {IP,Addrs} = get_ip(F, Addr),
-    [{IP,?u16(P1, P0)}|get_addrs(Addrs)].
-
-get_ip(?INET_AF_INET, Addr)  -> get_ip4(Addr);
-get_ip(?INET_AF_INET6, Addr) -> get_ip6(Addr).
+get_addrs([F|Addrs]) ->
+    {Addr,Rest} = get_addr(F, Addrs),
+    [Addr|get_addrs(Rest)].
+
+get_addr(?INET_AF_LOCAL, [0]) ->
+    {{local,<<>>},[]};
+get_addr(?INET_AF_LOCAL, [N|Addr]) ->
+    {A,Rest} = lists:split(N, Addr),
+    {{local,iolist_to_binary(A)},Rest};
+get_addr(?INET_AF_UNDEFINED, Rest) ->
+    {{undefined,0},Rest};
+get_addr(Family, [P1,P0|Addr]) ->
+    {IP,Rest} = get_ip(Family, Addr),
+    {{IP,?u16(P1, P0)},Rest}.
+
+get_ip(?INET_AF_INET, Addr) ->
+    get_ip4(Addr);
+get_ip(?INET_AF_INET6, Addr) ->
+    get_ip6(Addr).
 
 get_ip4([A,B,C,D | T]) -> {{A,B,C,D},T}.
 
 get_ip6([X1,X2,X3,X4,X5,X6,X7,X8,X9,X10,X11,X12,X13,X14,X15,X16 | T]) ->
     { { ?u16(X1,X2),?u16(X3,X4),?u16(X5,X6),?u16(X7,X8),
-	?u16(X9,X10),?u16(X11,X12),?u16(X13,X14),?u16(X15,X16)}, T}.
+	?u16(X9,X10),?u16(X11,X12),?u16(X13,X14),?u16(X15,X16)},
+      T }.
 
 
 %% Control command