Merge branch 'master' into careminster-presence-refactor

Also prevent god takes from ending up in Lost and Found

3 files changed, 475 insertions, 32 deletions

diff --git a/OpenSim/Framework/Serialization/External/ExternalRepresentationUtils.cs b/OpenSim/Framework/Serialization/External/ExternalRepresentationUtils.cs
new file mode 100644
index 0000000..6e8c2ee
--- /dev/null
+++ b/OpenSim/Framework/Serialization/External/ExternalRepresentationUtils.cs
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Xml;
+
+using OpenMetaverse;
+using OpenSim.Services.Interfaces;
+
+namespace OpenSim.Framework.Serialization.External
+{
+    /// <summary>
+    /// Utilities for manipulating external representations of data structures in OpenSim
+    /// </summary>
+    public class ExternalRepresentationUtils
+    {
+        /// <summary>
+        /// Takes a XML representation of a SceneObjectPart and returns another XML representation
+        /// with creator data added to it.
+        /// </summary>
+        /// <param name="xml">The SceneObjectPart represented in XML2</param>
+        /// <param name="profileURL">The URL of the profile service for the creator</param>
+        /// <param name="userService">The service for retrieving user account information</param>
+        /// <param name="scopeID">The scope of the user account information (Grid ID)</param>
+        /// <returns>The SceneObjectPart represented in XML2</returns>
+        public static string RewriteSOP(string xml, string profileURL, IUserAccountService userService, UUID scopeID)
+        {
+            if (xml == string.Empty || profileURL == string.Empty || userService == null)
+                return xml;
+
+            XmlDocument doc = new XmlDocument();
+            doc.LoadXml(xml);
+            XmlNodeList sops = doc.GetElementsByTagName("SceneObjectPart");
+
+            foreach (XmlNode sop in sops)
+            {
+                UserAccount creator = null;
+                bool hasCreatorData = false;
+                XmlNodeList nodes = sop.ChildNodes;
+                foreach (XmlNode node in nodes)
+                {
+                    if (node.Name == "CreatorID")
+                    {
+                        UUID uuid = UUID.Zero;
+                        UUID.TryParse(node.InnerText, out uuid);
+                        creator = userService.GetUserAccount(scopeID, uuid);
+                    }
+                    if (node.Name == "CreatorData" && node.InnerText != null && node.InnerText != string.Empty)
+                        hasCreatorData = true;
+
+                    //if (node.Name == "OwnerID")
+                    //{
+                    //    UserAccount owner = GetUser(node.InnerText);
+                    //    if (owner != null)
+                    //        node.InnerText = m_ProfileServiceURL + "/" + node.InnerText + "/" + owner.FirstName + " " + owner.LastName;
+                    //}
+                }
+                if (!hasCreatorData && creator != null)
+                {
+                    XmlElement creatorData = doc.CreateElement("CreatorData");
+                    creatorData.InnerText = profileURL + "/" + creator.PrincipalID + ";" + creator.FirstName + " " + creator.LastName;
+                    sop.AppendChild(creatorData);
+                }
+            }
+
+            using (StringWriter wr = new StringWriter())
+            {
+                doc.Save(wr);
+                return wr.ToString();
+            }
+
+        }
+    }
+}
diff --git a/OpenSim/Framework/Serialization/External/OspResolver.cs b/OpenSim/Framework/Serialization/External/OspResolver.cs
new file mode 100644
index 0000000..7e3dd1b
--- /dev/null
+++ b/OpenSim/Framework/Serialization/External/OspResolver.cs
@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System.Reflection;
+using System.Text;
+using log4net;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Services.Interfaces;
+
+namespace OpenSim.Framework.Serialization
+{
+    /// <summary>
+    /// Resolves OpenSim Profile Anchors (OSPA).  An OSPA is a string used to provide information for 
+    /// identifying user profiles or supplying a simple name if no profile is available.
+    /// </summary>
+    public class OspResolver
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        
+        public const string OSPA_PREFIX = "ospa:";
+        public const string OSPA_NAME_KEY = "n";
+        public const string OSPA_NAME_VALUE_SEPARATOR = " ";
+        public const string OSPA_TUPLE_SEPARATOR = "|";
+        public static readonly char[] OSPA_TUPLE_SEPARATOR_ARRAY = OSPA_TUPLE_SEPARATOR.ToCharArray();
+        public const string OSPA_PAIR_SEPARATOR = "=";
+
+        /// <summary>
+        /// Make an OSPA given a user UUID
+        /// </summary>
+        /// <param name="userId"></param>
+        /// <param name="commsManager"></param>
+        /// <returns>The OSPA.  Null if a user with the given UUID could not be found.</returns>
+        public static string MakeOspa(UUID userId, IUserAccountService userService)
+        {
+            if (userService == null)
+            {
+                m_log.Warn("[OSP RESOLVER]: UserService is null");
+                return userId.ToString();
+            }
+
+            UserAccount account = userService.GetUserAccount(UUID.Zero, userId);
+            if (account != null)
+                return MakeOspa(account.FirstName, account.LastName);
+
+            return null;
+        }
+        
+        /// <summary>
+        /// Make an OSPA given a user name
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        public static string MakeOspa(string firstName, string lastName)
+        {
+            return 
+                OSPA_PREFIX + OSPA_NAME_KEY + OSPA_PAIR_SEPARATOR + firstName + OSPA_NAME_VALUE_SEPARATOR + lastName;
+        }
+        
+        /// <summary>
+        /// Resolve an osp string into the most suitable internal OpenSim identifier.
+        /// </summary>
+        /// 
+        /// In some cases this will be a UUID if a suitable profile exists on the system.  In other cases, this may
+        /// just return the same identifier after creating a temporary profile.
+        /// 
+        /// <param name="ospa"></param>
+        /// <param name="commsManager"></param>
+        /// <returns>
+        /// A suitable UUID for use in Second Life client communication.  If the string was not a valid ospa, then UUID.Zero
+        /// is returned.
+        /// </returns>
+        public static UUID ResolveOspa(string ospa, IUserAccountService userService)
+        {
+            if (!ospa.StartsWith(OSPA_PREFIX))
+                return UUID.Zero;
+
+//            m_log.DebugFormat("[OSP RESOLVER]: Resolving {0}", ospa);
+            
+            string ospaMeat = ospa.Substring(OSPA_PREFIX.Length);
+            string[] ospaTuples = ospaMeat.Split(OSPA_TUPLE_SEPARATOR_ARRAY);
+            
+            foreach (string tuple in ospaTuples)
+            {
+                int tupleSeparatorIndex = tuple.IndexOf(OSPA_PAIR_SEPARATOR);
+
+                if (tupleSeparatorIndex < 0)
+                {
+                    m_log.WarnFormat("[OSP RESOLVER]: Ignoring non-tuple component {0} in OSPA {1}", tuple, ospa);
+                    continue;
+                }
+                
+                string key = tuple.Remove(tupleSeparatorIndex).Trim();
+                string value = tuple.Substring(tupleSeparatorIndex + 1).Trim();
+                
+                if (OSPA_NAME_KEY == key)
+                    return ResolveOspaName(value, userService);
+            }
+            
+            return UUID.Zero;
+        }
+        
+        /// <summary>
+        /// Hash a profile name into a UUID
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        public static UUID HashName(string name)
+        {
+            return new UUID(Utils.MD5(Encoding.Unicode.GetBytes(name)), 0);
+        }
+        
+        /// <summary>
+        /// Resolve an OSPI name by querying existing persistent user profiles.  If there is no persistent user profile
+        /// then a temporary user profile is inserted in the cache.
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="commsManager"></param>
+        /// <returns>
+        /// An OpenSim internal identifier for the name given.  Returns null if the name was not valid
+        /// </returns>
+        protected static UUID ResolveOspaName(string name, IUserAccountService userService)
+        {
+            if (userService == null)
+                return UUID.Zero;
+
+            int nameSeparatorIndex = name.IndexOf(OSPA_NAME_VALUE_SEPARATOR);
+            
+            if (nameSeparatorIndex < 0)
+            {
+                m_log.WarnFormat("[OSP RESOLVER]: Ignoring unseparated name {0}", name);
+                return UUID.Zero;
+            }
+            
+            string firstName = name.Remove(nameSeparatorIndex).TrimEnd();
+            string lastName = name.Substring(nameSeparatorIndex + 1).TrimStart();
+
+            UserAccount account = userService.GetUserAccount(UUID.Zero, firstName, lastName);
+            if (account != null)
+                return account.PrincipalID;
+
+            // XXX: Disable temporary user profile creation for now as implementation is incomplete - justincc
+            /*
+            UserProfileData tempUserProfile = new UserProfileData();
+            tempUserProfile.FirstName = firstName;
+            tempUserProfile.SurName = lastName;
+            tempUserProfile.ID = HashName(tempUserProfile.Name);
+            
+            m_log.DebugFormat(
+                "[OSP RESOLVER]: Adding temporary user profile for {0} {1}", tempUserProfile.Name, tempUserProfile.ID);
+            commsManager.UserService.AddTemporaryUserProfile(tempUserProfile);
+            
+            return tempUserProfile.ID;
+            */
+
+            return UUID.Zero;
+        }
+    }
+}
diff --git a/OpenSim/Framework/Serialization/External/UserInventoryItemSerializer.cs b/OpenSim/Framework/Serialization/External/UserInventoryItemSerializer.cs
index 862cc72..d5e84c7 100644
--- a/OpenSim/Framework/Serialization/External/UserInventoryItemSerializer.cs
+++ b/OpenSim/Framework/Serialization/External/UserInventoryItemSerializer.cs
@@ -26,11 +26,16 @@
  */
 
 using System;
+using System.Collections.Generic;
 using System.IO;
+using System.Reflection;
 using System.Text;
 using System.Xml;
+
+using log4net;
 using OpenMetaverse;
 using OpenSim.Framework;
+using OpenSim.Services.Interfaces;
     
 namespace OpenSim.Framework.Serialization.External
 {        
@@ -40,6 +45,141 @@ namespace OpenSim.Framework.Serialization.External
     /// XXX: Please do not use yet.
     public class UserInventoryItemSerializer
     {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private delegate void InventoryItemXmlProcessor(InventoryItemBase item, XmlTextReader reader);
+        private static Dictionary<string, InventoryItemXmlProcessor> m_InventoryItemXmlProcessors = new Dictionary<string, InventoryItemXmlProcessor>();
+
+        #region InventoryItemBase Processor initialization 
+        static UserInventoryItemSerializer()
+        {
+            m_InventoryItemXmlProcessors.Add("Name", ProcessName);
+            m_InventoryItemXmlProcessors.Add("ID", ProcessID);
+            m_InventoryItemXmlProcessors.Add("InvType", ProcessInvType);
+            m_InventoryItemXmlProcessors.Add("CreatorUUID", ProcessCreatorUUID);
+            m_InventoryItemXmlProcessors.Add("CreatorID", ProcessCreatorID); 
+            m_InventoryItemXmlProcessors.Add("CreatorData", ProcessCreatorData);
+            m_InventoryItemXmlProcessors.Add("CreationDate", ProcessCreationDate);
+            m_InventoryItemXmlProcessors.Add("Owner", ProcessOwner);
+            m_InventoryItemXmlProcessors.Add("Description", ProcessDescription);
+            m_InventoryItemXmlProcessors.Add("AssetType", ProcessAssetType);
+            m_InventoryItemXmlProcessors.Add("AssetID", ProcessAssetID);
+            m_InventoryItemXmlProcessors.Add("SaleType", ProcessSaleType);
+            m_InventoryItemXmlProcessors.Add("SalePrice", ProcessSalePrice);
+            m_InventoryItemXmlProcessors.Add("BasePermissions", ProcessBasePermissions);
+            m_InventoryItemXmlProcessors.Add("CurrentPermissions", ProcessCurrentPermissions);
+            m_InventoryItemXmlProcessors.Add("EveryOnePermissions", ProcessEveryOnePermissions);
+            m_InventoryItemXmlProcessors.Add("NextPermissions", ProcessNextPermissions);
+            m_InventoryItemXmlProcessors.Add("Flags", ProcessFlags);
+            m_InventoryItemXmlProcessors.Add("GroupID", ProcessGroupID);
+            m_InventoryItemXmlProcessors.Add("GroupOwned", ProcessGroupOwned);
+        }
+        #endregion 
+
+        #region InventoryItemBase Processors
+        private static void ProcessName(InventoryItemBase item, XmlTextReader reader)
+        {
+            item.Name = reader.ReadElementContentAsString("Name", String.Empty);
+        }
+
+        private static void ProcessID(InventoryItemBase item, XmlTextReader reader)
+        {
+            item.ID = Util.ReadUUID(reader, "ID");
+        }
+
+        private static void ProcessInvType(InventoryItemBase item, XmlTextReader reader)
+        {
+            item.InvType = reader.ReadElementContentAsInt("InvType", String.Empty);
+        }
+
+        private static void ProcessCreatorUUID(InventoryItemBase item, XmlTextReader reader)
+        {
+            item.CreatorId = reader.ReadElementContentAsString("CreatorUUID", String.Empty);
+        }
+
+        private static void ProcessCreatorID(InventoryItemBase item, XmlTextReader reader)
+        {
+            // when it exists, this overrides the previous
+            item.CreatorId = reader.ReadElementContentAsString("CreatorID", String.Empty);
+        }
+
+        private static void ProcessCreationDate(InventoryItemBase item, XmlTextReader reader)
+        {
+            item.CreationDate = reader.ReadElementContentAsInt("CreationDate", String.Empty);
+        }
+
+        private static void ProcessOwner(InventoryItemBase item, XmlTextReader reader)
+        {
+            item.Owner = Util.ReadUUID(reader, "Owner");
+        }
+
+        private static void ProcessDescription(InventoryItemBase item, XmlTextReader reader)
+        {
+            item.Description = reader.ReadElementContentAsString("Description", String.Empty);
+        }
+
+        private static void ProcessAssetType(InventoryItemBase item, XmlTextReader reader)
+        {
+            item.AssetType = reader.ReadElementContentAsInt("AssetType", String.Empty);
+        }
+
+        private static void ProcessAssetID(InventoryItemBase item, XmlTextReader reader)
+        {
+            item.AssetID = Util.ReadUUID(reader, "AssetID");
+        }
+
+        private static void ProcessSaleType(InventoryItemBase item, XmlTextReader reader)
+        {
+            item.SaleType = (byte)reader.ReadElementContentAsInt("SaleType", String.Empty);
+        }
+
+        private static void ProcessSalePrice(InventoryItemBase item, XmlTextReader reader)
+        {
+            item.SalePrice = reader.ReadElementContentAsInt("SalePrice", String.Empty);
+        }
+
+        private static void ProcessBasePermissions(InventoryItemBase item, XmlTextReader reader)
+        {
+            item.BasePermissions = (uint)reader.ReadElementContentAsInt("BasePermissions", String.Empty);
+        }
+
+        private static void ProcessCurrentPermissions(InventoryItemBase item, XmlTextReader reader)
+        {
+            item.CurrentPermissions = (uint)reader.ReadElementContentAsInt("CurrentPermissions", String.Empty);
+        }
+
+        private static void ProcessEveryOnePermissions(InventoryItemBase item, XmlTextReader reader)
+        {
+            item.EveryOnePermissions = (uint)reader.ReadElementContentAsInt("EveryOnePermissions", String.Empty);
+        }
+
+        private static void ProcessNextPermissions(InventoryItemBase item, XmlTextReader reader)
+        {
+            item.NextPermissions = (uint)reader.ReadElementContentAsInt("NextPermissions", String.Empty);
+        }
+
+        private static void ProcessFlags(InventoryItemBase item, XmlTextReader reader)
+        {
+            item.Flags = (uint)reader.ReadElementContentAsInt("Flags", String.Empty);
+        }
+
+        private static void ProcessGroupID(InventoryItemBase item, XmlTextReader reader)
+        {
+            item.GroupID = Util.ReadUUID(reader, "GroupID");
+        }
+
+        private static void ProcessGroupOwned(InventoryItemBase item, XmlTextReader reader)
+        {
+            item.GroupOwned = Util.ReadBoolean(reader);
+        }
+
+        private static void ProcessCreatorData(InventoryItemBase item, XmlTextReader reader)
+        {
+            item.CreatorData = reader.ReadElementContentAsString("CreatorData", String.Empty);
+        }
+
+        #endregion
+
         /// <summary>
         /// Deserialize item
         /// </summary>
@@ -60,40 +200,47 @@ namespace OpenSim.Framework.Serialization.External
         public static InventoryItemBase Deserialize(string serialization)
         {
             InventoryItemBase item = new InventoryItemBase();
-            
-            StringReader sr = new StringReader(serialization);
-            XmlTextReader xtr = new XmlTextReader(sr);
-            
-            xtr.ReadStartElement("InventoryItem");
-            
-            item.Name                   =                   xtr.ReadElementString("Name");
-            item.ID                     = UUID.Parse(       xtr.ReadElementString("ID"));
-            item.InvType                = Convert.ToInt32(  xtr.ReadElementString("InvType"));            
-            item.CreatorId              =                   xtr.ReadElementString("CreatorUUID");
-            item.CreationDate           = Convert.ToInt32(  xtr.ReadElementString("CreationDate"));
-            item.Owner                  = UUID.Parse(       xtr.ReadElementString("Owner"));
-            item.Description            =                   xtr.ReadElementString("Description");
-            item.AssetType              = Convert.ToInt32(  xtr.ReadElementString("AssetType"));
-            item.AssetID                = UUID.Parse(       xtr.ReadElementString("AssetID"));
-            item.SaleType               = Convert.ToByte(   xtr.ReadElementString("SaleType"));
-            item.SalePrice              = Convert.ToInt32(  xtr.ReadElementString("SalePrice"));
-            item.BasePermissions        = Convert.ToUInt32( xtr.ReadElementString("BasePermissions"));
-            item.CurrentPermissions     = Convert.ToUInt32( xtr.ReadElementString("CurrentPermissions"));
-            item.EveryOnePermissions    = Convert.ToUInt32( xtr.ReadElementString("EveryOnePermissions"));
-            item.NextPermissions        = Convert.ToUInt32( xtr.ReadElementString("NextPermissions"));
-            item.Flags                  = Convert.ToUInt32( xtr.ReadElementString("Flags"));
-            item.GroupID                = UUID.Parse(       xtr.ReadElementString("GroupID"));
-            item.GroupOwned             = Convert.ToBoolean(xtr.ReadElementString("GroupOwned"));
-            
-            xtr.ReadEndElement();
-            
-            xtr.Close();
-            sr.Close();
-            
+
+            using (XmlTextReader reader = new XmlTextReader(new StringReader(serialization)))
+            {
+                reader.ReadStartElement("InventoryItem");
+
+                string nodeName = string.Empty;
+                while (reader.NodeType != XmlNodeType.EndElement)
+                {
+                    nodeName = reader.Name;
+                    InventoryItemXmlProcessor p = null;
+                    if (m_InventoryItemXmlProcessors.TryGetValue(reader.Name, out p))
+                    {
+                        //m_log.DebugFormat("[XXX] Processing: {0}", reader.Name);
+                        try
+                        {
+                            p(item, reader);
+                        }
+                        catch (Exception e)
+                        {
+                            m_log.DebugFormat("[InventoryItemSerializer]: exception while parsing {0}: {1}", nodeName, e);
+                            if (reader.NodeType == XmlNodeType.EndElement)
+                                reader.Read();
+                        }
+                    }
+                    else
+                    {
+                        // m_log.DebugFormat("[InventoryItemSerializer]: caught unknown element {0}", nodeName);
+                        reader.ReadOuterXml(); // ignore
+                    }
+
+                }
+
+                reader.ReadEndElement(); // InventoryItem
+            }
+
+            //m_log.DebugFormat("[XXX]: parsed InventoryItemBase {0} - {1}", obj.Name, obj.UUID);
             return item;
+
         }      
         
-        public static string Serialize(InventoryItemBase inventoryItem)
+        public static string Serialize(InventoryItemBase inventoryItem, Dictionary<string, object> options, IUserAccountService userAccountService)
         {
             StringWriter sw = new StringWriter();
             XmlTextWriter writer = new XmlTextWriter(sw);
@@ -112,7 +259,7 @@ namespace OpenSim.Framework.Serialization.External
             writer.WriteString(inventoryItem.InvType.ToString());
             writer.WriteEndElement();
             writer.WriteStartElement("CreatorUUID");
-            writer.WriteString(inventoryItem.CreatorId);
+            writer.WriteString(OspResolver.MakeOspa(inventoryItem.CreatorIdAsUuid, userAccountService));
             writer.WriteEndElement();
             writer.WriteStartElement("CreationDate");
             writer.WriteString(inventoryItem.CreationDate.ToString());
@@ -156,6 +303,20 @@ namespace OpenSim.Framework.Serialization.External
             writer.WriteStartElement("GroupOwned");
             writer.WriteString(inventoryItem.GroupOwned.ToString());
             writer.WriteEndElement();
+            if (inventoryItem.CreatorData != null && inventoryItem.CreatorData != string.Empty)
+                writer.WriteElementString("CreatorData", inventoryItem.CreatorData);
+            else if (options.ContainsKey("profile"))
+            {
+                if (userAccountService != null)
+                {
+                    UserAccount account = userAccountService.GetUserAccount(UUID.Zero, inventoryItem.CreatorIdAsUuid);
+                    if (account != null)
+                    {
+                        writer.WriteElementString("CreatorData", (string)options["profile"] + "/" + inventoryItem.CreatorIdAsUuid + ";" + account.FirstName + " " + account.LastName);
+                    }
+                    writer.WriteElementString("CreatorID", inventoryItem.CreatorId);
+                }
+            }
 
             writer.WriteEndElement();