Plumb a code path for the entity transfer module to ask a destination scene

whether or not an agent is allowed there as a root agent.

OpenSim/Region/CoreModules/ServiceConnectorsOut/Simulation/LocalSimulationConnector.cs

@@ -257,6 +257,23 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Simulation
             return false;
         }
 
+        public bool QueryAccess(GridRegion destination, UUID id)
+        {
+            if (destination == null)
+                return false;
+
+            foreach (Scene s in m_sceneList)
+            {
+                if (s.RegionInfo.RegionHandle == destination.RegionHandle)
+                {
+                    //m_log.Debug("[LOCAL COMMS]: Found region to send QueryAccess");
+                    return s.QueryAccess(id);
+                }
+            }
+            //m_log.Debug("[LOCAL COMMS]: region not found for QueryAccess");
+            return false;
+        }
+
         public bool ReleaseAgent(UUID origin, UUID id, string uri)
         {
             foreach (Scene s in m_sceneList)

OpenSim/Region/CoreModules/ServiceConnectorsOut/Simulation/RemoteSimulationConnector.cs

@@ -239,6 +239,23 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Simulation
 
         }
 
+        public bool QueryAccess(GridRegion destination, UUID id)
+        {
+            if (destination == null)
+                return false;
+
+            // Try local first
+            if (m_localBackend.QueryAccess(destination, id))
+                return true;
+
+            // else do the remote thing
+            if (!m_localBackend.IsLocalRegion(destination.RegionHandle))
+                return m_remoteConnector.QueryAccess(destination, id);
+
+            return false;
+
+        }
+
         public bool ReleaseAgent(UUID origin, UUID id, string uri)
         {
             // Try local first

OpenSim/Region/Framework/Scenes/Scene.cs

@@ -5160,5 +5160,16 @@ namespace OpenSim.Region.Framework.Scenes
                     break;
             }
         }
+
+        // This method is called across the simulation connector to
+        // determine if a given agent is allowed in this region
+        // AS A ROOT AGENT. Returning false here will prevent them
+        // from logging into the region, teleporting into the region
+        // or corssing the broder walking, but will NOT prevent
+        // child agent creation, thereby emulating the SL behavior.
+        public bool QueryAccess(UUID agentID)
+        {
+            return true;
+        }
     }
 }

OpenSim/Server/Handlers/Simulation/AgentHandlers.cs

@@ -115,6 +115,11 @@ namespace OpenSim.Server.Handlers.Simulation
                 DoChildAgentDelete(request, responsedata, agentID, action, regionID);
                 return responsedata;
             }
+            else if (method.Equals("QUERYACCESSS"))
+            {
+                DoQueryAccess(request, responsedata, agentID, regionID);
+                return responsedata;
+            }
             else
             {
                 m_log.InfoFormat("[AGENT HANDLER]: method {0} not supported in agent message", method);
@@ -305,6 +310,27 @@ namespace OpenSim.Server.Handlers.Simulation
             return m_SimulationService.UpdateAgent(destination, agent);
         }
 
+        protected virtual void DoQueryAccess(Hashtable request, Hashtable responsedata, UUID id, UUID regionID)
+        {
+            if (m_SimulationService == null)
+            {
+                m_log.Debug("[AGENT HANDLER]: Agent QUERY called. Harmless but useless.");
+                responsedata["content_type"] = "application/json";
+                responsedata["int_response_code"] = HttpStatusCode.NotImplemented;
+                responsedata["str_response_string"] = string.Empty;
+
+                return;
+            }
+
+            GridRegion destination = new GridRegion();
+            destination.RegionID = regionID;
+
+            bool result = m_SimulationService.QueryAccess(destination, id);
+
+            responsedata["int_response_code"] = HttpStatusCode.OK;
+            responsedata["str_response_string"] = result.ToString();
+        }
+
         protected virtual void DoAgentGet(Hashtable request, Hashtable responsedata, UUID id, UUID regionID)
         {
             if (m_SimulationService == null)

OpenSim/Services/Connectors/Simulation/SimulationServiceConnector.cs

@@ -411,6 +411,65 @@ namespace OpenSim.Services.Connectors.Simulation
             return false;
         }
 
+        public bool QueryAccess(GridRegion destination, UUID id)
+        {
+            IPEndPoint ext = destination.ExternalEndPoint;
+            if (ext == null) return false;
+            // Eventually, we want to use a caps url instead of the agentID
+            string uri = destination.ServerURI + AgentPath() + id + "/" + destination.RegionID.ToString() + "/";
+
+            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uri);
+            request.Method = "QUERYACCESS";
+            request.Timeout = 10000;
+            //request.Headers.Add("authorization", ""); // coming soon
+
+            HttpWebResponse webResponse = null;
+            string reply = string.Empty;
+            StreamReader sr = null;
+            try
+            {
+                webResponse = (HttpWebResponse)request.GetResponse();
+                if (webResponse == null)
+                {
+                    m_log.Debug("[REMOTE SIMULATION CONNECTOR]: Null reply on agent query ");
+                }
+
+                sr = new StreamReader(webResponse.GetResponseStream());
+                reply = sr.ReadToEnd().Trim();
+
+
+            }
+            catch (WebException ex)
+            {
+                m_log.WarnFormat("[REMOTE SIMULATION CONNECTOR]: exception on reply of agent query {0}", ex.Message);
+                // ignore, really
+                return false;
+            }
+            finally
+            {
+                if (sr != null)
+                    sr.Close();
+            }
+
+            if (webResponse.StatusCode == HttpStatusCode.OK)
+            {
+                try
+                {
+                    bool result;
+
+                    result = bool.Parse(reply);
+
+                    return result;
+                }
+                catch
+                {
+                    return false;
+                }
+            }
+
+            return false;
+        }
+
         public bool ReleaseAgent(UUID origin, UUID id, string uri)
         {
             WebRequest request = WebRequest.Create(uri);

OpenSim/Services/Interfaces/ISimulationService.cs

@@ -60,6 +60,8 @@ namespace OpenSim.Services.Interfaces
 
         bool RetrieveAgent(GridRegion destination, UUID id, out IAgentData agent);
 
+        bool QueryAccess(GridRegion destination, UUID id);
+
         /// <summary>
         /// Message from receiving region to departing region, telling it got contacted by the client.
         /// When sent over REST, it invokes the opaque uri.