4 files changed, 805 insertions, 58 deletions

diff --git a/OpenSim/Services/Connectors/Inventory/XInventoryConnector.cs b/OpenSim/Services/Connectors/Inventory/XInventoryConnector.cs
index 39e983b..9d96703 100644
--- a/OpenSim/Services/Connectors/Inventory/XInventoryConnector.cs
+++ b/OpenSim/Services/Connectors/Inventory/XInventoryConnector.cs
@@ -111,19 +111,21 @@ namespace OpenSim.Services.Connectors
             if (ret.Count == 0)
                 return null;
 
-            List<InventoryFolderBase> folders = new List<InventoryFolderBase>();
+            Dictionary<string, object> folders = (Dictionary<string, object>)ret["FOLDERS"];
+
+            List<InventoryFolderBase> fldrs = new List<InventoryFolderBase>();
 
             try
             {
-                foreach (Object o in ret.Values)
-                    folders.Add(BuildFolder((Dictionary<string, object>)o));
+                foreach (Object o in folders.Values)
+                    fldrs.Add(BuildFolder((Dictionary<string, object>)o));
             }
             catch (Exception e)
             {
                 m_log.DebugFormat("[XINVENTORY CONNECTOR STUB]: Exception unwrapping folder list: {0}", e.Message);
             }
 
-            return folders;
+            return fldrs;
         }
 
         public InventoryFolderBase GetRootFolder(UUID principalID)
@@ -492,12 +494,41 @@ namespace OpenSim.Services.Connectors
             return int.Parse(ret["RESULT"].ToString());
         }
 
-
-        // These are either obsolete or unused
-        //
         public InventoryCollection GetUserInventory(UUID principalID)
         {
-            return null;
+            InventoryCollection inventory = new InventoryCollection();
+            inventory.Folders = new List<InventoryFolderBase>();
+            inventory.Items = new List<InventoryItemBase>();
+            inventory.UserID = principalID;
+
+            try
+            {
+                Dictionary<string, object> ret = MakeRequest("GETUSERINVENTORY",
+                        new Dictionary<string, object> {
+                            { "PRINCIPAL", principalID.ToString() }
+                        });
+
+                if (ret == null)
+                    return null;
+                if (ret.Count == 0)
+                    return null;
+
+                Dictionary<string, object> folders =
+                        (Dictionary<string, object>)ret["FOLDERS"];
+                Dictionary<string, object> items =
+                        (Dictionary<string, object>)ret["ITEMS"];
+
+                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) // 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 in GetUserInventory: {0}", e.Message);
+            }
+
+            return inventory;
         }
 
         public void GetUserInventory(UUID principalID, InventoryReceiptCallback callback)
diff --git a/OpenSim/Services/HypergridService/HGInventoryService.cs b/OpenSim/Services/HypergridService/HGInventoryService.cs
index b29d803..2e9bd40 100644
--- a/OpenSim/Services/HypergridService/HGInventoryService.cs
+++ b/OpenSim/Services/HypergridService/HGInventoryService.cs
@@ -105,6 +105,12 @@ namespace OpenSim.Services.HypergridService
             return new List<InventoryFolderBase>();
         }
 
+        public override InventoryCollection GetUserInventory(UUID userID)
+        {
+            // NOGO for this inventory service
+            return null;
+        }
+
         public override InventoryFolderBase GetRootFolder(UUID principalID)
         {
             //m_log.DebugFormat("[HG INVENTORY SERVICE]: GetRootFolder for {0}", principalID);
diff --git a/OpenSim/Services/HypergridService/HGSuitcaseInventoryService.cs b/OpenSim/Services/HypergridService/HGSuitcaseInventoryService.cs
index cb686e2..e65ad17 100644
--- a/OpenSim/Services/HypergridService/HGSuitcaseInventoryService.cs
+++ b/OpenSim/Services/HypergridService/HGSuitcaseInventoryService.cs
@@ -48,7 +48,7 @@ namespace OpenSim.Services.HypergridService
     /// and it responds to GetRootFolder requests with the ID of the
     /// Suitcase folder, not the actual "My Inventory" folder.
     /// </summary>
-    public class HGSuitcaseInventoryService : XInventoryService, IInventoryService
+    public class HGSuitcaseInventoryService1 : XInventoryService, IInventoryService
     {
         private static readonly ILog m_log =
                 LogManager.GetLogger(
@@ -61,7 +61,7 @@ namespace OpenSim.Services.HypergridService
 
         private ExpiringCache<UUID, List<XInventoryFolder>> m_SuitcaseTrees = new ExpiringCache<UUID,List<XInventoryFolder>>();
 
-        public HGSuitcaseInventoryService(IConfigSource config, string configName)
+        public HGSuitcaseInventoryService1(IConfigSource config, string configName)
             : base(config, configName)
         {
             m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: Starting with config name {0}", configName);
@@ -104,11 +104,79 @@ namespace OpenSim.Services.HypergridService
             return false;
         }
 
-
         public override List<InventoryFolderBase> GetInventorySkeleton(UUID principalID)
         {
-            // NOGO for this inventory service
-            return new List<InventoryFolderBase>();
+            XInventoryFolder suitcase = GetSuitcaseXFolder(principalID);
+            XInventoryFolder root = GetRootXFolder(principalID);
+
+            List<XInventoryFolder> tree = GetFolderTree(suitcase.folderID);
+            if (tree == null || (tree != null && tree.Count == 0))
+                return null;
+
+            List<InventoryFolderBase> folders = new List<InventoryFolderBase>();
+            foreach (XInventoryFolder x in tree)
+            {
+                if (x.parentFolderID == suitcase.folderID)
+                    x.parentFolderID = root.folderID;
+
+                folders.Add(ConvertToOpenSim(x));
+            }
+
+            SetAsRootFolder(suitcase, root);
+            folders.Add(ConvertToOpenSim(suitcase));
+
+            return folders;
+        }
+
+        public override InventoryCollection GetUserInventory(UUID userID)
+        {
+            m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: Get Suitcase inventory for user {0}", userID);
+            InventoryCollection userInventory = new InventoryCollection();
+            userInventory.UserID = userID;
+            userInventory.Folders = new List<InventoryFolderBase>();
+            userInventory.Items = new List<InventoryItemBase>();
+
+            XInventoryFolder suitcase = GetSuitcaseXFolder(userID);
+            XInventoryFolder root = GetRootXFolder(userID);
+
+            List<XInventoryFolder> tree = GetFolderTree(suitcase.folderID);
+            if (tree == null || (tree != null && tree.Count == 0))
+            {
+                SetAsRootFolder(suitcase, root);
+                userInventory.Folders.Add(ConvertToOpenSim(suitcase));
+                return userInventory;
+            }
+
+            List<InventoryItemBase> items;
+            foreach (XInventoryFolder f in tree)
+            {
+                // Add the items of this subfolder
+                items = GetFolderItems(userID, f.folderID);
+                if (items != null && items.Count > 0)
+                {
+                    userInventory.Items.AddRange(items);
+                }
+
+                // Add the folder itself
+                if (f.parentFolderID == suitcase.folderID)
+                    f.parentFolderID = root.folderID;
+                userInventory.Folders.Add(ConvertToOpenSim(f));
+            }
+ 
+            items = GetFolderItems(userID, suitcase.folderID);
+            if (items != null && items.Count > 0)
+            {
+                foreach (InventoryItemBase i in items)
+                    i.Folder = root.folderID;
+                userInventory.Items.AddRange(items);
+            }
+
+            SetAsRootFolder(suitcase, root);
+            userInventory.Folders.Add(ConvertToOpenSim(suitcase));
+
+            m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: GetUserInventory for user {0} returning {1} folders and {2} items",
+                userID, userInventory.Folders.Count, userInventory.Items.Count);
+            return userInventory;
         }
 
         public override InventoryFolderBase GetRootFolder(UUID principalID)
@@ -131,23 +199,87 @@ namespace OpenSim.Services.HypergridService
             {
                 m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: User {0} does not have a Suitcase folder. Creating it...", principalID);
                 // make one, and let's add it to the user's inventory as a direct child of the root folder
+                // In the DB we tag it as type 100, but we use -1 (Unknown) outside
                 suitcase = CreateFolder(principalID, root.folderID, 100, "My Suitcase");
                 if (suitcase == null)
                     m_log.ErrorFormat("[HG SUITCASE INVENTORY SERVICE]: Unable to create suitcase folder");
+                suitcase.version = root.version;
+                m_Database.StoreFolder(suitcase);
 
+                // Create System folders
+                CreateSystemFolders(principalID, suitcase.folderID);
+            }
+            else if (suitcase.version < root.version)
+            {
+                suitcase.version = root.version;
                 m_Database.StoreFolder(suitcase);
             }
 
             // Now let's change the folder ID to match that of the real root folder
-            SetAsRootFolder(suitcase, root.folderID);
+            SetAsRootFolder(suitcase, root);
 
             return ConvertToOpenSim(suitcase);
         }
 
+        protected void CreateSystemFolders(UUID principalID, UUID rootID)
+        {
+            m_log.Debug("[HG SUITCASE INVENTORY SERVICE]: Creating System folders under Suitcase...");
+            XInventoryFolder[] sysFolders = GetSystemFolders(principalID, rootID);
+
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.Animation) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.Animation, "Animations");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.Bodypart) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.Bodypart, "Body Parts");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.CallingCard) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.CallingCard, "Calling Cards");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.Clothing) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.Clothing, "Clothing");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.Gesture) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.Gesture, "Gestures");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.Landmark) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.Landmark, "Landmarks");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.LostAndFoundFolder) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.LostAndFoundFolder, "Lost And Found");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.Notecard) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.Notecard, "Notecards");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.Object) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.Object, "Objects");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.SnapshotFolder) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.SnapshotFolder, "Photo Album");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.LSLText) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.LSLText, "Scripts");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.Sound) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.Sound, "Sounds");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.Texture) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.Texture, "Textures");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.TrashFolder) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.TrashFolder, "Trash");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.FavoriteFolder) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.FavoriteFolder, "Favorites");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.CurrentOutfitFolder) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.CurrentOutfitFolder, "Current Outfit");
+
+        }
+
         public override InventoryFolderBase GetFolderForType(UUID principalID, AssetType type)
         {
             //m_log.DebugFormat("[HG INVENTORY SERVICE]: GetFolderForType for {0} {0}", principalID, type);
-            return GetRootFolder(principalID);
+            XInventoryFolder suitcase = GetSuitcaseXFolder(principalID);
+            XInventoryFolder[] folders = m_Database.GetFolders(
+                    new string[] { "agentID", "type",  "parentFolderID"},
+                    new string[] { principalID.ToString(), ((int)type).ToString(), suitcase.folderID.ToString() });
+
+            if (folders.Length == 0)
+            {
+                m_log.WarnFormat("[HG SUITCASE INVENTORY SERVICE]: Found no folder for type {0} for user {1}", type, principalID);
+                return null;
+            }
+
+            m_log.DebugFormat(
+                "[HG SUITCASE INVENTORY SERVICE]: Found folder {0} {1} for type {2} for user {3}",
+                folders[0].folderName, folders[0].folderID, type, principalID);
+
+            return ConvertToOpenSim(folders[0]);
         }
 
         public override InventoryCollection GetFolderContent(UUID principalID, UUID folderID)
@@ -199,6 +331,7 @@ namespace OpenSim.Services.HypergridService
 
         public override bool AddFolder(InventoryFolderBase folder)
         {
+            m_log.WarnFormat("[HG SUITCASE INVENTORY SERVICE]: AddFolder {0} {1}", folder.Name, folder.ParentID);
             // Let's do a bit of sanity checking, more than the base service does
             // make sure the given folder's parent folder exists under the suitcase tree of this user
             XInventoryFolder root = GetRootXFolder(folder.Owner);
@@ -219,14 +352,37 @@ namespace OpenSim.Services.HypergridService
             return base.AddFolder(folder);
        }
 
-        public bool UpdateFolder(InventoryFolderBase folder)
+        public override bool UpdateFolder(InventoryFolderBase folder)
         {
             XInventoryFolder root = GetRootXFolder(folder.Owner);
             XInventoryFolder suitcase = GetSuitcaseXFolder(folder.Owner);
 
+            m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: Update folder {0}, version {1}", folder.ID, folder.Version);
             if (!IsWithinSuitcaseTree(folder.ID, root, suitcase))
+            {
+                m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: folder {0} not within Suitcase tree", folder.Name);
                 return false;
+            }
+
+            if (folder.ID == root.folderID)
+            {
+                if (folder.Version <= suitcase.version)
+                {
+                    m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: version {0} <= suitcase version {1}. Ignoring.", folder.Version, suitcase.version);
+                    return false;
+                }
+                if (folder.Version <= root.version)
+                {
+                    m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: version {0} <= root version {1}. Ignoring.", folder.Version, suitcase.version);
+                    return false;
+                }
+                suitcase.version = root.version = folder.Version;
+                m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: Storing {0} type {1} version {2}", suitcase.folderName, suitcase.type, suitcase.version);
+                m_Database.StoreFolder(suitcase);
+                m_Database.StoreFolder(root);
+            }
 
+            // For all others
             return base.UpdateFolder(folder);
         }
 
@@ -301,9 +457,6 @@ namespace OpenSim.Services.HypergridService
             XInventoryFolder root = GetRootXFolder(items[0].Owner);
             XInventoryFolder suitcase = GetSuitcaseXFolder(items[0].Owner);
 
-            if (!IsWithinSuitcaseTree(items[0].Folder, root, suitcase))
-                return false;
-
             foreach (InventoryItemBase it in items)
                 if (it.Folder == root.folderID)
                 {
@@ -312,6 +465,9 @@ namespace OpenSim.Services.HypergridService
                     it.Folder = suitcase.folderID;
                 }
 
+            if (!IsWithinSuitcaseTree(items[0].Folder, root, suitcase))
+                return false;
+
             return base.MoveItems(principalID, items);
 
         }
@@ -322,44 +478,57 @@ namespace OpenSim.Services.HypergridService
             return false;
         }
 
-        public override InventoryItemBase GetItem(InventoryItemBase item)
+        public new InventoryItemBase GetItem(InventoryItemBase item)
         {
             InventoryItemBase it = base.GetItem(item);
+            if (it == null)
+            {
+                m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: Unable to retrieve item {0} ({1}) in folder {2}",
+                    item.Name, item.ID, item.Folder);
+                return null;
+            }
             XInventoryFolder root = GetRootXFolder(it.Owner);
             XInventoryFolder suitcase = GetSuitcaseXFolder(it.Owner);
-
-            if (it != null)
+            if (root == null || suitcase == null)
             {
-                if (!IsWithinSuitcaseTree(it.Folder, root, suitcase))
-                    return null;
-
-                if (it.Folder == suitcase.folderID)
-                    it.Folder = root.folderID;
+                m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: Root or Suitcase are null for user {0}",
+                    it.Owner);
+                return null;
+            }
 
-                //    UserAccount user = m_Cache.GetUser(it.CreatorId);
+            if (it.Folder == suitcase.folderID)
+                it.Folder = root.folderID;
 
-                //    // Adjust the creator data
-                //    if (user != null && it != null && (it.CreatorData == null || it.CreatorData == string.Empty))
-                //        it.CreatorData = m_HomeURL + ";" + user.FirstName + " " + user.LastName;
-                //}
+            if (!IsWithinSuitcaseTree(it.Folder, root, suitcase))
+            {
+                m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: Item {0} (folder {1}) is not within Suitcase",
+                    it.Name, it.Folder);
+                return null;
             }
 
+            //    UserAccount user = m_Cache.GetUser(it.CreatorId);
+
+            //    // Adjust the creator data
+            //    if (user != null && it != null && (it.CreatorData == null || it.CreatorData == string.Empty))
+            //        it.CreatorData = m_HomeURL + ";" + user.FirstName + " " + user.LastName;
+            //}
+
             return it;
         }
 
-        public override InventoryFolderBase GetFolder(InventoryFolderBase folder)
+        public new InventoryFolderBase GetFolder(InventoryFolderBase folder)
         {
             InventoryFolderBase f = base.GetFolder(folder);
-            XInventoryFolder root = GetRootXFolder(f.Owner);
-            XInventoryFolder suitcase = GetSuitcaseXFolder(f.Owner);
 
             if (f != null)
             {
-                if (!IsWithinSuitcaseTree(f.ID, root, suitcase))
-                    return null;
-
+                XInventoryFolder root = GetRootXFolder(f.Owner);
+                XInventoryFolder suitcase = GetSuitcaseXFolder(f.Owner);
                 if (f.ParentID == suitcase.folderID)
                     f.ParentID = root.folderID;
+
+                if (!IsWithinSuitcaseTree(f.ID, root, suitcase))
+                    return null;
             }
 
             return f;
@@ -409,20 +578,22 @@ namespace OpenSim.Services.HypergridService
             return null;
         }
 
-        private void SetAsRootFolder(XInventoryFolder suitcase, UUID rootID)
+        private void SetAsRootFolder(XInventoryFolder suitcase, XInventoryFolder root)
         {
-            suitcase.folderID = rootID;
+            suitcase.version = root.version;
+            suitcase.folderID = root.folderID;
             suitcase.parentFolderID = UUID.Zero;
+            suitcase.type = (short)AssetType.Folder;
         }
 
-        private List<XInventoryFolder> GetFolderTree(UUID root)
+        private List<XInventoryFolder> GetFolderTree(UUID folder)
         {
             List<XInventoryFolder> t = null;
-            if (m_SuitcaseTrees.TryGetValue(root, out t))
+            if (m_SuitcaseTrees.TryGetValue(folder, out t))
                 return t;
 
-            t = GetFolderTreeRecursive(root);
-            m_SuitcaseTrees.AddOrUpdate(root, t, 120);
+            t = GetFolderTreeRecursive(folder);
+            m_SuitcaseTrees.AddOrUpdate(folder, t, 120);
             return t;
         }
 
@@ -447,6 +618,13 @@ namespace OpenSim.Services.HypergridService
 
         }
 
+        /// <summary>
+        /// Return true if the folderID is a subfolder of the Suitcase or the root folder ID itself
+        /// </summary>
+        /// <param name="folderID"></param>
+        /// <param name="root"></param>
+        /// <param name="suitcase"></param>
+        /// <returns></returns>
         private bool IsWithinSuitcaseTree(UUID folderID, XInventoryFolder root, XInventoryFolder suitcase)
         {
             List<XInventoryFolder> tree = new List<XInventoryFolder>();
@@ -463,4 +641,502 @@ namespace OpenSim.Services.HypergridService
         }
         #endregion
     }
+
+    public class HGSuitcaseInventoryService : XInventoryService, IInventoryService
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        private string m_HomeURL;
+        private IUserAccountService m_UserAccountService;
+
+        private UserAccountCache m_Cache;
+
+        private ExpiringCache<UUID, List<XInventoryFolder>> m_SuitcaseTrees = new ExpiringCache<UUID, List<XInventoryFolder>>();
+
+        public HGSuitcaseInventoryService(IConfigSource config, string configName)
+            : base(config, configName)
+        {
+            m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: Starting with config name {0}", configName);
+            if (configName != string.Empty)
+                m_ConfigName = configName;
+
+            if (m_Database == null)
+                m_log.WarnFormat("[XXX]: m_Database is null!");
+
+            //
+            // Try reading the [InventoryService] section, if it exists
+            //
+            IConfig invConfig = config.Configs[m_ConfigName];
+            if (invConfig != null)
+            {
+                // realm = authConfig.GetString("Realm", realm);
+                string userAccountsDll = invConfig.GetString("UserAccountsService", string.Empty);
+                if (userAccountsDll == string.Empty)
+                    throw new Exception("Please specify UserAccountsService in HGInventoryService configuration");
+
+                Object[] args = new Object[] { config };
+                m_UserAccountService = ServerUtils.LoadPlugin<IUserAccountService>(userAccountsDll, args);
+                if (m_UserAccountService == null)
+                    throw new Exception(String.Format("Unable to create UserAccountService from {0}", userAccountsDll));
+
+                // legacy configuration [obsolete]
+                m_HomeURL = invConfig.GetString("ProfileServerURI", string.Empty);
+                // Preferred
+                m_HomeURL = invConfig.GetString("HomeURI", m_HomeURL);
+
+                m_Cache = UserAccountCache.CreateUserAccountCache(m_UserAccountService);
+            }
+
+            m_log.Debug("[HG SUITCASE INVENTORY SERVICE]: Starting...");
+        }
+
+        public override bool CreateUserInventory(UUID principalID)
+        {
+            // NOGO
+            return false;
+        }
+
+        public override List<InventoryFolderBase> GetInventorySkeleton(UUID principalID)
+        {
+            XInventoryFolder suitcase = GetSuitcaseXFolder(principalID);
+            XInventoryFolder root = GetRootXFolder(principalID);
+
+            List<XInventoryFolder> tree = GetFolderTree(suitcase.folderID);
+            if (tree == null || (tree != null && tree.Count == 0))
+                return null;
+
+            List<InventoryFolderBase> folders = new List<InventoryFolderBase>();
+            foreach (XInventoryFolder x in tree)
+            {
+                folders.Add(ConvertToOpenSim(x));
+            }
+
+            SetAsRootFolder(suitcase, root);
+            folders.Add(ConvertToOpenSim(suitcase));
+
+            return folders;
+        }
+
+        public override InventoryCollection GetUserInventory(UUID userID)
+        {
+            m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: Get Suitcase inventory for user {0}", userID);
+            InventoryCollection userInventory = new InventoryCollection();
+            userInventory.UserID = userID;
+            userInventory.Folders = new List<InventoryFolderBase>();
+            userInventory.Items = new List<InventoryItemBase>();
+
+            XInventoryFolder suitcase = GetSuitcaseXFolder(userID);
+            XInventoryFolder root = GetRootXFolder(userID);
+
+            List<XInventoryFolder> tree = GetFolderTree(suitcase.folderID);
+            if (tree == null || (tree != null && tree.Count == 0))
+            {
+                SetAsRootFolder(suitcase, root);
+                userInventory.Folders.Add(ConvertToOpenSim(suitcase));
+                return userInventory;
+            }
+
+            List<InventoryItemBase> items;
+            foreach (XInventoryFolder f in tree)
+            {
+                // Add the items of this subfolder
+                items = GetFolderItems(userID, f.folderID);
+                if (items != null && items.Count > 0)
+                {
+                    userInventory.Items.AddRange(items);
+                }
+
+                // Add the folder itself
+                userInventory.Folders.Add(ConvertToOpenSim(f));
+            }
+
+            items = GetFolderItems(userID, suitcase.folderID);
+            if (items != null && items.Count > 0)
+            {
+                userInventory.Items.AddRange(items);
+            }
+
+            SetAsRootFolder(suitcase, root);
+            userInventory.Folders.Add(ConvertToOpenSim(suitcase));
+
+            m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: GetUserInventory for user {0} returning {1} folders and {2} items",
+                userID, userInventory.Folders.Count, userInventory.Items.Count);
+            return userInventory;
+        }
+
+        public override InventoryFolderBase GetRootFolder(UUID principalID)
+        {
+            m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: GetRootFolder for {0}", principalID);
+            if (m_Database == null)
+                m_log.ErrorFormat("[XXX]: m_Database is NULL!");
+
+            // Let's find out the local root folder
+            XInventoryFolder root = GetRootXFolder(principalID); ;
+            if (root == null)
+            {
+                m_log.WarnFormat("[HG SUITCASE INVENTORY SERVICE]: Unable to retrieve local root folder for user {0}", principalID);
+            }
+
+            // Warp! Root folder for travelers is the suitcase folder
+            XInventoryFolder suitcase = GetSuitcaseXFolder(principalID);
+
+            if (suitcase == null)
+            {
+                m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: User {0} does not have a Suitcase folder. Creating it...", principalID);
+                // make one, and let's add it to the user's inventory as a direct child of the root folder
+                // In the DB we tag it as type 100, but we use -1 (Unknown) outside
+                suitcase = CreateFolder(principalID, root.folderID, 100, "My Suitcase");
+                if (suitcase == null)
+                    m_log.ErrorFormat("[HG SUITCASE INVENTORY SERVICE]: Unable to create suitcase folder");
+                m_Database.StoreFolder(suitcase);
+
+                // Create System folders
+                CreateSystemFolders(principalID, suitcase.folderID);
+            }
+
+            SetAsRootFolder(suitcase, root);
+
+            return ConvertToOpenSim(suitcase);
+        }
+
+        protected void CreateSystemFolders(UUID principalID, UUID rootID)
+        {
+            m_log.Debug("[HG SUITCASE INVENTORY SERVICE]: Creating System folders under Suitcase...");
+            XInventoryFolder[] sysFolders = GetSystemFolders(principalID, rootID);
+
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.Animation) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.Animation, "Animations");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.Bodypart) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.Bodypart, "Body Parts");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.CallingCard) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.CallingCard, "Calling Cards");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.Clothing) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.Clothing, "Clothing");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.Gesture) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.Gesture, "Gestures");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.Landmark) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.Landmark, "Landmarks");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.LostAndFoundFolder) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.LostAndFoundFolder, "Lost And Found");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.Notecard) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.Notecard, "Notecards");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.Object) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.Object, "Objects");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.SnapshotFolder) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.SnapshotFolder, "Photo Album");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.LSLText) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.LSLText, "Scripts");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.Sound) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.Sound, "Sounds");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.Texture) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.Texture, "Textures");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.TrashFolder) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.TrashFolder, "Trash");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.FavoriteFolder) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.FavoriteFolder, "Favorites");
+            if (!Array.Exists(sysFolders, delegate(XInventoryFolder f) { if (f.type == (int)AssetType.CurrentOutfitFolder) return true; return false; }))
+                CreateFolder(principalID, rootID, (int)AssetType.CurrentOutfitFolder, "Current Outfit");
+
+        }
+
+        public override InventoryFolderBase GetFolderForType(UUID principalID, AssetType type)
+        {
+            //m_log.DebugFormat("[HG INVENTORY SERVICE]: GetFolderForType for {0} {0}", principalID, type);
+            XInventoryFolder suitcase = GetSuitcaseXFolder(principalID);
+            XInventoryFolder[] folders = m_Database.GetFolders(
+                    new string[] { "agentID", "type", "parentFolderID" },
+                    new string[] { principalID.ToString(), ((int)type).ToString(), suitcase.folderID.ToString() });
+
+            if (folders.Length == 0)
+            {
+                m_log.WarnFormat("[HG SUITCASE INVENTORY SERVICE]: Found no folder for type {0} for user {1}", type, principalID);
+                return null;
+            }
+
+            m_log.DebugFormat(
+                "[HG SUITCASE INVENTORY SERVICE]: Found folder {0} {1} for type {2} for user {3}",
+                folders[0].folderName, folders[0].folderID, type, principalID);
+
+            return ConvertToOpenSim(folders[0]);
+        }
+
+        public override InventoryCollection GetFolderContent(UUID principalID, UUID folderID)
+        {
+            InventoryCollection coll = null;
+            XInventoryFolder suitcase = GetSuitcaseXFolder(principalID);
+
+            if (!IsWithinSuitcaseTree(folderID, suitcase))
+                return new InventoryCollection();
+
+            coll = base.GetFolderContent(principalID, folderID);
+
+            if (coll == null)
+            {
+                m_log.WarnFormat("[HG SUITCASE INVENTORY SERVICE]: Something wrong with user {0}'s suitcase folder", principalID);
+                coll = new InventoryCollection();
+            }
+            return coll;
+        }
+
+        public override List<InventoryItemBase> GetFolderItems(UUID principalID, UUID folderID)
+        {
+            // Let's do a bit of sanity checking, more than the base service does
+            // make sure the given folder exists under the suitcase tree of this user
+            XInventoryFolder suitcase = GetSuitcaseXFolder(principalID);
+
+            if (!IsWithinSuitcaseTree(folderID, suitcase))
+                return new List<InventoryItemBase>();
+
+            return base.GetFolderItems(principalID, folderID);
+        }
+
+        public override bool AddFolder(InventoryFolderBase folder)
+        {
+            m_log.WarnFormat("[HG SUITCASE INVENTORY SERVICE]: AddFolder {0} {1}", folder.Name, folder.ParentID);
+            // Let's do a bit of sanity checking, more than the base service does
+            // make sure the given folder's parent folder exists under the suitcase tree of this user
+            XInventoryFolder suitcase = GetSuitcaseXFolder(folder.Owner);
+
+            if (!IsWithinSuitcaseTree(folder.ParentID, suitcase))
+                return false;
+
+            // OK, it's legit
+            return base.AddFolder(folder);
+        }
+
+        public override bool UpdateFolder(InventoryFolderBase folder)
+        {
+            XInventoryFolder suitcase = GetSuitcaseXFolder(folder.Owner);
+
+            m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: Update folder {0}, version {1}", folder.ID, folder.Version);
+            if (!IsWithinSuitcaseTree(folder.ID, suitcase))
+            {
+                m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: folder {0} not within Suitcase tree", folder.Name);
+                return false;
+            }
+
+            // For all others
+            return base.UpdateFolder(folder);
+        }
+
+        public override bool MoveFolder(InventoryFolderBase folder)
+        {
+            XInventoryFolder suitcase = GetSuitcaseXFolder(folder.Owner);
+
+            if (!IsWithinSuitcaseTree(folder.ID, suitcase) || !IsWithinSuitcaseTree(folder.ParentID, suitcase))
+                return false;
+
+            return base.MoveFolder(folder);
+        }
+
+        public override bool DeleteFolders(UUID principalID, List<UUID> folderIDs)
+        {
+            // NOGO
+            return false;
+        }
+
+        public override bool PurgeFolder(InventoryFolderBase folder)
+        {
+            // NOGO
+            return false;
+        }
+
+        public override bool AddItem(InventoryItemBase item)
+        {
+            // Let's do a bit of sanity checking, more than the base service does
+            // make sure the given folder's parent folder exists under the suitcase tree of this user
+            XInventoryFolder suitcase = GetSuitcaseXFolder(item.Owner);
+
+            if (!IsWithinSuitcaseTree(item.Folder, suitcase))
+                return false;
+
+            // OK, it's legit
+            return base.AddItem(item);
+
+        }
+
+        public override bool UpdateItem(InventoryItemBase item)
+        {
+            XInventoryFolder suitcase = GetSuitcaseXFolder(item.Owner);
+
+            if (!IsWithinSuitcaseTree(item.Folder, suitcase))
+                return false;
+
+            return base.UpdateItem(item);
+        }
+
+        public override bool MoveItems(UUID principalID, List<InventoryItemBase> items)
+        {
+            // Principal is b0rked. *sigh*
+
+            XInventoryFolder suitcase = GetSuitcaseXFolder(items[0].Owner);
+
+            if (!IsWithinSuitcaseTree(items[0].Folder, suitcase))
+                return false;
+
+            return base.MoveItems(principalID, items);
+
+        }
+
+        public override bool DeleteItems(UUID principalID, List<UUID> itemIDs)
+        {
+            return false;
+        }
+
+        public new InventoryItemBase GetItem(InventoryItemBase item)
+        {
+            InventoryItemBase it = base.GetItem(item);
+            if (it == null)
+            {
+                m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: Unable to retrieve item {0} ({1}) in folder {2}",
+                    item.Name, item.ID, item.Folder);
+                return null;
+            }
+            XInventoryFolder suitcase = GetSuitcaseXFolder(it.Owner);
+            if (suitcase == null)
+            {
+                m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: Root or Suitcase are null for user {0}",
+                    it.Owner);
+                return null;
+            }
+
+            if (!IsWithinSuitcaseTree(it.Folder, suitcase))
+            {
+                m_log.DebugFormat("[HG SUITCASE INVENTORY SERVICE]: Item {0} (folder {1}) is not within Suitcase",
+                    it.Name, it.Folder);
+                return null;
+            }
+
+            //    UserAccount user = m_Cache.GetUser(it.CreatorId);
+
+            //    // Adjust the creator data
+            //    if (user != null && it != null && (it.CreatorData == null || it.CreatorData == string.Empty))
+            //        it.CreatorData = m_HomeURL + ";" + user.FirstName + " " + user.LastName;
+            //}
+
+            return it;
+        }
+
+        public new InventoryFolderBase GetFolder(InventoryFolderBase folder)
+        {
+            InventoryFolderBase f = base.GetFolder(folder);
+
+            if (f != null)
+            {
+                XInventoryFolder suitcase = GetSuitcaseXFolder(f.Owner);
+
+                if (!IsWithinSuitcaseTree(f.ID, suitcase))
+                    return null;
+            }
+
+            return f;
+        }
+
+        //public List<InventoryItemBase> GetActiveGestures(UUID principalID)
+        //{
+        //}
+
+        //public int GetAssetPermissions(UUID principalID, UUID assetID)
+        //{
+        //}
+
+        #region Auxiliary functions
+        private XInventoryFolder GetXFolder(UUID userID, UUID folderID)
+        {
+            XInventoryFolder[] folders = m_Database.GetFolders(
+                    new string[] { "agentID", "folderID" },
+                    new string[] { userID.ToString(), folderID.ToString() });
+
+            if (folders.Length == 0)
+                return null;
+
+            return folders[0];
+        }
+
+        private XInventoryFolder GetRootXFolder(UUID principalID)
+        {
+            XInventoryFolder[] folders = m_Database.GetFolders(
+                new string[] { "agentID", "folderName", "type" },
+                new string[] { principalID.ToString(), "My Inventory", ((int)AssetType.RootFolder).ToString() });
+
+            if (folders != null && folders.Length > 0)
+                return folders[0];
+            return null;
+        }
+
+        private XInventoryFolder GetSuitcaseXFolder(UUID principalID)
+        {
+            // Warp! Root folder for travelers
+            XInventoryFolder[] folders = m_Database.GetFolders(
+                    new string[] { "agentID", "type" },
+                    new string[] { principalID.ToString(), "100" }); // This is a special folder type...
+
+            if (folders != null && folders.Length > 0)
+                return folders[0];
+            return null;
+        }
+
+        private void SetAsRootFolder(XInventoryFolder suitcase, XInventoryFolder root)
+        {
+            suitcase.type = (short)AssetType.Folder;
+        }
+
+        private List<XInventoryFolder> GetFolderTree(UUID folder)
+        {
+            List<XInventoryFolder> t = null;
+            if (m_SuitcaseTrees.TryGetValue(folder, out t))
+                return t;
+
+            t = GetFolderTreeRecursive(folder);
+            m_SuitcaseTrees.AddOrUpdate(folder, t, 120);
+            return t;
+        }
+
+        private List<XInventoryFolder> GetFolderTreeRecursive(UUID root)
+        {
+            List<XInventoryFolder> tree = new List<XInventoryFolder>();
+            XInventoryFolder[] folders = m_Database.GetFolders(
+                    new string[] { "parentFolderID" },
+                    new string[] { root.ToString() });
+
+            if (folders == null || (folders != null && folders.Length == 0))
+                return tree; // empty tree
+            else
+            {
+                foreach (XInventoryFolder f in folders)
+                {
+                    tree.Add(f);
+                    tree.AddRange(GetFolderTreeRecursive(f.folderID));
+                }
+                return tree;
+            }
+
+        }
+
+        /// <summary>
+        /// Return true if the folderID is a subfolder of the Suitcase or the suitcase folder  itself
+        /// </summary>
+        /// <param name="folderID"></param>
+        /// <param name="root"></param>
+        /// <param name="suitcase"></param>
+        /// <returns></returns>
+        private bool IsWithinSuitcaseTree(UUID folderID, XInventoryFolder suitcase)
+        {
+            List<XInventoryFolder> tree = new List<XInventoryFolder>();
+            tree.Add(suitcase); // Warp! the tree is the real root folder plus the children of the suitcase folder
+            tree.AddRange(GetFolderTree(suitcase.folderID));
+            XInventoryFolder f = tree.Find(delegate(XInventoryFolder fl)
+            {
+                if (fl.folderID == folderID) return true;
+                else return false;
+            });
+
+            if (f == null) return false;
+            else return true;
+        }
+        #endregion
+    }
+
 }
diff --git a/OpenSim/Services/InventoryService/XInventoryService.cs b/OpenSim/Services/InventoryService/XInventoryService.cs
index 7b2c3a6..0e7a358 100644
--- a/OpenSim/Services/InventoryService/XInventoryService.cs
+++ b/OpenSim/Services/InventoryService/XInventoryService.cs
@@ -40,9 +40,9 @@ namespace OpenSim.Services.InventoryService
 {
     public class XInventoryService : ServiceBase, IInventoryService
     {
-//        private static readonly ILog m_log =
-//                LogManager.GetLogger(
-//                MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
 
         protected IXInventoryData m_Database;
         protected bool m_AllowDelete = true;
@@ -113,7 +113,7 @@ namespace OpenSim.Services.InventoryService
                 result = true;
             }
 
-            XInventoryFolder[] sysFolders = GetSystemFolders(principalID);
+            XInventoryFolder[] sysFolders = GetSystemFolders(principalID, rootFolder.ID);
 
             if (!Array.Exists(sysFolders, delegate (XInventoryFolder f) { if (f.type == (int)AssetType.Animation) return true; return false; }))
                 CreateFolder(principalID, rootFolder.ID, (int)AssetType.Animation, "Animations");
@@ -163,13 +163,13 @@ namespace OpenSim.Services.InventoryService
             return newFolder;
         }
 
-        protected virtual XInventoryFolder[] GetSystemFolders(UUID principalID)
+        protected virtual XInventoryFolder[] GetSystemFolders(UUID principalID, UUID rootID)
         {
 //            m_log.DebugFormat("[XINVENTORY SERVICE]: Getting system folders for {0}", principalID);
             
             XInventoryFolder[] allFolders = m_Database.GetFolders(
-                    new string[] { "agentID" },
-                    new string[] { principalID.ToString() });
+                    new string[] { "agentID", "parentFolderID" },
+                    new string[] { principalID.ToString(), rootID.ToString() });
 
             XInventoryFolder[] sysFolders = Array.FindAll(
                     allFolders,
@@ -301,16 +301,26 @@ namespace OpenSim.Services.InventoryService
 
         public virtual bool AddFolder(InventoryFolderBase folder)
         {
+            //m_log.DebugFormat("[XINVENTORY]: Add folder {0} type {1} in parent {2}", folder.Name, folder.Type, folder.ParentID);
             InventoryFolderBase check = GetFolder(folder);
             if (check != null)
                 return false;
 
-            XInventoryFolder xFolder = ConvertFromOpenSim(folder);
-            return m_Database.StoreFolder(xFolder);
+            if (folder.Type == (short)AssetType.Folder || folder.Type == (short)AssetType.Unknown ||
+                GetFolderForType(folder.Owner, (AssetType)(folder.Type)) == null)
+            {
+                XInventoryFolder xFolder = ConvertFromOpenSim(folder);
+                return m_Database.StoreFolder(xFolder);
+            }
+            else
+                m_log.DebugFormat("[XINVENTORY]: Folder {0} of type {1} already exists", folder.Name, folder.Type);
+
+            return false;
         }
 
         public virtual bool UpdateFolder(InventoryFolderBase folder)
         {
+            //m_log.DebugFormat("[XINVENTORY]: Update folder {0} {1} ({2})", folder.Name, folder.Type, folder.ID);
             XInventoryFolder xFolder = ConvertFromOpenSim(folder);
             InventoryFolderBase check = GetFolder(folder);
             if (check == null)
@@ -319,9 +329,13 @@ namespace OpenSim.Services.InventoryService
             if (check.Type != -1 || xFolder.type != -1)
             {
                 if (xFolder.version < check.Version)
+                {
+                    //m_log.DebugFormat("[XINVENTORY]: {0} < {1} can't do", xFolder.version, check.Version);
                     return false;
+                }
                 check.Version = (ushort)xFolder.version;
                 xFolder = ConvertFromOpenSim(check);
+                //m_log.DebugFormat("[XINVENTORY]: Storing {0} {1} {2}", xFolder.folderName, xFolder.version, xFolder.type);
                 return m_Database.StoreFolder(xFolder);
             }
 
@@ -499,13 +513,30 @@ namespace OpenSim.Services.InventoryService
             return m_Database.GetAssetPermissions(principalID, assetID);
         }
 
-        // CM never needed those. Left unimplemented.
-        // Obsolete in core
-        //
-        public InventoryCollection GetUserInventory(UUID userID)
+        public virtual InventoryCollection GetUserInventory(UUID userID)
         {
-            return null;
+            InventoryCollection userInventory = new InventoryCollection();
+            userInventory.UserID = userID;
+            userInventory.Folders = new List<InventoryFolderBase>();
+            userInventory.Items = new List<InventoryItemBase>();
+
+            List<InventoryFolderBase> skel = GetInventorySkeleton(userID);
+            if (skel != null)
+            {
+                foreach (InventoryFolderBase f in skel)
+                {
+                    InventoryCollection c = GetFolderContent(userID, f.ID);
+                    if (c != null && c.Items != null && c.Items.Count > 0)
+                        userInventory.Items.AddRange(c.Items);
+                    if (c != null && c.Folders != null && c.Folders.Count > 0)
+                        userInventory.Folders.AddRange(c.Folders);
+                }
+            }
+            m_log.DebugFormat("[XINVENTORY SERVICE]: GetUserInventory for user {0} returning {1} folders and {2} items",
+                userID, userInventory.Folders.Count, userInventory.Items.Count);
+            return userInventory;
         }
+
         public void GetUserInventory(UUID userID, InventoryReceiptCallback callback)
         {
         }
@@ -525,6 +556,9 @@ namespace OpenSim.Services.InventoryService
 
             newFolder.ParentID = folder.parentFolderID;
             newFolder.Type = (short)folder.type;
+            // Viewer can't understand anything that's not in it's LLFolderType enum
+            if (newFolder.Type == 100)
+                newFolder.Type = -1;
             newFolder.Version = (ushort)folder.version;
             newFolder.Name = folder.folderName;
             newFolder.Owner = folder.agentID;