[esock] Handle wildcard address 'broadcast' when binding

Its now possible to bind a socket to the (limited) broadcast
address by specifying 'broadcast' as address:

   socket:bind(Socket, broadcast)

This is *only* valid for family 'inet'.

Add testing of sending (broadcasting) to both "limited" broadcast address
and "subnet-directed" broadcast address.

OTP-15904

5 files changed, 454 insertions, 80 deletions

diff --git a/erts/emulator/nifs/common/socket_util.c b/erts/emulator/nifs/common/socket_util.c
index 2740cb51ef..54c310ecc7 100644
--- a/erts/emulator/nifs/common/socket_util.c
+++ b/erts/emulator/nifs/common/socket_util.c
@@ -741,16 +741,24 @@ char* esock_decode_ip4_address(ErlNifEnv*      env,
            "\r\n", eAddr) );
 
     if (IS_ATOM(env, eAddr)) {
-        /* This is either 'any' or 'loopback' */
+
+        /* This is either 'any' | 'broadcast' | 'loopback' */
 
         if (COMPARE(esock_atom_loopback, eAddr) == 0) {
-            UDBG( ("SUTIL", "esock_decode_ip4_address -> address: lookback\r\n") );
+            UDBG( ("SUTIL",
+		   "esock_decode_ip4_address -> address: lookback\r\n") );
             addr.s_addr = htonl(INADDR_LOOPBACK);
         } else if (COMPARE(esock_atom_any, eAddr) == 0) {
-            UDBG( ("SUTIL", "esock_decode_ip4_address -> address: any\r\n") );
-            addr.s_addr = htonl(INADDR_ANY);
+	  UDBG( ("SUTIL",
+		 "esock_decode_ip4_address -> address: any\r\n") );
+	  addr.s_addr = htonl(INADDR_ANY);
+        } else if (COMPARE(esock_atom_broadcast, eAddr) == 0) {
+	  UDBG( ("SUTIL",
+		 "esock_decode_ip4_address -> address: broadcast\r\n") );
+	  addr.s_addr = htonl(INADDR_BROADCAST);
         } else {
-            UDBG( ("SUTIL", "esock_decode_ip4_address -> address: unknown\r\n") );
+            UDBG( ("SUTIL",
+		   "esock_decode_ip4_address -> address: unknown\r\n") );
             return ESOCK_STR_EINVAL;
         }
 
diff --git a/erts/emulator/test/socket_SUITE.erl b/erts/emulator/test/socket_SUITE.erl
index 6c2900a31b..cbf612948b 100644
--- a/erts/emulator/test/socket_SUITE.erl
+++ b/erts/emulator/test/socket_SUITE.erl
@@ -124,6 +124,7 @@
          api_opt_sock_acceptconn/1,
          api_opt_sock_acceptfilter/1,
          api_opt_sock_bindtodevice/1,
+         api_opt_sock_broadcast/1,
          api_opt_ip_add_drop_membership/1,
 
          %% *** API Operation Timeout ***
@@ -785,7 +786,8 @@ api_options_socket_cases() ->
     [
      api_opt_sock_acceptconn,
      api_opt_sock_acceptfilter,
-     api_opt_sock_bindtodevice
+     api_opt_sock_bindtodevice,
+     api_opt_sock_broadcast
     ].
 
 api_options_ip_cases() ->
@@ -8847,7 +8849,7 @@ api_opt_sock_bindtodevice() ->
          #{desc => "which local address",
            cmd  => fun(#{domain := Domain} = State) ->
                            case ?LIB:which_local_host_info(Domain) of
-                               {ok, {Name, _, Addr}} ->
+                               {ok, #{name := Name, addr := Addr}} ->
                                    ?SEV_IPRINT("local host info (~p): "
                                                "~n   Name: ~p"
                                                "~n   Addr: ~p",
@@ -8903,8 +8905,13 @@ api_opt_sock_bindtodevice() ->
                                {ok, Dev} ->
                                    ?SEV_IPRINT("Expected Success: ~p", [Dev]),
                                    ok;
+                               {error, enoprotoopt = Reason} ->
+                                   ?SEV_EPRINT("Unexpected Failure: ~p => SKIP",
+					       [Reason]),
+                                   {skip, Reason};
                                {error, Reason} = ERROR ->
-                                   ?SEV_EPRINT("Unexpected Failure: ~p", [Reason]),
+                                   ?SEV_EPRINT("Unexpected Failure: ~p",
+					       [Reason]),
                                    ERROR
                            end
                    end},
@@ -9078,6 +9085,326 @@ api_opt_sock_bindtodevice() ->
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
+%% Tests the socket option broadcast.
+%% Make it possible for datagram sockets to send packets to a broadcast
+%% address (IPv4 only).
+
+api_opt_sock_broadcast(suite) ->
+    [];
+api_opt_sock_broadcast(doc) ->
+    [];
+api_opt_sock_broadcast(_Config) when is_list(_Config) ->
+    ?TT(?SECS(30)),
+    tc_try(api_opt_sock_broadcast,
+           fun() -> has_support_sock_broadcast() end,
+           fun() -> api_opt_sock_broadcast() end).
+
+
+api_opt_sock_broadcast() ->
+    Opt    = broadcast,
+    Set    = fun(S, Val) when is_boolean(Val) ->
+                     socket:setopt(S, socket, Opt, Val)
+             end,
+    Get    = fun(S) ->
+                     socket:getopt(S, socket, Opt)
+             end,
+
+    TesterSeq =
+        [
+         #{desc => "which local address",
+           cmd  => fun(#{domain := Domain} = State) ->
+                           case ?LIB:which_local_host_info(Domain) of
+                               {ok, #{name      := Name,
+                                      addr      := Addr,
+                                      broadaddr := BAddr}} ->
+                                   ?SEV_IPRINT("local host info: "
+                                               "~n   Name:           ~p"
+                                               "~n   Addr:           ~p"
+                                               "~n   Broadcast Addr: ~p",
+                                               [Name, Addr, BAddr]),
+                                   LSA = #{family => Domain,
+                                           addr   => Addr},
+                                   BSA = #{family => Domain,
+                                           addr   => BAddr},
+                                   {ok, State#{lsa => LSA,
+                                               bsa => BSA}};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+
+         #{desc => "[socket 1] create UDP socket (listening 1)",
+           cmd  => fun(#{domain := Domain} = State) ->
+                           case socket:open(Domain, dgram, udp) of
+                               {ok, Sock} ->
+                                   {ok, State#{sock1 => Sock}};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "[socket 1] Bind UDP socket (to limited broadcast address)",
+           cmd  => fun(#{sock1 := Sock} = State) ->
+			   BSA = #{family => inet,
+				   addr   => broadcast},
+                           ?SEV_IPRINT("Try bind (socket 1) to: "
+                                       "~n   ~p", [BSA]),
+                           case socket:bind(Sock, BSA) of
+                               {ok, Port} ->
+                                   ?SEV_IPRINT("Expected Success (bound): ~p",
+                                               [Port]),
+                                   {ok, State#{sa1 => BSA#{port => Port}}};
+                               {error, Reason} = ERROR ->
+                                   ?SEV_EPRINT("Unexpected Failure: ~p",
+					       [Reason]),
+                                   ERROR
+                           end
+                   end},
+         #{desc => "[socket 1] UDP socket sockname",
+           cmd  => fun(#{sock1 := Sock} = _State) ->
+                           case socket:sockname(Sock) of
+                               {ok, SA} ->
+				   ?SEV_IPRINT("SA: ~p", [SA]),
+                                   ok;
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+
+         ?SEV_SLEEP(?SECS(1)),
+
+         #{desc => "[socket 2] create UDP socket (listening 2)",
+           cmd  => fun(#{domain := Domain} = State) ->
+                           case socket:open(Domain, dgram, udp) of
+                               {ok, Sock} ->
+                                   {ok, State#{sock2 => Sock}};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "[socket 2] Bind UDP socket (to subnet-directed broadcast address)",
+           cmd  => fun(#{sock2 := Sock,
+			 bsa   := BSA} = State) ->
+                           ?SEV_IPRINT("Try bind (socket 1) to: "
+                                       "~n   ~p", [BSA]),
+                           case socket:bind(Sock, BSA) of
+                               {ok, Port} ->
+                                   ?SEV_IPRINT("Expected Success (bound): ~p",
+                                               [Port]),
+                                   {ok, State#{sa2 => BSA#{port => Port}}};
+                               {error, Reason} = ERROR ->
+                                   ?SEV_EPRINT("Unexpected Failure: ~p",
+					       [Reason]),
+                                   ERROR
+                           end
+                   end},
+         #{desc => "[socket 2] UDP socket sockname",
+           cmd  => fun(#{sock2 := Sock} = _State) ->
+                           case socket:sockname(Sock) of
+                               {ok, SA} ->
+				   ?SEV_IPRINT("SA: ~p", [SA]),
+                                   ok;
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+
+         ?SEV_SLEEP(?SECS(1)),
+
+         #{desc => "[socket 3] create UDP socket (sender)",
+           cmd  => fun(#{domain := Domain} = State) ->
+                           case socket:open(Domain, dgram, udp) of
+                               {ok, Sock} ->
+                                   {ok, State#{sock3 => Sock}};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "[socket 3][get] verify UDP socket (before bind and set)",
+           cmd  => fun(#{sock3 := Sock} = _State) ->
+                           case Get(Sock) of
+                               {ok, false} ->
+                                   ?SEV_IPRINT("Expected Success: "
+                                               "broadcast not allowed"),
+                                   ok;
+                               {ok, true} ->
+                                   ?SEV_IPRINT("Unexpected Success result: "
+                                               "broadcast already allowed"),
+                                   ok;
+                               {error, Reason} = ERROR ->
+                                   ?SEV_EPRINT("Unexpected Failure: ~p",
+					       [Reason]),
+                                   ERROR
+                           end
+                   end},
+         #{desc => "[socket 3] Try make broadcast allowed",
+           cmd  => fun(#{sock3 := Sock} = _State) ->
+                           case Set(Sock, true) of
+                               ok ->
+                                   ?SEV_IPRINT("Expected Success: "
+                                               "broadcast now allowed"),
+                                   ok;
+                               {error, Reason} = ERROR ->
+                                   ?SEV_EPRINT("Unexpected Failure: ~p",
+					       [Reason]),
+                                   ERROR
+                           end
+                   end},
+         #{desc => "[socket 3] verify UDP socket broadcast allowed",
+           cmd  => fun(#{sock3 := Sock} = _State) ->
+                           case Get(Sock) of
+                               {ok, true} ->
+                                   ?SEV_IPRINT("Expected Success: "
+                                               "broadcast allowed"),
+                                   ok;
+                               {ok, false} ->
+                                   ?SEV_IPRINT("Unexpected Success result: "
+                                               "broadcast *not* allowed"),
+                                   ok;
+                               {error, Reason} = ERROR ->
+                                   ?SEV_EPRINT("Unexpected Failure: ~p",
+					       [Reason]),
+                                   ERROR
+                           end
+                   end},
+         #{desc => "[socket 3] Bind UDP socket (to local address)",
+           cmd  => fun(#{sock3 := Sock, lsa := LSA} = State) ->
+                           ?SEV_IPRINT("Try bind (socket 2) to: "
+                                       "~n   ~p", [LSA]),
+                           case socket:bind(Sock, LSA) of
+                               {ok, Port} ->
+                                   ?SEV_IPRINT("Expected Success (bound): ~p",
+                                               [Port]),
+                                   {ok, State#{sa3 => LSA#{port => Port}}};
+                               {error, Reason} = ERROR ->
+                                   ?SEV_EPRINT("Unexpected Failure: ~p",
+					       [Reason]),
+                                   ERROR
+                           end
+                   end},
+         #{desc => "[socket 3] verify UDP socket (after bind and before set)",
+           cmd  => fun(#{sock3 := Sock} = _State) ->
+                           case Get(Sock) of
+                               {ok, false} ->
+                                   ?SEV_IPRINT("Expected Success: "
+                                               "broadcast not allowed"),
+                                   ok;
+                               {ok, true} ->
+                                   ?SEV_IPRINT("Unexpected Success result: "
+                                               "broadcast already allowed"),
+                                   ok;
+                               {error, Reason} = ERROR ->
+                                   ?SEV_EPRINT("Unexpected Failure: ~p",
+					       [Reason]),
+                                   ERROR
+                           end
+                   end},
+
+	 ?SEV_SLEEP(?SECS(1)),
+
+         #{desc => "[socket 3] try send to limited broadcast address",
+           cmd  => fun(#{sock3 := Sock,
+                         sa1   := Dest} = _State) ->
+                           Data = list_to_binary("hejsan"),
+                           ?SEV_IPRINT("try send to bradcast address: "
+                                       "~n   ~p", [Dest]),
+                           case socket:sendto(Sock, Data, Dest) of
+                               ok ->
+                                   ?SEV_IPRINT("Expected Success: "
+                                               "broadcast message sent"),
+                                   ok;
+                               {error, Reason} = ERROR ->
+                                   ?SEV_EPRINT("Unexpected Failure: ~p",
+					       [Reason]),
+                                   ERROR
+                           end
+                   end},
+         #{desc => "[socket 1] try recv",
+           cmd  => fun(#{sock1 := Sock} = _State) ->
+                           case socket:recvfrom(Sock, 0, 5000) of
+                               {ok, _} ->
+                                   ?SEV_IPRINT("Expected Success: "
+                                               "received message"),
+                                   ok;
+                               {error, Reason} = ERROR ->
+                                   ?SEV_EPRINT("Unexpected Failure: ~p",
+					       [Reason]),
+                                   ERROR
+                           end
+                   end},
+
+	 ?SEV_SLEEP(?SECS(1)),
+
+         #{desc => "[socket 3] try send to subnet-directed broadcast address",
+           cmd  => fun(#{sock3 := Sock,
+                         sa2   := Dest} = _State) ->
+                           Data = list_to_binary("hejsan"),
+                           ?SEV_IPRINT("try send to bradcast address: "
+                                       "~n   ~p", [Dest]),
+                           case socket:sendto(Sock, Data, Dest) of
+                               ok ->
+                                   ?SEV_IPRINT("Expected Success: "
+                                               "broadcast message sent"),
+                                   ok;
+                               {error, Reason} = ERROR ->
+                                   ?SEV_EPRINT("Unexpected Failure: ~p",
+					       [Reason]),
+                                   ERROR
+                           end
+                   end},
+         #{desc => "[socket 2] try recv",
+           cmd  => fun(#{sock2 := Sock} = _State) ->
+                           case socket:recvfrom(Sock, 0, 5000) of
+                               {ok, _} ->
+                                   ?SEV_IPRINT("Expected Success: "
+                                               "received message"),
+                                   ok;
+                               {error, Reason} = ERROR ->
+                                   ?SEV_EPRINT("Unexpected Failure: ~p",
+					       [Reason]),
+                                   ERROR
+                           end
+                   end},
+
+         %% *** Termination ***
+         #{desc => "[socket 3] close UDP socket (sender)",
+           cmd  => fun(#{sock3 := Sock} = State0) ->
+                           socket:close(Sock),
+			   State1 = maps:remove(sock3, State0),
+			   State2 = maps:remove(sa3,   State1),
+			   {ok, State2}
+                   end},
+         #{desc => "[socket 2] close UDP socket (listener 2)",
+           cmd  => fun(#{sock2 := Sock} = State0) ->
+                           socket:close(Sock),
+			   State1 = maps:remove(sock2, State0),
+			   State2 = maps:remove(sa2,   State1),
+                           {ok, State2}
+                   end},
+         #{desc => "[socket 1] close UDP socket (listener 1)",
+           cmd  => fun(#{sock1 := Sock} = State0) ->
+                           socket:close(Sock),
+			   State1 = maps:remove(sock1, State0),
+			   State2 = maps:remove(sa1,   State1),
+                           {ok, State2}
+                   end},
+
+         %% *** We are done ***
+         ?SEV_FINISH_NORMAL
+        ],
+
+    Domain = inet,
+
+    i("start tester evaluator"),
+    InitState = #{domain => Domain},
+    Tester = ?SEV_START("tester", TesterSeq, InitState),
+
+    i("await evaluator(s)"),
+    ok = ?SEV_AWAIT_FINISH([Tester]).
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
 %% Tests that the add_mambership and drop_membership ip options work.
 %% We create one server and two clients. The server only send messages,
 %% the clients only receives messages.
@@ -9400,7 +9727,7 @@ which_multicast_address3(Domain, [MAddrStr|MAddrs]) ->
     
 which_local_host_ifname(Domain) ->
     case ?LIB:which_local_host_info(Domain) of
-        {ok, {Name, _Addr, _Flags}} ->
+        {ok, #{name := Name}} ->
             Name;
         {error, Reason} ->
             not_supported({multicast, Reason})
@@ -27760,7 +28087,7 @@ which_local_socket_addr(local = Domain) ->
 %% but until that gets the necessary functionality...
 which_local_socket_addr(Domain) ->
     case ?LIB:which_local_host_info(Domain) of
-        {ok, {_Name, _Flags, Addr}} ->
+        {ok, #{addr := Addr}} ->
             #{family => Domain,
               addr   => Addr};
         {error, Reason} ->
@@ -27776,12 +28103,7 @@ which_local_addr(local = _Domain) ->
 %% We should really implement this using the (new) net module,
 %% but until that gets the necessary functionality...
 which_local_addr(Domain) ->
-    case ?LIB:which_local_host_info(Domain) of
-        {ok, {_Name, _Flags, Addr}} ->
-            Addr;
-        {error, Reason} ->
-            ?FAIL(Reason)
-    end.
+    ?LIB:which_local_addr(Domain).
 
 
 
@@ -27799,7 +28121,7 @@ has_support_ip_multicast() ->
         {unix, OsName} when (OsName =:= linux) orelse
                             (OsName =:= sunos) ->
             case ?LIB:which_local_host_info(inet) of
-                {ok, {_Name, Flags, _Addr}} ->
+                {ok, #{flags := Flags}} ->
                     case lists:member(multicast, Flags) of
                         true ->
                             ok;
@@ -27819,6 +28141,21 @@ has_support_sock_acceptconn() ->
 has_support_sock_bindtodevice() ->
     has_support_socket_option_sock(bindtodevice).
 
+has_support_sock_broadcast() ->
+    has_support_socket_option_sock(broadcast),
+    case ?LIB:which_local_host_info(inet) of
+        {ok, #{flags := Flags}} ->
+            case lists:member(broadcast, Flags) of
+                true ->
+                    ok;
+                false ->
+                    not_supported({broadcast, Flags})
+            end;
+        {error, Reason} ->
+            not_supported({broadcast, Reason})
+    end.
+
+
 has_support_ip_add_membership() ->
     has_support_socket_option_ip(add_membership).
 
diff --git a/erts/emulator/test/socket_test_lib.erl b/erts/emulator/test/socket_test_lib.erl
index 2ded82ae13..39cbf0c79f 100644
--- a/erts/emulator/test/socket_test_lib.erl
+++ b/erts/emulator/test/socket_test_lib.erl
@@ -36,6 +36,7 @@
          has_support_ipv6/0,
 
          which_local_host_info/1,
+         which_local_addr/1,
 
          %% Skipping
          not_yet_implemented/0,
@@ -174,46 +175,12 @@ has_support_ipv6() ->
 %% but until that gets the necessary functionality...
 which_local_addr(Domain) ->
     case which_local_host_info(Domain) of
-        {ok, {_Name, _Flags, Addr}} ->
+        {ok, #{addr := Addr}} ->
             {ok, Addr};
         {error, _Reason} = ERROR ->
             ERROR
     end.
     
-%%     case inet:getifaddrs() of
-%%         {ok, IFL} ->
-%%             which_addr(Domain, IFL);
-%%         {error, Reason} ->
-%%             ?FAIL({inet, getifaddrs, Reason})
-%%     end.
-
-%% which_addr(_Domain, []) ->
-%%     ?FAIL(no_address);
-%% which_addr(Domain, [{"lo" ++ _, _}|IFL]) ->
-%%     which_addr(Domain, IFL);
-%% which_addr(Domain, [{_Name, IFO}|IFL]) ->
-%%     case which_addr2(Domain, IFO) of
-%%         {ok, Addr} ->
-%%             Addr;
-%%         {error, no_address} ->
-%%             which_addr(Domain, IFL)
-%%     end;
-%% which_addr(Domain, [_|IFL]) ->
-%%     which_addr(Domain, IFL).
-
-%% which_addr2(_Domain, []) ->
-%%     {error, no_address};
-%% which_addr2(inet = _Domain, [{addr, Addr}|_IFO])
-%%   when (size(Addr) =:= 4) andalso (element(1, Addr) =/= 127) ->
-%%     {ok, Addr};
-%% which_addr2(inet6 = _Domain, [{addr, Addr}|_IFO])
-%%   when (size(Addr) =:= 8) andalso 
-%%        (element(1, Addr) =/= 0) andalso
-%%        (element(1, Addr) =/= 16#fe80) ->
-%%     {ok, Addr};
-%% which_addr2(Domain, [_|IFO]) ->
-%%     which_addr2(Domain, IFO).
-
 
 %% Returns the interface (name), flags and address (not 127...)
 %% of the local host.
@@ -234,35 +201,89 @@ which_local_host_info(Domain, [{"docker" ++ _, _}|IFL]) ->
 which_local_host_info(Domain, [{"br-" ++ _, _}|IFL]) ->
     which_local_host_info(Domain, IFL);
 which_local_host_info(Domain, [{Name, IFO}|IFL]) ->
-    case which_local_host_info2(Domain, IFO) of
-        {ok, {Flags, Addr}} ->
-            {ok, {Name, Flags, Addr}};
-        {error, _} ->
+    try which_local_host_info2(Domain, IFO) of
+        Info ->
+            {ok, Info#{name => Name}}
+    catch
+        throw:_:_ ->
             which_local_host_info(Domain, IFL)
     end;
 which_local_host_info(Domain, [_|IFL]) ->
     which_local_host_info(Domain, IFL).
 
-which_local_host_info2(Domain, IFO) ->
-    case lists:keysearch(flags, 1, IFO) of
-        {value, {flags, Flags}} ->
-            which_local_host_info2(Domain, IFO, Flags);
+%% which_local_host_info2(Domain, IFO) ->
+%%     case lists:keysearch(flags, 1, IFO) of
+%%         {value, {flags, Flags}} ->
+%%             which_local_host_info2(Domain, IFO, Flags);
+%%         false ->
+%%             {error, no_flags}
+%%     end.
+
+
+%% which_local_host_info2(_Domain, [], _Flags) ->
+%%     {error, no_address};
+%% which_local_host_info2(inet = _Domain, [{addr, Addr}|_IFO], Flags)
+%%   when (size(Addr) =:= 4) andalso (element(1, Addr) =/= 127) ->
+%%     {ok, {Flags, Addr}};
+%% which_local_host_info2(inet6 = _Domain, [{addr, Addr}|_IFO], Flags)
+%%   when (size(Addr) =:= 8) andalso 
+%%        (element(1, Addr) =/= 0) andalso
+%%        (element(1, Addr) =/= 16#fe80) ->
+%%     {ok, {Flags, Addr}};
+%% which_local_host_info2(Domain, [_|IFO], Flags) ->
+%%     which_local_host_info2(Domain, IFO, Flags).
+
+%% foo(Info, inet = Domain, IFO) ->
+%%     foo(Info, Domain, IFO, [flags, addr, netmask, broadaddr, hwaddr]);
+%% foo(Info, inet6 = Domain, IFO) ->
+%%     foo(Info, Domain, IFO, [flags, addr, netmask, hwaddr]).
+
+which_local_host_info2(inet = _Domain, IFO) ->
+    Addr      = which_local_host_info3(addr,  IFO,
+                                       fun({A, _, _, _}) when (A =/= 127) -> true;
+                                          (_) -> false
+                                       end),
+    NetMask   = which_local_host_info3(netmask,  IFO,
+                                       fun({_, _, _, _}) -> true;
+                                          (_) -> false
+                                       end),
+    BroadAddr = which_local_host_info3(broadaddr,  IFO,
+                                       fun({_, _, _, _}) -> true;
+                                          (_) -> false
+                                       end),
+    Flags     = which_local_host_info3(flags, IFO, fun(_) -> true end),
+    #{flags     => Flags,
+      addr      => Addr,
+      broadaddr => BroadAddr,
+      netmask   => NetMask};
+which_local_host_info2(inet6 = _Domain, IFO) ->
+    Addr    = which_local_host_info3(addr,  IFO,
+                                     fun({A, _, _, _, _, _, _, _}) 
+                                           when (A =/= 0) andalso 
+                                                (A =/= 16#fe80) -> true;
+                                        (_) -> false
+                                     end),
+    NetMask = which_local_host_info3(netmask,  IFO,
+                                       fun({_, _, _, _, _, _, _, _}) -> true;
+                                          (_) -> false
+                                       end),
+    Flags   = which_local_host_info3(flags, IFO, fun(_) -> true end),
+    #{flags   => Flags,
+      addr    => Addr,
+      netmask => NetMask}.
+
+which_local_host_info3(_Key, [], _) ->
+    throw({error, no_address});
+which_local_host_info3(Key, [{Key, Val}|IFO], Check) ->
+    case Check(Val) of
+        true ->
+            Val;
         false ->
-            {error, no_flags}
-    end.
+            which_local_host_info3(Key, IFO, Check)
+    end;
+which_local_host_info3(Key, [_|IFO], Check) ->
+    which_local_host_info3(Key, IFO, Check).
 
-which_local_host_info2(_Domain, [], _Flags) ->
-    {error, no_address};
-which_local_host_info2(inet = _Domain, [{addr, Addr}|_IFO], Flags)
-  when (size(Addr) =:= 4) andalso (element(1, Addr) =/= 127) ->
-    {ok, {Flags, Addr}};
-which_local_host_info2(inet6 = _Domain, [{addr, Addr}|_IFO], Flags)
-  when (size(Addr) =:= 8) andalso 
-       (element(1, Addr) =/= 0) andalso
-       (element(1, Addr) =/= 16#fe80) ->
-    {ok, {Flags, Addr}};
-which_local_host_info2(Domain, [_|IFO], Flags) ->
-    which_local_host_info2(Domain, IFO, Flags).
 
 
 
diff --git a/erts/preloaded/ebin/socket.beam b/erts/preloaded/ebin/socket.beam
index 7f7ba46e04..408c51b57a 100644
--- a/erts/preloaded/ebin/socket.beam
+++ b/erts/preloaded/ebin/socket.beam
diff --git a/erts/preloaded/src/socket.erl b/erts/preloaded/src/socket.erl
index 016b479c4d..b9b67f25b4 100644
--- a/erts/preloaded/src/socket.erl
+++ b/erts/preloaded/src/socket.erl
@@ -313,7 +313,8 @@
                           path   := binary() | string()}.
 -type sockaddr_in4() :: #{family := inet,
                           port   := port_number(),
-                          addr   := any | loopback | ip4_address()}.
+			  %% The 'broadcast' here is the "limited broadcast"
+                          addr   := any | broadcast | loopback | ip4_address()}.
 -type sockaddr_in6() :: #{family   := inet6,
                           port     := port_number(),
                           addr     := any | loopback | ip6_address(),
@@ -334,7 +335,7 @@
 -define(SOCKADDR_IN6_DEFAULTS,    ?SOCKADDR_IN6_DEFAULTS(any)).
 -define(SOCKADDR_IN6_DEFAULT(A),  (?SOCKADDR_IN6_DEFAULTS(A))#{family => inet6}).
 
-%% otp    - The option is internal to our (OTP) imeplementation.
+%% otp    - This option is internal to our (OTP) implementation.
 %% socket - The socket layer (SOL_SOCKET).
 %% ip     - The IP layer (SOL_IP or is it IPPROTO_IP?).
 %% ipv6   - The IPv6 layer (SOL_IPV6).
@@ -342,6 +343,7 @@
 %% udp    - The UDP (User Datagram Protocol) layer (IPPROTO_UDP).
 %% sctp   - The SCTP (Stream Control Transmission Protocol) layer (IPPROTO_SCTP).
 %% Int    - Raw level, sent down and used "as is".
+%%          Its up to the caller to make sure this is correct!
 -type sockopt_level() :: otp |
                          socket |
                          ip | ipv6 | tcp | udp | sctp |
@@ -1146,19 +1148,25 @@ open(Domain, Type, Protocol, Extra) when is_map(Extra) ->
 %%
 %% bind - bind a name to a socket
 %%
+%% Note that Addr can only have the value of broadcast *if* Domain =:= inet!
+%%
 
 -spec bind(Socket, Addr) -> ok | {error, Reason} when
       Socket :: socket(),
-      Addr   :: any | loopback | sockaddr(),
+      Addr   :: any | broadcast | loopback | sockaddr(),
       Reason :: term().
 
 bind(#socket{ref = SockRef}, Addr)
-  when ((Addr =:= any) orelse (Addr =:= loopback)) ->
+  when ((Addr =:= any) orelse
+	(Addr =:= broadcast) orelse
+	(Addr =:= loopback)) ->
     try which_domain(SockRef) of
         inet ->
             nif_bind(SockRef, ?SOCKADDR_IN4_DEFAULT(Addr));
-        inet6 ->
-            nif_bind(SockRef, ?SOCKADDR_IN6_DEFAULT(Addr))
+        inet6 when (Addr =:= any) orelse (Addr =:= loopback) ->
+            nif_bind(SockRef, ?SOCKADDR_IN6_DEFAULT(Addr));
+	_ ->
+	    einval()
     catch
         %% <WIN32-TEMPORARY>
         error:notsup:S ->