mirror of
https://github.com/opensim/opensim.git
synced 2026-06-19 20:05:47 +08:00
694 lines
30 KiB
C#
694 lines
30 KiB
C#
/*
|
|
* Copyright (c) Contributors, http://opensimulator.org/
|
|
* See CONTRIBUTORS.TXT for a full list of copyright holders.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of the OpenSimulator Project nor the
|
|
* names of its contributors may be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.IO.Compression;
|
|
using System.Reflection;
|
|
using System.Net;
|
|
|
|
using OpenSim.Services.Interfaces;
|
|
using GridRegion = OpenSim.Services.Interfaces.GridRegion;
|
|
using OpenSim.Framework;
|
|
using OpenSim.Framework.Servers.HttpServer;
|
|
|
|
using OpenMetaverse;
|
|
using OpenMetaverse.StructuredData;
|
|
|
|
using log4net;
|
|
|
|
|
|
namespace OpenSim.Server.Handlers.Simulation
|
|
{
|
|
//this is only for hg homeagent and gatekeeperagent
|
|
public class AgentPostHandler : SimpleStreamHandler
|
|
{
|
|
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
|
|
|
|
protected bool m_Proxy = false;
|
|
|
|
public AgentPostHandler(string path) : base(path)
|
|
{
|
|
}
|
|
|
|
protected override void ProcessRequest(IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
|
|
{
|
|
// m_log.DebugFormat("[SIMULATION]: Stream handler called");
|
|
|
|
httpResponse.ContentType = "text/html"; //??
|
|
httpResponse.KeepAlive = false;
|
|
|
|
if(httpRequest.HttpMethod != "POST")
|
|
{
|
|
httpResponse.StatusCode = (int)HttpStatusCode.MethodNotAllowed;
|
|
httpResponse.RawBuffer = Utils.falseStrBytes;
|
|
}
|
|
|
|
if (httpRequest.ContentType != "application/json" && httpRequest.ContentType != "application/x-gzip")
|
|
{
|
|
httpResponse.StatusCode = (int)HttpStatusCode.NotAcceptable;
|
|
httpResponse.RawBuffer = Utils.falseStrBytes;
|
|
}
|
|
|
|
UUID agentID;
|
|
UUID regionID;
|
|
string action;
|
|
|
|
if (!Utils.GetParams(httpRequest.UriPath, out agentID, out regionID, out action))
|
|
{
|
|
m_log.InfoFormat("[AGENT HANDLER]: Invalid parameters for agent message {0}", httpRequest.RawUrl);
|
|
|
|
httpResponse.StatusCode = (int)HttpStatusCode.NotFound;
|
|
httpResponse.RawBuffer = Utils.falseStrBytes;
|
|
}
|
|
|
|
OSDMap args = Utils.DeserializeJSONOSMap(httpRequest);
|
|
if (args == null)
|
|
{
|
|
httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
|
|
httpResponse.RawBuffer = Utils.falseStrBytes;
|
|
}
|
|
|
|
DoAgentPost(args, httpRequest.RemoteIPEndPoint.Address.ToString(), httpResponse, agentID);
|
|
|
|
httpResponse.StatusCode = 200;
|
|
}
|
|
|
|
protected void DoAgentPost(OSDMap args, string remoteAddress, IOSHttpResponse response, UUID id)
|
|
{
|
|
OSD tmpOSD;
|
|
EntityTransferContext ctx = new EntityTransferContext();
|
|
if (args.TryGetValue("context", out tmpOSD) && tmpOSD is OSDMap)
|
|
ctx.Unpack((OSDMap)tmpOSD);
|
|
|
|
AgentDestinationData data = CreateAgentDestinationData();
|
|
UnpackData(args, data, remoteAddress);
|
|
|
|
GridRegion destination = new GridRegion();
|
|
destination.RegionID = data.uuid;
|
|
destination.RegionLocX = data.x;
|
|
destination.RegionLocY = data.y;
|
|
destination.RegionName = data.name;
|
|
|
|
GridRegion gatekeeper = ExtractGatekeeper(data);
|
|
|
|
AgentCircuitData aCircuit = new AgentCircuitData();
|
|
try
|
|
{
|
|
aCircuit.UnpackAgentCircuitData(args);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
m_log.InfoFormat("[AGENT HANDLER]: exception on unpacking ChildCreate message {0}", ex.Message);
|
|
response.StatusCode = (int)HttpStatusCode.BadRequest;
|
|
return;
|
|
}
|
|
|
|
GridRegion source = null;
|
|
|
|
if (args.TryGetValue("source_uuid", out tmpOSD))
|
|
{
|
|
source = new GridRegion();
|
|
source.RegionID = UUID.Parse(tmpOSD.AsString());
|
|
source.RegionLocX = Int32.Parse(args["source_x"].AsString());
|
|
source.RegionLocY = Int32.Parse(args["source_y"].AsString());
|
|
source.RegionName = args["source_name"].AsString();
|
|
|
|
if (args.TryGetValue("source_server_uri", out tmpOSD))
|
|
source.RawServerURI = tmpOSD.AsString();
|
|
else
|
|
source.RawServerURI = null;
|
|
}
|
|
|
|
OSDMap resp = new OSDMap(2);
|
|
string reason = string.Empty;
|
|
|
|
bool result = CreateAgent(source, gatekeeper, destination, aCircuit, data.flags, data.fromLogin, ctx, out reason);
|
|
|
|
resp["reason"] = OSD.FromString(reason);
|
|
resp["success"] = OSD.FromBoolean(result);
|
|
// Let's also send out the IP address of the caller back to the caller (HG 1.5)
|
|
resp["your_ip"] = remoteAddress;
|
|
|
|
response.StatusCode = (int)HttpStatusCode.OK;
|
|
response.RawBuffer = OSDParser.SerializeJsonToBytes(resp);
|
|
}
|
|
|
|
protected virtual AgentDestinationData CreateAgentDestinationData()
|
|
{
|
|
return new AgentDestinationData();
|
|
}
|
|
|
|
protected virtual void UnpackData(OSDMap args, AgentDestinationData data, string remoteAddress)
|
|
{
|
|
OSD tmpOSD;
|
|
// retrieve the input arguments
|
|
if (args.TryGetValue("destination_x", out tmpOSD) && tmpOSD != null)
|
|
Int32.TryParse(tmpOSD.AsString(), out data.x);
|
|
else
|
|
m_log.WarnFormat(" -- request didn't have destination_x");
|
|
|
|
if (args.TryGetValue("destination_y", out tmpOSD) && tmpOSD != null)
|
|
Int32.TryParse(tmpOSD.AsString(), out data.y);
|
|
else
|
|
m_log.WarnFormat(" -- request didn't have destination_y");
|
|
|
|
if (args.TryGetValue("destination_uuid", out tmpOSD) && tmpOSD != null)
|
|
UUID.TryParse(tmpOSD.AsString(), out data.uuid);
|
|
|
|
if (args.TryGetValue("destination_name", out tmpOSD) && tmpOSD != null)
|
|
data.name = tmpOSD.ToString();
|
|
|
|
if (args.TryGetValue("teleport_flags", out tmpOSD) && tmpOSD != null)
|
|
data.flags = tmpOSD.AsUInteger();
|
|
}
|
|
|
|
protected virtual GridRegion ExtractGatekeeper(AgentDestinationData data)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// subclasses must override this
|
|
protected virtual bool CreateAgent(GridRegion source, GridRegion gatekeeper, GridRegion destination,
|
|
AgentCircuitData aCircuit, uint teleportFlags, bool fromLogin, EntityTransferContext ctx, out string reason)
|
|
{
|
|
reason = "Configuration issues, plz mantis";
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public class AgentSimpleHandler : SimpleStreamHandler
|
|
{
|
|
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
|
|
|
|
private ISimulationService m_SimulationService;
|
|
protected bool m_Proxy = false;
|
|
|
|
public AgentSimpleHandler(ISimulationService service) : base("/agent")
|
|
{
|
|
m_SimulationService = service;
|
|
}
|
|
|
|
protected override void ProcessRequest(IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
|
|
{
|
|
httpResponse.KeepAlive = false;
|
|
httpResponse.ContentType = "application/json";
|
|
if (m_SimulationService == null)
|
|
{
|
|
m_log.Debug("[AGENT HANDLER]: ProcessRequest called with null Simulation Service");
|
|
httpResponse.StatusCode = (int)HttpStatusCode.InternalServerError;
|
|
httpResponse.RawBuffer = Utils.falseStrBytes;
|
|
return;
|
|
}
|
|
|
|
if (!Utils.GetParams(httpRequest.UriPath, out UUID agentID, out UUID regionID, out string action))
|
|
{
|
|
m_log.InfoFormat("[AGENT HANDLER]: Invalid parameters for agent message {0}", httpRequest.UriPath);
|
|
|
|
httpResponse.StatusCode = (int)HttpStatusCode.NotFound;
|
|
httpResponse.RawBuffer = Utils.falseStrBytes;
|
|
return;
|
|
}
|
|
|
|
switch(httpRequest.HttpMethod)
|
|
{
|
|
case "QUERYACCESS":
|
|
{
|
|
if (agentID == UUID.Zero || regionID == UUID.Zero)
|
|
{
|
|
httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
|
|
httpResponse.RawBuffer = Utils.falseStrBytes;
|
|
return;
|
|
}
|
|
OSDMap args = Utils.DeserializeJSONOSMap(httpRequest);
|
|
if (args == null)
|
|
{
|
|
httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
|
|
httpResponse.RawBuffer = Utils.falseStrBytes;
|
|
return;
|
|
}
|
|
DoQueryAccess(args, httpResponse, agentID, regionID);
|
|
break;
|
|
}
|
|
case "PUT":
|
|
{
|
|
OSDMap args = Utils.DeserializeJSONOSMap(httpRequest);
|
|
if (args == null)
|
|
{
|
|
httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
|
|
httpResponse.RawBuffer = Utils.falseStrBytes;
|
|
return;
|
|
}
|
|
|
|
DoAgentPut(args, httpResponse);
|
|
break;
|
|
}
|
|
case "POST":
|
|
{
|
|
if (agentID == UUID.Zero)
|
|
{
|
|
httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
|
|
httpResponse.RawBuffer = Utils.falseStrBytes;
|
|
return;
|
|
}
|
|
OSDMap args = Utils.DeserializeJSONOSMap(httpRequest);
|
|
if (args == null)
|
|
{
|
|
httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
|
|
httpResponse.RawBuffer = Utils.falseStrBytes;
|
|
return;
|
|
}
|
|
DoAgentPost(args, httpRequest, httpResponse, agentID);
|
|
break;
|
|
}
|
|
case "DELETE":
|
|
{
|
|
if (agentID == UUID.Zero || regionID == UUID.Zero)
|
|
{
|
|
httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
|
|
httpResponse.RawBuffer = Utils.falseStrBytes;
|
|
return;
|
|
}
|
|
httpRequest.QueryAsDictionary.TryGetValue("auth", out string auth_token);
|
|
|
|
DoAgentDelete(httpRequest, httpResponse, agentID, action, regionID, auth_token);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
httpResponse.StatusCode = (int)HttpStatusCode.MethodNotAllowed;
|
|
httpResponse.RawBuffer = Utils.falseStrBytes;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual void DoQueryAccess(OSDMap args, IOSHttpResponse httpResponse, UUID agentID, UUID regionID)
|
|
{
|
|
bool viaTeleport = true;
|
|
OSD tmpOSD;
|
|
if (args.TryGetValue("viaTeleport", out tmpOSD))
|
|
viaTeleport = tmpOSD.AsBoolean();
|
|
|
|
Vector3 position = Vector3.Zero;
|
|
if (args.TryGetValue("position", out tmpOSD))
|
|
position = Vector3.Parse(tmpOSD.AsString());
|
|
|
|
string agentHomeURI = null;
|
|
if (args.TryGetValue("agent_home_uri", out tmpOSD))
|
|
agentHomeURI = tmpOSD.AsString();
|
|
|
|
// Decode the legacy (string) version and extract the number
|
|
float theirVersion = 0f;
|
|
if (args.TryGetValue("my_version", out tmpOSD))
|
|
{
|
|
string theirVersionStr = tmpOSD.AsString();
|
|
string[] parts = theirVersionStr.Split(new char[] { '/' });
|
|
if (parts.Length > 1)
|
|
theirVersion = float.Parse(parts[1], Culture.FormatProvider);
|
|
}
|
|
|
|
EntityTransferContext ctx = new EntityTransferContext();
|
|
if (args.TryGetValue("context", out tmpOSD) && tmpOSD is OSDMap)
|
|
ctx.Unpack((OSDMap)tmpOSD);
|
|
|
|
// Decode the new versioning data
|
|
float minVersionRequired = 0f;
|
|
float maxVersionRequired = 0f;
|
|
float minVersionProvided = 0f;
|
|
float maxVersionProvided = 0f;
|
|
|
|
if (args.TryGetValue("simulation_service_supported_min", out tmpOSD))
|
|
minVersionProvided = (float)tmpOSD.AsReal();
|
|
if (args.TryGetValue("simulation_service_supported_max", out tmpOSD))
|
|
maxVersionProvided = (float)tmpOSD.AsReal();
|
|
|
|
if (args.TryGetValue("simulation_service_accepted_min", out tmpOSD))
|
|
minVersionRequired = (float)tmpOSD.AsReal();
|
|
if (args.TryGetValue("simulation_service_accepted_max", out tmpOSD))
|
|
maxVersionRequired = (float)tmpOSD.AsReal();
|
|
|
|
OSDMap resp = new OSDMap(3);
|
|
|
|
float version = 0f;
|
|
|
|
httpResponse.StatusCode = (int)HttpStatusCode.OK;
|
|
|
|
|
|
float outboundVersion = 0f;
|
|
float inboundVersion = 0f;
|
|
|
|
if (minVersionProvided == 0f) // string version or older
|
|
{
|
|
// If there is no version in the packet at all we're looking at 0.6 or
|
|
// even more ancient. Refuse it.
|
|
if (theirVersion == 0f)
|
|
{
|
|
resp["success"] = OSD.FromBoolean(false);
|
|
resp["reason"] = OSD.FromString("Your region is running a old version of opensim no longer supported. Consider updating it");
|
|
httpResponse.RawBuffer = Util.UTF8.GetBytes(OSDParser.SerializeJsonString(resp, true));
|
|
return;
|
|
}
|
|
|
|
version = theirVersion;
|
|
|
|
if (version < VersionInfo.SimulationServiceVersionAcceptedMin ||
|
|
version > VersionInfo.SimulationServiceVersionAcceptedMax)
|
|
{
|
|
resp["success"] = OSD.FromBoolean(false);
|
|
resp["reason"] = OSD.FromString(String.Format("Your region protocol version is {0} and we accept only {1} - {2}. No version overlap.", theirVersion, VersionInfo.SimulationServiceVersionAcceptedMin, VersionInfo.SimulationServiceVersionAcceptedMax));
|
|
httpResponse.RawBuffer = Util.UTF8.GetBytes(OSDParser.SerializeJsonString(resp, true));
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Test for no overlap
|
|
if (minVersionProvided > VersionInfo.SimulationServiceVersionAcceptedMax ||
|
|
maxVersionProvided < VersionInfo.SimulationServiceVersionAcceptedMin)
|
|
{
|
|
resp["success"] = OSD.FromBoolean(false);
|
|
resp["reason"] = OSD.FromString(String.Format("Your region provide protocol versions {0} - {1} and we accept only {2} - {3}. No version overlap.", minVersionProvided, maxVersionProvided, VersionInfo.SimulationServiceVersionAcceptedMin, VersionInfo.SimulationServiceVersionAcceptedMax));
|
|
httpResponse.RawBuffer = Util.UTF8.GetBytes(OSDParser.SerializeJsonString(resp, true));
|
|
return;
|
|
}
|
|
if (minVersionRequired > VersionInfo.SimulationServiceVersionSupportedMax ||
|
|
maxVersionRequired < VersionInfo.SimulationServiceVersionSupportedMin)
|
|
{
|
|
resp["success"] = OSD.FromBoolean(false);
|
|
resp["reason"] = OSD.FromString(String.Format("You require region protocol versions {0} - {1} and we provide only {2} - {3}. No version overlap.", minVersionRequired, maxVersionRequired, VersionInfo.SimulationServiceVersionSupportedMin, VersionInfo.SimulationServiceVersionSupportedMax));
|
|
httpResponse.RawBuffer = Util.UTF8.GetBytes(OSDParser.SerializeJsonString(resp, true));
|
|
return;
|
|
}
|
|
|
|
// Determine versions to use
|
|
// This is intentionally inverted. Inbound and Outbound refer to the direction of the transfer.
|
|
// Therefore outbound means from the sender to the receier and inbound means from the receiver to the sender.
|
|
// So outbound is what we will accept and inbound is what we will send. Confused yet?
|
|
outboundVersion = Math.Min(maxVersionProvided, VersionInfo.SimulationServiceVersionAcceptedMax);
|
|
inboundVersion = Math.Min(maxVersionRequired, VersionInfo.SimulationServiceVersionSupportedMax);
|
|
}
|
|
|
|
List<UUID> features = new List<UUID>();
|
|
|
|
if (args.TryGetValue("features", out tmpOSD) && tmpOSD is OSDArray)
|
|
{
|
|
OSDArray array = (OSDArray)tmpOSD;
|
|
|
|
foreach (OSD o in array)
|
|
features.Add(new UUID(o.AsString()));
|
|
}
|
|
|
|
GridRegion destination = new GridRegion();
|
|
destination.RegionID = regionID;
|
|
|
|
string reason;
|
|
// We're sending the version numbers down to the local connector to do the varregion check.
|
|
ctx.InboundVersion = inboundVersion;
|
|
ctx.OutboundVersion = outboundVersion;
|
|
if (minVersionProvided == 0f)
|
|
{
|
|
ctx.InboundVersion = version;
|
|
ctx.OutboundVersion = version;
|
|
}
|
|
|
|
bool result = m_SimulationService.QueryAccess(destination, agentID, agentHomeURI, viaTeleport, position, features, ctx, out reason);
|
|
m_log.DebugFormat("[AGENT HANDLER]: QueryAccess returned {0} ({1}). Version={2}, {3}/{4}",
|
|
result, reason, version, inboundVersion, outboundVersion);
|
|
|
|
resp["success"] = OSD.FromBoolean(result);
|
|
resp["reason"] = OSD.FromString(reason);
|
|
string legacyVersion = String.Format(Culture.FormatProvider, "SIMULATION/{0}", version);
|
|
resp["version"] = OSD.FromString(legacyVersion);
|
|
resp["negotiated_inbound_version"] = OSD.FromReal(inboundVersion);
|
|
resp["negotiated_outbound_version"] = OSD.FromReal(outboundVersion);
|
|
|
|
OSDArray featuresWanted = new OSDArray();
|
|
foreach (UUID feature in features)
|
|
featuresWanted.Add(OSD.FromString(feature.ToString()));
|
|
|
|
resp["features"] = featuresWanted;
|
|
|
|
httpResponse.KeepAlive = result;
|
|
|
|
// We must preserve defaults here, otherwise a false "success" will not be put into the JSON map!
|
|
httpResponse.RawBuffer = Util.UTF8.GetBytes(OSDParser.SerializeJsonString(resp, true));
|
|
|
|
// console.WriteLine("str_response_string [{0}]", responsedata["str_response_string"]);
|
|
}
|
|
|
|
protected void DoAgentDelete(IOSHttpRequest httpRequest, IOSHttpResponse httpResponse, UUID agentID, string action, UUID regionID, string auth_token)
|
|
{
|
|
if (string.IsNullOrEmpty(action))
|
|
m_log.DebugFormat("[AGENT HANDLER]: >>> DELETE <<< RegionID: {0}; from: {1}; auth_code: {2}",
|
|
regionID, httpRequest.RemoteIPEndPoint.Address.ToString(), auth_token);
|
|
else
|
|
m_log.DebugFormat("[AGENT HANDLER]: Release {0} to RegionID: {1}", agentID, regionID);
|
|
|
|
|
|
if (action.Equals("release"))
|
|
m_SimulationService.ReleaseAgent(regionID, agentID, "");
|
|
else
|
|
{
|
|
GridRegion destination = new GridRegion();
|
|
destination.RegionID = regionID;
|
|
Util.FireAndForget(
|
|
o => m_SimulationService.CloseAgent(destination, agentID, auth_token), null, "AgentHandler.DoAgentDelete");
|
|
}
|
|
|
|
httpResponse.StatusCode = (int)HttpStatusCode.OK;
|
|
httpResponse.RawBuffer = Util.UTF8.GetBytes("OpenSim agent " + agentID.ToString());
|
|
|
|
//m_log.DebugFormat("[AGENT HANDLER]: Agent {0} Released/Deleted from region {1}", id, regionID);
|
|
}
|
|
|
|
protected void DoAgentPost(OSDMap args, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse, UUID agentID)
|
|
{
|
|
OSD tmpOSD;
|
|
EntityTransferContext ctx = new EntityTransferContext();
|
|
if (args.TryGetValue("context", out tmpOSD) && tmpOSD is OSDMap)
|
|
ctx.Unpack((OSDMap)tmpOSD);
|
|
|
|
AgentDestinationData data = CreateAgentDestinationData();
|
|
UnpackData(args, data);
|
|
|
|
GridRegion destination = new GridRegion();
|
|
destination.RegionID = data.uuid;
|
|
destination.RegionLocX = data.x;
|
|
destination.RegionLocY = data.y;
|
|
destination.RegionName = data.name;
|
|
|
|
GridRegion gatekeeper = ExtractGatekeeper(data);
|
|
|
|
AgentCircuitData aCircuit = new AgentCircuitData();
|
|
try
|
|
{
|
|
aCircuit.UnpackAgentCircuitData(args);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
m_log.InfoFormat("[AGENT HANDLER]: exception on unpacking ChildCreate message {0}", ex.Message);
|
|
httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
|
|
httpResponse.RawBuffer = Util.UTF8.GetBytes("false");
|
|
return;
|
|
}
|
|
|
|
GridRegion source = null;
|
|
|
|
if (args.TryGetValue("source_uuid", out tmpOSD))
|
|
{
|
|
source = new GridRegion();
|
|
source.RegionID = UUID.Parse(tmpOSD.AsString());
|
|
source.RegionLocX = Int32.Parse(args["source_x"].AsString());
|
|
source.RegionLocY = Int32.Parse(args["source_y"].AsString());
|
|
source.RegionName = args["source_name"].AsString();
|
|
|
|
if (args.TryGetValue("source_server_uri", out tmpOSD))
|
|
source.RawServerURI = tmpOSD.AsString();
|
|
else
|
|
source.RawServerURI = null;
|
|
}
|
|
|
|
OSDMap resp = new OSDMap(2);
|
|
string reason = string.Empty;
|
|
|
|
bool result = CreateAgent(source, gatekeeper, destination, aCircuit, data.flags, ctx, out reason);
|
|
|
|
resp["reason"] = OSD.FromString(reason);
|
|
resp["success"] = OSD.FromBoolean(result);
|
|
// Let's also send out the IP address of the caller back to the caller (HG 1.5)
|
|
resp["your_ip"] = OSD.FromString(httpRequest.RemoteIPEndPoint.Address.ToString());
|
|
|
|
httpResponse.StatusCode = (int)HttpStatusCode.OK;
|
|
httpResponse.RawBuffer = Util.UTF8.GetBytes(OSDParser.SerializeJsonString(resp));
|
|
httpResponse.KeepAlive = (data.flags & (uint)(TeleportFlags.ViaLogin | TeleportFlags.ViaHGLogin)) != (uint)TeleportFlags.ViaLogin;
|
|
}
|
|
|
|
protected virtual AgentDestinationData CreateAgentDestinationData()
|
|
{
|
|
return new AgentDestinationData();
|
|
}
|
|
|
|
protected virtual void UnpackData(OSDMap args, AgentDestinationData data)
|
|
{
|
|
OSD tmpOSD;
|
|
// retrieve the input arguments
|
|
if (args.TryGetValue("destination_x", out tmpOSD) && tmpOSD != null)
|
|
Int32.TryParse(tmpOSD.AsString(), out data.x);
|
|
else
|
|
m_log.WarnFormat(" -- request didn't have destination_x");
|
|
|
|
if (args.TryGetValue("destination_y", out tmpOSD) && tmpOSD != null)
|
|
Int32.TryParse(tmpOSD.AsString(), out data.y);
|
|
else
|
|
m_log.WarnFormat(" -- request didn't have destination_y");
|
|
|
|
if (args.TryGetValue("destination_uuid", out tmpOSD) && tmpOSD != null)
|
|
UUID.TryParse(tmpOSD.AsString(), out data.uuid);
|
|
|
|
if (args.TryGetValue("destination_name", out tmpOSD) && tmpOSD != null)
|
|
data.name = tmpOSD.ToString();
|
|
|
|
if (args.TryGetValue("teleport_flags", out tmpOSD) && tmpOSD != null)
|
|
data.flags = tmpOSD.AsUInteger();
|
|
}
|
|
|
|
protected virtual GridRegion ExtractGatekeeper(AgentDestinationData data)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// subclasses can override this
|
|
protected virtual bool CreateAgent(GridRegion source, GridRegion gatekeeper, GridRegion destination,
|
|
AgentCircuitData aCircuit, uint teleportFlags, EntityTransferContext ctx, out string reason)
|
|
{
|
|
reason = string.Empty;
|
|
bool ret = m_SimulationService.CreateAgent(source, destination, aCircuit, teleportFlags, ctx, out reason);
|
|
// m_log.DebugFormat("[AGENT HANDLER]: SYNC CreateAgent {0} {1}", ret.ToString(), reason);
|
|
return ret;
|
|
}
|
|
|
|
protected void DoAgentPut(OSDMap args, IOSHttpResponse httpResponse)
|
|
{
|
|
// retrieve the input arguments
|
|
OSD tmpOSD;
|
|
EntityTransferContext ctx = new EntityTransferContext();
|
|
int x = 0, y = 0;
|
|
UUID uuid = UUID.Zero;
|
|
string regionname = string.Empty;
|
|
if (args.TryGetValue("destination_x", out tmpOSD) && tmpOSD != null)
|
|
Int32.TryParse(tmpOSD.AsString(), out x);
|
|
if (args.TryGetValue("destination_y", out tmpOSD) && tmpOSD != null)
|
|
Int32.TryParse(tmpOSD.AsString(), out y);
|
|
if (args.TryGetValue("destination_uuid", out tmpOSD) && tmpOSD != null)
|
|
UUID.TryParse(tmpOSD.AsString(), out uuid);
|
|
if (args.TryGetValue("destination_name", out tmpOSD) && tmpOSD != null)
|
|
regionname = tmpOSD.ToString();
|
|
if (args.TryGetValue("context", out tmpOSD) && tmpOSD is OSDMap)
|
|
ctx.Unpack((OSDMap)tmpOSD);
|
|
|
|
GridRegion destination = new GridRegion();
|
|
destination.RegionID = uuid;
|
|
destination.RegionLocX = x;
|
|
destination.RegionLocY = y;
|
|
destination.RegionName = regionname;
|
|
|
|
string messageType;
|
|
if (args["message_type"] != null)
|
|
messageType = args["message_type"].AsString();
|
|
else
|
|
{
|
|
m_log.Warn("[AGENT HANDLER]: Agent Put Message Type not found. ");
|
|
messageType = "AgentData";
|
|
}
|
|
|
|
bool result = true;
|
|
if ("AgentData".Equals(messageType))
|
|
{
|
|
AgentData agent = new AgentData();
|
|
try
|
|
{
|
|
agent.Unpack(args, m_SimulationService.GetScene(destination.RegionID), ctx);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
m_log.InfoFormat("[AGENT HANDLER]: exception on unpacking ChildAgentUpdate message {0}", ex.Message);
|
|
httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
|
|
httpResponse.RawBuffer = Util.UTF8.GetBytes("false");
|
|
return;
|
|
}
|
|
|
|
//agent.Dump();
|
|
// This is one of the meanings of PUT agent
|
|
result = UpdateAgent(destination, agent);
|
|
}
|
|
else if ("AgentPosition".Equals(messageType))
|
|
{
|
|
AgentPosition agent = new AgentPosition();
|
|
try
|
|
{
|
|
agent.Unpack(args, m_SimulationService.GetScene(destination.RegionID), ctx);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
m_log.InfoFormat("[AGENT HANDLER]: exception on unpacking ChildAgentUpdate message {0}", ex.Message);
|
|
httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
|
|
httpResponse.RawBuffer = Util.UTF8.GetBytes("false");
|
|
return;
|
|
}
|
|
//agent.Dump();
|
|
// This is one of the meanings of PUT agent
|
|
result = m_SimulationService.UpdateAgent(destination, agent);
|
|
}
|
|
|
|
httpResponse.StatusCode = (int)HttpStatusCode.OK;
|
|
httpResponse.RawBuffer = Util.UTF8.GetBytes(result.ToString());
|
|
//responsedata["str_response_string"] = OSDParser.SerializeJsonString(resp); ??? instead
|
|
}
|
|
|
|
// subclasses can override this
|
|
protected virtual bool UpdateAgent(GridRegion destination, AgentData agent)
|
|
{
|
|
// The data and protocols are already defined so this is just a dummy to satisfy the interface
|
|
// TODO: make this end-to-end
|
|
return m_SimulationService.UpdateAgent(destination, agent, new EntityTransferContext());
|
|
}
|
|
}
|
|
|
|
public class AgentDestinationData
|
|
{
|
|
public int x;
|
|
public int y;
|
|
public string name;
|
|
public UUID uuid;
|
|
public uint flags;
|
|
public bool fromLogin;
|
|
}
|
|
}
|