mirror of
https://github.com/opensim/opensim.git
synced 2026-06-27 09:15:49 +08:00
923 lines
33 KiB
C#
923 lines
33 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 OpenSim 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.IO;
|
|
using System.Net;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using log4net;
|
|
using Nini.Config;
|
|
using OpenMetaverse;
|
|
using OpenMetaverse.StructuredData;
|
|
using OpenSim.Framework;
|
|
using OpenSim.Framework.Communications;
|
|
using OpenSim.Framework.Communications.Clients;
|
|
using OpenSim.Region.CoreModules.Communications.Local;
|
|
using OpenSim.Region.Framework.Interfaces;
|
|
using OpenSim.Region.Framework.Scenes;
|
|
using OpenSim.Region.Framework.Scenes.Hypergrid;
|
|
|
|
namespace OpenSim.Region.CoreModules.Communications.REST
|
|
{
|
|
public class RESTInterregionComms : IRegionModule, IInterregionCommsOut
|
|
{
|
|
private bool initialized = false;
|
|
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
|
|
|
|
protected bool m_enabled = false;
|
|
protected Scene m_aScene;
|
|
// RESTInterregionComms does not care about local regions; it delegates that to the Local module
|
|
protected LocalInterregionComms m_localBackend;
|
|
|
|
protected CommunicationsManager m_commsManager;
|
|
|
|
protected RegionToRegionClient m_regionClient;
|
|
|
|
protected bool m_safemode;
|
|
protected IPAddress m_thisIP;
|
|
|
|
#region IRegionModule
|
|
|
|
public virtual void Initialise(Scene scene, IConfigSource config)
|
|
{
|
|
if (!initialized)
|
|
{
|
|
initialized = true;
|
|
IConfig startupConfig = config.Configs["Communications"];
|
|
|
|
if ((startupConfig == null)
|
|
|| (startupConfig != null)
|
|
&& (startupConfig.GetString("InterregionComms", "RESTComms") == "RESTComms"))
|
|
{
|
|
m_log.Info("[REST COMMS]: Enabling InterregionComms RESTComms module");
|
|
m_enabled = true;
|
|
if (config.Configs["Hypergrid"] != null)
|
|
m_safemode = config.Configs["Hypergrid"].GetBoolean("safemode", false);
|
|
|
|
InitOnce(scene);
|
|
}
|
|
}
|
|
|
|
if (!m_enabled)
|
|
return;
|
|
|
|
InitEach(scene);
|
|
|
|
}
|
|
|
|
public virtual void PostInitialise()
|
|
{
|
|
if (m_enabled)
|
|
AddHTTPHandlers();
|
|
}
|
|
|
|
public virtual void Close()
|
|
{
|
|
}
|
|
|
|
public virtual string Name
|
|
{
|
|
get { return "RESTInterregionCommsModule"; }
|
|
}
|
|
|
|
public virtual bool IsSharedModule
|
|
{
|
|
get { return true; }
|
|
}
|
|
|
|
protected virtual void InitEach(Scene scene)
|
|
{
|
|
m_localBackend.Init(scene);
|
|
scene.RegisterModuleInterface<IInterregionCommsOut>(this);
|
|
}
|
|
|
|
protected virtual void InitOnce(Scene scene)
|
|
{
|
|
m_localBackend = new LocalInterregionComms();
|
|
m_commsManager = scene.CommsManager;
|
|
m_aScene = scene;
|
|
m_regionClient = new RegionToRegionClient(m_aScene);
|
|
m_thisIP = Util.GetHostFromDNS(scene.RegionInfo.ExternalHostName);
|
|
}
|
|
|
|
protected virtual void AddHTTPHandlers()
|
|
{
|
|
m_aScene.CommsManager.HttpServer.AddHTTPHandler("/agent/", AgentHandler);
|
|
m_aScene.CommsManager.HttpServer.AddHTTPHandler("/object/", ObjectHandler);
|
|
m_aScene.CommsManager.HttpServer.AddHTTPHandler("/region/", RegionHandler);
|
|
}
|
|
|
|
#endregion /* IRegionModule */
|
|
|
|
#region IInterregionComms
|
|
|
|
/**
|
|
* Agent-related communications
|
|
*/
|
|
|
|
public bool SendCreateChildAgent(ulong regionHandle, AgentCircuitData aCircuit)
|
|
{
|
|
// Try local first
|
|
if (m_localBackend.SendCreateChildAgent(regionHandle, aCircuit))
|
|
return true;
|
|
|
|
// else do the remote thing
|
|
if (!m_localBackend.IsLocalRegion(regionHandle))
|
|
{
|
|
RegionInfo regInfo = m_commsManager.GridService.RequestNeighbourInfo(regionHandle);
|
|
if (regInfo != null)
|
|
{
|
|
m_regionClient.SendUserInformation(regInfo, aCircuit);
|
|
|
|
return m_regionClient.DoCreateChildAgentCall(regInfo, aCircuit, "None");
|
|
}
|
|
//else
|
|
// m_log.Warn("[REST COMMS]: Region not found " + regionHandle);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public bool SendChildAgentUpdate(ulong regionHandle, AgentData cAgentData)
|
|
{
|
|
// Try local first
|
|
if (m_localBackend.SendChildAgentUpdate(regionHandle, cAgentData))
|
|
return true;
|
|
|
|
// else do the remote thing
|
|
if (!m_localBackend.IsLocalRegion(regionHandle))
|
|
{
|
|
RegionInfo regInfo = m_commsManager.GridService.RequestNeighbourInfo(regionHandle);
|
|
if (regInfo != null)
|
|
{
|
|
return m_regionClient.DoChildAgentUpdateCall(regInfo, cAgentData);
|
|
}
|
|
//else
|
|
// m_log.Warn("[REST COMMS]: Region not found " + regionHandle);
|
|
}
|
|
return false;
|
|
|
|
}
|
|
|
|
public bool SendChildAgentUpdate(ulong regionHandle, AgentPosition cAgentData)
|
|
{
|
|
// Try local first
|
|
if (m_localBackend.SendChildAgentUpdate(regionHandle, cAgentData))
|
|
return true;
|
|
|
|
// else do the remote thing
|
|
if (!m_localBackend.IsLocalRegion(regionHandle))
|
|
{
|
|
RegionInfo regInfo = m_commsManager.GridService.RequestNeighbourInfo(regionHandle);
|
|
if (regInfo != null)
|
|
{
|
|
return m_regionClient.DoChildAgentUpdateCall(regInfo, cAgentData);
|
|
}
|
|
//else
|
|
// m_log.Warn("[REST COMMS]: Region not found " + regionHandle);
|
|
}
|
|
return false;
|
|
|
|
}
|
|
|
|
public bool SendRetrieveRootAgent(ulong regionHandle, UUID id, out IAgentData agent)
|
|
{
|
|
// Try local first
|
|
if (m_localBackend.SendRetrieveRootAgent(regionHandle, id, out agent))
|
|
return true;
|
|
|
|
// else do the remote thing
|
|
if (!m_localBackend.IsLocalRegion(regionHandle))
|
|
{
|
|
RegionInfo regInfo = m_commsManager.GridService.RequestNeighbourInfo(regionHandle);
|
|
if (regInfo != null)
|
|
{
|
|
return m_regionClient.DoRetrieveRootAgentCall(regInfo, id, out agent);
|
|
}
|
|
//else
|
|
// m_log.Warn("[REST COMMS]: Region not found " + regionHandle);
|
|
}
|
|
return false;
|
|
|
|
}
|
|
|
|
public bool SendReleaseAgent(ulong regionHandle, UUID id, string uri)
|
|
{
|
|
// Try local first
|
|
if (m_localBackend.SendReleaseAgent(regionHandle, id, uri))
|
|
return true;
|
|
|
|
// else do the remote thing
|
|
return m_regionClient.DoReleaseAgentCall(regionHandle, id, uri);
|
|
}
|
|
|
|
|
|
public bool SendCloseAgent(ulong regionHandle, UUID id)
|
|
{
|
|
// Try local first
|
|
if (m_localBackend.SendCloseAgent(regionHandle, id))
|
|
return true;
|
|
|
|
// else do the remote thing
|
|
if (!m_localBackend.IsLocalRegion(regionHandle))
|
|
{
|
|
RegionInfo regInfo = m_commsManager.GridService.RequestNeighbourInfo(regionHandle);
|
|
if (regInfo != null)
|
|
{
|
|
return m_regionClient.DoCloseAgentCall(regInfo, id);
|
|
}
|
|
//else
|
|
// m_log.Warn("[REST COMMS]: Region not found " + regionHandle);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Object-related communications
|
|
*/
|
|
|
|
public bool SendCreateObject(ulong regionHandle, ISceneObject sog, bool isLocalCall)
|
|
{
|
|
// Try local first
|
|
if (m_localBackend.SendCreateObject(regionHandle, sog, true))
|
|
{
|
|
//m_log.Debug("[REST COMMS]: LocalBackEnd SendCreateObject succeeded");
|
|
return true;
|
|
}
|
|
|
|
// else do the remote thing
|
|
if (!m_localBackend.IsLocalRegion(regionHandle))
|
|
{
|
|
RegionInfo regInfo = m_commsManager.GridService.RequestNeighbourInfo(regionHandle);
|
|
if (regInfo != null)
|
|
{
|
|
return m_regionClient.DoCreateObjectCall(regInfo, sog, m_aScene.m_allowScriptCrossings);
|
|
}
|
|
//else
|
|
// m_log.Warn("[REST COMMS]: Region not found " + regionHandle);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public bool SendCreateObject(ulong regionHandle, UUID userID, UUID itemID)
|
|
{
|
|
// Not Implemented
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Region-related communications
|
|
*/
|
|
|
|
public bool SendHelloNeighbour(ulong regionHandle, RegionInfo thisRegion)
|
|
{
|
|
// Try local first
|
|
if (m_localBackend.SendHelloNeighbour(regionHandle, thisRegion))
|
|
{
|
|
//m_log.Debug("[REST COMMS]: LocalBackEnd SendHelloNeighbour succeeded");
|
|
return true;
|
|
}
|
|
|
|
// else do the remote thing
|
|
RegionInfo regInfo = m_commsManager.GridService.RequestNeighbourInfo(regionHandle);
|
|
if ((regInfo != null) &&
|
|
// Don't remote-call this instance; that's a startup hickup
|
|
!((regInfo.ExternalHostName == thisRegion.ExternalHostName) && (regInfo.HttpPort == thisRegion.HttpPort)))
|
|
{
|
|
return m_regionClient.DoHelloNeighbourCall(regInfo, thisRegion);
|
|
}
|
|
//else
|
|
// m_log.Warn("[REST COMMS]: Region not found " + regionHandle);
|
|
return false;
|
|
}
|
|
|
|
#endregion /* IInterregionComms */
|
|
|
|
#region Incoming calls from remote instances
|
|
|
|
/**
|
|
* Agent-related incoming calls
|
|
*/
|
|
|
|
public Hashtable AgentHandler(Hashtable request)
|
|
{
|
|
//m_log.Debug("[CONNECTION DEBUGGING]: AgentHandler Called");
|
|
|
|
m_log.Debug("---------------------------");
|
|
m_log.Debug(" >> uri=" + request["uri"]);
|
|
m_log.Debug(" >> content-type=" + request["content-type"]);
|
|
m_log.Debug(" >> http-method=" + request["http-method"]);
|
|
m_log.Debug("---------------------------\n");
|
|
|
|
Hashtable responsedata = new Hashtable();
|
|
responsedata["content_type"] = "text/html";
|
|
responsedata["keepalive"] = false;
|
|
|
|
|
|
UUID agentID;
|
|
string action;
|
|
ulong regionHandle;
|
|
if (!GetParams((string)request["uri"], out agentID, out regionHandle, out action))
|
|
{
|
|
m_log.InfoFormat("[REST COMMS]: Invalid parameters for agent message {0}", request["uri"]);
|
|
responsedata["int_response_code"] = 404;
|
|
responsedata["str_response_string"] = "false";
|
|
|
|
return responsedata;
|
|
}
|
|
|
|
// Next, let's parse the verb
|
|
string method = (string)request["http-method"];
|
|
if (method.Equals("PUT"))
|
|
{
|
|
DoAgentPut(request, responsedata);
|
|
return responsedata;
|
|
}
|
|
else if (method.Equals("POST"))
|
|
{
|
|
DoAgentPost(request, responsedata, agentID);
|
|
return responsedata;
|
|
}
|
|
else if (method.Equals("GET"))
|
|
{
|
|
DoAgentGet(request, responsedata, agentID, regionHandle);
|
|
return responsedata;
|
|
}
|
|
else if (method.Equals("DELETE"))
|
|
{
|
|
DoAgentDelete(request, responsedata, agentID, action, regionHandle);
|
|
return responsedata;
|
|
}
|
|
else
|
|
{
|
|
m_log.InfoFormat("[REST COMMS]: method {0} not supported in agent message", method);
|
|
responsedata["int_response_code"] = 404;
|
|
responsedata["str_response_string"] = "false";
|
|
|
|
return responsedata;
|
|
}
|
|
|
|
}
|
|
|
|
protected virtual void DoAgentPost(Hashtable request, Hashtable responsedata, UUID id)
|
|
{
|
|
if (m_safemode)
|
|
{
|
|
// Authentication
|
|
string authority = string.Empty;
|
|
string authToken = string.Empty;
|
|
if (!GetAuthentication(request, out authority, out authToken))
|
|
{
|
|
m_log.InfoFormat("[REST COMMS]: Authentication failed for agent message {0}", request["uri"]);
|
|
responsedata["int_response_code"] = 403;
|
|
responsedata["str_response_string"] = "Forbidden";
|
|
return ;
|
|
}
|
|
if (!VerifyKey(id, authority, authToken))
|
|
{
|
|
m_log.InfoFormat("[REST COMMS]: Authentication failed for agent message {0}", request["uri"]);
|
|
responsedata["int_response_code"] = 403;
|
|
responsedata["str_response_string"] = "Forbidden";
|
|
return ;
|
|
}
|
|
m_log.DebugFormat("[REST COMMS]: Authentication succeeded for {0}", id);
|
|
}
|
|
|
|
OSDMap args = RegionClient.GetOSDMap((string)request["body"]);
|
|
if (args == null)
|
|
{
|
|
responsedata["int_response_code"] = 400;
|
|
responsedata["str_response_string"] = "false";
|
|
return;
|
|
}
|
|
|
|
// retrieve the regionhandle
|
|
ulong regionhandle = 0;
|
|
if (args["destination_handle"] != null)
|
|
UInt64.TryParse(args["destination_handle"].AsString(), out regionhandle);
|
|
|
|
AgentCircuitData aCircuit = new AgentCircuitData();
|
|
try
|
|
{
|
|
aCircuit.UnpackAgentCircuitData(args);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
m_log.InfoFormat("[REST COMMS]: exception on unpacking ChildCreate message {0}", ex.Message);
|
|
return;
|
|
}
|
|
|
|
// This is the meaning of POST agent
|
|
m_regionClient.AdjustUserInformation(aCircuit);
|
|
bool result = m_localBackend.SendCreateChildAgent(regionhandle, aCircuit);
|
|
|
|
responsedata["int_response_code"] = 200;
|
|
responsedata["str_response_string"] = result.ToString();
|
|
}
|
|
|
|
protected virtual void DoAgentPut(Hashtable request, Hashtable responsedata)
|
|
{
|
|
OSDMap args = RegionClient.GetOSDMap((string)request["body"]);
|
|
if (args == null)
|
|
{
|
|
responsedata["int_response_code"] = 400;
|
|
responsedata["str_response_string"] = "false";
|
|
return;
|
|
}
|
|
|
|
// retrieve the regionhandle
|
|
ulong regionhandle = 0;
|
|
if (args["destination_handle"] != null)
|
|
UInt64.TryParse(args["destination_handle"].AsString(), out regionhandle);
|
|
|
|
string messageType;
|
|
if (args["message_type"] != null)
|
|
messageType = args["message_type"].AsString();
|
|
else
|
|
{
|
|
m_log.Warn("[REST COMMS]: Agent Put Message Type not found. ");
|
|
messageType = "AgentData";
|
|
}
|
|
|
|
bool result = true;
|
|
if ("AgentData".Equals(messageType))
|
|
{
|
|
AgentData agent = new AgentData();
|
|
try
|
|
{
|
|
agent.Unpack(args);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
m_log.InfoFormat("[REST COMMS]: exception on unpacking ChildAgentUpdate message {0}", ex.Message);
|
|
return;
|
|
}
|
|
|
|
//agent.Dump();
|
|
// This is one of the meanings of PUT agent
|
|
result = m_localBackend.SendChildAgentUpdate(regionhandle, agent);
|
|
|
|
}
|
|
else if ("AgentPosition".Equals(messageType))
|
|
{
|
|
AgentPosition agent = new AgentPosition();
|
|
try
|
|
{
|
|
agent.Unpack(args);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
m_log.InfoFormat("[REST COMMS]: exception on unpacking ChildAgentUpdate message {0}", ex.Message);
|
|
return;
|
|
}
|
|
//agent.Dump();
|
|
// This is one of the meanings of PUT agent
|
|
result = m_localBackend.SendChildAgentUpdate(regionhandle, agent);
|
|
|
|
}
|
|
|
|
responsedata["int_response_code"] = 200;
|
|
responsedata["str_response_string"] = result.ToString();
|
|
}
|
|
|
|
protected virtual void DoAgentGet(Hashtable request, Hashtable responsedata, UUID id, ulong regionHandle)
|
|
{
|
|
IAgentData agent = null;
|
|
bool result = m_localBackend.SendRetrieveRootAgent(regionHandle, id, out agent);
|
|
OSDMap map = null;
|
|
if (result)
|
|
{
|
|
if (agent != null) // just to make sure
|
|
{
|
|
map = agent.Pack();
|
|
string strBuffer = "";
|
|
try
|
|
{
|
|
strBuffer = OSDParser.SerializeJsonString(map);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
m_log.WarnFormat("[REST COMMS]: Exception thrown on serialization of CreateObject: {0}", e.Message);
|
|
// ignore. buffer will be empty, caller should check.
|
|
}
|
|
|
|
responsedata["content_type"] = "application/json";
|
|
responsedata["int_response_code"] = 200;
|
|
responsedata["str_response_string"] = strBuffer;
|
|
}
|
|
else
|
|
{
|
|
responsedata["int_response_code"] = 500;
|
|
responsedata["str_response_string"] = "Internal error";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
responsedata["int_response_code"] = 404;
|
|
responsedata["str_response_string"] = "Not Found";
|
|
}
|
|
}
|
|
|
|
protected virtual void DoAgentDelete(Hashtable request, Hashtable responsedata, UUID id, string action, ulong regionHandle)
|
|
{
|
|
//m_log.Debug(" >>> DoDelete action:" + action + "; regionHandle:" + regionHandle);
|
|
|
|
if (action.Equals("release"))
|
|
m_localBackend.SendReleaseAgent(regionHandle, id, "");
|
|
else
|
|
m_localBackend.SendCloseAgent(regionHandle, id);
|
|
|
|
responsedata["int_response_code"] = 200;
|
|
responsedata["str_response_string"] = "OpenSim agent " + id.ToString();
|
|
|
|
m_log.Debug("[REST COMMS]: Agent Deleted.");
|
|
}
|
|
|
|
/**
|
|
* Object-related incoming calls
|
|
*/
|
|
|
|
public Hashtable ObjectHandler(Hashtable request)
|
|
{
|
|
m_log.Debug("[CONNECTION DEBUGGING]: ObjectHandler Called");
|
|
|
|
m_log.Debug("---------------------------");
|
|
m_log.Debug(" >> uri=" + request["uri"]);
|
|
m_log.Debug(" >> content-type=" + request["content-type"]);
|
|
m_log.Debug(" >> http-method=" + request["http-method"]);
|
|
m_log.Debug("---------------------------\n");
|
|
|
|
Hashtable responsedata = new Hashtable();
|
|
responsedata["content_type"] = "text/html";
|
|
|
|
UUID objectID;
|
|
string action;
|
|
ulong regionHandle;
|
|
if (!GetParams((string)request["uri"], out objectID, out regionHandle, out action))
|
|
{
|
|
m_log.InfoFormat("[REST COMMS]: Invalid parameters for object message {0}", request["uri"]);
|
|
responsedata["int_response_code"] = 404;
|
|
responsedata["str_response_string"] = "false";
|
|
|
|
return responsedata;
|
|
}
|
|
|
|
// Next, let's parse the verb
|
|
string method = (string)request["http-method"];
|
|
if (method.Equals("POST"))
|
|
{
|
|
DoObjectPost(request, responsedata, regionHandle);
|
|
return responsedata;
|
|
}
|
|
else if (method.Equals("PUT"))
|
|
{
|
|
DoObjectPut(request, responsedata, regionHandle);
|
|
return responsedata;
|
|
}
|
|
//else if (method.Equals("DELETE"))
|
|
//{
|
|
// DoObjectDelete(request, responsedata, agentID, action, regionHandle);
|
|
// return responsedata;
|
|
//}
|
|
else
|
|
{
|
|
m_log.InfoFormat("[REST COMMS]: method {0} not supported in object message", method);
|
|
responsedata["int_response_code"] = 404;
|
|
responsedata["str_response_string"] = "false";
|
|
|
|
return responsedata;
|
|
}
|
|
|
|
}
|
|
|
|
protected virtual void DoObjectPost(Hashtable request, Hashtable responsedata, ulong regionhandle)
|
|
{
|
|
OSDMap args = RegionClient.GetOSDMap((string)request["body"]);
|
|
if (args == null)
|
|
{
|
|
responsedata["int_response_code"] = 400;
|
|
responsedata["str_response_string"] = "false";
|
|
return;
|
|
}
|
|
|
|
string sogXmlStr = "", extraStr = "", stateXmlStr = "";
|
|
if (args["sog"] != null)
|
|
sogXmlStr = args["sog"].AsString();
|
|
if (args["extra"] != null)
|
|
extraStr = args["extra"].AsString();
|
|
|
|
UUID regionID = m_localBackend.GetRegionID(regionhandle);
|
|
SceneObjectGroup sog = null;
|
|
try
|
|
{
|
|
sog = new SceneObjectGroup(sogXmlStr);
|
|
sog.ExtraFromXmlString(extraStr);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
m_log.InfoFormat("[REST COMMS]: exception on deserializing scene object {0}", ex.Message);
|
|
responsedata["int_response_code"] = 400;
|
|
responsedata["str_response_string"] = "false";
|
|
return;
|
|
}
|
|
|
|
if ((args["state"] != null) && m_aScene.m_allowScriptCrossings)
|
|
{
|
|
stateXmlStr = args["state"].AsString();
|
|
if (stateXmlStr != "")
|
|
{
|
|
try
|
|
{
|
|
sog.SetState(stateXmlStr, regionID);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
m_log.InfoFormat("[REST COMMS]: exception on setting state for scene object {0}", ex.Message);
|
|
|
|
}
|
|
}
|
|
}
|
|
// This is the meaning of POST object
|
|
bool result = m_localBackend.SendCreateObject(regionhandle, sog, false);
|
|
|
|
responsedata["int_response_code"] = 200;
|
|
responsedata["str_response_string"] = result.ToString();
|
|
}
|
|
|
|
protected virtual void DoObjectPut(Hashtable request, Hashtable responsedata, ulong regionhandle)
|
|
{
|
|
OSDMap args = RegionClient.GetOSDMap((string)request["body"]);
|
|
if (args == null)
|
|
{
|
|
responsedata["int_response_code"] = 400;
|
|
responsedata["str_response_string"] = "false";
|
|
return;
|
|
}
|
|
|
|
UUID userID = UUID.Zero, itemID = UUID.Zero;
|
|
if (args["userid"] != null)
|
|
userID = args["userid"].AsUUID();
|
|
if (args["itemid"] != null)
|
|
itemID = args["itemid"].AsUUID();
|
|
|
|
//UUID regionID = m_localBackend.GetRegionID(regionhandle);
|
|
|
|
// This is the meaning of PUT object
|
|
bool result = m_localBackend.SendCreateObject(regionhandle, userID, itemID);
|
|
|
|
responsedata["int_response_code"] = 200;
|
|
responsedata["str_response_string"] = result.ToString();
|
|
}
|
|
|
|
/*
|
|
* Region-related incoming calls
|
|
*
|
|
*/
|
|
|
|
public Hashtable RegionHandler(Hashtable request)
|
|
{
|
|
//m_log.Debug("[CONNECTION DEBUGGING]: RegionHandler Called");
|
|
|
|
//m_log.Debug("---------------------------");
|
|
//m_log.Debug(" >> uri=" + request["uri"]);
|
|
//m_log.Debug(" >> content-type=" + request["content-type"]);
|
|
//m_log.Debug(" >> http-method=" + request["http-method"]);
|
|
//m_log.Debug("---------------------------\n");
|
|
|
|
Hashtable responsedata = new Hashtable();
|
|
responsedata["content_type"] = "text/html";
|
|
|
|
UUID regionID;
|
|
string action;
|
|
ulong regionHandle;
|
|
if (!GetParams((string)request["uri"], out regionID, out regionHandle, out action))
|
|
{
|
|
m_log.InfoFormat("[REST COMMS]: Invalid parameters for object message {0}", request["uri"]);
|
|
responsedata["int_response_code"] = 404;
|
|
responsedata["str_response_string"] = "false";
|
|
|
|
return responsedata;
|
|
}
|
|
|
|
// Next, let's parse the verb
|
|
string method = (string)request["http-method"];
|
|
if (method.Equals("POST"))
|
|
{
|
|
DoRegionPost(request, responsedata, regionID);
|
|
return responsedata;
|
|
}
|
|
//else if (method.Equals("PUT"))
|
|
//{
|
|
// DoRegionPut(request, responsedata, regionID);
|
|
// return responsedata;
|
|
//}
|
|
//else if (method.Equals("DELETE"))
|
|
//{
|
|
// DoRegionDelete(request, responsedata, regiontID);
|
|
// return responsedata;
|
|
//}
|
|
else
|
|
{
|
|
m_log.InfoFormat("[REST COMMS]: method {0} not supported in region message", method);
|
|
responsedata["int_response_code"] = 404;
|
|
responsedata["str_response_string"] = "false";
|
|
|
|
return responsedata;
|
|
}
|
|
|
|
}
|
|
|
|
protected virtual void DoRegionPost(Hashtable request, Hashtable responsedata, UUID id)
|
|
{
|
|
OSDMap args = RegionClient.GetOSDMap((string)request["body"]);
|
|
if (args == null)
|
|
{
|
|
responsedata["int_response_code"] = 400;
|
|
responsedata["str_response_string"] = "false";
|
|
return;
|
|
}
|
|
|
|
// retrieve the regionhandle
|
|
ulong regionhandle = 0;
|
|
if (args["destination_handle"] != null)
|
|
UInt64.TryParse(args["destination_handle"].AsString(), out regionhandle);
|
|
|
|
RegionInfo aRegion = new RegionInfo();
|
|
try
|
|
{
|
|
aRegion.UnpackRegionInfoData(args);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
m_log.InfoFormat("[REST COMMS]: exception on unpacking HelloNeighbour message {0}", ex.Message);
|
|
return;
|
|
}
|
|
|
|
// This is the meaning of POST region
|
|
bool result = m_localBackend.SendHelloNeighbour(regionhandle, aRegion);
|
|
|
|
responsedata["int_response_code"] = 200;
|
|
responsedata["str_response_string"] = result.ToString();
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
#region Misc
|
|
|
|
|
|
/// <summary>
|
|
/// Extract the param from an uri.
|
|
/// </summary>
|
|
/// <param name="uri">Something like this: /agent/uuid/ or /agent/uuid/handle/release</param>
|
|
/// <param name="uri">uuid on uuid field</param>
|
|
/// <param name="action">optional action</param>
|
|
public static bool GetParams(string uri, out UUID uuid, out ulong regionHandle, out string action)
|
|
{
|
|
uuid = UUID.Zero;
|
|
action = "";
|
|
regionHandle = 0;
|
|
|
|
uri = uri.Trim(new char[] { '/' });
|
|
string[] parts = uri.Split('/');
|
|
if (parts.Length <= 1)
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
if (!UUID.TryParse(parts[1], out uuid))
|
|
return false;
|
|
|
|
if (parts.Length >= 3)
|
|
UInt64.TryParse(parts[2], out regionHandle);
|
|
if (parts.Length >= 4)
|
|
action = parts[3];
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public static bool GetAuthentication(Hashtable request, out string authority, out string authKey)
|
|
{
|
|
authority = string.Empty;
|
|
authKey = string.Empty;
|
|
|
|
Uri authUri;
|
|
Hashtable headers = (Hashtable)request["headers"];
|
|
|
|
// Authorization keys look like this:
|
|
// http://orgrid.org:8002/<uuid>
|
|
if (headers.ContainsKey("authorization") && (string)headers["authorization"] != "None")
|
|
{
|
|
if (Uri.TryCreate((string)headers["authorization"], UriKind.Absolute, out authUri))
|
|
{
|
|
authority = authUri.Authority;
|
|
authKey = authUri.PathAndQuery.Trim('/');
|
|
m_log.DebugFormat("[REST COMMS]: Got authority {0} and key {1}", authority, authKey);
|
|
return true;
|
|
}
|
|
else
|
|
m_log.Debug("[REST COMMS]: Wrong format for Authorization header: " + (string)headers["authorization"]);
|
|
}
|
|
else
|
|
m_log.Debug("[REST COMMS]: Authorization header not found");
|
|
|
|
return false;
|
|
}
|
|
|
|
bool VerifyKey(UUID userID, string authority, string key)
|
|
{
|
|
string[] parts = authority.Split(':');
|
|
IPAddress ipaddr = IPAddress.None;
|
|
uint port = 0;
|
|
if (parts.Length <= 2)
|
|
ipaddr = Util.GetHostFromDNS(parts[0]);
|
|
if (parts.Length == 2)
|
|
UInt32.TryParse(parts[1], out port);
|
|
|
|
// local authority (standalone), local call
|
|
if (m_thisIP.Equals(ipaddr) && (m_aScene.RegionInfo.HttpPort == port))
|
|
return ((IAuthentication)m_aScene.CommsManager.UserAdminService).VerifyKey(userID, key);
|
|
// remote call
|
|
else
|
|
return AuthClient.VerifyKey("http://" + authority, userID, key);
|
|
}
|
|
|
|
|
|
#endregion Misc
|
|
|
|
protected class RegionToRegionClient : RegionClient
|
|
{
|
|
Scene m_aScene = null;
|
|
|
|
public RegionToRegionClient(Scene s)
|
|
{
|
|
m_aScene = s;
|
|
}
|
|
|
|
public override ulong GetRegionHandle(ulong handle)
|
|
{
|
|
if (m_aScene.SceneGridService is HGSceneCommunicationService)
|
|
return ((HGSceneCommunicationService)(m_aScene.SceneGridService)).m_hg.FindRegionHandle(handle);
|
|
|
|
return handle;
|
|
}
|
|
|
|
public override bool IsHyperlink(ulong handle)
|
|
{
|
|
if (m_aScene.SceneGridService is HGSceneCommunicationService)
|
|
return ((HGSceneCommunicationService)(m_aScene.SceneGridService)).m_hg.IsHyperlinkRegion(handle);
|
|
|
|
return false;
|
|
}
|
|
|
|
public override void SendUserInformation(RegionInfo regInfo, AgentCircuitData aCircuit)
|
|
{
|
|
try
|
|
{
|
|
if (m_aScene.SceneGridService is HGSceneCommunicationService)
|
|
{
|
|
((HGSceneCommunicationService)(m_aScene.SceneGridService)).m_hg.SendUserInformation(regInfo, aCircuit);
|
|
}
|
|
}
|
|
catch // Bad cast
|
|
{ }
|
|
|
|
}
|
|
|
|
public override void AdjustUserInformation(AgentCircuitData aCircuit)
|
|
{
|
|
if (m_aScene.SceneGridService is HGSceneCommunicationService)
|
|
((HGSceneCommunicationService)(m_aScene.SceneGridService)).m_hg.AdjustUserInformation(aCircuit);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|