Format IPv4-mapped IPv6 addresses as IPv4, put brackets round IPv6 addresses that are adjacent to colons.

6 files changed, 28 insertions, 10 deletions

diff --git a/src/rabbit_control.erl b/src/rabbit_control.erl
index df55d9612b..e214345c6e 100644
--- a/src/rabbit_control.erl
+++ b/src/rabbit_control.erl
@@ -338,11 +338,11 @@ format_info_item(#resource{name = Name}) ->
     escape(Name);
 format_info_item({N1, N2, N3, N4} = Value) when
       ?IS_U8(N1), ?IS_U8(N2), ?IS_U8(N3), ?IS_U8(N4) ->
-    inet_parse:ntoa(Value);
+    rabbit_misc:ntoa(Value);
 format_info_item({K1, K2, K3, K4, K5, K6, K7, K8} = Value) when
       ?IS_U16(K1), ?IS_U16(K2), ?IS_U16(K3), ?IS_U16(K4),
       ?IS_U16(K5), ?IS_U16(K6), ?IS_U16(K7), ?IS_U16(K8) ->
-    inet_parse:ntoa(Value);
+    rabbit_misc:ntoa(Value);
 format_info_item(Value) when is_pid(Value) ->
     rabbit_misc:pid_to_string(Value);
 format_info_item(Value) when is_binary(Value) ->
diff --git a/src/rabbit_misc.erl b/src/rabbit_misc.erl
index 06ba319b8c..bdc9965d7f 100644
--- a/src/rabbit_misc.erl
+++ b/src/rabbit_misc.erl
@@ -67,6 +67,7 @@
 -export([all_module_attributes/1, build_acyclic_graph/3]).
 -export([now_ms/0]).
 -export([lock_file/1]).
+-export([ntoa/1, ntoab/1]).
 
 %%----------------------------------------------------------------------------
 
@@ -197,6 +198,8 @@
                                       digraph:vertex(), digraph:vertex()})).
 -spec(now_ms/0 :: () -> non_neg_integer()).
 -spec(lock_file/1 :: (file:filename()) -> rabbit_types:ok_or_error('eexist')).
+-spec(ntoa/1 :: (inet:ip_address()) -> string()).
+-spec(ntoab/1 :: (inet:ip_address()) -> string()).
 
 -endif.
 
@@ -817,3 +820,17 @@ lock_file(Path) ->
         false -> {ok, Lock} = file:open(Path, [write]),
                  ok = file:close(Lock)
     end.
+
+%% Format IPv4-mapped IPv6 addresses as IPv4, since they're what we see
+%% when IPv6 is enabled but not used (i.e. 99% of the time).
+ntoa({0,0,0,0,0,16#ffff,AB,CD} = Foo) ->
+    inet_parse:ntoa({AB bsr 8, AB rem 256, CD bsr 8, CD rem 256});
+ntoa(IP) ->
+    inet_parse:ntoa(IP).
+
+ntoab(IP) ->
+    Str = ntoa(IP),
+    case string:str(Str, ":") of
+        0 -> Str;
+        _ -> "[" ++ Str ++ "]"
+    end.
diff --git a/src/rabbit_networking.erl b/src/rabbit_networking.erl
index f394a1ab04..ceb2196d6c 100644
--- a/src/rabbit_networking.erl
+++ b/src/rabbit_networking.erl
@@ -320,7 +320,7 @@ tcp_host({0,0,0,0,0,0,0,0}) ->
 tcp_host(IPAddress) ->
     case inet:gethostbyaddr(IPAddress) of
         {ok, #hostent{h_name = Name}} -> Name;
-        {error, _Reason} -> inet_parse:ntoa(IPAddress)
+        {error, _Reason} -> rabbit_misc:ntoa(IPAddress)
     end.
 
 hostname() ->
diff --git a/src/rabbit_reader.erl b/src/rabbit_reader.erl
index 92a2f4d7fe..0429fda978 100644
--- a/src/rabbit_reader.erl
+++ b/src/rabbit_reader.erl
@@ -269,7 +269,7 @@ start_connection(Parent, ChannelSupSupPid, Collector, StartHeartbeatFun, Deb,
                  Sock, SockTransform) ->
     process_flag(trap_exit, true),
     {PeerAddress, PeerPort} = socket_op(Sock, fun rabbit_net:peername/1),
-    PeerAddressS = inet_parse:ntoa(PeerAddress),
+    PeerAddressS = rabbit_misc:ntoab(PeerAddress),
     rabbit_log:info("starting TCP connection ~p from ~s:~p~n",
                     [self(), PeerAddressS, PeerPort]),
     ClientSock = socket_op(Sock, SockTransform),
diff --git a/src/tcp_acceptor.erl b/src/tcp_acceptor.erl
index c9809ace61..c59a9d5a4f 100644
--- a/src/tcp_acceptor.erl
+++ b/src/tcp_acceptor.erl
@@ -74,8 +74,8 @@ handle_info({inet_async, LSock, Ref, {ok, Sock}},
         {Address, Port}         = inet_op(fun () -> inet:sockname(LSock) end),
         {PeerAddress, PeerPort} = inet_op(fun () -> inet:peername(Sock) end),
         error_logger:info_msg("accepted TCP connection on ~s:~p from ~s:~p~n",
-                              [inet_parse:ntoa(Address), Port,
-                               inet_parse:ntoa(PeerAddress), PeerPort]),
+                              [rabbit_misc:ntoab(Address), Port,
+                               rabbit_misc:ntoab(PeerAddress), PeerPort]),
         %% In the event that somebody floods us with connections we can spew
         %% the above message at error_logger faster than it can keep up.
         %% So error_logger's mailbox grows unbounded until we eat all the
diff --git a/src/tcp_listener.erl b/src/tcp_listener.erl
index 73ef9586bf..e5fa65d68c 100644
--- a/src/tcp_listener.erl
+++ b/src/tcp_listener.erl
@@ -65,8 +65,9 @@ init({IPAddress, Port, SocketOpts,
                           end,
                           lists:duplicate(ConcurrentAcceptorCount, dummy)),
             {ok, {LIPAddress, LPort}} = inet:sockname(LSock),
-            error_logger:info_msg("started ~s on ~s:~p~n",
-                                  [Label, inet_parse:ntoa(LIPAddress), LPort]),
+            error_logger:info_msg(
+              "started ~s on ~s:~p~n",
+              [Label, rabbit_misc:ntoab(LIPAddress), LPort]),
             apply(M, F, A ++ [IPAddress, Port]),
             {ok, #state{sock = LSock,
                         on_startup = OnStartup, on_shutdown = OnShutdown,
@@ -74,7 +75,7 @@ init({IPAddress, Port, SocketOpts,
         {error, Reason} ->
             error_logger:error_msg(
               "failed to start ~s on ~s:~p - ~p~n",
-              [Label, inet_parse:ntoa(IPAddress), Port, Reason]),
+              [Label, rabbit_misc:ntoab(IPAddress), Port, Reason]),
             {stop, {cannot_listen, IPAddress, Port, Reason}}
     end.
 
@@ -91,7 +92,7 @@ terminate(_Reason, #state{sock=LSock, on_shutdown = {M,F,A}, label=Label}) ->
     {ok, {IPAddress, Port}} = inet:sockname(LSock),
     gen_tcp:close(LSock),
     error_logger:info_msg("stopped ~s on ~s:~p~n",
-                          [Label, inet_parse:ntoa(IPAddress), Port]),
+                          [Label, rabbit_misc:ntoab(IPAddress), Port]),
     apply(M, F, A ++ [IPAddress, Port]).
 
 code_change(_OldVsn, State, _Extra) ->