Fixed ICE-7755 - listen on all IPs associated with a DNS name

8 files changed, 178 insertions, 23 deletions

diff --git a/java/src/Ice/src/main/java/com/zeroc/Ice/ObjectAdapterI.java b/java/src/Ice/src/main/java/com/zeroc/Ice/ObjectAdapterI.java
index 6a8103283b5..3b9dfd5343f 100644
--- a/java/src/Ice/src/main/java/com/zeroc/Ice/ObjectAdapterI.java
+++ b/java/src/Ice/src/main/java/com/zeroc/Ice/ObjectAdapterI.java
@@ -14,6 +14,7 @@ import java.util.List;
 import java.util.ArrayList;
 
 import com.zeroc.IceInternal.IncomingConnectionFactory;
+import com.zeroc.IceInternal.EndpointI;
 
 public final class ObjectAdapterI implements ObjectAdapter
 {
@@ -754,7 +755,7 @@ public final class ObjectAdapterI implements ObjectAdapter
                     }
                     for(IncomingConnectionFactory p : _incomingConnectionFactories)
                     {
-                        if(endpoint.equivalent(p.endpoint()))
+                        if(p.isLocal(endpoint))
                         {
                             return true;
                         }
@@ -1075,14 +1076,21 @@ public final class ObjectAdapterI implements ObjectAdapter
                 // Parse the endpoints, but don't store them in the adapter. The connection
                 // factory might change it, for example, to fill in the real port number.
                 //
-                List<com.zeroc.IceInternal.EndpointI> endpoints =
-                    parseEndpoints(properties.getProperty(_name + ".Endpoints"), true);
-                for(com.zeroc.IceInternal.EndpointI endp : endpoints)
+                List<EndpointI> endpoints = parseEndpoints(properties.getProperty(_name + ".Endpoints"), true);
+                for(EndpointI endp : endpoints)
                 {
-                    IncomingConnectionFactory factory = new IncomingConnectionFactory(instance, endp, this);
-                    _incomingConnectionFactories.add(factory);
+                    EndpointI.ExpandHostResult result = endp.expandHost();
+                    for(EndpointI expanded : result.endpoints)
+                    {
+
+                        IncomingConnectionFactory factory = new IncomingConnectionFactory(instance,
+                                                                                          expanded,
+                                                                                          result.publish,
+                                                                                          this);
+                        _incomingConnectionFactories.add(factory);
+                    }
                 }
-                if(endpoints.size() == 0)
+                if(endpoints.isEmpty())
                 {
                     com.zeroc.IceInternal.TraceLevels tl = _instance.traceLevels();
                     if(tl.network >= 2)
@@ -1338,7 +1346,18 @@ public final class ObjectAdapterI implements ObjectAdapter
             //
             for(IncomingConnectionFactory factory : _incomingConnectionFactories)
             {
-                endpoints.addAll(factory.endpoint().expand());
+                for(EndpointI endpt : factory.endpoint().expandIfWildcard())
+                {
+                    //
+                    // Check for duplicate endpoints, this might occur if an endpoint with a DNS name
+                    // expands to multiple addresses. In this case, multiple incoming connection
+                    // factories can point to the same published endpoint.
+                    //
+                    if(!endpoints.contains(endpt))
+                    {
+                        endpoints.add(endpt);
+                    }
+                }
             }
         }
 
diff --git a/java/src/Ice/src/main/java/com/zeroc/IceInternal/EndpointI.java b/java/src/Ice/src/main/java/com/zeroc/IceInternal/EndpointI.java
index f0c0c353f26..824a1849e70 100644
--- a/java/src/Ice/src/main/java/com/zeroc/IceInternal/EndpointI.java
+++ b/java/src/Ice/src/main/java/com/zeroc/IceInternal/EndpointI.java
@@ -11,6 +11,12 @@ package com.zeroc.IceInternal;
 
 abstract public class EndpointI implements com.zeroc.Ice.Endpoint, java.lang.Comparable<EndpointI>
 {
+    public class ExpandHostResult
+    {
+        public EndpointI publish;
+        public java.util.List<EndpointI> endpoints;
+    };
+
     public void streamWrite(com.zeroc.Ice.OutputStream s)
     {
         s.startEncapsulation();
@@ -120,7 +126,18 @@ abstract public class EndpointI implements com.zeroc.Ice.Endpoint, java.lang.Com
     // Expand endpoint out in to separate endpoints for each local
     // host if listening on INADDR_ANY.
     //
-    public abstract java.util.List<EndpointI> expand();
+    public abstract java.util.List<EndpointI> expandIfWildcard();
+
+    //
+    // Expand endpoint out into separate endpoints for each IP
+    // address returned by the DNS resolver. Also returns the
+    // endpoint which can be used to connect to the returned
+    // endpoints or null if no specific endpoint can be used to
+    // connect to these endpoints (e.g.: with the IP endpoint,
+    // it returns this endpoint if it uses a fixed port, null
+    // otherwise).
+    //
+    public abstract ExpandHostResult expandHost();
 
     //
     // Check whether the endpoint is equivalent to another one.
diff --git a/java/src/Ice/src/main/java/com/zeroc/IceInternal/IPEndpointI.java b/java/src/Ice/src/main/java/com/zeroc/IceInternal/IPEndpointI.java
index c9d01736d7f..53d1d4fad64 100644
--- a/java/src/Ice/src/main/java/com/zeroc/IceInternal/IPEndpointI.java
+++ b/java/src/Ice/src/main/java/com/zeroc/IceInternal/IPEndpointI.java
@@ -9,6 +9,8 @@
 
 package com.zeroc.IceInternal;
 
+import com.zeroc.Ice.EndpointSelectionType;
+
 public abstract class IPEndpointI extends EndpointI
 {
     protected IPEndpointI(ProtocolInstance instance, String host, int port, java.net.InetSocketAddress sourceAddr,
@@ -113,7 +115,7 @@ public abstract class IPEndpointI extends EndpointI
     }
 
     @Override
-    public java.util.List<EndpointI> expand()
+    public java.util.List<EndpointI> expandIfWildcard()
     {
         java.util.List<EndpointI> endps = new java.util.ArrayList<>();
         java.util.List<String> hosts = Network.getHostsForEndpointExpand(_host, _instance.protocolSupport(), false);
@@ -132,6 +134,51 @@ public abstract class IPEndpointI extends EndpointI
     }
 
     @Override
+    public EndpointI.ExpandHostResult expandHost()
+    {
+        EndpointI.ExpandHostResult result = new EndpointI.ExpandHostResult();
+
+        //
+        // If this endpoint has an empty host (wildcard address), don't expand, just return
+        // this endpoint.
+        //
+        if(_host.isEmpty())
+        {
+            result.endpoints = new java.util.ArrayList<>();
+            result.endpoints.add(this);
+            return result;
+        }
+
+        //
+        // If using a fixed port, this endpoint can be used as the published endpoint to
+        // access the returned endpoints. Otherwise, we'll publish each individual expanded
+        // endpoint.
+        //
+        result.publish = _port > 0 ? this : null;
+
+        java.util.List<java.net.InetSocketAddress> addresses = Network.getAddresses(_host,
+                                                                                    _port,
+                                                                                    _instance.protocolSupport(),
+                                                                                    EndpointSelectionType.Ordered,
+                                                                                    _instance.preferIPv6(),
+                                                                                    true);
+
+        result.endpoints = new java.util.ArrayList<>();
+        if(addresses.size() == 1)
+        {
+            result.endpoints.add(this);
+        }
+        else
+        {
+            for(java.net.InetSocketAddress addr : addresses)
+            {
+                result.endpoints.add(createEndpoint(addr.getAddress().getHostAddress(), addr.getPort(), _connectionId));
+            }
+        }
+        return result;
+    }
+
+    @Override
     public boolean equivalent(EndpointI endpoint)
     {
         if(!(endpoint instanceof IPEndpointI))
diff --git a/java/src/Ice/src/main/java/com/zeroc/IceInternal/IncomingConnectionFactory.java b/java/src/Ice/src/main/java/com/zeroc/IceInternal/IncomingConnectionFactory.java
index cd534fa7523..806d4ed9887 100644
--- a/java/src/Ice/src/main/java/com/zeroc/IceInternal/IncomingConnectionFactory.java
+++ b/java/src/Ice/src/main/java/com/zeroc/IceInternal/IncomingConnectionFactory.java
@@ -165,11 +165,30 @@ public final class IncomingConnectionFactory extends EventHandler implements Con
         }
     }
 
+    public boolean
+    isLocal(EndpointI endpoint)
+    {
+        if(_publishedEndpoint != null && endpoint.equivalent(_publishedEndpoint))
+        {
+            return true;
+        }
+        synchronized(this)
+        {
+            return endpoint.equivalent(_endpoint);
+        }
+    }
+
     public EndpointI
     endpoint()
     {
-        // No mutex protection necessary, _endpoint is immutable.
-        return _endpoint;
+        if(_publishedEndpoint != null)
+        {
+            return _publishedEndpoint;
+        }
+        synchronized(this)
+        {
+            return _endpoint;
+        }
     }
 
     public synchronized java.util.LinkedList<ConnectionI>
@@ -416,10 +435,12 @@ public final class IncomingConnectionFactory extends EventHandler implements Con
     }
 
     public
-    IncomingConnectionFactory(Instance instance, EndpointI endpoint, com.zeroc.Ice.ObjectAdapterI adapter)
+    IncomingConnectionFactory(Instance instance, EndpointI endpoint, EndpointI publish,
+                              com.zeroc.Ice.ObjectAdapterI adapter)
     {
         _instance = instance;
         _endpoint = endpoint;
+        _publishedEndpoint = publish;
         _adapter = adapter;
         _warn = _instance.initializationData().properties.getPropertyAsInt("Ice.Warn.Connections") > 0 ? true : false;
         _state = StateHolding;
@@ -708,6 +729,7 @@ public final class IncomingConnectionFactory extends EventHandler implements Con
     private Acceptor _acceptor;
     private Transceiver _transceiver;
     private EndpointI _endpoint;
+    private final EndpointI _publishedEndpoint;
 
     private com.zeroc.Ice.ObjectAdapterI _adapter;
 
diff --git a/java/src/Ice/src/main/java/com/zeroc/IceInternal/OpaqueEndpointI.java b/java/src/Ice/src/main/java/com/zeroc/IceInternal/OpaqueEndpointI.java
index e4dd3fec957..2c842ddd77c 100644
--- a/java/src/Ice/src/main/java/com/zeroc/IceInternal/OpaqueEndpointI.java
+++ b/java/src/Ice/src/main/java/com/zeroc/IceInternal/OpaqueEndpointI.java
@@ -218,13 +218,22 @@ final class OpaqueEndpointI extends EndpointI
     // was specified on client side.
     //
     @Override
-    public java.util.List<EndpointI> expand()
+    public java.util.List<EndpointI> expandIfWildcard()
     {
         java.util.List<EndpointI> endps = new java.util.ArrayList<>();
         endps.add(this);
         return endps;
     }
 
+    @Override
+    public EndpointI.ExpandHostResult expandHost()
+    {
+        EndpointI.ExpandHostResult result = new EndpointI.ExpandHostResult();
+        result.endpoints = new java.util.ArrayList<>();
+        result.endpoints.add(this);
+        return result;
+    }
+
     //
     // Check whether the endpoint is equivalent to another one.
     //
diff --git a/java/src/Ice/src/main/java/com/zeroc/IceInternal/WSEndpoint.java b/java/src/Ice/src/main/java/com/zeroc/IceInternal/WSEndpoint.java
index 3334bf385c4..80ffeab3803 100644
--- a/java/src/Ice/src/main/java/com/zeroc/IceInternal/WSEndpoint.java
+++ b/java/src/Ice/src/main/java/com/zeroc/IceInternal/WSEndpoint.java
@@ -209,9 +209,9 @@ final class WSEndpoint extends EndpointI
     }
 
     @Override
-    public java.util.List<EndpointI> expand()
+    public java.util.List<EndpointI> expandIfWildcard()
     {
-        java.util.List<EndpointI> endps = _delegate.expand();
+        java.util.List<EndpointI> endps = _delegate.expandIfWildcard();
         java.util.List<EndpointI> l = new java.util.ArrayList<>();
         for(EndpointI e : endps)
         {
@@ -221,6 +221,23 @@ final class WSEndpoint extends EndpointI
     }
 
     @Override
+    public EndpointI.ExpandHostResult expandHost()
+    {
+        EndpointI.ExpandHostResult result = _delegate.expandHost();
+        java.util.List<EndpointI> l = new java.util.ArrayList<>();
+        for(EndpointI e : result.endpoints)
+        {
+            l.add(e == _delegate ? this : new WSEndpoint(_instance, e, _resource));
+        }
+        result.endpoints = l;
+        if(result.publish != null)
+        {
+            result.publish = result.publish == _delegate ? this : new WSEndpoint(_instance, result.publish, _resource);
+        }
+        return result;
+    }
+
+    @Override
     public boolean equivalent(EndpointI endpoint)
     {
         if(!(endpoint instanceof WSEndpoint))
diff --git a/java/src/IceBT/src/main/java/com/zeroc/IceBT/EndpointI.java b/java/src/IceBT/src/main/java/com/zeroc/IceBT/EndpointI.java
index b57cc25368b..c6589932874 100644
--- a/java/src/IceBT/src/main/java/com/zeroc/IceBT/EndpointI.java
+++ b/java/src/IceBT/src/main/java/com/zeroc/IceBT/EndpointI.java
@@ -195,15 +195,23 @@ final class EndpointI extends com.zeroc.IceInternal.EndpointI
     }
 
     @Override
-    public java.util.List<com.zeroc.IceInternal.EndpointI> expand()
+    public java.util.List<com.zeroc.IceInternal.EndpointI> expandIfWildcard()
     {
-        java.util.List<com.zeroc.IceInternal.EndpointI> endps =
-            new java.util.ArrayList<com.zeroc.IceInternal.EndpointI>();
+        java.util.List<com.zeroc.IceInternal.EndpointI> endps = new java.util.ArrayList<>();
         endps.add(this);
         return endps;
     }
 
     @Override
+    public com.zeroc.IceInternal.EndpointI.ExpandHostResult expandHost()
+    {
+        com.zeroc.IceInternal.EndpointI.ExpandHostResult result = new com.zeroc.IceInternal.EndpointI.ExpandHostResult();
+        result.endpoints = new java.util.ArrayList<>();
+        result.endpoints.add(this);
+        return result;
+    }
+
+    @Override
     public boolean equivalent(com.zeroc.IceInternal.EndpointI endpoint)
     {
         if(!(endpoint instanceof EndpointI))
diff --git a/java/src/IceSSL/src/main/java/com/zeroc/IceSSL/EndpointI.java b/java/src/IceSSL/src/main/java/com/zeroc/IceSSL/EndpointI.java
index 6e88f00868b..bcad6368785 100644
--- a/java/src/IceSSL/src/main/java/com/zeroc/IceSSL/EndpointI.java
+++ b/java/src/IceSSL/src/main/java/com/zeroc/IceSSL/EndpointI.java
@@ -197,11 +197,10 @@ final class EndpointI extends com.zeroc.IceInternal.EndpointI
     }
 
     @Override
-    public java.util.List<com.zeroc.IceInternal.EndpointI> expand()
+    public java.util.List<com.zeroc.IceInternal.EndpointI> expandIfWildcard()
     {
-        java.util.List<com.zeroc.IceInternal.EndpointI> endps = _delegate.expand();
-        java.util.List<com.zeroc.IceInternal.EndpointI> l = new java.util.ArrayList<com.zeroc.IceInternal.EndpointI>();
-        for(com.zeroc.IceInternal.EndpointI e : endps)
+        java.util.List<com.zeroc.IceInternal.EndpointI> l = new java.util.ArrayList<>();
+        for(com.zeroc.IceInternal.EndpointI e : _delegate.expandIfWildcard())
         {
             l.add(e == _delegate ? this : new EndpointI(_instance, e));
         }
@@ -209,6 +208,23 @@ final class EndpointI extends com.zeroc.IceInternal.EndpointI
     }
 
     @Override
+    public com.zeroc.IceInternal.EndpointI.ExpandHostResult expandHost()
+    {
+        com.zeroc.IceInternal.EndpointI.ExpandHostResult result = _delegate.expandHost();
+        java.util.List<com.zeroc.IceInternal.EndpointI> l = new java.util.ArrayList<>();
+        for(com.zeroc.IceInternal.EndpointI e : result.endpoints)
+        {
+            l.add(e == _delegate ? this : new EndpointI(_instance, e));
+        }
+        result.endpoints = l;
+        if(result.publish != null)
+        {
+            result.publish = result.publish == _delegate ? this : new EndpointI(_instance, result.publish);
+        }
+        return result;
+    }
+
+    @Override
     public boolean equivalent(com.zeroc.IceInternal.EndpointI endpoint)
     {
         if(!(endpoint instanceof EndpointI))