Merge remote-tracking branch 'os/master'

3 files changed, 916 insertions, 0 deletions

diff --git a/OpenSim/Region/CoreModules/Agent/AssetTransaction/AgentAssetsTransactions.cs b/OpenSim/Region/CoreModules/Agent/AssetTransaction/AgentAssetsTransactions.cs
new file mode 100644
index 0000000..f56d17d
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Agent/AssetTransaction/AgentAssetsTransactions.cs
@@ -0,0 +1,184 @@
+/*
+ * 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.Collections.Generic;
+using System.Reflection;
+using log4net;
+using OpenMetaverse;
+using OpenSim.Framework;
+
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using OpenSim.Region.Framework.Interfaces;
+
+namespace OpenSim.Region.CoreModules.Agent.AssetTransaction
+{
+    /// <summary>
+    /// Manage asset transactions for a single agent.
+    /// </summary>
+    public class AgentAssetTransactions
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        // Fields
+        private bool m_dumpAssetsToFile;
+        private Scene m_Scene;
+        private Dictionary<UUID, AssetXferUploader> XferUploaders = new Dictionary<UUID, AssetXferUploader>();
+
+        // Methods
+        public AgentAssetTransactions(UUID agentID, Scene scene,
+                bool dumpAssetsToFile)
+        {
+            m_Scene = scene;
+            m_dumpAssetsToFile = dumpAssetsToFile;
+        }
+
+        /// <summary>
+        /// Return the xfer uploader for the given transaction.
+        /// </summary>
+        /// <remarks>
+        /// If an uploader does not already exist for this transaction then it is created, otherwise the existing
+        /// uploader is returned.
+        /// </remarks>
+        /// <param name="transactionID"></param>
+        /// <returns>The asset xfer uploader</returns>
+        public AssetXferUploader RequestXferUploader(UUID transactionID)
+        {
+            AssetXferUploader uploader;
+
+            lock (XferUploaders)
+            {
+                if (!XferUploaders.ContainsKey(transactionID))
+                {
+                    uploader = new AssetXferUploader(this, m_Scene, transactionID, m_dumpAssetsToFile);
+
+//                    m_log.DebugFormat(
+//                        "[AGENT ASSETS TRANSACTIONS]: Adding asset xfer uploader {0} since it didn't previously exist", transactionID);
+
+                    XferUploaders.Add(transactionID, uploader);
+                }
+                else
+                {
+                    uploader = XferUploaders[transactionID];
+                }
+            }
+
+            return uploader;
+        }
+
+        public void HandleXfer(ulong xferID, uint packetID, byte[] data)
+        {
+            AssetXferUploader foundUploader = null;
+
+            lock (XferUploaders)
+            {
+                foreach (AssetXferUploader uploader in XferUploaders.Values)
+                {
+//                    m_log.DebugFormat(
+//                        "[AGENT ASSETS TRANSACTIONS]: In HandleXfer, inspect xfer upload with xfer id {0}",
+//                        uploader.XferID);
+
+                    if (uploader.XferID == xferID)
+                    {
+                        foundUploader = uploader;
+                        break;
+                    }
+                }
+            }
+
+            if (foundUploader != null)
+            {
+//                m_log.DebugFormat(
+//                    "[AGENT ASSETS TRANSACTIONS]: Found xfer uploader for xfer id {0}, packet id {1}, data length {2}",
+//                    xferID, packetID, data.Length);
+
+                foundUploader.HandleXferPacket(xferID, packetID, data);
+            }
+            else
+            {
+                // Check if the xfer is a terrain xfer
+                IEstateModule estateModule = m_Scene.RequestModuleInterface<IEstateModule>();
+                if (estateModule != null)
+                {
+                    if (estateModule.IsTerrainXfer(xferID))
+                        return;
+                }
+                
+                m_log.ErrorFormat(
+                    "[AGENT ASSET TRANSACTIONS]: Could not find uploader for xfer id {0}, packet id {1}, data length {2}",
+                    xferID, packetID, data.Length);
+            }
+        }
+
+        public bool RemoveXferUploader(UUID transactionID)
+        {
+            lock (XferUploaders)
+            {
+                bool removed = XferUploaders.Remove(transactionID);
+
+                if (!removed)
+                    m_log.WarnFormat(
+                        "[AGENT ASSET TRANSACTIONS]: Received request to remove xfer uploader with transaction ID {0} but none found",
+                        transactionID);
+//                else
+//                    m_log.DebugFormat(
+//                        "[AGENT ASSET TRANSACTIONS]: Removed xfer uploader with transaction ID {0}", transactionID);
+
+                return removed;
+            }
+        }
+
+        public void RequestCreateInventoryItem(IClientAPI remoteClient,
+                UUID transactionID, UUID folderID, uint callbackID,
+                string description, string name, sbyte invType,
+               sbyte type, byte wearableType, uint nextOwnerMask)
+        {
+            AssetXferUploader uploader = RequestXferUploader(transactionID);
+
+            uploader.RequestCreateInventoryItem(
+                remoteClient, folderID, callbackID,
+                description, name, invType, type, wearableType, nextOwnerMask);
+        }
+
+        public void RequestUpdateTaskInventoryItem(IClientAPI remoteClient,
+                SceneObjectPart part, UUID transactionID,
+                TaskInventoryItem item)
+        {
+            AssetXferUploader uploader = RequestXferUploader(transactionID);
+
+            uploader.RequestUpdateTaskInventoryItem(remoteClient, item);
+        }
+
+        public void RequestUpdateInventoryItem(IClientAPI remoteClient,
+                UUID transactionID, InventoryItemBase item)
+        {
+            AssetXferUploader uploader = RequestXferUploader(transactionID);
+
+            uploader.RequestUpdateInventoryItem(remoteClient, item);
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/CoreModules/Agent/AssetTransaction/AssetTransactionModule.cs b/OpenSim/Region/CoreModules/Agent/AssetTransaction/AssetTransactionModule.cs
new file mode 100644
index 0000000..b67c0df
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Agent/AssetTransaction/AssetTransactionModule.cs
@@ -0,0 +1,302 @@
+/*
+ * 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.Reflection;
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using Mono.Addins;
+
+namespace OpenSim.Region.CoreModules.Agent.AssetTransaction
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "AssetTransactionModule")]
+    public class AssetTransactionModule : INonSharedRegionModule,
+            IAgentAssetTransactions
+    {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        
+        protected Scene m_Scene;
+        private bool m_dumpAssetsToFile = false;
+        private int  m_levelUpload = 0;
+
+        /// <summary>
+        /// Each agent has its own singleton collection of transactions
+        /// </summary>
+        private Dictionary<UUID, AgentAssetTransactions> AgentTransactions =
+            new Dictionary<UUID, AgentAssetTransactions>();
+        
+        #region Region Module interface
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig sconfig = source.Configs["Startup"];
+            if (sconfig != null)
+            {
+                m_levelUpload = sconfig.GetInt("LevelUpload", 0);
+            }
+        }
+
+        public void AddRegion(Scene scene)
+        {
+            m_Scene = scene;
+            scene.RegisterModuleInterface<IAgentAssetTransactions>(this);
+            scene.EventManager.OnNewClient += NewClient;
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+        }
+
+        public void Close()
+        {
+        }
+
+        public string Name
+        {
+            get { return "AgentTransactionModule"; }
+        }
+
+        public Type ReplaceableInterface
+        {
+            get { return typeof(IAgentAssetTransactions); }
+        }
+
+        #endregion
+
+        public void NewClient(IClientAPI client)
+        {
+            client.OnAssetUploadRequest += HandleUDPUploadRequest;
+            client.OnXferReceive += HandleXfer;
+        }
+
+        #region AgentAssetTransactions
+        /// <summary>
+        /// Get the collection of asset transactions for the given user.
+        /// If one does not already exist, it is created.
+        /// </summary>
+        /// <param name="userID"></param>
+        /// <returns></returns>
+        private AgentAssetTransactions GetUserTransactions(UUID userID)
+        {
+            lock (AgentTransactions)
+            {
+                if (!AgentTransactions.ContainsKey(userID))
+                {
+                    AgentAssetTransactions transactions =
+                            new AgentAssetTransactions(userID, m_Scene,
+                            m_dumpAssetsToFile);
+
+                    AgentTransactions.Add(userID, transactions);
+                }
+
+                return AgentTransactions[userID];
+            }
+        }
+
+        /// <summary>
+        /// Remove the given agent asset transactions. This should be called
+        /// when a client is departing from a scene (and hence won't be making
+        /// any more transactions here).
+        /// </summary>
+        /// <param name="userID"></param>
+        public void RemoveAgentAssetTransactions(UUID userID)
+        {
+            // m_log.DebugFormat("Removing agent asset transactions structure for agent {0}", userID);
+
+            lock (AgentTransactions)
+            {
+                AgentTransactions.Remove(userID);
+            }
+        }
+
+        /// <summary>
+        /// Create an inventory item from data that has been received through
+        /// a transaction.
+        /// This is called when new clothing or body parts are created.
+        /// It may also be called in other situations.
+        /// </summary>
+        /// <param name="remoteClient"></param>
+        /// <param name="transactionID"></param>
+        /// <param name="folderID"></param>
+        /// <param name="callbackID"></param>
+        /// <param name="description"></param>
+        /// <param name="name"></param>
+        /// <param name="invType"></param>
+        /// <param name="type"></param>
+        /// <param name="wearableType"></param>
+        /// <param name="nextOwnerMask"></param>
+        public void HandleItemCreationFromTransaction(IClientAPI remoteClient,
+                UUID transactionID, UUID folderID, uint callbackID,
+                string description, string name, sbyte invType,
+                sbyte type, byte wearableType, uint nextOwnerMask)
+        {
+//            m_log.DebugFormat(
+//                "[TRANSACTIONS MANAGER] Called HandleItemCreationFromTransaction with item {0}", name);
+
+            AgentAssetTransactions transactions =
+                    GetUserTransactions(remoteClient.AgentId);
+
+            transactions.RequestCreateInventoryItem(remoteClient, transactionID,
+                    folderID, callbackID, description, name, invType, type,
+                    wearableType, nextOwnerMask);
+        }
+
+        /// <summary>
+        /// Update an inventory item with data that has been received through a
+        /// transaction.
+        /// </summary>
+        /// <remarks>
+        /// This is called when clothing or body parts are updated (for
+        /// instance, with new textures or colours). It may also be called in
+        /// other situations.
+        /// </remarks>
+        /// <param name="remoteClient"></param>
+        /// <param name="transactionID"></param>
+        /// <param name="item"></param>
+        public void HandleItemUpdateFromTransaction(IClientAPI remoteClient,
+                UUID transactionID, InventoryItemBase item)
+        {
+//            m_log.DebugFormat(
+//                "[ASSET TRANSACTION MODULE]: Called HandleItemUpdateFromTransaction with item {0}",
+//                item.Name);
+
+            AgentAssetTransactions transactions = GetUserTransactions(remoteClient.AgentId);
+
+            transactions.RequestUpdateInventoryItem(remoteClient, transactionID, item);
+        }
+
+        /// <summary>
+        /// Update a task inventory item with data that has been received
+        /// through a transaction.
+        ///
+        /// This is currently called when, for instance, a notecard in a prim
+        /// is saved. The data is sent up through a single AssetUploadRequest.
+        /// A subsequent UpdateTaskInventory then references the transaction
+        /// and comes through this method.
+        /// </summary>
+        /// <param name="remoteClient"></param>
+        /// <param name="part"></param>
+        /// <param name="transactionID"></param>
+        /// <param name="item"></param>
+        public void HandleTaskItemUpdateFromTransaction(
+            IClientAPI remoteClient, SceneObjectPart part, UUID transactionID, TaskInventoryItem item)
+        {
+//            m_log.DebugFormat(
+//                "[ASSET TRANSACTION MODULE]: Called HandleTaskItemUpdateFromTransaction with item {0} in {1} for {2} in {3}",
+//                item.Name, part.Name, remoteClient.Name, m_Scene.RegionInfo.RegionName);
+
+            AgentAssetTransactions transactions =
+                    GetUserTransactions(remoteClient.AgentId);
+
+            transactions.RequestUpdateTaskInventoryItem(remoteClient, part,
+                    transactionID, item);
+        }
+
+        /// <summary>
+        /// Request that a client (agent) begin an asset transfer.
+        /// </summary>
+        /// <param name="remoteClient"></param>
+        /// <param name="assetID"></param>
+        /// <param name="transactionID"></param>
+        /// <param name="type"></param>
+        /// <param name="data"></param></param>
+        /// <param name="tempFile"></param>
+        public void HandleUDPUploadRequest(IClientAPI remoteClient,
+                UUID assetID, UUID transactionID, sbyte type, byte[] data,
+                bool storeLocal, bool tempFile)
+        {
+//            m_log.DebugFormat(
+//                "[ASSET TRANSACTION MODULE]: HandleUDPUploadRequest - assetID: {0}, transaction {1}, type {2}, storeLocal {3}, tempFile {4}, data.Length {5}",
+//                assetID, transactionID, type, storeLocal, tempFile, data.Length);
+            
+            if (((AssetType)type == AssetType.Texture ||
+                (AssetType)type == AssetType.Sound ||
+                (AssetType)type == AssetType.TextureTGA ||
+                (AssetType)type == AssetType.Animation) &&
+                tempFile == false)
+            {
+                ScenePresence avatar = null;
+                Scene scene = (Scene)remoteClient.Scene;
+                scene.TryGetScenePresence(remoteClient.AgentId, out avatar);
+
+                // check user level
+                if (avatar != null)
+                {
+                    if (avatar.UserLevel < m_levelUpload)
+                    {
+                        remoteClient.SendAgentAlertMessage("Unable to upload asset. Insufficient permissions.", false);
+                        return;
+                    }
+                }
+
+                // check funds
+                IMoneyModule mm = scene.RequestModuleInterface<IMoneyModule>();
+
+                if (mm != null)
+                {
+                    if (!mm.UploadCovered(remoteClient.AgentId, mm.UploadCharge))
+                    {
+                        remoteClient.SendAgentAlertMessage("Unable to upload asset. Insufficient funds.", false);
+                        return;
+                    }
+                }
+            }
+
+            AgentAssetTransactions transactions = GetUserTransactions(remoteClient.AgentId);
+            AssetXferUploader uploader = transactions.RequestXferUploader(transactionID);
+            uploader.StartUpload(remoteClient, assetID, transactionID, type, data, storeLocal, tempFile);
+        }
+
+        /// <summary>
+        /// Handle asset transfer data packets received in response to the
+        /// asset upload request in HandleUDPUploadRequest()
+        /// </summary>
+        /// <param name="remoteClient"></param>
+        /// <param name="xferID"></param>
+        /// <param name="packetID"></param>
+        /// <param name="data"></param>
+        public void HandleXfer(IClientAPI remoteClient, ulong xferID,
+                uint packetID, byte[] data)
+        {
+//            m_log.Debug("xferID: " + xferID + "  packetID: " + packetID + "  data length " + data.Length);
+            AgentAssetTransactions transactions = GetUserTransactions(remoteClient.AgentId);
+
+            transactions.HandleXfer(xferID, packetID, data);
+        }
+
+        #endregion
+    }
+}
diff --git a/OpenSim/Region/CoreModules/Agent/AssetTransaction/AssetXferUploader.cs b/OpenSim/Region/CoreModules/Agent/AssetTransaction/AssetXferUploader.cs
new file mode 100644
index 0000000..49a96f4
--- /dev/null
+++ b/OpenSim/Region/CoreModules/Agent/AssetTransaction/AssetXferUploader.cs
@@ -0,0 +1,430 @@
+/*
+ * 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.IO;
+using System.Reflection;
+using log4net;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using PermissionMask = OpenSim.Framework.PermissionMask;
+
+namespace OpenSim.Region.CoreModules.Agent.AssetTransaction
+{
+    public class AssetXferUploader
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// Upload state.
+        /// </summary>
+        /// <remarks>
+        /// New -> Uploading -> Complete
+        /// </remarks>
+        private enum UploadState
+        {
+            New,
+            Uploading,
+            Complete
+        }
+
+        /// <summary>
+        /// Reference to the object that holds this uploader.  Used to remove ourselves from it's list if we
+        /// are performing a delayed update.
+        /// </summary>
+        AgentAssetTransactions m_transactions;
+
+        private UploadState m_uploadState = UploadState.New;
+
+        private AssetBase m_asset;
+        private UUID InventFolder = UUID.Zero;
+        private sbyte invType = 0;
+
+        private bool m_createItem;
+        private uint m_createItemCallback;
+
+        private bool m_updateItem;
+        private InventoryItemBase m_updateItemData;
+
+        private bool m_updateTaskItem;
+        private TaskInventoryItem m_updateTaskItemData;
+
+        private string m_description = String.Empty;
+        private bool m_dumpAssetToFile;
+        private string m_name = String.Empty;
+//        private bool m_storeLocal;
+        private uint nextPerm = 0;
+        private IClientAPI ourClient;
+
+        private UUID m_transactionID;
+
+        private sbyte type = 0;
+        private byte wearableType = 0;
+        public ulong XferID;
+        private Scene m_Scene;
+
+        /// <summary>
+        /// AssetXferUploader constructor
+        /// </summary>
+        /// <param name='transactions'>/param>
+        /// <param name='scene'></param>
+        /// <param name='transactionID'></param>
+        /// <param name='dumpAssetToFile'>
+        /// If true then when the asset is uploaded it is dumped to a file with the format
+        /// String.Format("{6}_{7}_{0:d2}{1:d2}{2:d2}_{3:d2}{4:d2}{5:d2}.dat",
+        ///   now.Year, now.Month, now.Day, now.Hour, now.Minute,
+        ///   now.Second, m_asset.Name, m_asset.Type);
+        /// for debugging purposes.
+        /// </param>
+        public AssetXferUploader(
+            AgentAssetTransactions transactions, Scene scene, UUID transactionID, bool dumpAssetToFile)
+        {
+            m_asset = new AssetBase();
+
+            m_transactions = transactions;
+            m_transactionID = transactionID;
+            m_Scene = scene;
+            m_dumpAssetToFile = dumpAssetToFile;
+        }
+
+        /// <summary>
+        /// Process transfer data received from the client.
+        /// </summary>
+        /// <param name="xferID"></param>
+        /// <param name="packetID"></param>
+        /// <param name="data"></param>
+        /// <returns>True if the transfer is complete, false otherwise or if the xferID was not valid</returns>
+        public bool HandleXferPacket(ulong xferID, uint packetID, byte[] data)
+        {
+//            m_log.DebugFormat(
+//                "[ASSET XFER UPLOADER]: Received packet {0} for xfer {1} (data length {2})",
+//                packetID, xferID, data.Length);
+
+            if (XferID == xferID)
+            {
+                if (m_asset.Data.Length > 1)
+                {
+                    byte[] destinationArray = new byte[m_asset.Data.Length + data.Length];
+                    Array.Copy(m_asset.Data, 0, destinationArray, 0, m_asset.Data.Length);
+                    Array.Copy(data, 0, destinationArray, m_asset.Data.Length, data.Length);
+                    m_asset.Data = destinationArray;
+                }
+                else
+                {
+                    byte[] buffer2 = new byte[data.Length - 4];
+                    Array.Copy(data, 4, buffer2, 0, data.Length - 4);
+                    m_asset.Data = buffer2;
+                }
+
+                ourClient.SendConfirmXfer(xferID, packetID);
+
+                if ((packetID & 0x80000000) != 0)
+                {
+                    SendCompleteMessage();
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Start asset transfer from the client
+        /// </summary>
+        /// <param name="remoteClient"></param>
+        /// <param name="assetID"></param>
+        /// <param name="transaction"></param>
+        /// <param name="type"></param>
+        /// <param name="data">
+        /// Optional data.  If present then the asset is created immediately with this data
+        /// rather than requesting an upload from the client.  The data must be longer than 2 bytes.
+        /// </param>
+        /// <param name="storeLocal"></param>
+        /// <param name="tempFile"></param>
+        public void StartUpload(
+            IClientAPI remoteClient, UUID assetID, UUID transaction, sbyte type, byte[] data, bool storeLocal,
+            bool tempFile)
+        {
+//            m_log.DebugFormat(
+//                "[ASSET XFER UPLOADER]: Initialised xfer from {0}, asset {1}, transaction {2}, type {3}, storeLocal {4}, tempFile {5}, already received data length {6}",
+//                remoteClient.Name, assetID, transaction, type, storeLocal, tempFile, data.Length);
+
+            lock (this)
+            {
+                if (m_uploadState != UploadState.New)
+                {
+                    m_log.WarnFormat(
+                        "[ASSET XFER UPLOADER]: Tried to start upload of asset {0}, transaction {1} for {2} but this is already in state {3}.  Aborting.",
+                        assetID, transaction, remoteClient.Name, m_uploadState);
+
+                    return;
+                }
+
+                m_uploadState = UploadState.Uploading;
+            }
+
+            ourClient = remoteClient;
+
+            m_asset.FullID = assetID;
+            m_asset.Type = type;
+            m_asset.CreatorID = remoteClient.AgentId.ToString();
+            m_asset.Data = data;
+            m_asset.Local = storeLocal;
+            m_asset.Temporary = tempFile;
+
+//            m_storeLocal = storeLocal;
+
+            if (m_asset.Data.Length > 2)
+            {
+                SendCompleteMessage();
+            }
+            else
+            {
+                RequestStartXfer();
+            }
+        }
+
+        protected void RequestStartXfer()
+        {
+            XferID = Util.GetNextXferID();
+
+//            m_log.DebugFormat(
+//                "[ASSET XFER UPLOADER]: Requesting Xfer of asset {0}, type {1}, transfer id {2} from {3}",
+//                m_asset.FullID, m_asset.Type, XferID, ourClient.Name);
+
+            ourClient.SendXferRequest(XferID, m_asset.Type, m_asset.FullID, 0, new byte[0]);
+        }
+
+        protected void SendCompleteMessage()
+        {
+            // We must lock in order to avoid a race with a separate thread dealing with an inventory item or create
+            // message from other client UDP.
+            lock (this)
+            {
+                m_uploadState = UploadState.Complete;
+
+                ourClient.SendAssetUploadCompleteMessage(m_asset.Type, true, m_asset.FullID);
+
+                if (m_createItem)
+                {
+                    CompleteCreateItem(m_createItemCallback);
+                }
+                else if (m_updateItem)
+                {
+                    CompleteItemUpdate(m_updateItemData);
+                }
+                else if (m_updateTaskItem)
+                {
+                    CompleteTaskItemUpdate(m_updateTaskItemData);
+                }
+//                else if (m_storeLocal)
+//                {
+//                    m_Scene.AssetService.Store(m_asset);
+//                }
+            }
+
+            m_log.DebugFormat(
+                "[ASSET XFER UPLOADER]: Uploaded asset {0} for transaction {1}",
+                m_asset.FullID, m_transactionID);
+
+            if (m_dumpAssetToFile)
+            {
+                DateTime now = DateTime.Now;
+                string filename =
+                        String.Format("{6}_{7}_{0:d2}{1:d2}{2:d2}_{3:d2}{4:d2}{5:d2}.dat",
+                        now.Year, now.Month, now.Day, now.Hour, now.Minute,
+                        now.Second, m_asset.Name, m_asset.Type);
+                SaveAssetToFile(filename, m_asset.Data);
+            }
+        }
+
+        private void SaveAssetToFile(string filename, byte[] data)
+        {
+            string assetPath = "UserAssets";
+            if (!Directory.Exists(assetPath))
+            {
+                Directory.CreateDirectory(assetPath);
+            }
+            FileStream fs = File.Create(Path.Combine(assetPath, filename));
+            BinaryWriter bw = new BinaryWriter(fs);
+            bw.Write(data);
+            bw.Close();
+            fs.Close();
+        }
+
+        public void RequestCreateInventoryItem(IClientAPI remoteClient,
+                UUID folderID, uint callbackID,
+                string description, string name, sbyte invType,
+                sbyte type, byte wearableType, uint nextOwnerMask)
+        {
+            InventFolder = folderID;
+            m_name = name;
+            m_description = description;
+            this.type = type;
+            this.invType = invType;
+            this.wearableType = wearableType;
+            nextPerm = nextOwnerMask;
+            m_asset.Name = name;
+            m_asset.Description = description;
+            m_asset.Type = type;
+
+            // We must lock to avoid a race with a separate thread uploading the asset.
+            lock (this)
+            {
+                if (m_uploadState == UploadState.Complete)
+                {
+                    CompleteCreateItem(callbackID);
+                }
+                else
+                {
+                    m_createItem = true; //set flag so the inventory item is created when upload is complete
+                    m_createItemCallback = callbackID;
+                }
+            }
+        }
+
+        public void RequestUpdateInventoryItem(IClientAPI remoteClient, InventoryItemBase item)
+        {
+            // We must lock to avoid a race with a separate thread uploading the asset.
+            lock (this)
+            {
+                m_asset.Name = item.Name;
+                m_asset.Description = item.Description;
+                m_asset.Type = (sbyte)item.AssetType;
+
+                // We must always store the item at this point even if the asset hasn't finished uploading, in order
+                // to avoid a race condition when the appearance module retrieves the item to set the asset id in
+                // the AvatarAppearance structure.
+                item.AssetID = m_asset.FullID;
+                if (item.AssetID != UUID.Zero)
+                    m_Scene.InventoryService.UpdateItem(item);
+
+                if (m_uploadState == UploadState.Complete)
+                {
+                    CompleteItemUpdate(item);
+                }
+                else
+                {
+//                    m_log.DebugFormat(
+//                        "[ASSET XFER UPLOADER]: Holding update inventory item request {0} for {1} pending completion of asset xfer for transaction {2}",
+//                        item.Name, remoteClient.Name, transactionID);
+    
+                    m_updateItem = true;
+                    m_updateItemData = item;
+                }
+            }
+        }
+
+        public void RequestUpdateTaskInventoryItem(IClientAPI remoteClient, TaskInventoryItem taskItem)
+        {
+            // We must lock to avoid a race with a separate thread uploading the asset.
+            lock (this)
+            {
+                m_asset.Name = taskItem.Name;
+                m_asset.Description = taskItem.Description;
+                m_asset.Type = (sbyte)taskItem.Type;
+                taskItem.AssetID = m_asset.FullID;
+
+                if (m_uploadState == UploadState.Complete)
+                {
+                    CompleteTaskItemUpdate(taskItem);
+                }
+                else
+                {
+                    m_updateTaskItem = true;
+                    m_updateTaskItemData = taskItem;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Store the asset for the given item when it has been uploaded.
+        /// </summary>
+        /// <param name="item"></param>
+        private void CompleteItemUpdate(InventoryItemBase item)
+        {
+//            m_log.DebugFormat(
+//                "[ASSET XFER UPLOADER]: Storing asset {0} for earlier item update for {1} for {2}",
+//                m_asset.FullID, item.Name, ourClient.Name);
+
+            m_Scene.AssetService.Store(m_asset);
+
+            m_transactions.RemoveXferUploader(m_transactionID);
+
+            m_Scene.EventManager.TriggerOnNewInventoryItemUploadComplete(ourClient.AgentId, (AssetType)type, m_asset.FullID, m_asset.Name, 0);
+        }
+
+        /// <summary>
+        /// Store the asset for the given task item when it has been uploaded.
+        /// </summary>
+        /// <param name="taskItem"></param>
+        private void CompleteTaskItemUpdate(TaskInventoryItem taskItem)
+        {
+//            m_log.DebugFormat(
+//                "[ASSET XFER UPLOADER]: Storing asset {0} for earlier task item update for {1} for {2}",
+//                m_asset.FullID, taskItem.Name, ourClient.Name);
+
+            m_Scene.AssetService.Store(m_asset);
+
+            m_transactions.RemoveXferUploader(m_transactionID);
+        }
+
+        private void CompleteCreateItem(uint callbackID)
+        {
+            m_Scene.AssetService.Store(m_asset);
+
+            InventoryItemBase item = new InventoryItemBase();
+            item.Owner = ourClient.AgentId;
+            item.CreatorId = ourClient.AgentId.ToString();
+            item.ID = UUID.Random();
+            item.AssetID = m_asset.FullID;
+            item.Description = m_description;
+            item.Name = m_name;
+            item.AssetType = type;
+            item.InvType = invType;
+            item.Folder = InventFolder;
+            item.BasePermissions = (uint)(PermissionMask.All | PermissionMask.Export);
+            item.CurrentPermissions = item.BasePermissions;
+            item.GroupPermissions=0;
+            item.EveryOnePermissions=0;
+            item.NextPermissions = nextPerm;
+            item.Flags = (uint) wearableType;
+            item.CreationDate = Util.UnixTimeSinceEpoch();
+
+            if (m_Scene.AddInventoryItem(item))
+                ourClient.SendInventoryItemCreateUpdate(item, callbackID);
+            else
+                ourClient.SendAlertMessage("Unable to create inventory item");
+
+            m_transactions.RemoveXferUploader(m_transactionID);
+        }
+
+    }
+}
\ No newline at end of file