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

2 files changed, 245 insertions, 95 deletions

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