Merge tag 'OTP-19.0' into sverker/19/binary_to_atom-utf8-crash/ERL-474/OTP-14590

1 files changed, 387 insertions, 170 deletions

diff --git a/erts/preloaded/src/prim_inet.erl b/erts/preloaded/src/prim_inet.erl
index fb1269cf91..560810d222 100644
--- a/erts/preloaded/src/prim_inet.erl
+++ b/erts/preloaded/src/prim_inet.erl
@@ -1,18 +1,19 @@
 %%
 %% %CopyrightBegin%
 %% 
-%% Copyright Ericsson AB 2000-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2000-2016. All Rights Reserved.
 %% 
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
-%% 
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
+%%
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %% 
 %% %CopyrightEnd%
 %%
@@ -25,7 +26,7 @@
 
 %% Primitive inet_drv interface
 
--export([open/3, fdopen/4, close/1]).
+-export([open/3, open/4, fdopen/4, fdopen/5, close/1]).
 -export([bind/3, listen/1, listen/2, peeloff/2]).
 -export([connect/3, connect/4, async_connect/4]).
 -export([accept/1, accept/2, async_accept/2]).
@@ -41,8 +42,8 @@
 	 getifaddrs/1, getiflist/1, ifget/3, ifset/3,
 	 gethostname/1]).
 -export([getservbyname/3, getservbyport/3]).
--export([peername/1, setpeername/2]).
--export([sockname/1, setsockname/2]).
+-export([peername/1, setpeername/2, peernames/1, peernames/2]).
+-export([sockname/1, setsockname/2, socknames/1, socknames/2]).
 -export([attach/1, detach/1]).
 
 -include("inet_sctp.hrl").
@@ -64,22 +65,38 @@
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 open(Protocol, Family, Type) ->
-    open(Protocol, Family, Type, ?INET_REQ_OPEN, []).
+    open(Protocol, Family, Type, [], ?INET_REQ_OPEN, []).
+
+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) ->
-    open(Protocol, Family, Type, ?INET_REQ_FDOPEN, ?int32(Fd)).
+    fdopen(Protocol, Family, Type, Fd, true).
+
+fdopen(Protocol, Family, Type, Fd, Bound)
+  when is_integer(Fd), is_boolean(Bound) ->
+    open(Protocol, Family, Type, [], ?INET_REQ_FDOPEN,
+         [?int32(Fd), enc_value_2(bool, Bound)]).
 
-open(Protocol, Family, Type, Req, Data) ->
+open(Protocol, Family, Type, Opts, Req, Data) ->
     Drv = protocol2drv(Protocol),
     AF = enc_family(Family),
     T = enc_type(Type),
     try erlang:open_port({spawn_driver,Drv}, [binary]) of
 	S ->
-	    case ctl_cmd(S, Req, [AF,T,Data]) of
-		{ok,_} -> {ok,S};
-		{error,_}=Error ->
+	    case setopts(S, Opts) of
+		ok ->
+		    case ctl_cmd(S, Req, [AF,T,Data]) of
+			{ok,_} -> {ok,S};
+			{error,_}=E1 ->
+			    close(S),
+			    E1
+		    end;
+		{error,_}=E2 ->
 		    close(S),
-		    Error
+		    E2
 	    end
     catch
 	%% The only (?) way to get here is to try to open
@@ -89,8 +106,9 @@ open(Protocol, Family, Type, 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;
@@ -113,37 +131,18 @@ drv2protocol(_)           -> undefined.
 %% TODO: shutdown equivalent for SCTP
 %%
 shutdown(S, read) when is_port(S) ->
-    shutdown_2(S, 0);
+    shutdown_1(S, 0);
 shutdown(S, write) when is_port(S) ->
     shutdown_1(S, 1);
 shutdown(S, read_write) when is_port(S) ->
     shutdown_1(S, 2).
 
 shutdown_1(S, How) ->
-    case subscribe(S, [subs_empty_out_q]) of
-	{ok,[{subs_empty_out_q,N}]} when N > 0 ->
-	    shutdown_pend_loop(S, N);   %% wait for pending output to be sent
-	_Other -> ok
-    end,
-    shutdown_2(S, How).
-
-shutdown_2(S, How) ->
     case ctl_cmd(S, ?TCP_REQ_SHUTDOWN, [How]) of
 	{ok, []} -> ok;
 	{error,_}=Error -> Error
     end.
 
-shutdown_pend_loop(S, N0) ->
-    receive
-	{empty_out_q,S} -> ok
-    after ?INET_CLOSE_TIMEOUT ->
-	    case getstat(S, [send_pend]) of
-                {ok,[{send_pend,N0}]} -> ok;
-                {ok,[{send_pend,N}]} -> shutdown_pend_loop(S, N);
-		_ -> ok
-	    end
-    end.
-
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%
 %% CLOSE(insock()) -> ok
@@ -151,11 +150,16 @@ shutdown_pend_loop(S, N0) ->
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 close(S) when is_port(S) ->
-    case subscribe(S, [subs_empty_out_q]) of
-	{ok, [{subs_empty_out_q,N}]} when N > 0 ->
-	    close_pend_loop(S, N);   %% wait for pending output to be sent
+    case getopt(S, linger) of
+    	{ok,{true,0}} -> 
+	    close_port(S);
 	_ ->
-	    close_port(S)
+	    case subscribe(S, [subs_empty_out_q]) of
+		{ok, [{subs_empty_out_q,N}]} when N > 0 ->
+		    close_pend_loop(S, N);   %% wait for pending output to be sent
+		_ ->
+		    close_port(S)
+	    end
     end.
 
 close_pend_loop(S, N) ->
@@ -177,32 +181,8 @@ close_pend_loop(S, N) ->
     end.
 
 close_port(S) ->
-    case erlang:process_info(self(), trap_exit) of
-	{trap_exit,true} ->
-	    %% Ensure exit message and consume it
-	    link(S),
-	    %% This is still not a perfect solution.
-	    %%
-	    %% The problem is to close the port and consume any exit
-	    %% message while not knowing if this process traps exit
-	    %% nor if this process has a link to the port. Here we
-	    %% just knows that this process traps exit.
-	    %%
-	    %% If we right here get killed for some reason that exit
-	    %% signal will propagate to the port and onwards to anyone
-	    %% that is linked to the port. E.g when we close a socket
-	    %% that is not ours.
-	    %%
-	    %% The problem can be solved with lists:member on our link
-	    %% list but we deem that as potentially too expensive. We
-	    %% need an is_linked/1 function or guard, or we need
-	    %% a port_close function that can atomically unlink...
-	    catch erlang:port_close(S),
-	    receive {'EXIT',S,_} -> ok end;
-	{trap_exit,false} ->
-	    catch erlang:port_close(S),
-	    ok
-    end.
+    catch erlang:port_close(S),
+    receive {'EXIT',S,_} -> ok after 0 -> ok end.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%
@@ -212,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}
@@ -255,7 +246,7 @@ bindx(S, AddFlag, Addrs) ->
 %% if timeout is given:
 %%       timeout < 0  -> infinity
 %%                 0  -> immediate connect (mostly works for loopback)
-%%               > 0  -> wait for timout ms if not connected then 
+%%               > 0  -> wait for timeout ms if not connected then 
 %%                       return {error, timeout} 
 %%
 %% ASYNC_CONNECT(insock(), IP, Port, Timeout) -> {ok, S, Ref} | {error, Reason}
@@ -265,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} ->
@@ -281,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.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -296,7 +313,7 @@ async_connect(S, IP, Port, Time) ->
 %% if timeout is given:
 %%       timeout < 0  -> infinity
 %%                 0  -> immediate accept (poll)
-%%               > 0  -> wait for timout ms for accept if no accept then 
+%%               > 0  -> wait for timeout ms for accept if no accept then 
 %%                       return {error, timeout}
 %%
 %% ASYNC_ACCEPT(insock(), Timeout)
@@ -423,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).
+
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%
@@ -507,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, _}} ->
@@ -548,21 +587,56 @@ 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.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%
+%% PEERNAMES(insock()) -> {ok, [{IP, Port}, ...]} | {error, Reason}
+%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+peernames(S) when is_port(S) ->
+    peernames(S, undefined).
+
+peernames(S, #sctp_assoc_change{assoc_id=AssocId}) when is_port(S) ->
+    peernames(S, AssocId);
+peernames(S, AssocId)
+  when is_port(S), is_integer(AssocId);
+       is_port(S), AssocId =:= undefined ->
+    Q = get,
+    Type = [[sctp_assoc_id,0]],
+    case type_value(Q, Type, AssocId) of
+	true ->
+	    case ctl_cmd
+		(S, ?INET_REQ_GETPADDRS,
+		 enc_value(Q, Type, AssocId)) of
+		{ok,Addrs} ->
+		    {ok,get_addrs(Addrs)};
+		Error ->
+		    Error
+	    end;
+	false ->
+	    {error,einval}
     end.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -573,21 +647,58 @@ setpeername(S, undefined) when is_port(S) ->
 
 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.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%
+%% SOCKNAMES(insock()) -> {ok, [{IP, Port}, ...]} | {error, Reason}
+%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+socknames(S) when is_port(S) ->
+    socknames(S, undefined).
+
+socknames(S, #sctp_assoc_change{assoc_id=AssocId}) when is_port(S) ->
+    socknames(S, AssocId);
+socknames(S, AssocId)
+  when is_port(S), is_integer(AssocId);
+       is_port(S), AssocId =:= undefined ->
+    Q = get,
+    Type = [[sctp_assoc_id,0]],
+    case type_value(Q, Type, AssocId) of
+	true ->
+	    case ctl_cmd
+		(S, ?INET_REQ_GETLADDRS,
+		 enc_value(Q, Type, AssocId)) of
+		{ok,Addrs} ->
+		    {ok,get_addrs(Addrs)};
+		Error ->
+		    Error
+	    end;
+	false ->
+	    {error,einval}
     end.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -1108,6 +1219,9 @@ enc_opt(send_timeout_close) -> ?INET_LOPT_TCP_SEND_TIMEOUT_CLOSE;
 enc_opt(delay_send)      -> ?INET_LOPT_TCP_DELAY_SEND;
 enc_opt(packet_size)     -> ?INET_LOPT_PACKET_SIZE;
 enc_opt(read_packets)    -> ?INET_LOPT_READ_PACKETS;
+enc_opt(netns)           -> ?INET_LOPT_NETNS;
+enc_opt(show_econnreset) -> ?INET_LOPT_TCP_SHOW_ECONNRESET;
+enc_opt(line_delimiter)  -> ?INET_LOPT_LINE_DELIM;
 enc_opt(raw)             -> ?INET_OPT_RAW;
 % Names of SCTP opts:
 enc_opt(sctp_rtoinfo)	 	   -> ?SCTP_OPT_RTOINFO;
@@ -1164,6 +1278,9 @@ dec_opt(?INET_LOPT_TCP_SEND_TIMEOUT_CLOSE) -> send_timeout_close;
 dec_opt(?INET_LOPT_TCP_DELAY_SEND)   -> delay_send;
 dec_opt(?INET_LOPT_PACKET_SIZE)      -> packet_size;
 dec_opt(?INET_LOPT_READ_PACKETS)     -> read_packets;
+dec_opt(?INET_LOPT_NETNS)           -> netns;
+dec_opt(?INET_LOPT_TCP_SHOW_ECONNRESET) -> show_econnreset;
+dec_opt(?INET_LOPT_LINE_DELIM)      -> line_delimiter;
 dec_opt(?INET_OPT_RAW)              -> raw;
 dec_opt(I) when is_integer(I)     -> undefined.
 
@@ -1226,7 +1343,8 @@ type_opt_1(buffer)          -> int;
 type_opt_1(active) ->
     {enum,[{false, ?INET_PASSIVE}, 
 	   {true, ?INET_ACTIVE}, 
-	   {once, ?INET_ONCE}]};
+	   {once, ?INET_ONCE},
+           {multi, ?INET_MULTI}]};
 type_opt_1(packet) -> 
     {enum,[{0, ?TCP_PB_RAW},
 	   {1, ?TCP_PB_1},
@@ -1245,6 +1363,7 @@ type_opt_1(packet) ->
 	   {httph_bin,?TCP_PB_HTTPH_BIN},
 	   {ssl, ?TCP_PB_SSL_TLS}, % obsolete
 	   {ssl_tls, ?TCP_PB_SSL_TLS}]};
+type_opt_1(line_delimiter)  -> int;
 type_opt_1(mode) ->
     {enum,[{list, ?INET_MODE_LIST},
 	   {binary, ?INET_MODE_BINARY}]};
@@ -1261,6 +1380,8 @@ type_opt_1(send_timeout_close) -> bool;
 type_opt_1(delay_send)      -> bool;
 type_opt_1(packet_size)     -> uint;
 type_opt_1(read_packets)    -> uint;
+type_opt_1(netns)           -> binary;
+type_opt_1(show_econnreset) -> bool;
 %% 
 %% SCTP options (to be set). If the type is a record type, the corresponding
 %% record signature is returned, otherwise, an "elementary" type tag 
@@ -1449,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, {{A,B,C,D,E,F,G,H},Port}) when ?ip6(A,B,C,D,E,F,G,H) ->
+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, {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) -> 
@@ -1487,9 +1643,12 @@ type_value_2({bitenumlist,List,_}, EnumList) ->
 	Ls when is_list(Ls)                         -> true;
 	false                                       -> false
     end;
-type_value_2(binary,Bin) when is_binary(Bin) -> true;
-type_value_2(binary_or_uint,Bin) when is_binary(Bin) -> true;
-type_value_2(binary_or_uint,Int) when is_integer(Int), Int >= 0 -> true;
+type_value_2(binary,Bin)
+  when is_binary(Bin), byte_size(Bin) < (1 bsl 32)  -> true;
+type_value_2(binary_or_uint,Bin)
+  when is_binary(Bin), byte_size(Bin) < (1 bsl 32)  -> true;
+type_value_2(binary_or_uint,Int)
+  when is_integer(Int), Int >= 0                    -> true;
 %% Type-checking of SCTP options
 type_value_2(sctp_assoc_id, X)
   when X band 16#ffffffff =:= X                     -> true;
@@ -1561,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}) ->
@@ -1569,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 encoded according to
+    %% the current system filename encoding mode.
+    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];
@@ -1701,11 +1890,14 @@ encode_opt_val(Opts) ->
 	Reason -> {error,Reason}
     end.
 
+%% {active, once} and {active, N} are specially optimized because they will
+%% be used for every packet or every N packets, not only once when
+%% initializing the socket.  Measurements show that this optimization is
+%% worthwhile.
 enc_opt_val([{active,once}|Opts], Acc) ->
-    %% Specially optimized because {active,once} will be used for
-    %% every packet, not only once when initializing the socket.
-    %% Measurements show that this optimization is worthwhile.
     enc_opt_val(Opts, [<<?INET_LOPT_ACTIVE:8,?INET_ONCE:32>>|Acc]);
+enc_opt_val([{active,N}|Opts], Acc) when is_integer(N), N < 32768, N >= -32768 ->
+    enc_opt_val(Opts, [<<?INET_LOPT_ACTIVE:8,?INET_MULTI:32,N:16>>|Acc]);
 enc_opt_val([{raw,P,O,B}|Opts], Acc) ->
     enc_opt_val(Opts, Acc, raw, {P,O,B});
 enc_opt_val([{Opt,Val}|Opts], Acc) ->
@@ -1795,6 +1987,14 @@ dec_opt_val([]) -> [].
 dec_opt_val(Buf, raw, Type) ->
     {{P,O,B},T} = dec_value(Type, Buf),
     [{raw,P,O,B}|dec_opt_val(T)];
+dec_opt_val(Buf, active, Type) ->
+    case dec_value(Type, Buf) of
+        {multi,[M0,M1|T]} ->
+            <<N:16>> = list_to_binary([M0,M1]),
+            [{active,N}|dec_opt_val(T)];
+        {Val,T} ->
+            [{active,Val}|dec_opt_val(T)]
+    end;
 dec_opt_val(Buf, Opt, Type) ->
     {Val,T} = dec_value(Type, Buf),
     [{Opt,Val}|dec_opt_val(T)].
@@ -2188,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].
 
@@ -2198,14 +2395,34 @@ ip6_to_bytes({A,B,C,D,E,F,G,H}) ->
     [?int16(A), ?int16(B), ?int16(C), ?int16(D),
      ?int16(E), ?int16(F), ?int16(G), ?int16(H)].
 
-get_ip(?INET_AF_INET, Addr)  -> get_ip4(Addr);
-get_ip(?INET_AF_INET6, Addr) -> get_ip6(Addr).
+get_addrs([]) ->
+    [];
+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