Fixed ICE-5215: IPv6 support enabled by default

20 files changed, 277 insertions, 139 deletions

diff --git a/java/src/IceInternal/BasicStream.java b/java/src/IceInternal/BasicStream.java
index f3d4966b6e8..58b7a55e8c2 100644
--- a/java/src/IceInternal/BasicStream.java
+++ b/java/src/IceInternal/BasicStream.java
@@ -4006,7 +4006,6 @@ public class BasicStream
         void startInstance(SliceType sliceType, Ice.SlicedData sliceData)
         {
             _sliceType = sliceType;
-            _firstSlice = true;
         }
 
         void endInstance()
@@ -4052,7 +4051,6 @@ public class BasicStream
             _stream.writeInt(0); // Placeholder for the slice length.
 
             _writeSlice = _stream.pos();
-            _firstSlice = false;
         }
 
         void endSlice()
@@ -4136,7 +4134,6 @@ public class BasicStream
 
         // Instance attributes
         private SliceType _sliceType;
-        private boolean _firstSlice;
 
         // Slice attributes
         private int _writeSlice;        // Position of the slice data members
diff --git a/java/src/IceInternal/EndpointHostResolver.java b/java/src/IceInternal/EndpointHostResolver.java
index 2c5f4e99ecf..cdf59edb4fb 100644
--- a/java/src/IceInternal/EndpointHostResolver.java
+++ b/java/src/IceInternal/EndpointHostResolver.java
@@ -14,6 +14,8 @@ public class EndpointHostResolver
     EndpointHostResolver(Instance instance)
     {
         _instance = instance;
+        _protocol = instance.protocolSupport();
+        _preferIPv6 = instance.preferIPv6();
         try
         {
             _thread = new HelperThread();
@@ -33,7 +35,7 @@ public class EndpointHostResolver
     }
 
     public java.util.List<Connector> 
-    resolve(String host, int port, EndpointI endpoint)
+    resolve(String host, int port, Ice.EndpointSelectionType selType, EndpointI endpoint)
     {
         Ice.Instrumentation.CommunicatorObserver obsv = _instance.initializationData().observer;
         Ice.Instrumentation.Observer observer = null;
@@ -49,7 +51,7 @@ public class EndpointHostResolver
         java.util.List<Connector> connectors = null;
         try 
         {
-            connectors = endpoint.connectors(Network.getAddresses(host, port, _instance.protocolSupport()));
+            connectors = endpoint.connectors(Network.getAddresses(host, port, _protocol, selType, _preferIPv6));
         }
         catch(Ice.LocalException ex)
         {
@@ -70,7 +72,7 @@ public class EndpointHostResolver
     }
     
     synchronized public void
-    resolve(String host, int port, EndpointI endpoint, EndpointI_connectors callback)
+    resolve(String host, int port, Ice.EndpointSelectionType selType, EndpointI endpoint, EndpointI_connectors callback)
     {
         //
         // TODO: Optimize to avoid the lookup if the given host is a textual IPv4 or IPv6
@@ -83,6 +85,7 @@ public class EndpointHostResolver
         ResolveEntry entry = new ResolveEntry();
         entry.host = host;
         entry.port = port;
+        entry.selType = selType;
         entry.endpoint = endpoint;
         entry.callback = callback;
 
@@ -156,7 +159,6 @@ public class EndpointHostResolver
                 threadObserver = _observer;
             }
 
-            int protocol = _instance.protocolSupport();
             try
             {
                 if(threadObserver != null)
@@ -165,7 +167,11 @@ public class EndpointHostResolver
                                                 Ice.Instrumentation.ThreadState.ThreadStateInUseForOther);
                 }
 
-                r.callback.connectors(r.endpoint.connectors(Network.getAddresses(r.host, r.port, protocol)));
+                r.callback.connectors(r.endpoint.connectors(Network.getAddresses(r.host, 
+                                                                                 r.port, 
+                                                                                 _protocol, 
+                                                                                 r.selType,
+                                                                                 _preferIPv6)));
 
                 if(threadObserver != null)
                 {
@@ -224,12 +230,15 @@ public class EndpointHostResolver
     {
         String host;
         int port;
+        Ice.EndpointSelectionType selType;
         EndpointI endpoint;
         EndpointI_connectors callback;
         Ice.Instrumentation.Observer observer;
     }
 
     private final Instance _instance;
+    private final int _protocol;
+    private final boolean _preferIPv6;
     private boolean _destroyed;
     private java.util.LinkedList<ResolveEntry> _queue = new java.util.LinkedList<ResolveEntry>();
     private Ice.Instrumentation.ThreadObserver _observer;
diff --git a/java/src/IceInternal/EndpointI.java b/java/src/IceInternal/EndpointI.java
index f3a6949bc1a..f4d477581b5 100644
--- a/java/src/IceInternal/EndpointI.java
+++ b/java/src/IceInternal/EndpointI.java
@@ -103,8 +103,8 @@ abstract public class EndpointI implements Ice.Endpoint, java.lang.Comparable<En
     // Return connectors for this endpoint, or empty list if no connector
     // is available.
     //
-    public abstract java.util.List<Connector> connectors();
-    public abstract void connectors_async(EndpointI_connectors callback);
+    public abstract java.util.List<Connector> connectors(Ice.EndpointSelectionType selType);
+    public abstract void connectors_async(Ice.EndpointSelectionType selType, EndpointI_connectors callback);
 
     //
     // Return an acceptor for this endpoint, or null if no acceptors
diff --git a/java/src/IceInternal/Instance.java b/java/src/IceInternal/Instance.java
index 7a505c4e721..68c5b7bf0f0 100644
--- a/java/src/IceInternal/Instance.java
+++ b/java/src/IceInternal/Instance.java
@@ -177,17 +177,18 @@ public final class Instance
         return _objectAdapterFactory;
     }
 
-    public synchronized int
+    public int
     protocolSupport()
     {
-        if(_state == StateDestroyed)
-        {
-            throw new Ice.CommunicatorDestroyedException();
-        }
-
         return _protocolSupport;
     }
 
+    public boolean
+    preferIPv6()
+    {
+        return _preferIPv6;
+    }
+
     public synchronized ThreadPool
     clientThreadPool()
     {
@@ -760,7 +761,7 @@ public final class Instance
             _proxyFactory = new ProxyFactory(this);
 
             boolean ipv4 = _initData.properties.getPropertyAsIntWithDefault("Ice.IPv4", 1) > 0;
-            boolean ipv6 = _initData.properties.getPropertyAsIntWithDefault("Ice.IPv6", 0) > 0;
+            boolean ipv6 = _initData.properties.getPropertyAsIntWithDefault("Ice.IPv6", 1) > 0;
             if(!ipv4 && !ipv6)
             {
                 throw new Ice.InitializationException("Both IPV4 and IPv6 support cannot be disabled.");
@@ -777,6 +778,7 @@ public final class Instance
             {
                 _protocolSupport = Network.EnableIPv6;
             }
+            _preferIPv6 = _initData.properties.getPropertyAsInt("Ice.PreferIPv6Address") > 0;
             _endpointFactoryManager = new EndpointFactoryManager(this);
             EndpointFactory tcpEndpointFactory = new TcpEndpointFactory(this);
             _endpointFactoryManager.add(tcpEndpointFactory);
@@ -1204,6 +1206,7 @@ public final class Instance
     private ObjectFactoryManager _servantFactoryManager;
     private ObjectAdapterFactory _objectAdapterFactory;
     private int _protocolSupport;
+    private boolean _preferIPv6;
     private ThreadPool _clientThreadPool;
     private ThreadPool _serverThreadPool;
     private EndpointHostResolver _endpointHostResolver;
diff --git a/java/src/IceInternal/Network.java b/java/src/IceInternal/Network.java
index 058c4fd88ba..06766c4a5ae 100644
--- a/java/src/IceInternal/Network.java
+++ b/java/src/IceInternal/Network.java
@@ -674,15 +674,32 @@ public final class Network
     }
 
     public static java.net.InetSocketAddress
-    getAddress(String host, int port, int protocol)
-    {
-        return getAddressImpl(host, port, protocol, false);
-    }
-
-    public static java.net.InetSocketAddress
-    getAddressForServer(String host, int port, int protocol)
+    getAddressForServer(String host, int port, int protocol, boolean preferIPv6)
     {    
-        return getAddressImpl(host, port, protocol, true);
+        if(host == null || host.length() == 0)
+        {
+            try
+            {
+                if(protocol != EnableIPv4)
+                {
+                    return new java.net.InetSocketAddress(java.net.InetAddress.getByName("::0"), port);
+                }
+                else
+                {
+                    return new java.net.InetSocketAddress(java.net.InetAddress.getByName("0.0.0.0"), port);
+                }
+            }
+            catch(java.net.UnknownHostException ex)
+            {
+                assert(false);
+                return null;
+            }
+            catch(java.lang.SecurityException ex)
+            {
+                throw new Ice.SocketException(ex);
+            } 
+        }
+        return getAddresses(host, port, protocol, Ice.EndpointSelectionType.Ordered, preferIPv6).get(0);
     }
 
     public static int
@@ -773,11 +790,10 @@ public final class Network
         return addr;
     }
 
-    public static java.util.ArrayList<java.net.InetSocketAddress>
-    getAddresses(String host, int port, int protocol)
+    public static java.util.List<java.net.InetSocketAddress>
+    getAddresses(String host, int port, int protocol, Ice.EndpointSelectionType selType, boolean preferIPv6)
     {
-        java.util.ArrayList<java.net.InetSocketAddress> addresses =
-            new java.util.ArrayList<java.net.InetSocketAddress>();
+        java.util.List<java.net.InetSocketAddress> addresses = new java.util.ArrayList<java.net.InetSocketAddress>();
         try
         {
             java.net.InetAddress[] addrs;
@@ -797,6 +813,23 @@ public final class Network
                     addresses.add(new java.net.InetSocketAddress(addr, port));
                 }
             }
+
+            if(selType == Ice.EndpointSelectionType.Random)
+            {
+                java.util.Collections.shuffle(addresses);
+            }
+
+            if(protocol == EnableBoth)
+            {
+                if(preferIPv6)
+                {
+                    java.util.Collections.sort(addresses, _preferIPv6Comparator);
+                }
+                else
+                {
+                    java.util.Collections.sort(addresses, _preferIPv4Comparator);
+                }
+            }
         }
         catch(java.net.UnknownHostException ex)
         {
@@ -810,7 +843,7 @@ public final class Network
         //
         // No Inet4Address/Inet6Address available.
         //
-        if(addresses.size() == 0)
+        if(addresses.isEmpty())
         {
             throw new Ice.DNSException(0, host);
         }
@@ -1134,51 +1167,6 @@ public final class Network
         return s.toString();
     }
 
-    private static java.net.InetSocketAddress
-    getAddressImpl(String host, int port, int protocol, boolean server)
-    {
-        try
-        {
-            java.net.InetAddress[] addrs;
-            if(host == null || host.length() == 0)
-            {
-                if(server)
-                {
-                    addrs = getWildcardAddresses(protocol);
-                }
-                else
-                {
-                    addrs = getLoopbackAddresses(protocol);
-                }
-            }
-            else
-            {
-                addrs = java.net.InetAddress.getAllByName(host);
-            }
-
-            for(java.net.InetAddress addr : addrs)
-            {
-                if(protocol == EnableBoth || isValidAddr(addr, protocol))
-                {
-                    return new java.net.InetSocketAddress(addr, port);
-                }
-            }
-        }
-        catch(java.net.UnknownHostException ex)
-        {
-            throw new Ice.DNSException(0, host, ex);
-        }
-        catch(java.lang.SecurityException ex)
-        {
-            throw new Ice.SocketException(ex);
-        }
-
-        //
-        // No Inet4Address/Inet6Address available.
-        //
-        throw new Ice.DNSException(0, host);
-    }
-
     private static java.net.InetAddress[]
     getLoopbackAddresses(int protocol)
     {
@@ -1207,31 +1195,33 @@ public final class Network
         }
     }
 
-    private static java.net.InetAddress[]
-    getWildcardAddresses(int protocol)
+    static class IPAddressComparator implements java.util.Comparator<java.net.InetSocketAddress>
     {
-        try
+        IPAddressComparator(boolean ipv6)
         {
-            java.net.InetAddress[] addrs = new java.net.InetAddress[protocol == EnableBoth ? 2 : 1];
-            int i = 0;
-            if(protocol != EnableIPv4)
+            _ipv6 = ipv6;
+        }
+        
+        public int
+        compare(java.net.InetSocketAddress lhs, java.net.InetSocketAddress rhs)
+        {
+            if(lhs.getAddress().getAddress().length < rhs.getAddress().getAddress().length)
             {
-                addrs[i++] = java.net.InetAddress.getByName("::0");
+                return _ipv6 ? 1 : -1;
             }
-            if(protocol != EnableIPv6)
+            else if(lhs.getAddress().getAddress().length > rhs.getAddress().getAddress().length)
             {
-                addrs[i++] = java.net.InetAddress.getByName("0.0.0.0");
+                return _ipv6 ? -1 : 1;
+            }
+            else
+            {
+                return 0;
             }
-            return addrs;
-        }
-        catch(java.net.UnknownHostException ex)
-        {
-            assert(false);
-            return null;
-        }
-        catch(java.lang.SecurityException ex)
-        {
-            throw new Ice.SocketException(ex);
         }
+
+        final private boolean _ipv6;
     }
+
+    private static IPAddressComparator _preferIPv4Comparator = new IPAddressComparator(false);
+    private static IPAddressComparator _preferIPv6Comparator = new IPAddressComparator(true);
 }
diff --git a/java/src/IceInternal/OpaqueEndpointI.java b/java/src/IceInternal/OpaqueEndpointI.java
index de10f8d1bc6..2e47b08ed27 100644
--- a/java/src/IceInternal/OpaqueEndpointI.java
+++ b/java/src/IceInternal/OpaqueEndpointI.java
@@ -319,13 +319,13 @@ final class OpaqueEndpointI extends EndpointI
     // is available.
     //
     public java.util.List<Connector>
-    connectors()
+    connectors(Ice.EndpointSelectionType selType)
     {
         return new java.util.ArrayList<Connector>();
     }
 
     public void
-    connectors_async(EndpointI_connectors callback)
+    connectors_async(Ice.EndpointSelectionType selType, EndpointI_connectors callback)
     {
         callback.connectors(new java.util.ArrayList<Connector>());
     }
diff --git a/java/src/IceInternal/OutgoingConnectionFactory.java b/java/src/IceInternal/OutgoingConnectionFactory.java
index 95baab48072..76c496c378f 100644
--- a/java/src/IceInternal/OutgoingConnectionFactory.java
+++ b/java/src/IceInternal/OutgoingConnectionFactory.java
@@ -181,17 +181,8 @@ public final class OutgoingConnectionFactory
             //
             try
             {
-                java.util.List<Connector> cons = endpoint.connectors();
+                java.util.List<Connector> cons = endpoint.connectors(selType);
                 assert(cons.size() > 0);
-
-                //
-                // Shuffle connectors if endpoint selection type is Random.
-                //
-                if(selType == Ice.EndpointSelectionType.Random)
-                {
-                    java.util.Collections.shuffle(cons);
-                }
-
                 for(Connector c : cons)
                 {
                     connectors.add(new ConnectorInfo(c, endpoint));
@@ -312,8 +303,7 @@ public final class OutgoingConnectionFactory
     }
 
     public void
-    create(EndpointI[] endpts, boolean hasMore, Ice.EndpointSelectionType selType,
-           CreateConnectionCallback callback)
+    create(EndpointI[] endpts, boolean hasMore, Ice.EndpointSelectionType selType, CreateConnectionCallback callback)
     {
         assert(endpts.length > 0);
 
@@ -1058,14 +1048,6 @@ public final class OutgoingConnectionFactory
         public void
         connectors(java.util.List<Connector> cons)
         {
-            //
-            // Shuffle connectors if endpoint selection type is Random.
-            //
-            if(_selType == Ice.EndpointSelectionType.Random)
-            {
-                java.util.Collections.shuffle(cons);
-            }
-
             for(Connector p : cons)
             {
                 _connectors.add(new ConnectorInfo(p, _currentEndpoint));
@@ -1181,7 +1163,7 @@ public final class OutgoingConnectionFactory
             {
                 assert(_endpointsIter.hasNext());
                 _currentEndpoint = _endpointsIter.next();
-                _currentEndpoint.connectors_async(this);
+                _currentEndpoint.connectors_async(_selType, this);
             }
             catch(Ice.LocalException ex)
             {
diff --git a/java/src/IceInternal/PropertyNames.java b/java/src/IceInternal/PropertyNames.java
index 77eec82cfe0..88281cb6a99 100644
--- a/java/src/IceInternal/PropertyNames.java
+++ b/java/src/IceInternal/PropertyNames.java
@@ -8,7 +8,7 @@
 // **********************************************************************
 
 //
-// Generated by makeprops.py from file ./config/PropertyNames.xml, Thu Jan 24 22:31:36 2013
+// Generated by makeprops.py from file ../config/PropertyNames.xml, Thu Feb  7 14:51:12 2013
 
 // IMPORTANT: Do not edit this file -- any edits made here will be lost!
 
@@ -105,6 +105,7 @@ public final class PropertyNames
         new Property("Ice\\.Package\\.[^\\s]+", false, null),
         new Property("Ice\\.Plugin\\.[^\\s]+", false, null),
         new Property("Ice\\.PluginLoadOrder", false, null),
+        new Property("Ice\\.PreferIPv6Address", false, null),
         new Property("Ice\\.PrintAdapterReady", false, null),
         new Property("Ice\\.PrintProcessId", false, null),
         new Property("Ice\\.PrintStackTraces", false, null),
diff --git a/java/src/IceInternal/ProtocolPluginFacade.java b/java/src/IceInternal/ProtocolPluginFacade.java
index 717010b0312..a9240f0f93d 100644
--- a/java/src/IceInternal/ProtocolPluginFacade.java
+++ b/java/src/IceInternal/ProtocolPluginFacade.java
@@ -28,6 +28,11 @@ public interface ProtocolPluginFacade
     int getProtocolSupport();
 
     //
+    // Get the protocol support.
+    //
+    boolean getPreferIPv6();
+
+    //
     // Get the default encoding to be used in endpoints.
     //
     Ice.EncodingVersion getDefaultEncoding();
diff --git a/java/src/IceInternal/ProtocolPluginFacadeI.java b/java/src/IceInternal/ProtocolPluginFacadeI.java
index ca10a4f412c..12bb966c869 100644
--- a/java/src/IceInternal/ProtocolPluginFacadeI.java
+++ b/java/src/IceInternal/ProtocolPluginFacadeI.java
@@ -46,6 +46,12 @@ public class ProtocolPluginFacadeI implements ProtocolPluginFacade
         return _instance.protocolSupport();
     }    
 
+    public boolean
+    getPreferIPv6()
+    {
+        return _instance.preferIPv6();
+    }
+
     //
     // Get the default encoding to be used in endpoints.
     //
diff --git a/java/src/IceInternal/TcpAcceptor.java b/java/src/IceInternal/TcpAcceptor.java
index 412211bd080..e7d05e18660 100644
--- a/java/src/IceInternal/TcpAcceptor.java
+++ b/java/src/IceInternal/TcpAcceptor.java
@@ -110,7 +110,7 @@ class TcpAcceptor implements Acceptor
                 //
                 Network.setReuseAddress(_fd, true);
             }
-            _addr = Network.getAddressForServer(host, port, _instance.protocolSupport());
+            _addr = Network.getAddressForServer(host, port, _instance.protocolSupport(), _instance.preferIPv6());
             if(_traceLevels.network >= 2)
             {
                 String s = "attempting to bind to tcp socket " + toString();
diff --git a/java/src/IceInternal/TcpEndpointI.java b/java/src/IceInternal/TcpEndpointI.java
index 64a4a4822f7..74f46099677 100644
--- a/java/src/IceInternal/TcpEndpointI.java
+++ b/java/src/IceInternal/TcpEndpointI.java
@@ -390,15 +390,16 @@ final class TcpEndpointI extends EndpointI
     // is available.
     //
     public java.util.List<Connector>
-    connectors()
+    connectors(Ice.EndpointSelectionType selType)
     {
-        return connectors(Network.getAddresses(_host, _port, _instance.protocolSupport()));
+        return connectors(Network.getAddresses(_host, _port, _instance.protocolSupport(), selType,
+                                               _instance.preferIPv6()));
     }
 
     public void
-    connectors_async(EndpointI_connectors callback)
+    connectors_async(Ice.EndpointSelectionType selType, EndpointI_connectors callback)
     {
-        _instance.endpointHostResolver().resolve(_host, _port, this, callback);
+        _instance.endpointHostResolver().resolve(_host, _port, selType, this, callback);
     }
 
     //
diff --git a/java/src/IceInternal/UdpEndpointI.java b/java/src/IceInternal/UdpEndpointI.java
index 151c6b13599..bff17d92542 100644
--- a/java/src/IceInternal/UdpEndpointI.java
+++ b/java/src/IceInternal/UdpEndpointI.java
@@ -451,15 +451,16 @@ final class UdpEndpointI extends EndpointI
     // is available.
     //
     public java.util.List<Connector>
-    connectors()
+    connectors(Ice.EndpointSelectionType selType)
     {
-        return connectors(Network.getAddresses(_host, _port, _instance.protocolSupport()));
+        return connectors(Network.getAddresses(_host, _port, _instance.protocolSupport(), selType,
+                                               _instance.preferIPv6()));
     }
 
     public void
-    connectors_async(EndpointI_connectors callback)
+    connectors_async(Ice.EndpointSelectionType selType, EndpointI_connectors callback)
     {
-        _instance.endpointHostResolver().resolve(_host, _port, this, callback);
+        _instance.endpointHostResolver().resolve(_host, _port, selType, this, callback);
     }
 
     //
diff --git a/java/src/IceInternal/UdpTransceiver.java b/java/src/IceInternal/UdpTransceiver.java
index 8b49ec6754b..6799e35feca 100644
--- a/java/src/IceInternal/UdpTransceiver.java
+++ b/java/src/IceInternal/UdpTransceiver.java
@@ -350,7 +350,7 @@ final class UdpTransceiver implements Transceiver
 
         try
         {
-             _addr = Network.getAddressForServer(host, port, instance.protocolSupport());
+            _addr = Network.getAddressForServer(host, port, instance.protocolSupport(), instance.preferIPv6());
             _fd = Network.createUdpSocket(_addr);
             setBufSize(instance);
             Network.setBlock(_fd, false);
@@ -375,7 +375,7 @@ final class UdpTransceiver implements Transceiver
                     //
                     int protocol = 
                         _mcastAddr.getAddress().getAddress().length == 4 ? Network.EnableIPv4 : Network.EnableIPv6;
-                    _addr = Network.getAddressForServer("", port, protocol);
+                    _addr = Network.getAddressForServer("", port, protocol, instance.preferIPv6());
                 }
                 _addr = Network.doBind(_fd, _addr);
                 configureMulticast(_mcastAddr, mcastInterface, -1);
@@ -563,7 +563,8 @@ final class UdpTransceiver implements Transceiver
                     intf = java.net.NetworkInterface.getByName(interfaceAddr);
                     if(intf == null)
                     {
-                        java.net.InetSocketAddress addr = Network.getAddress(interfaceAddr, 0, Network.EnableIPv4);
+                        java.net.InetSocketAddress addr = Network.getAddressForServer(interfaceAddr, 0, 
+                                                                                      Network.EnableIPv4, false);
                         intf = java.net.NetworkInterface.getByInetAddress(addr.getAddress());
                     }
                 }
diff --git a/java/src/IceSSL/AcceptorI.java b/java/src/IceSSL/AcceptorI.java
index 25b3412265e..a7ca7a29949 100644
--- a/java/src/IceSSL/AcceptorI.java
+++ b/java/src/IceSSL/AcceptorI.java
@@ -133,7 +133,8 @@ final class AcceptorI implements IceInternal.Acceptor
                 //
                 IceInternal.Network.setReuseAddress(_fd, true);
             }
-            _addr = IceInternal.Network.getAddressForServer(host, port, _instance.protocolSupport());
+            _addr = IceInternal.Network.getAddressForServer(host, port, _instance.protocolSupport(), 
+                                                            _instance.preferIPv6());
             if(_instance.networkTraceLevel() >= 2)
             {
                 String s = "attempting to bind to ssl socket " + toString();
diff --git a/java/src/IceSSL/EndpointI.java b/java/src/IceSSL/EndpointI.java
index 99c94fb7997..9949d3b04c3 100644
--- a/java/src/IceSSL/EndpointI.java
+++ b/java/src/IceSSL/EndpointI.java
@@ -390,15 +390,16 @@ final class EndpointI extends IceInternal.EndpointI
     // is available.
     //
     public java.util.List<IceInternal.Connector>
-    connectors()
+    connectors(Ice.EndpointSelectionType selType)
     {
-        return connectors(IceInternal.Network.getAddresses(_host, _port, _instance.protocolSupport()));
+        return connectors(IceInternal.Network.getAddresses(_host, _port, _instance.protocolSupport(), selType,
+                                                           _instance.preferIPv6()));
     }
 
     public void
-    connectors_async(IceInternal.EndpointI_connectors callback)
+    connectors_async(Ice.EndpointSelectionType selType, IceInternal.EndpointI_connectors callback)
     {
-        _instance.endpointHostResolver().resolve(_host, _port, this, callback);
+        _instance.endpointHostResolver().resolve(_host, _port, selType, this, callback);
     }
 
     //
diff --git a/java/src/IceSSL/Instance.java b/java/src/IceSSL/Instance.java
index 1f6b745daa9..2c1c7d67107 100644
--- a/java/src/IceSSL/Instance.java
+++ b/java/src/IceSSL/Instance.java
@@ -656,6 +656,12 @@ class Instance
         return _facade.getProtocolSupport();
     }
 
+    boolean
+    preferIPv6()
+    {
+        return _facade.getPreferIPv6();
+    }
+
     Ice.EncodingVersion
     defaultEncoding()
     {
diff --git a/java/test/Ice/background/EndpointI.java b/java/test/Ice/background/EndpointI.java
index f0eec528b8e..377a34eb6e1 100644
--- a/java/test/Ice/background/EndpointI.java
+++ b/java/test/Ice/background/EndpointI.java
@@ -193,11 +193,11 @@ final class EndpointI extends IceInternal.EndpointI
     // is available.
     //
     public java.util.List<IceInternal.Connector>
-    connectors()
+    connectors(Ice.EndpointSelectionType selType)
     {
         _configuration.checkConnectorsException();
         java.util.List<IceInternal.Connector> connectors = new java.util.ArrayList<IceInternal.Connector>();
-        for(IceInternal.Connector p : _endpoint.connectors())
+        for(IceInternal.Connector p : _endpoint.connectors(selType))
         {
             connectors.add(new Connector(_configuration, p));
         }
@@ -205,7 +205,7 @@ final class EndpointI extends IceInternal.EndpointI
     }
 
     public void
-    connectors_async(final IceInternal.EndpointI_connectors cb)
+    connectors_async(Ice.EndpointSelectionType selType, final IceInternal.EndpointI_connectors cb)
     {
         class Callback implements IceInternal.EndpointI_connectors
         {
@@ -230,7 +230,7 @@ final class EndpointI extends IceInternal.EndpointI
         try
         {
             _configuration.checkConnectorsException();
-            _endpoint.connectors_async(new Callback());
+            _endpoint.connectors_async(selType, new Callback());
         }
         catch(Ice.LocalException ex)
         {
diff --git a/java/test/Ice/binding/AllTests.java b/java/test/Ice/binding/AllTests.java
index 65c84f0b2cc..df1c729185c 100644
--- a/java/test/Ice/binding/AllTests.java
+++ b/java/test/Ice/binding/AllTests.java
@@ -843,6 +843,125 @@ public class AllTests
             out.println("ok");
         }
 
+        {
+            out.print("testing ipv4 & ipv6 connections... ");
+            out.flush();
+
+            Ice.Properties ipv4 = Ice.Util.createProperties();
+            ipv4.setProperty("Ice.IPv4", "1");
+            ipv4.setProperty("Ice.IPv6", "0");
+            ipv4.setProperty("Adapter.Endpoints", "tcp -h localhost");
+
+            Ice.Properties ipv6 = Ice.Util.createProperties();
+            ipv6.setProperty("Ice.IPv4", "0");
+            ipv6.setProperty("Ice.IPv6", "1");
+            ipv6.setProperty("Adapter.Endpoints", "tcp -h localhost");
+
+            Ice.Properties bothPreferIPv4 = Ice.Util.createProperties();
+            bothPreferIPv4.setProperty("Ice.IPv4", "1");
+            bothPreferIPv4.setProperty("Ice.IPv6", "1");
+            bothPreferIPv4.setProperty("Ice.PreferIPv6Address", "0");
+            bothPreferIPv4.setProperty("Adapter.Endpoints", "tcp -h localhost");
+
+            Ice.Properties bothPreferIPv6 = Ice.Util.createProperties();
+            bothPreferIPv6.setProperty("Ice.IPv4", "1");
+            bothPreferIPv6.setProperty("Ice.IPv6", "1");
+            bothPreferIPv6.setProperty("Ice.PreferIPv6Address", "1");
+            bothPreferIPv6.setProperty("Adapter.Endpoints", "tcp -h localhost");
+
+            java.util.List<Ice.Properties> clientProps = new java.util.ArrayList<Ice.Properties>();
+            clientProps.add(ipv4);
+            clientProps.add(ipv6);
+            clientProps.add(bothPreferIPv4);
+            clientProps.add(bothPreferIPv6);
+
+            Ice.Properties anyipv4 = ipv4._clone();
+            anyipv4.setProperty("Adapter.Endpoints", "tcp -p 12012");
+            anyipv4.setProperty("Adapter.PublishedEndpoints", "tcp -h 127.0.0.1 -p 12012");
+
+            Ice.Properties anyipv6 = ipv6._clone();
+            anyipv6.setProperty("Adapter.Endpoints", "tcp -p 12012");
+            anyipv6.setProperty("Adapter.PublishedEndpoints", "tcp -h \".1\" -p 12012");
+
+            Ice.Properties anyboth = Ice.Util.createProperties();
+            anyboth.setProperty("Ice.IPv4", "1");
+            anyboth.setProperty("Ice.IPv6", "1");
+            anyboth.setProperty("Adapter.Endpoints", "tcp -p 12012");
+            anyboth.setProperty("Adapter.PublishedEndpoints", "tcp -h \"::1\" -p 12012:tcp -h 127.0.0.1 -p 12012");
+
+            Ice.Properties localipv4 = ipv4._clone();
+            localipv4.setProperty("Adapter.Endpoints", "tcp -h 127.0.0.1");
+
+            Ice.Properties localipv6 = ipv6._clone();
+            localipv6.setProperty("Adapter.Endpoints", "tcp -h \"::1\"");
+
+            java.util.List<Ice.Properties> serverProps = new java.util.ArrayList<Ice.Properties>(clientProps);
+            serverProps.add(anyipv4);
+            serverProps.add(anyipv6);
+            serverProps.add(anyboth);
+            serverProps.add(localipv4);
+            serverProps.add(localipv6);
+        
+            for(Ice.Properties p : serverProps)
+            {
+                Ice.InitializationData serverInitData = new Ice.InitializationData();
+                serverInitData.properties = p;
+                Ice.Communicator serverCommunicator = Ice.Util.initialize(serverInitData);
+                Ice.ObjectAdapter oa;
+                try
+                {
+                    oa = serverCommunicator.createObjectAdapter("Adapter");
+                    oa.activate();
+                }
+                catch(Ice.DNSException ex)
+                {
+                    continue; // IP version not supported.
+                }
+                catch(Ice.SocketException ex)
+                {
+                    continue; // IP version not supported.
+                }
+
+                String strPrx = oa.createProxy(serverCommunicator.stringToIdentity("dummy")).toString();
+                for(Ice.Properties q : clientProps)
+                {
+                    Ice.InitializationData clientInitData = new Ice.InitializationData();
+                    clientInitData.properties = q;
+                    Ice.Communicator clientCommunicator = Ice.Util.initialize(clientInitData);
+                    Ice.ObjectPrx prx = clientCommunicator.stringToProxy(strPrx);
+                    try
+                    {
+                        prx.ice_ping();
+                        test(false);
+                    }
+                    catch(Ice.ObjectNotExistException ex)
+                    {
+                        // Expected, no object registered.
+                    }
+                    catch(Ice.DNSException ex)
+                    {
+                        // Expected if no IPv4 or IPv6 address is
+                        // associated to localhost or if trying to connect
+                        // to an any endpoint with the wrong IP version,
+                        // e.g.: resolving an IPv4 address when only IPv6
+                        // is enabled fails with a DNS exception.
+                    }
+                    catch(Ice.SocketException ex)
+                    {
+                        test((p == ipv4 && q == ipv6) || (p == ipv6 && q == ipv4) ||
+                             (p == bothPreferIPv4 && q == ipv6) || (p == bothPreferIPv6 && q == ipv4) ||
+                             (p == anyipv4 && q == ipv6) || (p == anyipv6 && q == ipv4) ||
+                             (p == localipv4 && q == ipv6) || (p == localipv6 && q == ipv4));
+                        continue;
+                    }
+                    clientCommunicator.destroy();
+                }
+                serverCommunicator.destroy();
+            }
+            
+            out.println("ok");
+        }
+
         com.shutdown();
     }
 }
diff --git a/java/test/Ice/metrics/AllTests.java b/java/test/Ice/metrics/AllTests.java
index eec37632bcf..5d9da52e2b6 100644
--- a/java/test/Ice/metrics/AllTests.java
+++ b/java/test/Ice/metrics/AllTests.java
@@ -489,6 +489,21 @@ public class AllTests
         test(cm2.sentBytes - cm1.sentBytes == requestSz + bs.length + 4); // 4 is for the seq variable size
         test(cm2.receivedBytes - cm1.receivedBytes == replySz);
         test(sm2.receivedBytes - sm1.receivedBytes == requestSz + bs.length + 4);
+        if(sm2.sentBytes - sm1.sentBytes != replySz)
+        {
+            // On some platforms, it's necessary to wait a little before obtaining the server metrics
+            // to get an accurate sentBytes metric. The sentBytes metric is updated before the response
+            // to the operation is sent and getMetricsView can be dispatched before the metric is really
+            // updated.
+            try
+            {
+                Thread.sleep(100);
+            }
+            catch(InterruptedException ex)
+            {
+            }
+            sm2 = (IceMX.ConnectionMetrics)serverMetrics.getMetricsView("View", timestamp).get("Connection")[0];
+        }
         test(sm2.sentBytes - sm1.sentBytes == replySz);
 
         cm1 = cm2;