1 files changed, 626 insertions, 0 deletions

diff --git a/OpenSim/Region/Environment/Modules/Avatar/InstantMessage/MessageTransferModule.cs b/OpenSim/Region/Environment/Modules/Avatar/InstantMessage/MessageTransferModule.cs
new file mode 100644
index 0000000..d1543a0
--- /dev/null
+++ b/OpenSim/Region/Environment/Modules/Avatar/InstantMessage/MessageTransferModule.cs
@@ -0,0 +1,626 @@
+/*
+ * 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.Collections.Generic;
+using System.Reflection;
+using System.Net;
+using System.Threading;
+using OpenMetaverse;
+using log4net;
+using Nini.Config;
+using Nwc.XmlRpc;
+using OpenSim.Framework;
+using OpenSim.Framework.Client;
+using OpenSim.Region.Interfaces;
+using OpenSim.Region.Environment.Interfaces;
+using OpenSim.Region.Environment.Scenes;
+
+namespace OpenSim.Region.Environment.Modules.Avatar.InstantMessage
+{
+    public class MessageTransferModule : IRegionModule, IMessageTransferModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private bool m_Enabled = false;
+        private bool m_Gridmode = false;
+        private List<Scene> m_Scenes = new List<Scene>();
+        private Dictionary<UUID, ulong> m_UserRegionMap = new Dictionary<UUID, ulong>();
+
+        public void Initialise(Scene scene, IConfigSource config)
+        {
+            if (config.Configs["Messaging"] != null)
+            {
+                IConfig cnf = config.Configs["Messaging"];
+                if (cnf == null || cnf.GetString(
+                        "MessageTransferModule", "MessageTransferModule") !=
+                        "MessageTransferModule")
+                    return;
+
+                cnf = config.Configs["Startup"];
+                if (cnf != null)
+                    m_Gridmode = cnf.GetBoolean("m_Gridmode", false);
+
+                m_Enabled = true;
+            }
+
+            lock (m_Scenes)
+            {
+                if (m_Scenes.Count == 0)
+                {
+                    scene.AddXmlRPCHandler("grid_instant_message", processXMLRPCGridInstantMessage);
+                    scene.RegisterModuleInterface<IMessageTransferModule>(this);
+                }
+
+                m_Scenes.Add(scene);
+            }
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public void Close()
+        {
+        }
+
+        public string Name
+        {
+            get { return "MessageTransferModule"; }
+        }
+
+        public bool IsSharedModule
+        {
+            get { return true; }
+        }
+
+        public void SendInstantMessage(GridInstantMessage im, MessageResultNotification result)
+        {
+            UUID toAgentID = new UUID(im.toAgentID);
+
+            m_log.DebugFormat("[INSTANT MESSAGE]: Attempting delivery of IM fromn {0} to {1}", im.fromAgentName, toAgentID.ToString());
+
+            // Try root avatar only first
+            foreach (Scene scene in m_Scenes)
+            {
+                if (scene.Entities.ContainsKey(toAgentID) &&
+                        scene.Entities[toAgentID] is ScenePresence)
+                {
+                    m_log.DebugFormat("[INSTANT MESSAGE]: Looking for {0} in {1}", toAgentID.ToString(), scene.RegionInfo.RegionName);
+                    // Local message
+                    ScenePresence user = (ScenePresence) scene.Entities[toAgentID];
+                    if (!user.IsChildAgent)
+                    {
+                        m_log.DebugFormat("[INSTANT MESSAGE]: Delivering to client");
+                        user.ControllingClient.SendInstantMessage(
+                                new UUID(im.fromAgentID),
+                                im.message,
+                                new UUID(im.toAgentID),
+                                im.fromAgentName,
+                                im.dialog,
+                                im.timestamp,
+                                new UUID(im.imSessionID),
+                                im.fromGroup,
+                                im.binaryBucket);
+                        // Message sent
+                        result(true);
+                        return;
+                    }
+                }
+            }
+
+            // try child avatar second
+            foreach (Scene scene in m_Scenes)
+            {
+                m_log.DebugFormat("[INSTANT MESSAGE]: Looking for child of {0} in {1}", toAgentID.ToString(), scene.RegionInfo.RegionName);
+
+                if (scene.Entities.ContainsKey(toAgentID) &&
+                        scene.Entities[toAgentID] is ScenePresence)
+                {
+                    // Local message
+                    ScenePresence user = (ScenePresence) scene.Entities[toAgentID];
+
+                    m_log.DebugFormat("[INSTANT MESSAGE]: Delivering to client");
+                    user.ControllingClient.SendInstantMessage(
+                            new UUID(im.fromAgentID),
+                            im.message,
+                            new UUID(im.toAgentID),
+                            im.fromAgentName,
+                            im.dialog,
+                            im.timestamp,
+                            new UUID(im.imSessionID),
+                            im.fromGroup,
+                            im.binaryBucket);
+                    // Message sent
+                    result(true);
+                    return;
+                }
+            }
+
+            if (m_Gridmode)
+            {
+                m_log.DebugFormat("[INSTANT MESSAGE]: Delivering via grid");
+                // Still here, try send via Grid
+                SendGridInstantMessageViaXMLRPC(im, result);
+                return;
+            }
+
+            m_log.DebugFormat("[INSTANT MESSAGE]: Undeliverable");
+            result(false);
+            return;
+        }
+
+        /// <summary>
+        /// Process a XMLRPC Grid Instant Message
+        /// </summary>
+        /// <param name="request">XMLRPC parameters
+        /// </param>
+        /// <returns>Nothing much</returns>
+        protected virtual XmlRpcResponse processXMLRPCGridInstantMessage(XmlRpcRequest request)
+        {
+            bool successful = false;
+            // various rational defaults
+            UUID fromAgentID = UUID.Zero;
+            UUID fromAgentSession = UUID.Zero;
+            UUID toAgentID = UUID.Zero;
+            UUID imSessionID = UUID.Zero;
+            uint timestamp = 0;
+            string fromAgentName = "";
+            string message = "";
+            byte dialog = (byte)0;
+            bool fromGroup = false;
+            byte offline = (byte)0;
+            uint ParentEstateID=0;
+            Vector3 Position = Vector3.Zero;
+            UUID RegionID = UUID.Zero ;
+            byte[] binaryBucket = new byte[0];
+
+            float pos_x = 0;
+            float pos_y = 0;
+            float pos_z = 0;
+            //m_log.Info("Processing IM");
+
+
+            Hashtable requestData = (Hashtable)request.Params[0];
+            // Check if it's got all the data
+            if (requestData.ContainsKey("from_agent_id") && requestData.ContainsKey("from_agent_session")
+                    && requestData.ContainsKey("to_agent_id") && requestData.ContainsKey("im_session_id")
+                    && requestData.ContainsKey("timestamp") && requestData.ContainsKey("from_agent_name")
+                    && requestData.ContainsKey("message") && requestData.ContainsKey("dialog")
+                    && requestData.ContainsKey("from_group")
+                    && requestData.ContainsKey("offline") && requestData.ContainsKey("parent_estate_id")
+                    && requestData.ContainsKey("position_x") && requestData.ContainsKey("position_y")
+                    && requestData.ContainsKey("position_z") && requestData.ContainsKey("region_id")
+                    && requestData.ContainsKey("binary_bucket"))
+            {
+                // Do the easy way of validating the UUIDs
+                UUID.TryParse((string)requestData["from_agent_id"], out fromAgentID);
+                UUID.TryParse((string)requestData["from_agent_session"], out fromAgentSession);
+                UUID.TryParse((string)requestData["to_agent_id"], out toAgentID);
+                UUID.TryParse((string)requestData["im_session_id"], out imSessionID);
+                UUID.TryParse((string)requestData["region_id"], out RegionID);
+
+                try
+                {
+                    timestamp = (uint)Convert.ToInt32((string)requestData["timestamp"]);
+                }
+                catch (ArgumentException)
+                {
+                }
+                catch (FormatException)
+                {
+                }
+                catch (OverflowException)
+                {
+                }
+
+                fromAgentName = (string)requestData["from_agent_name"];
+                message = (string)requestData["message"];
+
+                // Bytes don't transfer well over XMLRPC, so, we Base64 Encode them.
+                string requestData1 = (string)requestData["dialog"];
+                if (string.IsNullOrEmpty(requestData1))
+                {
+                    dialog = 0;
+                }
+                else
+                {
+                    byte[] dialogdata = Convert.FromBase64String(requestData1);
+                    dialog = dialogdata[0];
+                }
+
+                if ((string)requestData["from_group"] == "TRUE")
+                    fromGroup = true;
+
+                string requestData2 = (string)requestData["offline"];
+                if (String.IsNullOrEmpty(requestData2))
+                {
+                    offline = 0;
+                }
+                else
+                {
+                    byte[] offlinedata = Convert.FromBase64String(requestData2);
+                    offline = offlinedata[0];
+                }
+
+                try
+                {
+                    ParentEstateID = (uint)Convert.ToInt32((string)requestData["parent_estate_id"]);
+                }
+                catch (ArgumentException)
+                {
+                }
+                catch (FormatException)
+                {
+                }
+                catch (OverflowException)
+                {
+                }
+
+                try
+                {
+                    pos_x = (uint)Convert.ToInt32((string)requestData["position_x"]);
+                }
+                catch (ArgumentException)
+                {
+                }
+                catch (FormatException)
+                {
+                }
+                catch (OverflowException)
+                {
+                }
+                try
+                {
+                    pos_y = (uint)Convert.ToInt32((string)requestData["position_y"]);
+                }
+                catch (ArgumentException)
+                {
+                }
+                catch (FormatException)
+                {
+                }
+                catch (OverflowException)
+                {
+                }
+                try
+                {
+                    pos_z = (uint)Convert.ToInt32((string)requestData["position_z"]);
+                }
+                catch (ArgumentException)
+                {
+                }
+                catch (FormatException)
+                {
+                }
+                catch (OverflowException)
+                {
+                }
+
+                Position = new Vector3(pos_x, pos_y, pos_z);
+
+                string requestData3 = (string)requestData["binary_bucket"];
+                if (string.IsNullOrEmpty(requestData3))
+                {
+                    binaryBucket = new byte[0];
+                }
+                else
+                {
+                    binaryBucket = Convert.FromBase64String(requestData3);
+                }
+
+                // Create a New GridInstantMessageObject the the data
+                GridInstantMessage gim = new GridInstantMessage();
+                gim.fromAgentID = fromAgentID.Guid;
+                gim.fromAgentName = fromAgentName;
+                gim.fromAgentSession = fromAgentSession.Guid;
+                gim.fromGroup = fromGroup;
+                gim.imSessionID = imSessionID.Guid;
+                gim.RegionID = RegionID.Guid;
+                gim.timestamp = timestamp;
+                gim.toAgentID = toAgentID.Guid;
+                gim.message = message;
+                gim.dialog = dialog;
+                gim.offline = offline;
+                gim.ParentEstateID = ParentEstateID;
+                gim.Position = Position;
+                gim.binaryBucket = binaryBucket;
+
+
+                // Trigger the Instant message in the scene.
+                foreach (Scene scene in m_Scenes)
+                {
+                    if (scene.Entities.ContainsKey(toAgentID) &&
+                            scene.Entities[toAgentID] is ScenePresence)
+                    {
+                        ScenePresence user =
+                                (ScenePresence)scene.Entities[toAgentID];
+
+                        if (!user.IsChildAgent)
+                        {
+                            scene.EventManager.TriggerIncomingInstantMessage(gim);
+                            successful = true;
+                        }
+                    }
+                }
+                if (!successful)
+                {
+                    // If the message can't be delivered to an agent, it
+                    // is likely to be a group IM. On a group IM, the
+                    // imSessionID = toAgentID = group id. Raise the
+                    // unhandled IM event to give the groups module
+                    // a chance to pick it up. We raise that in a random
+                    // scene, since the groups module is shared.
+                    //
+                    m_Scenes[0].EventManager.TriggerUnhandledInstantMessage(gim);
+                }
+            }
+
+            //Send response back to region calling if it was successful
+            // calling region uses this to know when to look up a user's location again.
+            XmlRpcResponse resp = new XmlRpcResponse();
+            Hashtable respdata = new Hashtable();
+            if (successful)
+                respdata["success"] = "TRUE";
+            else
+                respdata["success"] = "FALSE";
+            resp.Value = respdata;
+
+            return resp;
+        }
+
+        /// <summary>
+        /// delegate for sending a grid instant message asynchronously
+        /// </summary>
+        public delegate void GridInstantMessageDelegate(GridInstantMessage im, MessageResultNotification result, ulong prevRegionHandle);
+
+        private void GridInstantMessageCompleted(IAsyncResult iar)
+        {
+            GridInstantMessageDelegate icon =
+                    (GridInstantMessageDelegate)iar.AsyncState;
+            icon.EndInvoke(iar);
+        }
+
+
+        protected virtual void SendGridInstantMessageViaXMLRPC(GridInstantMessage im, MessageResultNotification result)
+        {
+            GridInstantMessageDelegate d = SendGridInstantMessageViaXMLRPCAsync;
+
+            d.BeginInvoke(im, result, 0, GridInstantMessageCompleted, d);
+        }
+
+        /// <summary>
+        /// Recursive SendGridInstantMessage over XMLRPC method.
+        /// </summary>
+        /// <param name="prevRegionHandle"></param>
+        protected virtual void SendGridInstantMessageViaXMLRPCAsync(GridInstantMessage im, MessageResultNotification result, ulong prevRegionHandle)
+        {
+            UUID toAgentID = new UUID(im.toAgentID);
+
+            UserAgentData  upd = null;
+
+            bool lookupAgent = false;
+
+            lock (m_UserRegionMap)
+            {
+                if (m_UserRegionMap.ContainsKey(toAgentID))
+                {
+                    upd = new UserAgentData();
+                    upd.AgentOnline = true;
+                    upd.Handle = m_UserRegionMap[toAgentID];
+                }
+                else
+                {
+                    lookupAgent = true;
+                }
+            }
+
+            // Are we needing to look-up an agent?
+            if (lookupAgent)
+            {
+                // Non-cached user agent lookup.
+                upd = m_Scenes[0].CommsManager.UserService.GetAgentByUUID(toAgentID);
+
+                if (upd != null)
+                {
+                    // check if we've tried this before..
+                    // This is one way to end the recursive loop
+                    //
+                    if (upd.Handle == prevRegionHandle)
+                    {
+                        m_log.Error("[GRID INSTANT MESSAGE]: Unable to deliver an instant message");
+                        result(false);
+                        return;
+                    }
+                }
+                else
+                {
+                    m_log.Error("[GRID INSTANT MESSAGE]: Unable to deliver an instant message");
+                    result(false);
+                    return;
+                }
+            }
+
+            if (upd != null)
+            {
+                if (upd.AgentOnline)
+                {
+                    RegionInfo reginfo = m_Scenes[0].SceneGridService.RequestNeighbouringRegionInfo(upd.Handle);
+                    if (reginfo != null)
+                    {
+                        Hashtable msgdata = ConvertGridInstantMessageToXMLRPC(im);
+                        // Not actually used anymore, left in for compatibility
+                        // Remove at next interface change
+                        //
+                        msgdata["region_handle"] = 0;
+                        bool imresult = doIMSending(reginfo, msgdata);
+                        if (imresult)
+                        {
+                            // IM delivery successful, so store the Agent's location in our local cache.
+                            lock (m_UserRegionMap)
+                            {
+                                if (m_UserRegionMap.ContainsKey(toAgentID))
+                                {
+                                    m_UserRegionMap[toAgentID] = upd.Handle;
+                                }
+                                else
+                                {
+                                    m_UserRegionMap.Add(toAgentID, upd.Handle);
+                                }
+                            }
+                            result(true);
+                        }
+                        else
+                        {
+                            // try again, but lookup user this time.
+                            // Warning, this must call the Async version
+                            // of this method or we'll be making thousands of threads
+                            // The version within the spawned thread is SendGridInstantMessageViaXMLRPCAsync
+                            // The version that spawns the thread is SendGridInstantMessageViaXMLRPC
+
+                            // This is recursive!!!!!
+                            SendGridInstantMessageViaXMLRPCAsync(im, result,
+                                    upd.Handle);
+                        }
+
+                    }
+                }
+                else
+                {
+                    result(false);
+                }
+            }
+            else
+            {
+                result(false);
+            }
+
+        }
+
+        /// <summary>
+        /// This actually does the XMLRPC Request
+        /// </summary>
+        /// <param name="reginfo">RegionInfo we pull the data out of to send the request to</param>
+        /// <param name="xmlrpcdata">The Instant Message data Hashtable</param>
+        /// <returns>Bool if the message was successfully delivered at the other side.</returns>
+        private bool doIMSending(RegionInfo reginfo, Hashtable xmlrpcdata)
+        {
+
+            ArrayList SendParams = new ArrayList();
+            SendParams.Add(xmlrpcdata);
+            XmlRpcRequest GridReq = new XmlRpcRequest("grid_instant_message", SendParams);
+            try
+            {
+
+                XmlRpcResponse GridResp = GridReq.Send("http://" + reginfo.ExternalHostName + ":" + reginfo.HttpPort, 3000);
+
+                Hashtable responseData = (Hashtable)GridResp.Value;
+
+                if (responseData.ContainsKey("success"))
+                {
+                    if ((string)responseData["success"] == "TRUE")
+                    {
+                        return true;
+                    }
+                    else
+                    {
+                        return false;
+                    }
+                }
+                else
+                {
+                    return false;
+                }
+            }
+            catch (WebException e)
+            {
+                m_log.ErrorFormat("[GRID INSTANT MESSAGE]: Error sending message to http://{0}:{1} the host didn't respond ({2})", 
+                                  reginfo.ExternalHostName, reginfo.HttpPort, e.Message);
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Get ulong region handle for region by it's Region UUID.
+        /// We use region handles over grid comms because there's all sorts of free and cool caching.
+        /// </summary>
+        /// <param name="regionID">UUID of region to get the region handle for</param>
+        /// <returns></returns>
+        private ulong getLocalRegionHandleFromUUID(UUID regionID)
+        {
+            ulong returnhandle = 0;
+
+            lock (m_Scenes)
+            {
+                foreach (Scene sn in m_Scenes)
+                {
+                    if (sn.RegionInfo.RegionID == regionID)
+                    {
+                        returnhandle = sn.RegionInfo.RegionHandle;
+                        break;
+                    }
+                }
+            }
+            return returnhandle;
+        }
+
+        /// <summary>
+        /// Takes a GridInstantMessage and converts it into a Hashtable for XMLRPC
+        /// </summary>
+        /// <param name="msg">The GridInstantMessage object</param>
+        /// <returns>Hashtable containing the XMLRPC request</returns>
+        private Hashtable ConvertGridInstantMessageToXMLRPC(GridInstantMessage msg)
+        {
+            Hashtable gim = new Hashtable();
+            gim["from_agent_id"] = msg.fromAgentID.ToString();
+            gim["from_agent_session"] = msg.fromAgentSession.ToString();
+            gim["to_agent_id"] = msg.toAgentID.ToString();
+            gim["im_session_id"] = msg.imSessionID.ToString();
+            gim["timestamp"] = msg.timestamp.ToString();
+            gim["from_agent_name"] = msg.fromAgentName;
+            gim["message"] = msg.message;
+            byte[] dialogdata = new byte[1];dialogdata[0] = msg.dialog;
+            gim["dialog"] = Convert.ToBase64String(dialogdata,Base64FormattingOptions.None);
+
+            if (msg.fromGroup)
+                gim["from_group"] = "TRUE";
+            else
+                gim["from_group"] = "FALSE";
+            byte[] offlinedata = new byte[1]; offlinedata[0] = msg.offline;
+            gim["offline"] = Convert.ToBase64String(offlinedata, Base64FormattingOptions.None);
+            gim["parent_estate_id"] = msg.ParentEstateID.ToString();
+            gim["position_x"] = msg.Position.X.ToString();
+            gim["position_y"] = msg.Position.Y.ToString();
+            gim["position_z"] = msg.Position.Z.ToString();
+            gim["region_id"] = msg.RegionID.ToString();
+            gim["binary_bucket"] = Convert.ToBase64String(msg.binaryBucket,Base64FormattingOptions.None);
+            return gim;
+        }
+
+    }
+}