Merge branch 'master' of ssh://opensimulator.org/var/git/opensim

1 files changed, 408 insertions, 0 deletions

diff --git a/OpenSim/Services/HypergridService/HGFriendsService.cs b/OpenSim/Services/HypergridService/HGFriendsService.cs
new file mode 100644
index 0000000..39524ab
--- /dev/null
+++ b/OpenSim/Services/HypergridService/HGFriendsService.cs
@@ -0,0 +1,408 @@
+/*
+ * 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.Generic;
+using System.Net;
+using System.Reflection;
+
+using OpenSim.Framework;
+using OpenSim.Services.Connectors.Friends;
+using OpenSim.Services.Connectors.Hypergrid;
+using OpenSim.Services.Interfaces;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+using OpenSim.Server.Base;
+using FriendInfo = OpenSim.Services.Interfaces.FriendInfo;
+
+using OpenMetaverse;
+using log4net;
+using Nini.Config;
+
+namespace OpenSim.Services.HypergridService
+{
+    /// <summary>
+    /// W2W social networking
+    /// </summary>
+    public class HGFriendsService : IHGFriendsService
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        static bool m_Initialized = false;
+
+        protected static IGridUserService m_GridUserService;
+        protected static IGridService m_GridService;
+        protected static IGatekeeperService m_GatekeeperService;
+        protected static IFriendsService m_FriendsService;
+        protected static IPresenceService m_PresenceService;
+        protected static IUserAccountService m_UserAccountService;
+        protected static IFriendsSimConnector m_FriendsLocalSimConnector; // standalone, points to HGFriendsModule
+        protected static FriendsSimConnector m_FriendsSimConnector; // grid
+
+        private static string m_ConfigName = "HGFriendsService";
+
+        public HGFriendsService(IConfigSource config, String configName, IFriendsSimConnector localSimConn)
+        {
+            if (m_FriendsLocalSimConnector == null)
+                m_FriendsLocalSimConnector = localSimConn;
+
+            if (!m_Initialized)
+            {
+                m_Initialized = true;
+
+                if (configName != String.Empty)
+                    m_ConfigName = configName;
+
+                Object[] args = new Object[] { config };
+
+                IConfig serverConfig = config.Configs[m_ConfigName];
+                if (serverConfig == null)
+                    throw new Exception(String.Format("No section {0} in config file", m_ConfigName));
+
+                string theService = serverConfig.GetString("FriendsService", string.Empty);
+                if (theService == String.Empty)
+                    throw new Exception("No FriendsService in config file " + m_ConfigName);
+                m_FriendsService = ServerUtils.LoadPlugin<IFriendsService>(theService, args);
+
+                theService = serverConfig.GetString("UserAccountService", string.Empty);
+                if (theService == String.Empty)
+                    throw new Exception("No UserAccountService in " + m_ConfigName);
+                m_UserAccountService = ServerUtils.LoadPlugin<IUserAccountService>(theService, args);
+
+                theService = serverConfig.GetString("GridService", string.Empty);
+                if (theService == String.Empty)
+                    throw new Exception("No GridService in " + m_ConfigName);
+                m_GridService = ServerUtils.LoadPlugin<IGridService>(theService, args);
+
+                theService = serverConfig.GetString("PresenceService", string.Empty);
+                if (theService == String.Empty)
+                    throw new Exception("No PresenceService in " + m_ConfigName);
+                m_PresenceService = ServerUtils.LoadPlugin<IPresenceService>(theService, args);
+
+                m_FriendsSimConnector = new FriendsSimConnector();
+
+                m_log.DebugFormat("[HGFRIENDS SERVICE]: Starting...");
+
+            }
+        }
+
+        #region IHGFriendsService
+
+        public int GetFriendPerms(UUID userID, UUID friendID)
+        {
+            FriendInfo[] friendsInfo = m_FriendsService.GetFriends(userID);
+            foreach (FriendInfo finfo in friendsInfo)
+            {
+                if (finfo.Friend.StartsWith(friendID.ToString()))
+                    return finfo.TheirFlags;
+            }
+            return -1;
+        }
+
+        public bool NewFriendship(FriendInfo friend, bool verified)
+        {
+            UUID friendID;
+            string tmp = string.Empty, url = String.Empty, first = String.Empty, last = String.Empty;
+            if (!Util.ParseUniversalUserIdentifier(friend.Friend, out friendID, out url, out first, out last, out tmp))
+                return false;
+
+            m_log.DebugFormat("[HGFRIENDS SERVICE]: New friendship {0} {1} ({2})", friend.PrincipalID, friend.Friend, verified);
+
+            // Does the friendship already exist?
+            FriendInfo[] finfos = m_FriendsService.GetFriends(friend.PrincipalID);
+            foreach (FriendInfo finfo in finfos)
+            {
+                if (finfo.Friend.StartsWith(friendID.ToString()))
+                    return false;
+            }
+            // Verified user session. But the user needs to confirm friendship when he gets home
+            if (verified)
+                return m_FriendsService.StoreFriend(friend.PrincipalID.ToString(), friend.Friend, 0);
+
+            // Does the reverted friendship exist? meaning that this user initiated the request
+            finfos = m_FriendsService.GetFriends(friendID);
+            bool userInitiatedOffer = false;
+            foreach (FriendInfo finfo in finfos)
+            {
+                if (friend.Friend.StartsWith(finfo.PrincipalID.ToString()) && finfo.Friend.StartsWith(friend.PrincipalID.ToString()) && finfo.TheirFlags == -1)
+                {
+                    userInitiatedOffer = true;
+                    // Let's delete the existing friendship relations that was stored
+                    m_FriendsService.Delete(friendID, finfo.Friend);
+                    break;
+                }
+            }
+
+            if (userInitiatedOffer)
+            {
+                m_FriendsService.StoreFriend(friend.PrincipalID.ToString(), friend.Friend, 1);
+                m_FriendsService.StoreFriend(friend.Friend, friend.PrincipalID.ToString(), 1);
+                // notify the user
+                ForwardToSim("ApproveFriendshipRequest", friendID, Util.UniversalName(first, last, url), "", friend.PrincipalID, "");
+                return true;
+            }
+            return false;
+        }
+
+        public bool DeleteFriendship(FriendInfo friend, string secret)
+        {
+            FriendInfo[] finfos = m_FriendsService.GetFriends(friend.PrincipalID);
+            foreach (FriendInfo finfo in finfos)
+            {
+                // We check the secret here. Or if the friendship request was initiated here, and was declined
+                if (finfo.Friend.StartsWith(friend.Friend) && finfo.Friend.EndsWith(secret))
+                {
+                    m_log.DebugFormat("[HGFRIENDS SERVICE]: Delete friendship {0} {1}", friend.PrincipalID, friend.Friend);
+                    m_FriendsService.Delete(friend.PrincipalID, finfo.Friend);
+                    m_FriendsService.Delete(finfo.Friend, friend.PrincipalID.ToString());
+
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        public bool FriendshipOffered(UUID fromID, string fromName, UUID toID, string message)
+        {
+            UserAccount account = m_UserAccountService.GetUserAccount(UUID.Zero, toID);
+            if (account == null)
+                return false;
+
+            // OK, we have that user here.
+            // So let's send back the call, but start a thread to continue
+            // with the verification and the actual action.
+
+            Util.FireAndForget(delegate { ProcessFriendshipOffered(fromID, fromName, toID, message); });
+
+            return true;
+        }
+
+        public bool ValidateFriendshipOffered(UUID fromID, UUID toID)
+        {
+            FriendInfo[] finfos = m_FriendsService.GetFriends(toID.ToString());
+            foreach (FriendInfo fi in finfos)
+            {
+                if (fi.Friend.StartsWith(fromID.ToString()) && fi.TheirFlags == -1)
+                    return true;
+            }
+            return false;
+        }
+
+        public List<UUID> StatusNotification(List<string> friends, UUID foreignUserID, bool online)
+        {
+            if (m_FriendsService == null || m_PresenceService == null)
+            {
+                m_log.WarnFormat("[HGFRIENDS SERVICE]: Unable to perform status notifications because friends or presence services are missing");
+                return new List<UUID>();
+            }
+
+            // Let's unblock the caller right now, and take it from here async
+
+            List<UUID> localFriendsOnline = new List<UUID>();
+
+            m_log.DebugFormat("[HGFRIENDS SERVICE]: Status notification: foreign user {0} wants to notify {1} local friends of {2} status", 
+                foreignUserID, friends.Count, (online ? "online" : "offline"));
+
+            // First, let's double check that the reported friends are, indeed, friends of that user
+            // And let's check that the secret matches
+            List<string> usersToBeNotified = new List<string>();
+            foreach (string uui in friends)
+            {
+                UUID localUserID;
+                string secret = string.Empty, tmp = string.Empty;
+                if (Util.ParseUniversalUserIdentifier(uui, out localUserID, out tmp, out tmp, out tmp, out secret))
+                {
+                    FriendInfo[] friendInfos = m_FriendsService.GetFriends(localUserID);
+                    foreach (FriendInfo finfo in friendInfos)
+                    {
+                        if (finfo.Friend.StartsWith(foreignUserID.ToString()) && finfo.Friend.EndsWith(secret))
+                        {
+                            // great!
+                            usersToBeNotified.Add(localUserID.ToString());
+                        }
+                    }
+                }
+            }
+
+            // Now, let's send the notifications
+            //m_log.DebugFormat("[HGFRIENDS SERVICE]: Status notification: user has {0} local friends", usersToBeNotified.Count);
+
+            // First, let's send notifications to local users who are online in the home grid
+            PresenceInfo[] friendSessions = m_PresenceService.GetAgents(usersToBeNotified.ToArray());
+            if (friendSessions != null && friendSessions.Length > 0)
+            {
+                PresenceInfo friendSession = null;
+                foreach (PresenceInfo pinfo in friendSessions)
+                    if (pinfo.RegionID != UUID.Zero) // let's guard against traveling agents
+                    {
+                        friendSession = pinfo;
+                        break;
+                    }
+
+                if (friendSession != null)
+                {
+                    ForwardStatusNotificationToSim(friendSession.RegionID, foreignUserID, friendSession.UserID, online);
+                    usersToBeNotified.Remove(friendSession.UserID.ToString());
+                    UUID id;
+                    if (UUID.TryParse(friendSession.UserID, out id))
+                        localFriendsOnline.Add(id);
+
+                }
+            }
+
+            // Lastly, let's notify the rest who may be online somewhere else
+            foreach (string user in usersToBeNotified)
+            {
+                UUID id = new UUID(user);
+                //m_UserAgentService.LocateUser(id);
+                //etc...
+                //if (m_TravelingAgents.ContainsKey(id) && m_TravelingAgents[id].GridExternalName != m_GridName)
+                //{
+                //    string url = m_TravelingAgents[id].GridExternalName;
+                //    // forward
+                //}
+                //m_log.WarnFormat("[HGFRIENDS SERVICE]: User {0} is visiting another grid. HG Status notifications still not implemented.", user);
+            }
+
+            // and finally, let's send the online friends
+            if (online)
+            {
+                return localFriendsOnline;
+            }
+            else
+                return new List<UUID>();
+        }
+
+        #endregion IHGFriendsService
+
+        #region Aux
+
+        private void ProcessFriendshipOffered(UUID fromID, String fromName, UUID toID, String message)
+        {
+            // Great, it's a genuine request. Let's proceed.
+            // But now we need to confirm that the requester is who he says he is
+            // before we act on the friendship request.
+
+            if (!fromName.Contains("@"))
+                return;
+
+            string[] parts = fromName.Split(new char[] {'@'});
+            if (parts.Length != 2)
+                return;
+
+            string uriStr = "http://" + parts[1];
+            try
+            {
+                new Uri(uriStr);
+            }
+            catch (UriFormatException)
+            {
+                return;
+            }
+
+            UserAgentServiceConnector uasConn = new UserAgentServiceConnector(uriStr);
+            Dictionary<string, object> servers = uasConn.GetServerURLs(fromID);
+            if (!servers.ContainsKey("FriendsServerURI"))
+                return;
+
+            HGFriendsServicesConnector friendsConn = new HGFriendsServicesConnector(servers["FriendsServerURI"].ToString());
+            if (!friendsConn.ValidateFriendshipOffered(fromID, toID))
+            {
+                m_log.WarnFormat("[HGFRIENDS SERVICE]: Friendship request from {0} to {1} is invalid. Impersonations?", fromID, toID);
+                return;
+            }
+
+            string fromUUI = Util.UniversalIdentifier(fromID, parts[0], "@" + parts[1], uriStr);
+            // OK, we're good!
+            ForwardToSim("FriendshipOffered", fromID, fromName, fromUUI, toID, message);
+        }
+
+        private bool ForwardToSim(string op, UUID fromID, string name, String fromUUI, UUID toID, string message)
+        {
+            PresenceInfo session = null;
+            GridRegion region = null;
+            PresenceInfo[] sessions = m_PresenceService.GetAgents(new string[] { toID.ToString() });
+            if (sessions != null && sessions.Length > 0)
+                session = sessions[0];
+            if (session != null)
+                region = m_GridService.GetRegionByUUID(UUID.Zero, session.RegionID);
+
+            switch (op)
+            {
+                case "FriendshipOffered":
+                    // Let's store backwards
+                    string secret = UUID.Random().ToString().Substring(0, 8);
+                    m_FriendsService.StoreFriend(toID.ToString(), fromUUI + ";" + secret, 0);
+                    if (m_FriendsLocalSimConnector != null) // standalone
+                    {
+                        GridInstantMessage im = new GridInstantMessage(null, fromID, name, toID,
+                            (byte)InstantMessageDialog.FriendshipOffered, message, false, Vector3.Zero);
+                        // !! HACK
+                        im.imSessionID = im.fromAgentID;
+                        return m_FriendsLocalSimConnector.LocalFriendshipOffered(toID, im);
+                    }
+                    else if (region != null) // grid
+                        return m_FriendsSimConnector.FriendshipOffered(region, fromID, toID, message, name);
+                    break;
+                case "ApproveFriendshipRequest":
+                    if (m_FriendsLocalSimConnector != null) // standalone
+                        return m_FriendsLocalSimConnector.LocalFriendshipApproved(fromID, name, toID);
+                    else if (region != null) //grid
+                        return m_FriendsSimConnector.FriendshipApproved(region, fromID, name, toID);
+                    break;
+            }
+
+            return false;
+        }
+
+        protected void ForwardStatusNotificationToSim(UUID regionID, UUID foreignUserID, string user, bool online)
+        {
+            UUID userID;
+            if (UUID.TryParse(user, out userID))
+            {
+                if (m_FriendsLocalSimConnector != null)
+                {
+                    m_log.DebugFormat("[HGFRIENDS SERVICE]: Local Notify, user {0} is {1}", foreignUserID, (online ? "online" : "offline"));
+                    m_FriendsLocalSimConnector.StatusNotify(foreignUserID, userID, online);
+                }
+                else
+                {
+                    GridRegion region = m_GridService.GetRegionByUUID(UUID.Zero /* !!! */, regionID);
+                    if (region != null)
+                    {
+                        m_log.DebugFormat("[HGFRIENDS SERVICE]: Remote Notify to region {0}, user {1} is {2}", region.RegionName, foreignUserID, (online ? "online" : "offline"));
+                        m_FriendsSimConnector.StatusNotify(region, foreignUserID, userID, online);
+                    }
+                }
+            }
+        }
+
+        #endregion Aux
+    }
+}