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

.gitignore

@@ -9,6 +9,14 @@
 *.pdb
 *.pidb
 *.dll.build
+*.dll
+*.VisualState.xml
+*/*/obj
+*/*/*/obj
+*/*/*/*/obj
+*/*/*/*/*/obj
+*/*/*/*/*/*/obj
+*/*/*/*/*/*/*/obj
 */*/bin
 */*/*/bin
 */*/*/*/bin
@@ -45,6 +53,7 @@ bin/OpenSim.Grid.InventoryServer.log
 bin/OpenSim.Grid.MessagingServer.log
 bin/OpenSim.Grid.UserServer.log
 bin/OpenSim.log
+bin/*.manifest
 bin/crashes/
 Examples/*.dll
 OpenSim.build

OpenSim/Data/Migration.cs

@@ -53,8 +53,8 @@ namespace OpenSim.Data
     /// When a database driver starts up, it specifies a resource that
     /// needs to be brought up to the current revision.  For instance:
     ///
-    ///    Migration um = new Migration(Assembly, DbConnection, "Users");
+    ///    Migration um = new Migration(DbConnection, Assembly, "Users");
-    ///    um.Upgrade();
+    ///    um.Update();
     ///
     /// This works out which version Users is at, and applies all the
     /// revisions past it to it.  If there is no users table, all
@@ -110,10 +110,11 @@ namespace OpenSim.Data
                 return;
 
             // If not, create the migration tables
-            DbCommand cmd = _conn.CreateCommand();
+            using (DbCommand cmd = _conn.CreateCommand())
+            {
                 cmd.CommandText = _migrations_create;
                 cmd.ExecuteNonQuery();
-            cmd.Dispose();
+            }
 
             InsertVersion("migrations", 1);
         }
@@ -131,7 +132,8 @@ namespace OpenSim.Data
             m_log.InfoFormat("[MIGRATIONS] Upgrading {0} to latest revision {1}.", _type, migrations.Keys[migrations.Count - 1]);
             m_log.Info("[MIGRATIONS] NOTE: this may take a while, don't interupt this process!");
 
-            DbCommand cmd = _conn.CreateCommand();
+            using (DbCommand cmd = _conn.CreateCommand())
+            {
                 foreach (KeyValuePair<int, string> kvp in migrations)
                 {
                     int newversion = kvp.Key;
@@ -160,8 +162,7 @@ namespace OpenSim.Data
                     }
                     version = newversion;
                 }
-
+            }
-            cmd.Dispose();            
         }
 
         // private int MaxVersion()
@@ -200,7 +201,8 @@ namespace OpenSim.Data
         protected virtual int FindVersion(DbConnection conn, string type)
         {
             int version = 0;
-            DbCommand cmd = conn.CreateCommand();
+            using (DbCommand cmd = conn.CreateCommand())
+            {
                 try
                 {
                     cmd.CommandText = "select version from migrations where name='" + type + "' order by version desc";
@@ -217,26 +219,28 @@ namespace OpenSim.Data
                 {
                     // Something went wrong, so we're version 0
                 }
-            cmd.Dispose();
+            }
             return version;
         }
 
         private void InsertVersion(string type, int version)
         {
-            DbCommand cmd = _conn.CreateCommand();
+            using (DbCommand cmd = _conn.CreateCommand())
+            {
                 cmd.CommandText = "insert into migrations(name, version) values('" + type + "', " + version + ")";
                 m_log.InfoFormat("[MIGRATIONS]: Creating {0} at version {1}", type, version);
                 cmd.ExecuteNonQuery();
-            cmd.Dispose();
+            }
         }
 
         private void UpdateVersion(string type, int version)
         {
-            DbCommand cmd = _conn.CreateCommand();
+            using (DbCommand cmd = _conn.CreateCommand())
+            {
                 cmd.CommandText = "update migrations set version=" + version + " where name='" + type + "'";
                 m_log.InfoFormat("[MIGRATIONS]: Updating {0} to version {1}", type, version);
                 cmd.ExecuteNonQuery();
-            cmd.Dispose();
+            }
         }
 
         // private SortedList<int, string> GetAllMigrations()

OpenSim/Data/MySQL/MySQLInventoryData.cs

@@ -145,7 +145,7 @@ namespace OpenSim.Data.MySQL
         /// <summary>
         /// Returns a list of the root folders within a users inventory
         /// </summary>
-        /// <param name="user">The user whos inventory is to be searched</param>
+        /// <param name="user">The user whose inventory is to be searched</param>
         /// <returns>A list of folder objects</returns>
         public List<InventoryFolderBase> getUserRootFolders(UUID user)
         {
@@ -284,7 +284,7 @@ namespace OpenSim.Data.MySQL
             {
                 InventoryItemBase item = new InventoryItemBase();
 
-                // TODO: this is to handle a case where NULLs creep in there, which we are not sure is indemic to the system, or legacy.  It would be nice to live fix these.
+                // TODO: this is to handle a case where NULLs creep in there, which we are not sure is endemic to the system, or legacy.  It would be nice to live fix these.
                 if (reader["creatorID"] == null) 
                 {
                     item.CreatorId  = UUID.Zero.ToString();

OpenSim/Framework/IClientAPI.cs

@@ -73,7 +73,7 @@ namespace OpenSim.Framework
 
     public delegate void LinkObjects(IClientAPI remoteClient, uint parent, List<uint> children);
 
-    public delegate void DelinkObjects(List<uint> primIds);
+    public delegate void DelinkObjects(List<uint> primIds, IClientAPI client);
 
     public delegate void RequestMapBlocks(IClientAPI remoteClient, int minX, int minY, int maxX, int maxY, uint flag);
 

OpenSim/Framework/PrimitiveBaseShape.cs

@@ -236,7 +236,7 @@ namespace OpenSim.Framework
                 catch { }
 
                 m_log.Warn("[SHAPE]: Failed to decode texture, length=" + ((m_textureEntry != null) ? m_textureEntry.Length : 0));
-                return new Primitive.TextureEntry(null);
+                return new Primitive.TextureEntry(UUID.Zero);
             }
 
             set { m_textureEntry = value.GetBytes(); }

OpenSim/Framework/Servers/HttpServer/SynchronousRestFormsRequester.cs

@@ -81,7 +81,7 @@ namespace OpenSim.Framework.Servers.HttpServer
                 }
                 catch (Exception e)
                 {
-                    m_log.DebugFormat("[FORMS]: exception occured on sending request {0}", e.Message);
+                    m_log.DebugFormat("[FORMS]: exception occured on sending request to {0}: {1}", requestUrl, e.Message);
                 }
                 finally
                 {

OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs

@@ -6151,7 +6151,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             DelinkObjects handlerDelinkObjects = OnDelinkObjects;
             if (handlerDelinkObjects != null)
             {
-                handlerDelinkObjects(prims);
+                handlerDelinkObjects(prims, this);
             }
 
             return true;

OpenSim/Region/CoreModules/Avatar/Friends/FriendsModule.cs

@@ -149,7 +149,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Friends
 
             if (m_FriendsService == null)
             {
-                m_log.Error("[FRIENDS]: No Connector defined in section Friends, or filed to load, cannot continue");
+                m_log.Error("[FRIENDS]: No Connector defined in section Friends, or failed to load, cannot continue");
                 throw new Exception("Connector load error");
             }
 

OpenSim/Region/CoreModules/Resources/CoreModulePlugin.addin.xml

@@ -45,6 +45,7 @@
         <RegionModule id="HGAssetBroker" type="OpenSim.Region.CoreModules.ServiceConnectorsOut.Asset.HGAssetBroker" />
         <RegionModule id="LocalInventoryServicesConnector" type="OpenSim.Region.CoreModules.ServiceConnectorsOut.Inventory.LocalInventoryServicesConnector" />
         <RegionModule id="RemoteInventoryServicesConnector" type="OpenSim.Region.CoreModules.ServiceConnectorsOut.Inventory.RemoteInventoryServicesConnector" />
+        <RegionModule id="RemoteXInventoryServicesConnector" type="OpenSim.Region.CoreModules.ServiceConnectorsOut.Inventory.RemoteXInventoryServicesConnector" />
         <RegionModule id="HGInventoryBroker" type="OpenSim.Region.CoreModules.ServiceConnectorsOut.Inventory.HGInventoryBroker" />
         <RegionModule id="LocalNeighbourServicesConnector" type="OpenSim.Region.CoreModules.ServiceConnectorsOut.Neighbour.LocalNeighbourServicesConnector" />
         <RegionModule id="RemoteNeighbourServicesConnector" type="OpenSim.Region.CoreModules.ServiceConnectorsOut.Neighbour.RemoteNeighbourServicesConnector" />

OpenSim/Region/CoreModules/ServiceConnectorsOut/Inventory/HGInventoryBroker2.cs

@@ -0,0 +1,618 @@
+/*
+ * 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 log4net;
+using Nini.Config;
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using OpenSim.Framework;
+
+using OpenSim.Server.Base;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using OpenSim.Services.Connectors;
+using OpenMetaverse;
+
+namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Inventory
+{
+    public class HGInventoryBroker2 : INonSharedRegionModule, IInventoryService
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private static bool m_Initialized = false;
+        private static bool m_Enabled = false;
+
+        private static IInventoryService m_LocalGridInventoryService;
+        private static ISessionAuthInventoryService m_HGService; // obsolete
+        private Dictionary<string, IInventoryService> m_connectors = new Dictionary<string, IInventoryService>();
+
+        // A cache of userIDs --> ServiceURLs, for HGBroker only
+        protected Dictionary<UUID, string> m_InventoryURLs;
+
+        private Scene m_Scene;
+        private List<Scene> m_Scenes = new List<Scene>();
+
+        private IUserAccountService m_UserAccountService; 
+
+        public Type ReplaceableInterface 
+        {
+            get { return null; }
+        }
+
+        public string Name
+        {
+            get { return "HGInventoryBroker2"; }
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+            if (!m_Initialized)
+            {
+                IConfig moduleConfig = source.Configs["Modules"];
+                if (moduleConfig != null)
+                {
+                    string name = moduleConfig.GetString("InventoryServices", "");
+                    if (name == Name)
+                    {
+                        IConfig inventoryConfig = source.Configs["InventoryService"];
+                        if (inventoryConfig == null)
+                        {
+                            m_log.Error("[HG INVENTORY CONNECTOR]: InventoryService missing from OpenSim.ini");
+                            return;
+                        }
+
+                        string localDll = inventoryConfig.GetString("LocalGridInventoryService",
+                                String.Empty);
+                        string HGDll = inventoryConfig.GetString("HypergridInventoryService",
+                                String.Empty);
+
+                        if (localDll == String.Empty)
+                        {
+                            m_log.Error("[HG INVENTORY CONNECTOR]: No LocalGridInventoryService named in section InventoryService");
+                            //return;
+                            throw new Exception("Unable to proceed. Please make sure your ini files in config-include are updated according to .example's");
+                        }
+
+                        if (HGDll == String.Empty)
+                        {
+                            m_log.Error("[HG INVENTORY CONNECTOR]: No HypergridInventoryService named in section InventoryService");
+                            //return;
+                            throw new Exception("Unable to proceed. Please make sure your ini files in config-include are updated according to .example's");
+                        }
+
+                        Object[] args = new Object[] { source };
+                        m_LocalGridInventoryService =
+                                ServerUtils.LoadPlugin<IInventoryService>(localDll,
+                                args);
+
+                        m_HGService =
+                                ServerUtils.LoadPlugin<ISessionAuthInventoryService>(HGDll,
+                                args);
+
+                        if (m_LocalGridInventoryService == null)
+                        {
+                            m_log.Error("[HG INVENTORY CONNECTOR]: Can't load local inventory service");
+                            return;
+                        }
+                        if (m_HGService == null)
+                        {
+                            m_log.Error("[HG INVENTORY CONNECTOR]: Can't load hypergrid inventory service");
+                            return;
+                        }
+
+                        m_Enabled = true;
+                        m_log.Info("[HG INVENTORY CONNECTOR]: HG inventory broker enabled");
+                    }
+                }
+                m_Initialized = true;
+            }
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public void Close()
+        {
+        }
+
+        public void AddRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            m_Scene = scene;
+            m_Scenes.Add(scene);
+            m_UserAccountService = m_Scene.UserAccountService;
+
+            scene.RegisterModuleInterface<IInventoryService>(this);
+
+            scene.EventManager.OnMakeRootAgent += OnMakeRootAgent;
+            scene.EventManager.OnClientClosed += OnClientClosed;
+
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            m_Scenes.Remove(scene);
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            m_log.InfoFormat("[HG INVENTORY CONNECTOR]: Enabled HG inventory for region {0}", scene.RegionInfo.RegionName);
+
+        }
+
+        #region Cache
+
+        void OnMakeRootAgent(ScenePresence presence)
+        {
+            if (!m_InventoryURLs.ContainsKey(presence.UUID))
+                CacheInventoryServiceURL(presence.Scene, presence.UUID);
+        }
+
+        void OnClientClosed(UUID clientID, Scene scene)
+        {
+            if (m_InventoryURLs.ContainsKey(clientID)) // if it's in cache
+            {
+                ScenePresence sp = null;
+                foreach (Scene s in m_Scenes)
+                {
+                    s.TryGetScenePresence(clientID, out sp);
+                    if ((sp != null) && !sp.IsChildAgent && (s != scene))
+                    {
+                        m_log.DebugFormat("[INVENTORY CACHE]: OnClientClosed in {0}, but user {1} still in sim. Keeping inventoryURL in cache",
+                            scene.RegionInfo.RegionName, clientID);
+                        return;
+                    }
+                }
+
+                m_log.DebugFormat(
+                    "[INVENTORY CACHE]: OnClientClosed in {0}, user {1} out of sim. Dropping inventory URL",
+                    scene.RegionInfo.RegionName, clientID);
+                DropInventoryServiceURL(clientID);
+            }
+        }
+
+        /// <summary>
+        /// Gets the user's inventory URL from its serviceURLs, if the user is foreign,
+        /// and sticks it in the cache
+        /// </summary>
+        /// <param name="userID"></param>
+        private void CacheInventoryServiceURL(Scene scene, UUID userID)
+        {
+            if (scene.UserAccountService.GetUserAccount(scene.RegionInfo.ScopeID, userID) == null)
+            {
+                // The user does not have a local account; let's cache its service URL
+                string inventoryURL = string.Empty;
+                ScenePresence sp = null;
+                scene.TryGetScenePresence(userID, out sp);
+                if (sp != null)
+                {
+                    AgentCircuitData aCircuit = scene.AuthenticateHandler.GetAgentCircuitData(sp.ControllingClient.CircuitCode);
+                    if (aCircuit.ServiceURLs.ContainsKey("InventoryServerURI"))
+                    {
+                        inventoryURL = aCircuit.ServiceURLs["InventoryServerURI"].ToString();
+                        if (inventoryURL != null && inventoryURL != string.Empty)
+                        {
+                            inventoryURL = inventoryURL.Trim(new char[] { '/' });
+                            m_InventoryURLs.Add(userID, inventoryURL);
+                        }
+                    }
+                }
+            }
+        }
+
+        private void DropInventoryServiceURL(UUID userID)
+        {
+            lock (m_InventoryURLs)
+                if (m_InventoryURLs.ContainsKey(userID))
+                    m_InventoryURLs.Remove(userID);
+        }
+
+        public string GetInventoryServiceURL(UUID userID)
+        {
+            if (m_InventoryURLs.ContainsKey(userID))
+                return m_InventoryURLs[userID];
+
+            return null;
+        }
+        #endregion
+
+        #region IInventoryService
+
+        public bool CreateUserInventory(UUID userID)
+        {
+            return m_LocalGridInventoryService.CreateUserInventory(userID);
+        }
+
+        public List<InventoryFolderBase> GetInventorySkeleton(UUID userId)
+        {
+            return m_LocalGridInventoryService.GetInventorySkeleton(userId);
+        }
+
+        public InventoryCollection GetUserInventory(UUID userID)
+        {
+            return null;
+        }
+
+        public void GetUserInventory(UUID userID, InventoryReceiptCallback callback)
+        {
+        }
+
+        public InventoryFolderBase GetRootFolder(UUID userID)
+        {
+            m_log.DebugFormat("[HGInventory]: GetRootFolder for {0}", userID);
+
+            string invURL = GetInventoryServiceURL(userID);
+
+            if (invURL == null) // not there, forward to local inventory connector to resolve
+                return m_LocalGridInventoryService.GetRootFolder(userID);
+
+            IInventoryService connector = GetConnector(invURL);
+
+            return connector.GetRootFolder(userID);
+        }
+
+        public InventoryFolderBase GetFolderForType(UUID userID, AssetType type)
+        {
+            m_log.DebugFormat("[HGInventory]: GetFolderForType {0} type {1}", userID, type);
+
+            string invURL = GetInventoryServiceURL(userID);
+
+            if (invURL == null) // not there, forward to local inventory connector to resolve
+                return m_LocalGridInventoryService.GetFolderForType(userID, type);
+
+            IInventoryService connector = GetConnector(invURL);
+
+            return connector.GetFolderForType(userID, type);
+        }
+
+        public InventoryCollection GetFolderContent(UUID userID, UUID folderID)
+        {
+            m_log.Debug("[HGInventory]: GetFolderContent " + folderID);
+
+            string invURL = GetInventoryServiceURL(userID);
+
+            if (invURL == null) // not there, forward to local inventory connector to resolve
+                return m_LocalGridInventoryService.GetFolderContent(userID, folderID);
+
+            IInventoryService connector = GetConnector(invURL);
+
+            return connector.GetFolderContent(userID, folderID);
+
+        }
+
+        public  List<InventoryItemBase> GetFolderItems(UUID userID, UUID folderID)
+        {
+            m_log.Debug("[HGInventory]: GetFolderItems " + folderID);
+
+            string invURL = GetInventoryServiceURL(userID);
+
+            if (invURL == null) // not there, forward to local inventory connector to resolve
+                return m_LocalGridInventoryService.GetFolderItems(userID, folderID);
+
+            IInventoryService connector = GetConnector(invURL);
+
+            return connector.GetFolderItems(userID, folderID);
+
+        }
+
+        public  bool AddFolder(InventoryFolderBase folder)
+        {
+            if (folder == null)
+                return false;
+
+            m_log.Debug("[HGInventory]: AddFolder " + folder.ID);
+
+            string invURL = GetInventoryServiceURL(folder.Owner);
+
+            if (invURL == null) // not there, forward to local inventory connector to resolve
+                return m_LocalGridInventoryService.AddFolder(folder);
+
+            IInventoryService connector = GetConnector(invURL);
+
+            return connector.AddFolder(folder);
+        }
+
+        public  bool UpdateFolder(InventoryFolderBase folder)
+        {
+            if (folder == null)
+                return false;
+
+            m_log.Debug("[HGInventory]: UpdateFolder " + folder.ID);
+
+            string invURL = GetInventoryServiceURL(folder.Owner);
+
+            if (invURL == null) // not there, forward to local inventory connector to resolve
+                return m_LocalGridInventoryService.UpdateFolder(folder);
+
+            IInventoryService connector = GetConnector(invURL);
+
+            return connector.UpdateFolder(folder);
+        }
+
+        public  bool DeleteFolders(UUID ownerID, List<UUID> folderIDs)
+        {
+            if (folderIDs == null)
+                return false;
+            if (folderIDs.Count == 0)
+                return false;
+
+            m_log.Debug("[HGInventory]: DeleteFolders for " + ownerID);
+
+            string invURL = GetInventoryServiceURL(ownerID);
+
+            if (invURL == null) // not there, forward to local inventory connector to resolve
+                return m_LocalGridInventoryService.DeleteFolders(ownerID, folderIDs);
+
+            IInventoryService connector = GetConnector(invURL);
+
+            return connector.DeleteFolders(ownerID, folderIDs);
+        }
+
+        public  bool MoveFolder(InventoryFolderBase folder)
+        {
+            if (folder == null)
+                return false;
+
+            m_log.Debug("[HGInventory]: MoveFolder for " + folder.Owner);
+
+            string invURL = GetInventoryServiceURL(folder.Owner);
+
+            if (invURL == null) // not there, forward to local inventory connector to resolve
+                return m_LocalGridInventoryService.MoveFolder(folder);
+
+            IInventoryService connector = GetConnector(invURL);
+
+            return connector.MoveFolder(folder);
+        }
+
+        public  bool PurgeFolder(InventoryFolderBase folder)
+        {
+            if (folder == null)
+                return false;
+
+            m_log.Debug("[HGInventory]: PurgeFolder for " + folder.Owner);
+
+            string invURL = GetInventoryServiceURL(folder.Owner);
+
+            if (invURL == null) // not there, forward to local inventory connector to resolve
+                return m_LocalGridInventoryService.PurgeFolder(folder);
+
+            IInventoryService connector = GetConnector(invURL);
+
+            return connector.PurgeFolder(folder);
+        }
+
+        public bool AddItem(InventoryItemBase item)
+        {
+            if (item == null)
+                return false;
+
+            m_log.Debug("[HGInventory]: AddItem " + item.ID);
+
+            string invURL = GetInventoryServiceURL(item.Owner);
+
+            if (invURL == null) // not there, forward to local inventory connector to resolve
+                return m_LocalGridInventoryService.AddItem(item);
+
+            IInventoryService connector = GetConnector(invURL);
+
+            return connector.AddItem(item);
+        }
+
+        public  bool UpdateItem(InventoryItemBase item)
+        {
+            if (item == null)
+                return false;
+
+            m_log.Debug("[HGInventory]: UpdateItem " + item.ID);
+
+            string invURL = GetInventoryServiceURL(item.Owner);
+
+            if (invURL == null) // not there, forward to local inventory connector to resolve
+                return m_LocalGridInventoryService.UpdateItem(item);
+
+            IInventoryService connector = GetConnector(invURL);
+
+            return connector.UpdateItem(item);
+        }
+
+        public  bool MoveItems(UUID ownerID, List<InventoryItemBase> items)
+        {
+            if (items == null)
+                return false;
+            if (items.Count == 0)
+                return true;
+
+            m_log.Debug("[HGInventory]: MoveItems for " + ownerID);
+
+            string invURL = GetInventoryServiceURL(ownerID);
+
+            if (invURL == null) // not there, forward to local inventory connector to resolve
+                return m_LocalGridInventoryService.MoveItems(ownerID, items);
+
+            IInventoryService connector = GetConnector(invURL);
+
+            return connector.MoveItems(ownerID, items);
+        }
+
+        public  bool DeleteItems(UUID ownerID, List<UUID> itemIDs)
+        {
+            m_log.DebugFormat("[HG INVENTORY CONNECTOR]: Delete {0} items for user {1}", itemIDs.Count, ownerID);
+
+            if (itemIDs == null)
+                return false;
+            if (itemIDs.Count == 0)
+                return true;
+
+            m_log.Debug("[HGInventory]: DeleteItems for " + ownerID);
+
+            string invURL = GetInventoryServiceURL(ownerID);
+
+            if (invURL == null) // not there, forward to local inventory connector to resolve
+                return m_LocalGridInventoryService.DeleteItems(ownerID, itemIDs);
+
+            IInventoryService connector = GetConnector(invURL);
+
+            return connector.DeleteItems(ownerID, itemIDs);
+        }
+
+        public  InventoryItemBase GetItem(InventoryItemBase item)
+        {
+            if (item == null)
+                return null;
+            m_log.Debug("[HGInventory]: GetItem " + item.ID);
+
+            string invURL = GetInventoryServiceURL(item.Owner);
+
+            if (invURL == null) // not there, forward to local inventory connector to resolve
+                return m_LocalGridInventoryService.GetItem(item);
+
+            IInventoryService connector = GetConnector(invURL);
+
+            return connector.GetItem(item);
+        }
+
+        public  InventoryFolderBase GetFolder(InventoryFolderBase folder)
+        {
+            if (folder == null)
+                return null;
+
+            m_log.Debug("[HGInventory]: GetFolder " + folder.ID);
+
+            string invURL = GetInventoryServiceURL(folder.Owner);
+
+            if (invURL == null) // not there, forward to local inventory connector to resolve
+                return m_LocalGridInventoryService.GetFolder(folder);
+
+            IInventoryService connector = GetConnector(invURL);
+
+            return connector.GetFolder(folder);
+        }
+
+        public  bool HasInventoryForUser(UUID userID)
+        {
+            return false;
+        }
+
+        public  List<InventoryItemBase> GetActiveGestures(UUID userId)
+        {
+            return new List<InventoryItemBase>();
+        }
+
+        public  int GetAssetPermissions(UUID userID, UUID assetID)
+        {
+            m_log.Debug("[HGInventory]: GetAssetPermissions " + assetID);
+
+            string invURL = GetInventoryServiceURL(userID);
+
+            if (invURL == null) // not there, forward to local inventory connector to resolve
+                return m_LocalGridInventoryService.GetAssetPermissions(userID, assetID);
+
+            IInventoryService connector = GetConnector(invURL);
+
+            return connector.GetAssetPermissions(userID, assetID);
+        }
+
+        #endregion
+
+        private IInventoryService GetConnector(string url)
+        {
+            IInventoryService connector = null;
+            lock (m_connectors)
+            {
+                if (m_connectors.ContainsKey(url))
+                {
+                    connector = m_connectors[url];
+                }
+                else
+                {
+                    // We're instantiating this class explicitly, but this won't
+                    // work in general, because the remote grid may be running
+                    // an inventory server that has a different protocol.
+                    // Eventually we will want a piece of protocol asking
+                    // the remote server about its kind. Definitely cool thing to do!
+                    connector = new RemoteXInventoryServicesConnector(url);
+                    m_connectors.Add(url, connector);
+                }
+            }
+            return connector;
+        }
+
+
+        private UUID GetSessionID(UUID userID)
+        {
+            ScenePresence sp = null;
+            if (m_Scene.TryGetScenePresence(userID, out sp))
+            {
+                return sp.ControllingClient.SessionId;
+            }
+
+            m_log.DebugFormat("[HG INVENTORY CONNECTOR]: scene presence for {0} not found", userID);
+            return UUID.Zero;
+        }
+
+        private bool IsForeignUser(UUID userID, out string inventoryURL)
+        {
+            inventoryURL = string.Empty;
+            UserAccount account = null;
+            if (m_Scene.UserAccountService != null)
+                account = m_Scene.UserAccountService.GetUserAccount(m_Scene.RegionInfo.ScopeID, userID);
+
+            if (account == null) // foreign user
+            {
+                ScenePresence sp = null;
+                m_Scene.TryGetScenePresence(userID, out sp);
+                if (sp != null)
+                {
+                    AgentCircuitData aCircuit = m_Scene.AuthenticateHandler.GetAgentCircuitData(sp.ControllingClient.CircuitCode);
+                    if (aCircuit.ServiceURLs.ContainsKey("InventoryServerURI"))
+                    {
+                        inventoryURL = aCircuit.ServiceURLs["InventoryServerURI"].ToString();
+                        inventoryURL = inventoryURL.Trim(new char[] { '/' });
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+
+
+    }
+}

OpenSim/Region/CoreModules/ServiceConnectorsOut/Inventory/InventoryCache.cs

@@ -51,6 +51,9 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Inventory
         // The cache proper
         protected Dictionary<UUID, Dictionary<AssetType, InventoryFolderBase>> m_InventoryCache;
 
+        // A cache of userIDs --> ServiceURLs, for HGBroker only
+        protected Dictionary<UUID, string> m_InventoryURLs;
+
         public virtual void Init(IConfigSource source, BaseInventoryConnector connector)
         {
             m_Scenes = new List<Scene>();
@@ -89,8 +92,11 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Inventory
 
             // If not, go get them and place them in the cache
             Dictionary<AssetType, InventoryFolderBase> folders = CacheSystemFolders(presence.UUID);
+            CacheInventoryServiceURL(presence.Scene, presence.UUID);
+            
             m_log.DebugFormat("[INVENTORY CACHE]: OnMakeRootAgent in {0}, fetched system folders for {1} {2}: count {3}", 
                 presence.Scene.RegionInfo.RegionName, presence.Firstname, presence.Lastname, folders.Count);
+
         }
 
         void OnClientClosed(UUID clientID, Scene scene)
@@ -113,6 +119,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Inventory
                     "[INVENTORY CACHE]: OnClientClosed in {0}, user {1} out of sim. Dropping system folders",
                     scene.RegionInfo.RegionName, clientID);
                 DropCachedSystemFolders(clientID);
+                DropInventoryServiceURL(clientID);
             }
         }
 
@@ -174,5 +181,49 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Inventory
 
             return null;
         }
+
+        /// <summary>
+        /// Gets the user's inventory URL from its serviceURLs, if the user is foreign,
+        /// and sticks it in the cache
+        /// </summary>
+        /// <param name="userID"></param>
+        private void CacheInventoryServiceURL(Scene scene, UUID userID)
+        {
+            if (scene.UserAccountService.GetUserAccount(scene.RegionInfo.ScopeID, userID) == null)
+            {
+                // The user does not have a local account; let's cache its service URL
+                string inventoryURL = string.Empty;
+                ScenePresence sp = null;
+                scene.TryGetScenePresence(userID, out sp);
+                if (sp != null)
+                {
+                    AgentCircuitData aCircuit = scene.AuthenticateHandler.GetAgentCircuitData(sp.ControllingClient.CircuitCode);
+                    if (aCircuit.ServiceURLs.ContainsKey("InventoryServerURI"))
+                    {
+                        inventoryURL = aCircuit.ServiceURLs["InventoryServerURI"].ToString();
+                        if (inventoryURL != null && inventoryURL != string.Empty)
+                        {
+                            inventoryURL = inventoryURL.Trim(new char[] { '/' });
+                            m_InventoryURLs.Add(userID, inventoryURL);
+                        }
+                    }
+                }
+            }
+        }
+
+        private void DropInventoryServiceURL(UUID userID)
+        {
+            lock (m_InventoryURLs)
+                if (m_InventoryURLs.ContainsKey(userID))
+                    m_InventoryURLs.Remove(userID);
+        }
+
+        public string GetInventoryServiceURL(UUID userID)
+        {
+            if (m_InventoryURLs.ContainsKey(userID))
+                return m_InventoryURLs[userID];
+
+            return null;
+        }
     }
 }

OpenSim/Region/CoreModules/ServiceConnectorsOut/Inventory/RemoteXInventoryServiceConnector.cs

@@ -0,0 +1,305 @@
+/*
+ * 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 log4net;
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenSim.Framework.Statistics;
+
+using OpenSim.Services.Connectors;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using OpenMetaverse;
+
+namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Inventory
+{
+    public class RemoteXInventoryServicesConnector : ISharedRegionModule, IInventoryService
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private bool m_Enabled = false;
+        private bool m_Initialized = false;
+        private Scene m_Scene;
+        private XInventoryServicesConnector m_RemoteConnector;
+
+        public Type ReplaceableInterface 
+        {
+            get { return null; }
+        }
+
+        public string Name
+        {
+            get { return "RemoteXInventoryServicesConnector"; }
+        }
+
+        public RemoteXInventoryServicesConnector()
+        {
+        }
+
+        public RemoteXInventoryServicesConnector(string url)
+        {
+            m_RemoteConnector = new XInventoryServicesConnector(url);
+        }
+
+        public RemoteXInventoryServicesConnector(IConfigSource source)
+        {
+            Init(source);
+        }
+
+        protected  void Init(IConfigSource source)
+        {
+            m_RemoteConnector = new XInventoryServicesConnector(source);
+        }
+
+
+        #region ISharedRegionModule
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig moduleConfig = source.Configs["Modules"];
+            if (moduleConfig != null)
+            {
+                string name = moduleConfig.GetString("InventoryServices", "");
+                if (name == Name)
+                {
+                    Init(source);
+                    m_Enabled = true;
+
+                    m_log.Info("[XINVENTORY CONNECTOR]: Remote XInventory enabled");
+                }
+            }
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public void Close()
+        {
+        }
+
+        public void AddRegion(Scene scene)
+        {
+            m_Scene = scene;
+            //m_log.Debug("[XXXX] Adding scene " + m_Scene.RegionInfo.RegionName);
+
+            if (!m_Enabled)
+                return;
+
+            if (!m_Initialized)
+            {
+                m_Initialized = true;
+            }
+
+            scene.RegisterModuleInterface<IInventoryService>(this);
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            m_log.InfoFormat("[XINVENTORY CONNECTOR]: Enabled remote XInventory for region {0}", scene.RegionInfo.RegionName);
+
+        }
+
+        #endregion ISharedRegionModule
+
+        #region IInventoryService
+
+        public  bool CreateUserInventory(UUID user)
+        {
+            return false;
+        }
+
+        public  List<InventoryFolderBase> GetInventorySkeleton(UUID userId)
+        {
+            return new List<InventoryFolderBase>();
+        }
+
+        public  InventoryCollection GetUserInventory(UUID userID)
+        {
+            return null;
+        }
+
+        public  void GetUserInventory(UUID userID, InventoryReceiptCallback callback)
+        {
+        }
+
+        public InventoryFolderBase GetRootFolder(UUID userID)
+        {
+            return m_RemoteConnector.GetRootFolder(userID);
+        }
+
+        public InventoryFolderBase GetFolderForType(UUID userID, AssetType type)
+        {
+            return m_RemoteConnector.GetFolderForType(userID, type);
+        }
+
+        public  Dictionary<AssetType, InventoryFolderBase> GetSystemFolders(UUID userID)
+        {
+            return m_RemoteConnector.GetSystemFolders(userID);
+        }
+
+        public  InventoryCollection GetFolderContent(UUID userID, UUID folderID)
+        {
+            return m_RemoteConnector.GetFolderContent(userID, folderID);
+        }
+
+        public  List<InventoryItemBase> GetFolderItems(UUID userID, UUID folderID)
+        {
+            return m_RemoteConnector.GetFolderItems(userID, folderID);
+        }
+
+        public  bool AddFolder(InventoryFolderBase folder)
+        {
+            if (folder == null)
+                return false;
+
+            return m_RemoteConnector.AddFolder(folder);
+        }
+
+        public  bool UpdateFolder(InventoryFolderBase folder)
+        {
+            if (folder == null)
+                return false;
+
+            return m_RemoteConnector.UpdateFolder(folder);
+        }
+
+        public  bool MoveFolder(InventoryFolderBase folder)
+        {
+            if (folder == null)
+                return false;
+
+            return m_RemoteConnector.MoveFolder(folder);
+        }
+
+        public  bool DeleteFolders(UUID ownerID, List<UUID> folderIDs)
+        {
+            if (folderIDs == null)
+                return false;
+            if (folderIDs.Count == 0)
+                return false;
+
+            return m_RemoteConnector.DeleteFolders(ownerID, folderIDs);
+        }
+
+
+        public  bool PurgeFolder(InventoryFolderBase folder)
+        {
+            if (folder == null)
+                return false;
+
+            return m_RemoteConnector.PurgeFolder(folder);
+        }
+
+        public  bool AddItem(InventoryItemBase item)
+        {
+            if (item == null)
+                return false;
+
+            return m_RemoteConnector.AddItem(item);
+        }
+
+        public  bool UpdateItem(InventoryItemBase item)
+        {
+            if (item == null)
+                return false;
+
+            return m_RemoteConnector.UpdateItem(item);
+        }
+
+        public  bool MoveItems(UUID ownerID, List<InventoryItemBase> items)
+        {
+            if (items == null)
+                return false;
+
+            return m_RemoteConnector.MoveItems(ownerID, items);
+        }
+
+
+        public  bool DeleteItems(UUID ownerID, List<UUID> itemIDs)
+        {
+            if (itemIDs == null)
+                return false;
+            if (itemIDs.Count == 0)
+                return true;
+
+            return m_RemoteConnector.DeleteItems(ownerID, itemIDs);
+        }
+
+        public  InventoryItemBase GetItem(InventoryItemBase item)
+        {
+            if (item == null)
+                return null;
+
+            return m_RemoteConnector.GetItem(item);
+        }
+
+        public  InventoryFolderBase GetFolder(InventoryFolderBase folder)
+        {
+            m_log.DebugFormat("[XINVENTORY CONNECTOR]: GetFolder {0}", folder.ID);
+            if (folder == null)
+                return null;
+
+            return m_RemoteConnector.GetFolder(folder);
+        }
+
+        public  bool HasInventoryForUser(UUID userID)
+        {
+            return false;
+        }
+
+        public  List<InventoryItemBase> GetActiveGestures(UUID userId)
+        {
+            return new List<InventoryItemBase>();
+        }
+
+        public  int GetAssetPermissions(UUID userID, UUID assetID)
+        {
+            return m_RemoteConnector.GetAssetPermissions(userID, assetID);
+        }
+
+
+        #endregion
+
+
+    }
+}

OpenSim/Region/CoreModules/World/Permissions/PermissionsModule.cs

@@ -1721,7 +1721,7 @@ namespace OpenSim.Region.CoreModules.World.Permissions
             DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
             if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-            return true;
+            return GenericObjectPermission(userID, objectID, false);
         }
 
         private bool CanDelinkObject(UUID userID, UUID objectID)
@@ -1729,7 +1729,7 @@ namespace OpenSim.Region.CoreModules.World.Permissions
             DebugPermissionInformation(MethodInfo.GetCurrentMethod().Name);
             if (m_bypassPermissions) return m_bypassPermissionsValue;
 
-            return true;
+            return GenericObjectPermission(userID, objectID, false);
         }
 
         private bool CanBuyLand(UUID userID, ILandObject parcel, Scene scene)

OpenSim/Region/DataSnapshot/ObjectSnapshot.cs

@@ -69,7 +69,7 @@ namespace OpenSim.Region.DataSnapshot.Providers
                 byte RayEndIsIntersection) { this.Stale = true; };
             client.OnLinkObjects += delegate (IClientAPI remoteClient, uint parent, List<uint> children)
                 { this.Stale = true; };
-            client.OnDelinkObjects += delegate(List<uint> primIds) { this.Stale = true; };
+            client.OnDelinkObjects += delegate(List<uint> primIds, IClientAPI clientApi) { this.Stale = true; };
             client.OnGrabUpdate += delegate(UUID objectID, Vector3 offset, Vector3 grapPos,
                 IClientAPI remoteClient, List<SurfaceTouchEventArgs> surfaceArgs) { this.Stale = true; };
             client.OnObjectAttach += delegate(IClientAPI remoteClient, uint objectLocalID, uint AttachmentPt,

OpenSim/Region/Framework/Interfaces/IEntityInventory.cs

@@ -161,6 +161,7 @@ namespace OpenSim.Region.Framework.Interfaces
         /// in this prim's inventory.</param>
         /// <returns>false if the item did not exist, true if the update occurred successfully</returns>
         bool UpdateInventoryItem(TaskInventoryItem item);
+        bool UpdateInventoryItem(TaskInventoryItem item, bool fireScriptEvents);
 
         /// <summary>
         /// Remove an item from this entity's inventory

OpenSim/Region/Framework/Scenes/Scene.Inventory.cs

@@ -1941,5 +1941,55 @@ namespace OpenSim.Region.Framework.Scenes
                 part.GetProperties(remoteClient);
             }
         }
+
+        public void DelinkObjects(List<uint> primIds, IClientAPI client)
+        {
+            List<SceneObjectPart> parts = new List<SceneObjectPart>();
+
+            foreach (uint localID in primIds)
+            {
+                SceneObjectPart part = GetSceneObjectPart(localID);
+
+                if (part == null)
+                    continue;
+
+                if (Permissions.CanDelinkObject(client.AgentId, part.ParentGroup.RootPart.UUID))
+                    parts.Add(part);
+            }
+
+            m_sceneGraph.DelinkObjects(parts);
+        }
+
+        public void LinkObjects(IClientAPI client, uint parentPrimId, List<uint> childPrimIds)
+        {
+            List<UUID> owners = new List<UUID>();
+
+            List<SceneObjectPart> children = new List<SceneObjectPart>();
+            SceneObjectPart root = GetSceneObjectPart(parentPrimId);
+
+            if (Permissions.CanLinkObject(client.AgentId, root.ParentGroup.RootPart.UUID))
+                return;
+
+            foreach (uint localID in childPrimIds)
+            {
+                SceneObjectPart part = GetSceneObjectPart(localID);
+
+                if (part == null)
+                    continue;
+
+                if (!owners.Contains(part.OwnerID))
+                    owners.Add(part.OwnerID);
+
+                if (Permissions.CanLinkObject(client.AgentId, part.ParentGroup.RootPart.UUID))
+                    children.Add(part);
+            }
+
+            // Must be all one owner
+            //
+            if (owners.Count > 1)
+                return;
+
+            m_sceneGraph.LinkObjects(root, children);
+        }
     }
 }

OpenSim/Region/Framework/Scenes/Scene.cs

@@ -2721,8 +2721,8 @@ namespace OpenSim.Region.Framework.Scenes
             client.OnObjectName += m_sceneGraph.PrimName;
             client.OnObjectClickAction += m_sceneGraph.PrimClickAction;
             client.OnObjectMaterial += m_sceneGraph.PrimMaterial;
-            client.OnLinkObjects += m_sceneGraph.LinkObjects;
+            client.OnLinkObjects += LinkObjects;
-            client.OnDelinkObjects += m_sceneGraph.DelinkObjects;
+            client.OnDelinkObjects += DelinkObjects;
             client.OnObjectDuplicate += m_sceneGraph.DuplicateObject;
             client.OnObjectDuplicateOnRay += doObjectDuplicateOnRay;
             client.OnUpdatePrimFlags += m_sceneGraph.UpdatePrimFlags;
@@ -2878,8 +2878,8 @@ namespace OpenSim.Region.Framework.Scenes
             client.OnObjectName -= m_sceneGraph.PrimName;
             client.OnObjectClickAction -= m_sceneGraph.PrimClickAction;
             client.OnObjectMaterial -= m_sceneGraph.PrimMaterial;
-            client.OnLinkObjects -= m_sceneGraph.LinkObjects;
+            client.OnLinkObjects -= LinkObjects;
-            client.OnDelinkObjects -= m_sceneGraph.DelinkObjects;
+            client.OnDelinkObjects -= DelinkObjects;
             client.OnObjectDuplicate -= m_sceneGraph.DuplicateObject;
             client.OnObjectDuplicateOnRay -= doObjectDuplicateOnRay;
             client.OnUpdatePrimFlags -= m_sceneGraph.UpdatePrimFlags;

OpenSim/Region/Framework/Scenes/SceneGraph.cs

@@ -1463,20 +1463,21 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="client"></param>
         /// <param name="parentPrim"></param>
         /// <param name="childPrims"></param>
-        protected internal void LinkObjects(IClientAPI client, uint parentPrimId, List<uint> childPrimIds)
+        protected internal void LinkObjects(SceneObjectPart root, List<SceneObjectPart> children)
         {
             Monitor.Enter(m_updateLock);
             try
             {
-                SceneObjectGroup parentGroup = GetGroupByPrim(parentPrimId);
+                SceneObjectGroup parentGroup = root.ParentGroup;
 
                 List<SceneObjectGroup> childGroups = new List<SceneObjectGroup>();
                 if (parentGroup != null)
                 {
                     // We do this in reverse to get the link order of the prims correct
-                    for (int i = childPrimIds.Count - 1; i >= 0; i--)
+                    for (int i = children.Count - 1; i >= 0; i--)
                     {
-                        SceneObjectGroup child = GetGroupByPrim(childPrimIds[i]);
+                        SceneObjectGroup child = children[i].ParentGroup;
+
                         if (child != null)
                         {
                             // Make sure no child prim is set for sale
@@ -1509,17 +1510,6 @@ namespace OpenSim.Region.Framework.Scenes
                 parentGroup.HasGroupChanged = true;
                 parentGroup.ScheduleGroupForFullUpdate();
                 
-//                if (client != null)
-//                {
-//                    parentGroup.GetProperties(client);
-//                }
-//                else
-//                {
-//                    foreach (ScenePresence p in GetScenePresences())
-//                    {
-//                        parentGroup.GetProperties(p.ControllingClient);
-//                    }
-//                }
             }
             finally
             {
@@ -1531,12 +1521,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// Delink a linkset
         /// </summary>
         /// <param name="prims"></param>
-        protected internal void DelinkObjects(List<uint> primIds)
+        protected internal void DelinkObjects(List<SceneObjectPart> prims)
-        {
-            DelinkObjects(primIds, true);
-        }
-
-        protected internal void DelinkObjects(List<uint> primIds, bool sendEvents)
         {
             Monitor.Enter(m_updateLock);
             try
@@ -1546,9 +1531,8 @@ namespace OpenSim.Region.Framework.Scenes
                 List<SceneObjectGroup> affectedGroups = new List<SceneObjectGroup>();
                 // Look them all up in one go, since that is comparatively expensive
                 //
-                foreach (uint primID in primIds)
+                foreach (SceneObjectPart part in prims)
                 {
-                    SceneObjectPart part = m_parentScene.GetSceneObjectPart(primID);
                     if (part != null)
                     {
                         if (part.ParentGroup.Children.Count != 1) // Skip single
@@ -1563,17 +1547,13 @@ namespace OpenSim.Region.Framework.Scenes
                                 affectedGroups.Add(group);
                         }
                     }
-                    else
-                    {
-                        m_log.ErrorFormat("Viewer requested unlink of nonexistent part {0}", primID);
-                    }
                 }
 
                 foreach (SceneObjectPart child in childParts)
                 {
                     // Unlink all child parts from their groups
                     //
-                    child.ParentGroup.DelinkFromGroup(child, sendEvents);
+                    child.ParentGroup.DelinkFromGroup(child, true);
                 }
 
                 foreach (SceneObjectPart root in rootParts)
@@ -1628,12 +1608,9 @@ namespace OpenSim.Region.Framework.Scenes
                             List<uint> linkIDs = new List<uint>();
 
                             foreach (SceneObjectPart newChild in newSet)
-                            {
                                 newChild.UpdateFlag = 0;
-                                linkIDs.Add(newChild.LocalId);
-                            }
 
-                            LinkObjects(null, newRoot.LocalId, linkIDs);
+                            LinkObjects(newRoot, newSet);
                             if (!affectedGroups.Contains(newRoot.ParentGroup))
                                 affectedGroups.Add(newRoot.ParentGroup);
                         }

OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs

@@ -608,8 +608,15 @@ namespace OpenSim.Region.Framework.Scenes
         /// in this prim's inventory.</param>
         /// <returns>false if the item did not exist, true if the update occurred successfully</returns>
         public bool UpdateInventoryItem(TaskInventoryItem item)
+        {
+            return UpdateInventoryItem(item, true);
+        }
+
+        public bool UpdateInventoryItem(TaskInventoryItem item, bool fireScriptEvents)
         {
             lock(m_items)
+            {
+                if (m_items.ContainsKey(item.ItemID))
                 {
                     if (m_items.ContainsKey(item.ItemID))
                     {
@@ -626,13 +633,12 @@ namespace OpenSim.Region.Framework.Scenes
                         {
                             item.AssetID = m_items[item.ItemID].AssetID;
                         }
-
                         m_items[item.ItemID] = item;
                         m_inventorySerial++;
+                        if (fireScriptEvents)
                             m_part.TriggerScriptChangedEvent(Changed.INVENTORY);
                         HasInventoryChanged = true;
                         m_part.ParentGroup.HasGroupChanged = true;
-
                         return true;
                     }
                     else
@@ -643,10 +649,11 @@ namespace OpenSim.Region.Framework.Scenes
                             item.ItemID, m_part.Name, m_part.UUID, 
                             m_part.AbsolutePosition, m_part.ParentGroup.Scene.RegionInfo.RegionName);
                     }
-            }
 
+                }
                 return false;
             }
+        }
 
         /// <summary>
         /// Remove an item from this prim's inventory

OpenSim/Region/OptionalModules/Scripting/Minimodule/Interfaces/IInventoryItem.cs

@@ -39,6 +39,6 @@ namespace OpenSim.Region.OptionalModules.Scripting.Minimodule
     {
         int Type { get; }
         UUID AssetID { get; }
-        T RetreiveAsset<T>() where T : Asset, new();
+        T RetrieveAsset<T>() where T : Asset, new();
     }
 }

OpenSim/Region/OptionalModules/Scripting/Minimodule/InventoryItem.cs

@@ -39,11 +39,11 @@ namespace OpenSim.Region.OptionalModules.Scripting.Minimodule
     public class InventoryItem : IInventoryItem
     {
         TaskInventoryItem m_privateItem;
-        Scene m_rootSceene;
+        Scene m_rootScene;
         
         public InventoryItem(Scene rootScene, TaskInventoryItem internalItem)
         {
-            m_rootSceene = rootScene;
+            m_rootScene = rootScene;
             m_privateItem = internalItem;
         }
 
@@ -82,9 +82,9 @@ namespace OpenSim.Region.OptionalModules.Scripting.Minimodule
         public UUID AssetID { get { return m_privateItem.AssetID; } }
         
         // This method exposes OpenSim/OpenMetaverse internals and needs to be replaced with a IAsset specific to MRM.
-        public T RetreiveAsset<T>() where T : OpenMetaverse.Assets.Asset, new()
+        public T RetrieveAsset<T>() where T : OpenMetaverse.Assets.Asset, new()
         {
-            AssetBase a = m_rootSceene.AssetService.Get(AssetID.ToString());
+            AssetBase a = m_rootScene.AssetService.Get(AssetID.ToString());
             T result = new T();
 
             if ((sbyte)result.AssetType != a.Type)

OpenSim/Region/ScriptEngine/Shared/CodeTools/Compiler.cs

@@ -261,13 +261,18 @@ namespace OpenSim.Region.ScriptEngine.Shared.CodeTools
         //    }
         //}
 
-        public object GetCompilerOutput(UUID assetID)
+        public string GetCompilerOutput(string assetID)
         {
             return Path.Combine(ScriptEnginesPath, Path.Combine(
                     m_scriptEngine.World.RegionInfo.RegionID.ToString(),
                     FilePrefix + "_compiled_" + assetID + ".dll"));
         }
 
+        public string GetCompilerOutput(UUID assetID)
+        {
+            return GetCompilerOutput(assetID.ToString());
+        }
+
         /// <summary>
         /// Converts script from LSL to CS and calls CompileFromCSText
         /// </summary>
@@ -279,9 +284,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.CodeTools
             linemap = null;
             m_warnings.Clear();
 
-            assembly = Path.Combine(ScriptEnginesPath, Path.Combine(
+            assembly = GetCompilerOutput(asset);
-                    m_scriptEngine.World.RegionInfo.RegionID.ToString(),
-                    FilePrefix + "_compiled_" + asset + ".dll"));
 
             if (!Directory.Exists(ScriptEnginesPath))
             {

OpenSim/Server/Handlers/Inventory/XInventoryInConnector.cs

@@ -91,7 +91,7 @@ namespace OpenSim.Server.Handlers.Asset
             sr.Close();
             body = body.Trim();
 
-            m_log.DebugFormat("[XXX]: query String: {0}", body);
+            //m_log.DebugFormat("[XXX]: query String: {0}", body);
 
             try
             {
@@ -144,6 +144,8 @@ namespace OpenSim.Server.Handlers.Asset
                         return HandleGetActiveGestures(request);
                     case "GETASSETPERMISSIONS":
                         return HandleGetAssetPermissions(request);
+                    case "GETSYSTEMFOLDERS":
+                        return HandleGetSystemFolders(request);
                 }
                 m_log.DebugFormat("[XINVENTORY HANDLER]: unknown method request: {0}", method);
             }
@@ -211,7 +213,7 @@ namespace OpenSim.Server.Handlers.Asset
                 result["RESULT"] = "False";
 
             string xmlString = ServerUtils.BuildXmlResponse(result);
-            m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
+            //m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
             UTF8Encoding encoding = new UTF8Encoding();
             return encoding.GetBytes(xmlString);
         }
@@ -226,12 +228,20 @@ namespace OpenSim.Server.Handlers.Asset
 
             List<InventoryFolderBase> folders = m_InventoryService.GetInventorySkeleton(new UUID(request["PRINCIPAL"].ToString()));
 
+            Dictionary<string, object> sfolders = new Dictionary<string, object>();
             if (folders != null)
+            {
+                int i = 0;
                 foreach (InventoryFolderBase f in folders)
-                    result[f.ID.ToString()] = EncodeFolder(f);
+                {
+                    sfolders["folder_" + i.ToString()] = EncodeFolder(f);
+                    i++;
+                }
+            }
+            result["FOLDERS"] = sfolders;
 
             string xmlString = ServerUtils.BuildXmlResponse(result);
-            m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
+            //m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
             UTF8Encoding encoding = new UTF8Encoding();
             return encoding.GetBytes(xmlString);
         }
@@ -244,10 +254,10 @@ namespace OpenSim.Server.Handlers.Asset
             UUID.TryParse(request["PRINCIPAL"].ToString(), out principal);
             InventoryFolderBase rfolder = m_InventoryService.GetRootFolder(principal);
             if (rfolder != null)
-                result[rfolder.ID.ToString()] = EncodeFolder(rfolder);
+                result["folder"] = EncodeFolder(rfolder);
 
             string xmlString = ServerUtils.BuildXmlResponse(result);
-            m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
+            //m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
             UTF8Encoding encoding = new UTF8Encoding();
             return encoding.GetBytes(xmlString);
         }
@@ -261,10 +271,10 @@ namespace OpenSim.Server.Handlers.Asset
             Int32.TryParse(request["TYPE"].ToString(), out type);
             InventoryFolderBase folder = m_InventoryService.GetFolderForType(principal, (AssetType)type);
             if (folder != null)
-                result[folder.ID.ToString()] = EncodeFolder(folder);
+                result["folder"] = EncodeFolder(folder);
 
             string xmlString = ServerUtils.BuildXmlResponse(result);
-            m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
+            //m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
             UTF8Encoding encoding = new UTF8Encoding();
             return encoding.GetBytes(xmlString);
         }
@@ -281,18 +291,26 @@ namespace OpenSim.Server.Handlers.Asset
             if (icoll != null)
             {
                 Dictionary<string, object> folders = new Dictionary<string, object>();
+                int i = 0;
                 foreach (InventoryFolderBase f in icoll.Folders)
-                    folders[f.ID.ToString()] = EncodeFolder(f);
+                {
+                    folders["folder_" + i.ToString()] = EncodeFolder(f);
+                    i++;
+                }
                 result["FOLDERS"] = folders;
 
+                i = 0;
                 Dictionary<string, object> items = new Dictionary<string, object>();
-                foreach (InventoryItemBase i in icoll.Items)
+                foreach (InventoryItemBase it in icoll.Items)
-                    items[i.ID.ToString()] = EncodeItem(i);
+                {
+                    items["item_" + i.ToString()] = EncodeItem(it);
+                    i++;
+                }
                 result["ITEMS"] = items;
             }
 
             string xmlString = ServerUtils.BuildXmlResponse(result);
-            m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
+            //m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
             UTF8Encoding encoding = new UTF8Encoding();
             return encoding.GetBytes(xmlString);
         }
@@ -306,12 +324,21 @@ namespace OpenSim.Server.Handlers.Asset
             UUID.TryParse(request["FOLDER"].ToString(), out folderID);
 
             List<InventoryItemBase> items = m_InventoryService.GetFolderItems(principal, folderID);
+            Dictionary<string, object> sitems = new Dictionary<string, object>();
+
             if (items != null)
+            {
+                int i = 0;
                 foreach (InventoryItemBase item in items)
-                    result[item.ID.ToString()] = EncodeItem(item);
+                {
+                    sitems["item_" + i.ToString()] = EncodeItem(item);
+                    i++;
+                }
+            }
+            result["ITEMS"] = sitems;
             
             string xmlString = ServerUtils.BuildXmlResponse(result);
-            m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
+            //m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
             UTF8Encoding encoding = new UTF8Encoding();
             return encoding.GetBytes(xmlString);
         }
@@ -481,10 +508,10 @@ namespace OpenSim.Server.Handlers.Asset
             InventoryItemBase item = new InventoryItemBase(id);
             item = m_InventoryService.GetItem(item);
             if (item != null)
-                result[item.ID.ToString()] = EncodeItem(item);
+                result["item"] = EncodeItem(item);
 
             string xmlString = ServerUtils.BuildXmlResponse(result);
-            m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
+            //m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
             UTF8Encoding encoding = new UTF8Encoding();
             return encoding.GetBytes(xmlString);
         }
@@ -498,10 +525,10 @@ namespace OpenSim.Server.Handlers.Asset
             InventoryFolderBase folder = new InventoryFolderBase(id);
             folder = m_InventoryService.GetFolder(folder);
             if (folder != null)
-                result[folder.ID.ToString()] = EncodeFolder(folder);
+                result["folder"] = EncodeFolder(folder);
 
             string xmlString = ServerUtils.BuildXmlResponse(result);
-            m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
+            //m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
             UTF8Encoding encoding = new UTF8Encoding();
             return encoding.GetBytes(xmlString);
         }
@@ -513,12 +540,20 @@ namespace OpenSim.Server.Handlers.Asset
             UUID.TryParse(request["PRINCIPAL"].ToString(), out principal);
 
             List<InventoryItemBase> gestures = m_InventoryService.GetActiveGestures(principal);
+            Dictionary<string, object> items = new Dictionary<string, object>();
             if (gestures != null)
+            {
+                int i = 0;
                 foreach (InventoryItemBase item in gestures)
-                    result[item.ID.ToString()] = EncodeItem(item);
+                {
+                    items["item_" + i.ToString()] = EncodeItem(item);
+                    i++;
+                }
+            }
+            result["ITEMS"] = items;
 
             string xmlString = ServerUtils.BuildXmlResponse(result);
-            m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
+            //m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
             UTF8Encoding encoding = new UTF8Encoding();
             return encoding.GetBytes(xmlString);
         }
@@ -535,7 +570,31 @@ namespace OpenSim.Server.Handlers.Asset
 
             result["RESULT"] = perms.ToString();
             string xmlString = ServerUtils.BuildXmlResponse(result);
-            m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
+            //m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
+            UTF8Encoding encoding = new UTF8Encoding();
+            return encoding.GetBytes(xmlString);
+        }
+
+        byte[] HandleGetSystemFolders(Dictionary<string, object> request)
+        {
+            Dictionary<string, object> result = new Dictionary<string, object>();
+            UUID principal = UUID.Zero;
+            UUID.TryParse(request["PRINCIPAL"].ToString(), out principal);
+
+            Dictionary<AssetType, InventoryFolderBase> sfolders = GetSystemFolders(principal);
+            //m_log.DebugFormat("[XXX]: SystemFolders got {0} folders", sfolders.Count);
+
+            Dictionary<string, object> folders = new Dictionary<string, object>();
+            int i = 0;
+            foreach (KeyValuePair<AssetType, InventoryFolderBase> kvp in sfolders)
+            {
+                folders["folder_" + i.ToString()] = EncodeFolder(kvp.Value);
+                i++;
+            }
+            result["FOLDERS"] = folders;
+            
+            string xmlString = ServerUtils.BuildXmlResponse(result);
+            //m_log.DebugFormat("[XXX]: resp string: {0}", xmlString);
             UTF8Encoding encoding = new UTF8Encoding();
             return encoding.GetBytes(xmlString);
         }
@@ -569,7 +628,7 @@ namespace OpenSim.Server.Handlers.Asset
             ret["Flags"] = item.Flags.ToString();
             ret["Folder"] = item.Folder.ToString();
             ret["GroupID"] = item.GroupID.ToString();
-            ret["GroupedOwned"] = item.GroupOwned.ToString();
+            ret["GroupOwned"] = item.GroupOwned.ToString();
             ret["GroupPermissions"] = item.GroupPermissions.ToString();
             ret["ID"] = item.ID.ToString();
             ret["InvType"] = item.InvType.ToString();
@@ -623,5 +682,31 @@ namespace OpenSim.Server.Handlers.Asset
 
             return item;
         }
+
+        #region Extra
+        private Dictionary<AssetType, InventoryFolderBase> GetSystemFolders(UUID userID)
+        {
+            InventoryFolderBase root = m_InventoryService.GetRootFolder(userID);
+            if (root != null)
+            {
+                InventoryCollection content = m_InventoryService.GetFolderContent(userID, root.ID);
+                if (content != null)
+                {
+                    Dictionary<AssetType, InventoryFolderBase> folders = new Dictionary<AssetType, InventoryFolderBase>();
+                    foreach (InventoryFolderBase folder in content.Folders)
+                    {
+                        if ((folder.Type != (short)AssetType.Folder) && (folder.Type != (short)AssetType.Unknown))
+                            folders[(AssetType)folder.Type] = folder;
+                    }
+                    // Put the root folder there, as type Folder
+                    folders[AssetType.Folder] = root;
+                    return folders;
+                }
+            }
+            m_log.WarnFormat("[XINVENTORY SERVICE]: System folders for {0} not found", userID);
+            return new Dictionary<AssetType, InventoryFolderBase>();
+        }
+        #endregion
+
     }
 }

OpenSim/Server/Handlers/Login/LLLoginHandlers.cs

@@ -72,6 +72,9 @@ namespace OpenSim.Server.Handlers.Login
                     string last = requestData["last"].ToString();
                     string passwd = requestData["passwd"].ToString();
                     string startLocation = string.Empty;
+                    UUID scopeID = UUID.Zero;
+                    if (requestData["scope_id"] != null)
+                        scopeID = new UUID(requestData["scope_id"].ToString());
                     if (requestData.ContainsKey("start"))
                         startLocation = requestData["start"].ToString();
 
@@ -83,7 +86,7 @@ namespace OpenSim.Server.Handlers.Login
                     m_log.InfoFormat("[LOGIN]: XMLRPC Login Requested for {0} {1}, starting in {2}, using {3}", first, last, startLocation, clientVersion);
 
                     LoginResponse reply = null;
-                    reply = m_LocalService.Login(first, last, passwd, startLocation, remoteClient);
+                    reply = m_LocalService.Login(first, last, passwd, startLocation, scopeID, remoteClient);
 
                     XmlRpcResponse response = new XmlRpcResponse();
                     response.Value = reply.ToHashtable();
@@ -109,10 +112,15 @@ namespace OpenSim.Server.Handlers.Login
                     if (map.ContainsKey("start"))
                         startLocation = map["start"].AsString();
 
+                    UUID scopeID = UUID.Zero;
+
+                    if (map.ContainsKey("scope_id"))
+                        scopeID = new UUID(map["scope_id"].AsString());
+
                     m_log.Info("[LOGIN]: LLSD Login Requested for: '" + map["first"].AsString() + "' '" + map["last"].AsString() + "' / " + startLocation);
 
                     LoginResponse reply = null;
-                    reply = m_LocalService.Login(map["first"].AsString(), map["last"].AsString(), map["passwd"].AsString(), startLocation, remoteClient);
+                    reply = m_LocalService.Login(map["first"].AsString(), map["last"].AsString(), map["passwd"].AsString(), startLocation, scopeID, remoteClient);
                     return reply.ToOSDMap();
 
                 }

OpenSim/Services/AssetService/AssetService.cs

@@ -106,7 +106,10 @@ namespace OpenSim.Services.AssetService
                 return null;
 
             AssetBase asset = m_Database.GetAsset(assetID);
+            if (asset != null)
                 return asset.Metadata;
+
+            return null;
         }
 
         public byte[] GetData(string id)

OpenSim/Services/Connectors/Inventory/XInventoryConnector.cs

@@ -112,8 +112,15 @@ namespace OpenSim.Services.Connectors
 
             List<InventoryFolderBase> folders = new List<InventoryFolderBase>();
 
+            try
+            {
                 foreach (Object o in ret.Values)
                     folders.Add(BuildFolder((Dictionary<string, object>)o));
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[XINVENTORY CONNECTOR STUB]: Exception unwrapping folder list: {0}", e.Message);
+            }
 
             return folders;
         }
@@ -130,7 +137,7 @@ namespace OpenSim.Services.Connectors
             if (ret.Count == 0)
                 return null;
 
-            return BuildFolder(ret);
+            return BuildFolder((Dictionary<string, object>)ret["folder"]);
         }
 
         public InventoryFolderBase GetFolderForType(UUID principalID, AssetType type)
@@ -146,7 +153,7 @@ namespace OpenSim.Services.Connectors
             if (ret.Count == 0)
                 return null;
 
-            return BuildFolder(ret);
+            return BuildFolder((Dictionary<string, object>)ret["folder"]);
         }
 
         public InventoryCollection GetFolderContent(UUID principalID, UUID folderID)
@@ -173,10 +180,17 @@ namespace OpenSim.Services.Connectors
             Dictionary<string,object> items =
                     (Dictionary<string,object>)ret["ITEMS"];
 
-            foreach (Object o in folders.Values)
+            try
+            {
+                foreach (Object o in folders.Values) // getting the values directly, we don't care about the keys folder_i
                     inventory.Folders.Add(BuildFolder((Dictionary<string, object>)o));
-            foreach (Object o in items.Values)
+                foreach (Object o in items.Values) // getting the values directly, we don't care about the keys item_i
                     inventory.Items.Add(BuildItem((Dictionary<string, object>)o));
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[XINVENTORY CONNECTOR STUB]: Exception unwrapping content list: {0}", e.Message);
+            }
 
             return inventory;
         }
@@ -194,13 +208,12 @@ namespace OpenSim.Services.Connectors
             if (ret.Count == 0)
                 return null;
 
+            Dictionary<string, object> items = (Dictionary<string, object>)ret["ITEMS"];
+            List<InventoryItemBase> fitems = new List<InventoryItemBase>();
+            foreach (Object o in items.Values) // getting the values directly, we don't care about the keys item_i
+                fitems.Add(BuildItem((Dictionary<string, object>)o));
 
-            List<InventoryItemBase> items = new List<InventoryItemBase>();
+            return fitems;
-            
-            foreach (Object o in ret.Values)
-                items.Add(BuildItem((Dictionary<string,object>)o));
-
-            return items;
         }
 
         public bool AddFolder(InventoryFolderBase folder)
@@ -405,7 +418,7 @@ namespace OpenSim.Services.Connectors
             if (ret.Count == 0)
                 return null;
 
-            return BuildItem(ret);
+            return BuildItem((Dictionary<string, object>)ret["item"]);
         }
 
         public InventoryFolderBase GetFolder(InventoryFolderBase folder)
@@ -420,7 +433,7 @@ namespace OpenSim.Services.Connectors
             if (ret.Count == 0)
                 return null;
 
-            return BuildFolder(ret);
+            return BuildFolder((Dictionary<string, object>)ret["folder"]);
         }
 
         public List<InventoryItemBase> GetActiveGestures(UUID principalID)
@@ -435,7 +448,7 @@ namespace OpenSim.Services.Connectors
 
             List<InventoryItemBase> items = new List<InventoryItemBase>();
 
-            foreach (Object o in ret.Values)
+            foreach (Object o in ret.Values) // getting the values directly, we don't care about the keys item_i
                 items.Add(BuildItem((Dictionary<string, object>)o));
 
             return items;
@@ -455,6 +468,36 @@ namespace OpenSim.Services.Connectors
             return int.Parse(ret["RESULT"].ToString());
         }
 
+        public Dictionary<AssetType, InventoryFolderBase> GetSystemFolders(UUID userID)
+        {
+            Dictionary<string, object> ret = MakeRequest("GETSYSTEMFOLDERS",
+                    new Dictionary<string, object> {
+                        { "PRINCIPAL", userID.ToString() },
+                    });
+
+            if (ret == null)
+                return new Dictionary<AssetType,InventoryFolderBase>();
+
+            Dictionary<AssetType, InventoryFolderBase> sfolders = new Dictionary<AssetType, InventoryFolderBase>();
+
+            try
+            {
+                Dictionary<string, object> folders = (Dictionary<string, object>)ret["FOLDERS"];
+
+                foreach (Object o in folders.Values) // getting the values directly, we don't care about the keys folder_i
+                {
+                    InventoryFolderBase folder = BuildFolder((Dictionary<string, object>)o);
+                    sfolders.Add((AssetType)folder.Type, folder);
+                }
+
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[XINVENTORY CONNECTOR STUB]: exception {0}", e.Message);
+            }
+
+            return sfolders;
+        }
 
         // These are either obsolete or unused
         //
@@ -493,12 +536,19 @@ namespace OpenSim.Services.Connectors
         {
             InventoryFolderBase folder = new InventoryFolderBase();
 
+            try
+            {                
                 folder.ParentID = new UUID(data["ParentID"].ToString());
                 folder.Type = short.Parse(data["Type"].ToString());
                 folder.Version = ushort.Parse(data["Version"].ToString());
                 folder.Name = data["Name"].ToString();
                 folder.Owner = new UUID(data["Owner"].ToString());
                 folder.ID = new UUID(data["ID"].ToString());
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[XINVENTORY CONNECTOR STUB]: Exception building folder: {0}", e.Message);
+            }
 
             return folder;
         }
@@ -507,6 +557,8 @@ namespace OpenSim.Services.Connectors
         {
             InventoryItemBase item = new InventoryItemBase();
 
+            try
+            {
                 item.AssetID = new UUID(data["AssetID"].ToString());
                 item.AssetType = int.Parse(data["AssetType"].ToString());
                 item.Name = data["Name"].ToString();
@@ -527,6 +579,11 @@ namespace OpenSim.Services.Connectors
                 item.SaleType = byte.Parse(data["SaleType"].ToString());
                 item.Flags = uint.Parse(data["Flags"].ToString());
                 item.CreationDate = int.Parse(data["CreationDate"].ToString());
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[XINVENTORY CONNECTOR STUB]: Exception building item: {0}", e.Message);
+            }
 
             return item;
         }

OpenSim/Services/Interfaces/ILoginService.cs

@@ -31,6 +31,7 @@ using System.Collections.Generic;
 using System.Net;
 
 using OpenMetaverse.StructuredData;
+using OpenMetaverse;
 
 namespace OpenSim.Services.Interfaces
 {
@@ -46,7 +47,7 @@ namespace OpenSim.Services.Interfaces
 
     public interface ILoginService
     {
-        LoginResponse Login(string firstName, string lastName, string passwd, string startLocation, IPEndPoint clientIP);
+        LoginResponse Login(string firstName, string lastName, string passwd, string startLocation, UUID scopeID, IPEndPoint clientIP);
     }
 
 

OpenSim/Services/InventoryService/InventoryService.cs

@@ -109,7 +109,7 @@ namespace OpenSim.Services.InventoryService
             {
                 existingRootFolder = GetRootFolder(user);
             }
-            catch (Exception e)
+            catch /*(Exception e)*/
             {
                 // Munch the exception, it has already been reported
                 //

OpenSim/Services/InventoryService/XInventoryService.cs

@@ -184,7 +184,7 @@ namespace OpenSim.Services.InventoryService
 
             foreach (XInventoryFolder x in allFolders)
             {
-                m_log.DebugFormat("[INVENTORY]: Adding folder {0} to skeleton", x.folderName);
+                //m_log.DebugFormat("[XINVENTORY]: Adding folder {0} to skeleton", x.folderName);
                 folders.Add(ConvertToOpenSim(x));
             }
 
@@ -221,7 +221,7 @@ namespace OpenSim.Services.InventoryService
             // connector. So we disregard the principal and look
             // by ID.
             //
-            m_log.DebugFormat("[INVENTORY]: Fetch contents for folder {0}", folderID.ToString());
+            m_log.DebugFormat("[XINVENTORY]: Fetch contents for folder {0}", folderID.ToString());
             InventoryCollection inventory = new InventoryCollection();
             inventory.UserID = principalID;
             inventory.Folders = new List<InventoryFolderBase>();
@@ -233,7 +233,7 @@ namespace OpenSim.Services.InventoryService
 
             foreach (XInventoryFolder x in folders)
             {
-                m_log.DebugFormat("[INVENTORY]: Adding folder {0} to response", x.folderName);
+                //m_log.DebugFormat("[XINVENTORY]: Adding folder {0} to response", x.folderName);
                 inventory.Folders.Add(ConvertToOpenSim(x));
             }
 
@@ -243,7 +243,7 @@ namespace OpenSim.Services.InventoryService
 
             foreach (XInventoryItem i in items)
             {
-                m_log.DebugFormat("[INVENTORY]: Adding item {0} to response", i.inventoryName);
+                //m_log.DebugFormat("[XINVENTORY]: Adding item {0} to response", i.inventoryName);
                 inventory.Items.Add(ConvertToOpenSim(i));
             }
 

OpenSim/Services/LLLoginService/LLLoginService.cs

@@ -147,7 +147,7 @@ namespace OpenSim.Services.LLLoginService
         {
         }
 
-        public LoginResponse Login(string firstName, string lastName, string passwd, string startLocation, IPEndPoint clientIP)
+        public LoginResponse Login(string firstName, string lastName, string passwd, string startLocation, UUID scopeID, IPEndPoint clientIP)
         {
             bool success = false;
             UUID session = UUID.Random();
@@ -157,7 +157,7 @@ namespace OpenSim.Services.LLLoginService
                 //
                 // Get the account and check that it exists
                 //
-                UserAccount account = m_UserAccountService.GetUserAccount(UUID.Zero, firstName, lastName);
+                UserAccount account = m_UserAccountService.GetUserAccount(scopeID, firstName, lastName);
                 if (account == null)
                 {
                     m_log.InfoFormat("[LLOGIN SERVICE]: Login failed, reason: user not found");
@@ -170,6 +170,22 @@ namespace OpenSim.Services.LLLoginService
                     return LLFailedLoginResponse.LoginBlockedProblem;
                 }
 
+                // If a scope id is requested, check that the account is in
+                // that scope, or unscoped.
+                //
+                if (scopeID != UUID.Zero)
+                {
+                    if (account.ScopeID != scopeID && account.ScopeID != UUID.Zero)
+                    {
+                        m_log.InfoFormat("[LLOGIN SERVICE]: Login failed, reason: user not found");
+                        return LLFailedLoginResponse.UserProblem;
+                    }
+                }
+                else
+                {
+                    scopeID = account.ScopeID;
+                }
+
                 //
                 // Authenticate this user
                 //
@@ -219,7 +235,7 @@ namespace OpenSim.Services.LLLoginService
                     // Get the home region
                     if ((presence.HomeRegionID != UUID.Zero) && m_GridService != null)
                     {
-                        home = m_GridService.GetRegionByUUID(account.ScopeID, presence.HomeRegionID);
+                        home = m_GridService.GetRegionByUUID(scopeID, presence.HomeRegionID);
                     }
                 }
 
@@ -230,7 +246,7 @@ namespace OpenSim.Services.LLLoginService
                 Vector3 position = Vector3.Zero;
                 Vector3 lookAt = Vector3.Zero;
                 GridRegion gatekeeper = null;
-                GridRegion destination = FindDestination(account, presence, session, startLocation, out gatekeeper, out where, out position, out lookAt);
+                GridRegion destination = FindDestination(account, scopeID, presence, session, startLocation, out gatekeeper, out where, out position, out lookAt);
                 if (destination == null)
                 {
                     m_PresenceService.LogoutAgent(session, presence.Position, presence.LookAt);
@@ -286,7 +302,7 @@ namespace OpenSim.Services.LLLoginService
             }
         }
 
-        protected GridRegion FindDestination(UserAccount account, PresenceInfo pinfo, UUID sessionID, string startLocation, out GridRegion gatekeeper, out string where, out Vector3 position, out Vector3 lookAt)
+        protected GridRegion FindDestination(UserAccount account, UUID scopeID, PresenceInfo pinfo, UUID sessionID, string startLocation, out GridRegion gatekeeper, out string where, out Vector3 position, out Vector3 lookAt)
         {
             m_log.DebugFormat("[LLOGIN SERVICE]: FindDestination for start location {0}", startLocation);
 
@@ -318,7 +334,7 @@ namespace OpenSim.Services.LLLoginService
                 }
                 else
                 {
-                    region = m_GridService.GetRegionByUUID(account.ScopeID, pinfo.HomeRegionID);
+                    region = m_GridService.GetRegionByUUID(scopeID, pinfo.HomeRegionID);
 
                     if (null == region)
                     {
@@ -332,7 +348,7 @@ namespace OpenSim.Services.LLLoginService
                 
                 if (tryDefaults)
                 {
-                    List<GridRegion> defaults = m_GridService.GetDefaultRegions(account.ScopeID);
+                    List<GridRegion> defaults = m_GridService.GetDefaultRegions(scopeID);
                     if (defaults != null && defaults.Count > 0)
                     {
                         region = defaults[0];
@@ -342,7 +358,7 @@ namespace OpenSim.Services.LLLoginService
                     {
                         m_log.WarnFormat("[LLOGIN SERVICE]: User {0} {1} does not have a valid home and this grid does not have default locations. Attempting to find random region",
                             account.FirstName, account.LastName);
-                        defaults = m_GridService.GetRegionsByName(account.ScopeID, "", 1);
+                        defaults = m_GridService.GetRegionsByName(scopeID, "", 1);
                         if (defaults != null && defaults.Count > 0)
                         {
                             region = defaults[0];
@@ -363,9 +379,9 @@ namespace OpenSim.Services.LLLoginService
 
                 GridRegion region = null;
 
-                if (pinfo.RegionID.Equals(UUID.Zero) || (region = m_GridService.GetRegionByUUID(account.ScopeID, pinfo.RegionID)) == null)
+                if (pinfo.RegionID.Equals(UUID.Zero) || (region = m_GridService.GetRegionByUUID(scopeID, pinfo.RegionID)) == null)
                 {
-                    List<GridRegion> defaults = m_GridService.GetDefaultRegions(account.ScopeID);
+                    List<GridRegion> defaults = m_GridService.GetDefaultRegions(scopeID);
                     if (defaults != null && defaults.Count > 0)
                     {
                         region = defaults[0];
@@ -374,7 +390,7 @@ namespace OpenSim.Services.LLLoginService
                     else
                     {
                         m_log.Info("[LLOGIN SERVICE]: Last Region Not Found Attempting to find random region");
-                        defaults = m_GridService.GetRegionsByName(account.ScopeID, "", 1);
+                        defaults = m_GridService.GetRegionsByName(scopeID, "", 1);
                         if (defaults != null && defaults.Count > 0)
                         {
                             region = defaults[0];
@@ -414,11 +430,11 @@ namespace OpenSim.Services.LLLoginService
                     {
                         if (!regionName.Contains("@"))
                         {
-                            List<GridRegion> regions = m_GridService.GetRegionsByName(account.ScopeID, regionName, 1);
+                            List<GridRegion> regions = m_GridService.GetRegionsByName(scopeID, regionName, 1);
                             if ((regions == null) || (regions != null && regions.Count == 0))
                             {
                                 m_log.InfoFormat("[LLLOGIN SERVICE]: Got Custom Login URI {0}, can't locate region {1}. Trying defaults.", startLocation, regionName);
-                                regions = m_GridService.GetDefaultRegions(UUID.Zero);
+                                regions = m_GridService.GetDefaultRegions(scopeID);
                                 if (regions != null && regions.Count > 0)
                                 {
                                     where = "safe"; 
@@ -461,7 +477,7 @@ namespace OpenSim.Services.LLLoginService
                     }
                     else
                     {
-                        List<GridRegion> defaults = m_GridService.GetDefaultRegions(account.ScopeID);
+                        List<GridRegion> defaults = m_GridService.GetDefaultRegions(scopeID);
                         if (defaults != null && defaults.Count > 0)
                         {
                             where = "safe"; 

prebuild.xml

@@ -2251,6 +2251,7 @@
       </Files>
     </Project>
 
+    
     <Project frameworkVersion="v3_5" name="OpenSim.Region.ScriptEngine.Shared" path="OpenSim/Region/ScriptEngine/Shared" type="Library">
       <Configuration name="Debug">
         <Options>