39 files changed, 1648 insertions, 687 deletions

diff --git a/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCaps.cs b/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCaps.cs
new file mode 100644
index 0000000..7945d5e
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCaps.cs
@@ -0,0 +1,1213 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+
+using OpenMetaverse;
+using Nini.Config;
+using log4net;
+
+using OpenSim.Framework;
+using OpenSim.Framework.Capabilities;
+using OpenSim.Region.Framework;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Services.Interfaces;
+
+using Caps = OpenSim.Framework.Capabilities.Caps;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+    public delegate void UpLoadedAsset(
+    string assetName, string description, UUID assetID, UUID inventoryItem, UUID parentFolder,
+    byte[] data, string inventoryType, string assetType);
+
+    public delegate void UploadedBakedTexture(UUID assetID, byte[] data);
+
+    public delegate UUID UpdateItem(UUID itemID, byte[] data);
+
+    public delegate void UpdateTaskScript(UUID itemID, UUID primID, bool isScriptRunning, byte[] data, ref ArrayList errors);
+
+    public delegate void NewInventoryItem(UUID userID, InventoryItemBase item);
+
+    public delegate void NewAsset(AssetBase asset);
+
+    public delegate UUID ItemUpdatedCallback(UUID userID, UUID itemID, byte[] data);
+
+    public delegate ArrayList TaskScriptUpdatedCallback(UUID userID, UUID itemID, UUID primID,
+                                                   bool isScriptRunning, byte[] data);
+
+    public delegate InventoryCollection FetchInventoryDescendentsCAPS(UUID agentID, UUID folderID, UUID ownerID,
+                                                                          bool fetchFolders, bool fetchItems, int sortOrder, out int version);
+
+    /// <summary>
+    /// XXX Probably not a particularly nice way of allow us to get the scene presence from the scene (chiefly so that
+    /// we can popup a message on the user's client if the inventory service has permanently failed).  But I didn't want
+    /// to just pass the whole Scene into CAPS.
+    /// </summary>
+    public delegate IClientAPI GetClientDelegate(UUID agentID);
+
+    public class BunchOfCaps
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private Scene m_Scene;
+        private Caps m_HostCapsObj;
+
+        private static readonly string m_requestPath = "0000/";
+        // private static readonly string m_mapLayerPath = "0001/";
+        private static readonly string m_newInventory = "0002/";
+        //private static readonly string m_requestTexture = "0003/";
+        private static readonly string m_notecardUpdatePath = "0004/";
+        private static readonly string m_notecardTaskUpdatePath = "0005/";
+        //        private static readonly string m_fetchInventoryPath = "0006/";
+        // private static readonly string m_remoteParcelRequestPath = "0009/";// This is in the LandManagementModule.
+        private static readonly string m_uploadBakedTexturePath = "0010/";// This is in the LandManagementModule.
+
+
+        // These are callbacks which will be setup by the scene so that we can update scene data when we
+        // receive capability calls
+        public NewInventoryItem AddNewInventoryItem = null;
+        public NewAsset AddNewAsset = null;
+        public ItemUpdatedCallback ItemUpdatedCall = null;
+        public TaskScriptUpdatedCallback TaskScriptUpdatedCall = null;
+        public FetchInventoryDescendentsCAPS CAPSFetchInventoryDescendents = null;
+        public GetClientDelegate GetClient = null;
+
+        private bool m_persistBakedTextures = false;
+        private IAssetService m_assetService;
+        private bool m_dumpAssetsToFile;
+        private string m_regionName;
+        private object m_fetchLock = new Object();
+
+        public BunchOfCaps(Scene scene, Caps caps)
+        {
+            m_Scene = scene;
+            m_HostCapsObj = caps;
+            IConfigSource config = m_Scene.Config;
+            if (config != null)
+            {
+                IConfig sconfig = config.Configs["Startup"];
+                if (sconfig != null)
+                    m_persistBakedTextures = sconfig.GetBoolean("PersistBakedTextures", m_persistBakedTextures);
+            }
+
+            m_assetService = m_Scene.AssetService;
+            m_regionName = m_Scene.RegionInfo.RegionName;
+
+            RegisterHandlers();
+
+            AddNewInventoryItem = m_Scene.AddUploadedInventoryItem;
+            ItemUpdatedCall = m_Scene.CapsUpdateInventoryItemAsset;
+            TaskScriptUpdatedCall = m_Scene.CapsUpdateTaskInventoryScriptAsset;
+            CAPSFetchInventoryDescendents = m_Scene.HandleFetchInventoryDescendentsCAPS;
+            GetClient = m_Scene.SceneContents.GetControllingClient;
+
+        }
+
+        /// <summary>
+        /// Register a bunch of CAPS http service handlers
+        /// </summary>
+        public void RegisterHandlers()
+        {
+            m_HostCapsObj.DeregisterHandlers();
+
+            string capsBase = "/CAPS/" + m_HostCapsObj.CapsObjectPath;
+
+            RegisterRegionServiceHandlers(capsBase);
+            RegisterInventoryServiceHandlers(capsBase);
+        }
+
+        public void RegisterRegionServiceHandlers(string capsBase)
+        {
+            try
+            {
+                // the root of all evil
+                m_HostCapsObj.RegisterHandler("SEED", new RestStreamHandler("POST", capsBase + m_requestPath, SeedCapRequest));
+                m_log.DebugFormat(
+                    "[CAPS]: Registered seed capability {0} for {1}", capsBase + m_requestPath, m_HostCapsObj.AgentID);
+
+                //m_capsHandlers["MapLayer"] =
+                //    new LLSDStreamhandler<OSDMapRequest, OSDMapLayerResponse>("POST",
+                //                                                                capsBase + m_mapLayerPath,
+                //                                                                GetMapLayer);
+                IRequestHandler req = new RestStreamHandler("POST", capsBase + m_notecardTaskUpdatePath, ScriptTaskInventory);
+                m_HostCapsObj.RegisterHandler("UpdateScriptTaskInventory", req);
+                m_HostCapsObj.RegisterHandler("UpdateScriptTask", req);
+                m_HostCapsObj.RegisterHandler("UploadBakedTexture", new RestStreamHandler("POST", capsBase + m_uploadBakedTexturePath, UploadBakedTexture));
+
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[CAPS]: " + e.ToString());
+            }
+        }
+
+        public void RegisterInventoryServiceHandlers(string capsBase)
+        {
+            try
+            {
+                // I don't think this one works...
+                m_HostCapsObj.RegisterHandler("NewFileAgentInventory", new LLSDStreamhandler<LLSDAssetUploadRequest, LLSDAssetUploadResponse>("POST",
+                                                                                           capsBase + m_newInventory,
+                                                                                           NewAgentInventoryRequest));
+                IRequestHandler req = new RestStreamHandler("POST", capsBase + m_notecardUpdatePath, NoteCardAgentInventory);
+                m_HostCapsObj.RegisterHandler("UpdateNotecardAgentInventory", req);
+                m_HostCapsObj.RegisterHandler("UpdateScriptAgentInventory", req);
+                m_HostCapsObj.RegisterHandler("UpdateScriptAgent", req);
+             
+                // As of RC 1.22.9 of the Linden client this is
+                // supported
+
+                //m_capsHandlers["WebFetchInventoryDescendents"] =new RestStreamHandler("POST", capsBase + m_fetchInventoryPath, FetchInventoryDescendentsRequest);
+
+                // justincc: I've disabled the CAPS service for now to fix problems with selecting textures, and
+                // subsequent inventory breakage, in the edit object pane (such as mantis 1085).  This requires
+                // enhancements (probably filling out the folder part of the LLSD reply) to our CAPS service,
+                // but when I went on the Linden grid, the
+                // simulators I visited (version 1.21) were, surprisingly, no longer supplying this capability.  Instead,
+                // the 1.19.1.4 client appeared to be happily flowing inventory data over UDP
+                //
+                // This is very probably just a temporary measure - once the CAPS service appears again on the Linden grid
+                // we will be
+                // able to get the data we need to implement the necessary part of the protocol to fix the issue above.
+                //                m_capsHandlers["FetchInventoryDescendents"] =
+                //                    new RestStreamHandler("POST", capsBase + m_fetchInventoryPath, FetchInventoryRequest);
+
+                // m_capsHandlers["FetchInventoryDescendents"] =
+                //     new LLSDStreamhandler<LLSDFetchInventoryDescendents, LLSDInventoryDescendents>("POST",
+                //                                                                                    capsBase + m_fetchInventory,
+                //                                                                                    FetchInventory));
+                // m_capsHandlers["RequestTextureDownload"] = new RestStreamHandler("POST",
+                //                                                                  capsBase + m_requestTexture,
+                //                                                                  RequestTexture);
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[CAPS]: " + e.ToString());
+            }
+        }
+
+        /// <summary>
+        /// Construct a client response detailing all the capabilities this server can provide.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <param name="httpRequest">HTTP request header object</param>
+        /// <param name="httpResponse">HTTP response header object</param>
+        /// <returns></returns>
+        public string SeedCapRequest(string request, string path, string param,
+                                  OSHttpRequest httpRequest, OSHttpResponse httpResponse)
+        {
+            m_log.Debug("[CAPS]: Seed Caps Request in region: " + m_regionName);
+
+            if (!m_Scene.CheckClient(m_HostCapsObj.AgentID, httpRequest.RemoteIPEndPoint))
+            {
+                m_log.DebugFormat("[CAPS]: Unauthorized CAPS client");
+                return string.Empty;
+            }
+
+            // WARNING: Add the external too
+            string result = LLSDHelpers.SerialiseLLSDReply(m_HostCapsObj.CapsHandlers.CapsDetails);
+
+            //m_log.DebugFormat("[CAPS] CapsRequest {0}", result);
+
+            return result;
+        }
+
+        /// <summary>
+        /// Called by the script task update handler.  Provides a URL to which the client can upload a new asset.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <param name="httpRequest">HTTP request header object</param>
+        /// <param name="httpResponse">HTTP response header object</param>
+        /// <returns></returns>
+        public string ScriptTaskInventory(string request, string path, string param,
+                                          OSHttpRequest httpRequest, OSHttpResponse httpResponse)
+        {
+            try
+            {
+                m_log.Debug("[CAPS]: ScriptTaskInventory Request in region: " + m_regionName);
+                //m_log.DebugFormat("[CAPS]: request: {0}, path: {1}, param: {2}", request, path, param);
+
+                Hashtable hash = (Hashtable)LLSD.LLSDDeserialize(Utils.StringToBytes(request));
+                LLSDTaskScriptUpdate llsdUpdateRequest = new LLSDTaskScriptUpdate();
+                LLSDHelpers.DeserialiseOSDMap(hash, llsdUpdateRequest);
+
+                string capsBase = "/CAPS/" + m_HostCapsObj.CapsObjectPath;
+                string uploaderPath = Util.RandomClass.Next(5000, 8000).ToString("0000");
+
+                TaskInventoryScriptUpdater uploader =
+                    new TaskInventoryScriptUpdater(
+                        llsdUpdateRequest.item_id,
+                        llsdUpdateRequest.task_id,
+                        llsdUpdateRequest.is_script_running,
+                        capsBase + uploaderPath,
+                        m_HostCapsObj.HttpListener,
+                        m_dumpAssetsToFile);
+                uploader.OnUpLoad += TaskScriptUpdated;
+
+                m_HostCapsObj.HttpListener.AddStreamHandler(new BinaryStreamHandler("POST", capsBase + uploaderPath, uploader.uploaderCaps));
+
+                string protocol = "http://";
+
+                if (m_HostCapsObj.SSLCaps)
+                    protocol = "https://";
+
+                string uploaderURL = protocol + m_HostCapsObj.HostName + ":" + m_HostCapsObj.Port.ToString() + capsBase +
+                                     uploaderPath;
+
+                LLSDAssetUploadResponse uploadResponse = new LLSDAssetUploadResponse();
+                uploadResponse.uploader = uploaderURL;
+                uploadResponse.state = "upload";
+
+                //                m_log.InfoFormat("[CAPS]: " +
+                //                                 "ScriptTaskInventory response: {0}",
+                //                                 LLSDHelpers.SerialiseLLSDReply(uploadResponse)));
+
+                return LLSDHelpers.SerialiseLLSDReply(uploadResponse);
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[CAPS]: " + e.ToString());
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Called when new asset data for an agent inventory item update has been uploaded.
+        /// </summary>
+        /// <param name="itemID">Item to update</param>
+        /// <param name="primID">Prim containing item to update</param>
+        /// <param name="isScriptRunning">Signals whether the script to update is currently running</param>
+        /// <param name="data">New asset data</param>
+        public void TaskScriptUpdated(UUID itemID, UUID primID, bool isScriptRunning, byte[] data, ref ArrayList errors)
+        {
+            if (TaskScriptUpdatedCall != null)
+            {
+                ArrayList e = TaskScriptUpdatedCall(m_HostCapsObj.AgentID, itemID, primID, isScriptRunning, data);
+                foreach (Object item in e)
+                    errors.Add(item);
+            }
+        }
+
+        public string UploadBakedTexture(string request, string path,
+                string param, OSHttpRequest httpRequest,
+                OSHttpResponse httpResponse)
+        {
+            try
+            {
+                //                m_log.Debug("[CAPS]: UploadBakedTexture Request in region: " +
+                //                        m_regionName);
+
+                string capsBase = "/CAPS/" + m_HostCapsObj.CapsObjectPath;
+                string uploaderPath = Util.RandomClass.Next(5000, 8000).ToString("0000");
+
+                BakedTextureUploader uploader =
+                    new BakedTextureUploader(capsBase + uploaderPath, m_HostCapsObj.HttpListener);
+                uploader.OnUpLoad += BakedTextureUploaded;
+
+                m_HostCapsObj.HttpListener.AddStreamHandler(
+                        new BinaryStreamHandler("POST", capsBase + uploaderPath,
+                        uploader.uploaderCaps));
+
+                string protocol = "http://";
+
+                if (m_HostCapsObj.SSLCaps)
+                    protocol = "https://";
+
+                string uploaderURL = protocol + m_HostCapsObj.HostName + ":" +
+                        m_HostCapsObj.Port.ToString() + capsBase + uploaderPath;
+
+                LLSDAssetUploadResponse uploadResponse =
+                        new LLSDAssetUploadResponse();
+                uploadResponse.uploader = uploaderURL;
+                uploadResponse.state = "upload";
+
+                return LLSDHelpers.SerialiseLLSDReply(uploadResponse);
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[CAPS]: " + e.ToString());
+            }
+
+            return null;
+        }
+
+        public void BakedTextureUploaded(UUID assetID, byte[] data)
+        {
+            //            m_log.WarnFormat("[CAPS]: Received baked texture {0}", assetID.ToString());
+
+            AssetBase asset;
+            asset = new AssetBase(assetID, "Baked Texture", (sbyte)AssetType.Texture, m_HostCapsObj.AgentID.ToString());
+            asset.Data = data;
+            asset.Temporary = true;
+            asset.Local = !m_persistBakedTextures; // Local assets aren't persisted, non-local are
+            m_assetService.Store(asset);
+        }
+
+        /// <summary>
+        /// Called when new asset data for an agent inventory item update has been uploaded.
+        /// </summary>
+        /// <param name="itemID">Item to update</param>
+        /// <param name="data">New asset data</param>
+        /// <returns></returns>
+        public UUID ItemUpdated(UUID itemID, byte[] data)
+        {
+            if (ItemUpdatedCall != null)
+            {
+                return ItemUpdatedCall(m_HostCapsObj.AgentID, itemID, data);
+            }
+
+            return UUID.Zero;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="llsdRequest"></param>
+        /// <returns></returns>
+        public LLSDAssetUploadResponse NewAgentInventoryRequest(LLSDAssetUploadRequest llsdRequest)
+        {
+            //m_log.Debug("[CAPS]: NewAgentInventoryRequest Request is: " + llsdRequest.ToString());
+            //m_log.Debug("asset upload request via CAPS" + llsdRequest.inventory_type + " , " + llsdRequest.asset_type);
+
+            if (llsdRequest.asset_type == "texture" ||
+                llsdRequest.asset_type == "animation" ||
+                llsdRequest.asset_type == "sound")
+            {
+                IClientAPI client = null;
+                IScene scene = null;
+                if (GetClient != null)
+                {
+                    client = GetClient(m_HostCapsObj.AgentID);
+                    scene = client.Scene;
+
+                    IMoneyModule mm = scene.RequestModuleInterface<IMoneyModule>();
+
+                    if (mm != null)
+                    {
+                        if (!mm.UploadCovered(client, mm.UploadCharge))
+                        {
+                            if (client != null)
+                                client.SendAgentAlertMessage("Unable to upload asset. Insufficient funds.", false);
+
+                            LLSDAssetUploadResponse errorResponse = new LLSDAssetUploadResponse();
+                            errorResponse.uploader = "";
+                            errorResponse.state = "error";
+                            return errorResponse;
+                        }
+                    }
+                }
+            }
+
+            string assetName = llsdRequest.name;
+            string assetDes = llsdRequest.description;
+            string capsBase = "/CAPS/" + m_HostCapsObj.CapsObjectPath;
+            UUID newAsset = UUID.Random();
+            UUID newInvItem = UUID.Random();
+            UUID parentFolder = llsdRequest.folder_id;
+            string uploaderPath = Util.RandomClass.Next(5000, 8000).ToString("0000");
+
+            AssetUploader uploader =
+                new AssetUploader(assetName, assetDes, newAsset, newInvItem, parentFolder, llsdRequest.inventory_type,
+                                  llsdRequest.asset_type, capsBase + uploaderPath, m_HostCapsObj.HttpListener, m_dumpAssetsToFile);
+            m_HostCapsObj.HttpListener.AddStreamHandler(
+                new BinaryStreamHandler("POST", capsBase + uploaderPath, uploader.uploaderCaps));
+
+            string protocol = "http://";
+
+            if (m_HostCapsObj.SSLCaps)
+                protocol = "https://";
+
+            string uploaderURL = protocol + m_HostCapsObj.HostName + ":" + m_HostCapsObj.Port.ToString() + capsBase +
+                                 uploaderPath;
+
+            LLSDAssetUploadResponse uploadResponse = new LLSDAssetUploadResponse();
+            uploadResponse.uploader = uploaderURL;
+            uploadResponse.state = "upload";
+            uploader.OnUpLoad += UploadCompleteHandler;
+            return uploadResponse;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="assetID"></param>
+        /// <param name="inventoryItem"></param>
+        /// <param name="data"></param>
+        public void UploadCompleteHandler(string assetName, string assetDescription, UUID assetID,
+                                          UUID inventoryItem, UUID parentFolder, byte[] data, string inventoryType,
+                                          string assetType)
+        {
+            sbyte assType = 0;
+            sbyte inType = 0;
+
+            if (inventoryType == "sound")
+            {
+                inType = 1;
+                assType = 1;
+            }
+            else if (inventoryType == "animation")
+            {
+                inType = 19;
+                assType = 20;
+            }
+            else if (inventoryType == "wearable")
+            {
+                inType = 18;
+                switch (assetType)
+                {
+                    case "bodypart":
+                        assType = 13;
+                        break;
+                    case "clothing":
+                        assType = 5;
+                        break;
+                }
+            }
+
+            AssetBase asset;
+            asset = new AssetBase(assetID, assetName, assType, m_HostCapsObj.AgentID.ToString());
+            asset.Data = data;
+            if (AddNewAsset != null)
+                AddNewAsset(asset);
+            else if (m_assetService != null)
+                m_assetService.Store(asset);
+
+            InventoryItemBase item = new InventoryItemBase();
+            item.Owner = m_HostCapsObj.AgentID;
+            item.CreatorId = m_HostCapsObj.AgentID.ToString();
+            item.CreatorData = String.Empty;
+            item.ID = inventoryItem;
+            item.AssetID = asset.FullID;
+            item.Description = assetDescription;
+            item.Name = assetName;
+            item.AssetType = assType;
+            item.InvType = inType;
+            item.Folder = parentFolder;
+            item.CurrentPermissions = (uint)PermissionMask.All;
+            item.BasePermissions = (uint)PermissionMask.All;
+            item.EveryOnePermissions = 0;
+            item.NextPermissions = (uint)(PermissionMask.Move | PermissionMask.Modify | PermissionMask.Transfer);
+            item.CreationDate = Util.UnixTimeSinceEpoch();
+
+            if (AddNewInventoryItem != null)
+            {
+                AddNewInventoryItem(m_HostCapsObj.AgentID, item);
+            }
+        }
+
+        /// <summary>
+        /// Processes a fetch inventory request and sends the reply
+
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        // Request is like:
+        //<llsd>
+        //   <map><key>folders</key>
+        //       <array>
+        //            <map>
+        //                <key>fetch-folders</key><boolean>1</boolean><key>fetch-items</key><boolean>1</boolean><key>folder-id</key><uuid>8e1e3a30-b9bf-11dc-95ff-0800200c9a66</uuid><key>owner-id</key><uuid>11111111-1111-0000-0000-000100bba000</uuid><key>sort-order</key><integer>1</integer>
+        //            </map>
+        //       </array>
+        //   </map>
+        //</llsd>
+        //
+        // multiple fetch-folder maps are allowed within the larger folders map.
+        public string FetchInventoryRequest(string request, string path, string param)
+        {
+            // string unmodifiedRequest = request.ToString();
+
+            //m_log.DebugFormat("[AGENT INVENTORY]: Received CAPS fetch inventory request {0}", unmodifiedRequest);
+            m_log.Debug("[CAPS]: Inventory Request in region: " + m_regionName);
+
+            Hashtable hash = new Hashtable();
+            try
+            {
+                hash = (Hashtable)LLSD.LLSDDeserialize(Utils.StringToBytes(request));
+            }
+            catch (LLSD.LLSDParseException pe)
+            {
+                m_log.Error("[AGENT INVENTORY]: Fetch error: " + pe.Message);
+                m_log.Error("Request: " + request.ToString());
+            }
+
+            ArrayList foldersrequested = (ArrayList)hash["folders"];
+
+            string response = "";
+
+            for (int i = 0; i < foldersrequested.Count; i++)
+            {
+                string inventoryitemstr = "";
+                Hashtable inventoryhash = (Hashtable)foldersrequested[i];
+
+                LLSDFetchInventoryDescendents llsdRequest = new LLSDFetchInventoryDescendents();
+                LLSDHelpers.DeserialiseOSDMap(inventoryhash, llsdRequest);
+                LLSDInventoryDescendents reply = FetchInventoryReply(llsdRequest);
+
+                inventoryitemstr = LLSDHelpers.SerialiseLLSDReply(reply);
+                inventoryitemstr = inventoryitemstr.Replace("<llsd><map><key>folders</key><array>", "");
+                inventoryitemstr = inventoryitemstr.Replace("</array></map></llsd>", "");
+
+                response += inventoryitemstr;
+            }
+
+            if (response.Length == 0)
+            {
+                // Ter-guess: If requests fail a lot, the client seems to stop requesting descendants.
+                // Therefore, I'm concluding that the client only has so many threads available to do requests
+                // and when a thread stalls..   is stays stalled.
+                // Therefore we need to return something valid
+                response = "<llsd><map><key>folders</key><array /></map></llsd>";
+            }
+            else
+            {
+                response = "<llsd><map><key>folders</key><array>" + response + "</array></map></llsd>";
+            }
+
+            //m_log.DebugFormat("[AGENT INVENTORY]: Replying to CAPS fetch inventory request with following xml");
+            //m_log.Debug(Util.GetFormattedXml(response));
+
+            return response;
+        }
+
+        public string FetchInventoryDescendentsRequest(string request, string path, string param, OSHttpRequest httpRequest, OSHttpResponse httpResponse)
+        {
+            // nasty temporary hack here, the linden client falsely
+            // identifies the uuid 00000000-0000-0000-0000-000000000000
+            // as a string which breaks us
+            //
+            // correctly mark it as a uuid
+            //
+            request = request.Replace("<string>00000000-0000-0000-0000-000000000000</string>", "<uuid>00000000-0000-0000-0000-000000000000</uuid>");
+
+            // another hack <integer>1</integer> results in a
+            // System.ArgumentException: Object type System.Int32 cannot
+            // be converted to target type: System.Boolean
+            //
+            request = request.Replace("<key>fetch_folders</key><integer>0</integer>", "<key>fetch_folders</key><boolean>0</boolean>");
+            request = request.Replace("<key>fetch_folders</key><integer>1</integer>", "<key>fetch_folders</key><boolean>1</boolean>");
+
+            Hashtable hash = new Hashtable();
+            try
+            {
+                hash = (Hashtable)LLSD.LLSDDeserialize(Utils.StringToBytes(request));
+            }
+            catch (LLSD.LLSDParseException pe)
+            {
+                m_log.Error("[AGENT INVENTORY]: Fetch error: " + pe.Message);
+                m_log.Error("Request: " + request.ToString());
+            }
+
+            ArrayList foldersrequested = (ArrayList)hash["folders"];
+
+            string response = "";
+            lock (m_fetchLock)
+            {
+                for (int i = 0; i < foldersrequested.Count; i++)
+                {
+                    string inventoryitemstr = "";
+                    Hashtable inventoryhash = (Hashtable)foldersrequested[i];
+
+                    LLSDFetchInventoryDescendents llsdRequest = new LLSDFetchInventoryDescendents();
+
+                    try
+                    {
+                        LLSDHelpers.DeserialiseOSDMap(inventoryhash, llsdRequest);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.Debug("[CAPS]: caught exception doing OSD deserialize" + e);
+                    }
+                    LLSDInventoryDescendents reply = FetchInventoryReply(llsdRequest);
+
+                    inventoryitemstr = LLSDHelpers.SerialiseLLSDReply(reply);
+                    inventoryitemstr = inventoryitemstr.Replace("<llsd><map><key>folders</key><array>", "");
+                    inventoryitemstr = inventoryitemstr.Replace("</array></map></llsd>", "");
+
+                    response += inventoryitemstr;
+                }
+
+
+                if (response.Length == 0)
+                {
+                    // Ter-guess: If requests fail a lot, the client seems to stop requesting descendants.
+                    // Therefore, I'm concluding that the client only has so many threads available to do requests
+                    // and when a thread stalls..   is stays stalled.
+                    // Therefore we need to return something valid
+                    response = "<llsd><map><key>folders</key><array /></map></llsd>";
+                }
+                else
+                {
+                    response = "<llsd><map><key>folders</key><array>" + response + "</array></map></llsd>";
+                }
+
+                //m_log.DebugFormat("[CAPS]: Replying to CAPS fetch inventory request with following xml");
+                //m_log.Debug("[CAPS] "+response);
+
+            }
+            return response;
+        }
+
+
+
+        /// <summary>
+        /// Construct an LLSD reply packet to a CAPS inventory request
+        /// </summary>
+        /// <param name="invFetch"></param>
+        /// <returns></returns>
+        private LLSDInventoryDescendents FetchInventoryReply(LLSDFetchInventoryDescendents invFetch)
+        {
+            LLSDInventoryDescendents reply = new LLSDInventoryDescendents();
+            LLSDInventoryFolderContents contents = new LLSDInventoryFolderContents();
+            contents.agent_id = m_HostCapsObj.AgentID;
+            contents.owner_id = invFetch.owner_id;
+            contents.folder_id = invFetch.folder_id;
+
+            reply.folders.Array.Add(contents);
+            InventoryCollection inv = new InventoryCollection();
+            inv.Folders = new List<InventoryFolderBase>();
+            inv.Items = new List<InventoryItemBase>();
+            int version = 0;
+            if (CAPSFetchInventoryDescendents != null)
+            {
+                inv = CAPSFetchInventoryDescendents(m_HostCapsObj.AgentID, invFetch.folder_id, invFetch.owner_id, invFetch.fetch_folders, invFetch.fetch_items, invFetch.sort_order, out version);
+            }
+
+            if (inv.Folders != null)
+            {
+                foreach (InventoryFolderBase invFolder in inv.Folders)
+                {
+                    contents.categories.Array.Add(ConvertInventoryFolder(invFolder));
+                }
+            }
+
+            if (inv.Items != null)
+            {
+                foreach (InventoryItemBase invItem in inv.Items)
+                {
+                    contents.items.Array.Add(ConvertInventoryItem(invItem));
+                }
+            }
+
+            contents.descendents = contents.items.Array.Count + contents.categories.Array.Count;
+            contents.version = version;
+
+            return reply;
+        }
+
+        /// <summary>
+        /// Convert an internal inventory folder object into an LLSD object.
+        /// </summary>
+        /// <param name="invFolder"></param>
+        /// <returns></returns>
+        private LLSDInventoryFolder ConvertInventoryFolder(InventoryFolderBase invFolder)
+        {
+            LLSDInventoryFolder llsdFolder = new LLSDInventoryFolder();
+            llsdFolder.folder_id = invFolder.ID;
+            llsdFolder.parent_id = invFolder.ParentID;
+            llsdFolder.name = invFolder.Name;
+            if (invFolder.Type < 0 || invFolder.Type >= TaskInventoryItem.Types.Length)
+                llsdFolder.type = "-1";
+            else
+                llsdFolder.type = TaskInventoryItem.Types[invFolder.Type];
+            llsdFolder.preferred_type = "-1";
+
+            return llsdFolder;
+        }
+
+        /// <summary>
+        /// Convert an internal inventory item object into an LLSD object.
+        /// </summary>
+        /// <param name="invItem"></param>
+        /// <returns></returns>
+        private LLSDInventoryItem ConvertInventoryItem(InventoryItemBase invItem)
+        {
+            LLSDInventoryItem llsdItem = new LLSDInventoryItem();
+            llsdItem.asset_id = invItem.AssetID;
+            llsdItem.created_at = invItem.CreationDate;
+            llsdItem.desc = invItem.Description;
+            llsdItem.flags = (int)invItem.Flags;
+            llsdItem.item_id = invItem.ID;
+            llsdItem.name = invItem.Name;
+            llsdItem.parent_id = invItem.Folder;
+            try
+            {
+                // TODO reevaluate after upgrade to libomv >= r2566. Probably should use UtilsConversions.
+                llsdItem.type = TaskInventoryItem.Types[invItem.AssetType];
+                llsdItem.inv_type = TaskInventoryItem.InvTypes[invItem.InvType];
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[CAPS]: Problem setting asset/inventory type while converting inventory item " + invItem.Name + " to LLSD:", e);
+            }
+            llsdItem.permissions = new LLSDPermissions();
+            llsdItem.permissions.creator_id = invItem.CreatorIdAsUuid;
+            llsdItem.permissions.base_mask = (int)invItem.CurrentPermissions;
+            llsdItem.permissions.everyone_mask = (int)invItem.EveryOnePermissions;
+            llsdItem.permissions.group_id = invItem.GroupID;
+            llsdItem.permissions.group_mask = (int)invItem.GroupPermissions;
+            llsdItem.permissions.is_owner_group = invItem.GroupOwned;
+            llsdItem.permissions.next_owner_mask = (int)invItem.NextPermissions;
+            llsdItem.permissions.owner_id = m_HostCapsObj.AgentID;
+            llsdItem.permissions.owner_mask = (int)invItem.CurrentPermissions;
+            llsdItem.sale_info = new LLSDSaleInfo();
+            llsdItem.sale_info.sale_price = invItem.SalePrice;
+            switch (invItem.SaleType)
+            {
+                default:
+                    llsdItem.sale_info.sale_type = "not";
+                    break;
+                case 1:
+                    llsdItem.sale_info.sale_type = "original";
+                    break;
+                case 2:
+                    llsdItem.sale_info.sale_type = "copy";
+                    break;
+                case 3:
+                    llsdItem.sale_info.sale_type = "contents";
+                    break;
+            }
+
+            return llsdItem;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="mapReq"></param>
+        /// <returns></returns>
+        public LLSDMapLayerResponse GetMapLayer(LLSDMapRequest mapReq)
+        {
+            m_log.Debug("[CAPS]: MapLayer Request in region: " + m_regionName);
+            LLSDMapLayerResponse mapResponse = new LLSDMapLayerResponse();
+            mapResponse.LayerData.Array.Add(GetOSDMapLayerResponse());
+            return mapResponse;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected static OSDMapLayer GetOSDMapLayerResponse()
+        {
+            OSDMapLayer mapLayer = new OSDMapLayer();
+            mapLayer.Right = 5000;
+            mapLayer.Top = 5000;
+            mapLayer.ImageID = new UUID("00000000-0000-1111-9999-000000000006");
+
+            return mapLayer;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        public string RequestTexture(string request, string path, string param)
+        {
+            m_log.Debug("texture request " + request);
+            // Needs implementing (added to remove compiler warning)
+            return String.Empty;
+        }
+
+
+        /// <summary>
+        /// Called by the notecard update handler.  Provides a URL to which the client can upload a new asset.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        public string NoteCardAgentInventory(string request, string path, string param,
+                                             OSHttpRequest httpRequest, OSHttpResponse httpResponse)
+        {
+            //m_log.Debug("[CAPS]: NoteCardAgentInventory Request in region: " + m_regionName + "\n" + request);
+            //m_log.Debug("[CAPS]: NoteCardAgentInventory Request is: " + request);
+
+            //OpenMetaverse.StructuredData.OSDMap hash = (OpenMetaverse.StructuredData.OSDMap)OpenMetaverse.StructuredData.LLSDParser.DeserializeBinary(Utils.StringToBytes(request));
+            Hashtable hash = (Hashtable)LLSD.LLSDDeserialize(Utils.StringToBytes(request));
+            LLSDItemUpdate llsdRequest = new LLSDItemUpdate();
+            LLSDHelpers.DeserialiseOSDMap(hash, llsdRequest);
+
+            string capsBase = "/CAPS/" + m_HostCapsObj.CapsObjectPath;
+            string uploaderPath = Util.RandomClass.Next(5000, 8000).ToString("0000");
+
+            ItemUpdater uploader =
+                new ItemUpdater(llsdRequest.item_id, capsBase + uploaderPath, m_HostCapsObj.HttpListener, m_dumpAssetsToFile);
+            uploader.OnUpLoad += ItemUpdated;
+
+            m_HostCapsObj.HttpListener.AddStreamHandler(
+                new BinaryStreamHandler("POST", capsBase + uploaderPath, uploader.uploaderCaps));
+
+            string protocol = "http://";
+
+            if (m_HostCapsObj.SSLCaps)
+                protocol = "https://";
+
+            string uploaderURL = protocol + m_HostCapsObj.HostName + ":" + m_HostCapsObj.Port.ToString() + capsBase +
+                                 uploaderPath;
+
+            LLSDAssetUploadResponse uploadResponse = new LLSDAssetUploadResponse();
+            uploadResponse.uploader = uploaderURL;
+            uploadResponse.state = "upload";
+
+            //            m_log.InfoFormat("[CAPS]: " +
+            //                             "NoteCardAgentInventory response: {0}",
+            //                             LLSDHelpers.SerialiseLLSDReply(uploadResponse)));
+
+            return LLSDHelpers.SerialiseLLSDReply(uploadResponse);
+        }
+    }
+
+    public class AssetUploader
+    {
+        public event UpLoadedAsset OnUpLoad;
+        private UpLoadedAsset handlerUpLoad = null;
+
+        private string uploaderPath = String.Empty;
+        private UUID newAssetID;
+        private UUID inventoryItemID;
+        private UUID parentFolder;
+        private IHttpServer httpListener;
+        private bool m_dumpAssetsToFile;
+        private string m_assetName = String.Empty;
+        private string m_assetDes = String.Empty;
+
+        private string m_invType = String.Empty;
+        private string m_assetType = String.Empty;
+
+        public AssetUploader(string assetName, string description, UUID assetID, UUID inventoryItem,
+                                UUID parentFolderID, string invType, string assetType, string path,
+                                IHttpServer httpServer, bool dumpAssetsToFile)
+        {
+            m_assetName = assetName;
+            m_assetDes = description;
+            newAssetID = assetID;
+            inventoryItemID = inventoryItem;
+            uploaderPath = path;
+            httpListener = httpServer;
+            parentFolder = parentFolderID;
+            m_assetType = assetType;
+            m_invType = invType;
+            m_dumpAssetsToFile = dumpAssetsToFile;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="data"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        public string uploaderCaps(byte[] data, string path, string param)
+        {
+            UUID inv = inventoryItemID;
+            string res = String.Empty;
+            LLSDAssetUploadComplete uploadComplete = new LLSDAssetUploadComplete();
+            uploadComplete.new_asset = newAssetID.ToString();
+            uploadComplete.new_inventory_item = inv;
+            uploadComplete.state = "complete";
+
+            res = LLSDHelpers.SerialiseLLSDReply(uploadComplete);
+
+            httpListener.RemoveStreamHandler("POST", uploaderPath);
+
+            // TODO: probably make this a better set of extensions here
+            string extension = ".jp2";
+            if (m_invType != "image")
+            {
+                extension = ".dat";
+            }
+
+            if (m_dumpAssetsToFile)
+            {
+                SaveAssetToFile(m_assetName + extension, data);
+            }
+            handlerUpLoad = OnUpLoad;
+            if (handlerUpLoad != null)
+            {
+                handlerUpLoad(m_assetName, m_assetDes, newAssetID, inv, parentFolder, data, m_invType, m_assetType);
+            }
+
+            return res;
+        }
+        ///Left this in and commented in case there are unforseen issues
+        //private void SaveAssetToFile(string filename, byte[] data)
+        //{
+        //    FileStream fs = File.Create(filename);
+        //    BinaryWriter bw = new BinaryWriter(fs);
+        //    bw.Write(data);
+        //    bw.Close();
+        //    fs.Close();
+        //}
+        private static void SaveAssetToFile(string filename, byte[] data)
+        {
+            string assetPath = "UserAssets";
+            if (!Directory.Exists(assetPath))
+            {
+                Directory.CreateDirectory(assetPath);
+            }
+            FileStream fs = File.Create(Path.Combine(assetPath, Util.safeFileName(filename)));
+            BinaryWriter bw = new BinaryWriter(fs);
+            bw.Write(data);
+            bw.Close();
+            fs.Close();
+        }
+    }
+
+    /// <summary>
+    /// This class is a callback invoked when a client sends asset data to
+    /// an agent inventory notecard update url
+    /// </summary>
+    public class ItemUpdater
+    {
+        public event UpdateItem OnUpLoad;
+
+        private UpdateItem handlerUpdateItem = null;
+
+        private string uploaderPath = String.Empty;
+        private UUID inventoryItemID;
+        private IHttpServer httpListener;
+        private bool m_dumpAssetToFile;
+
+        public ItemUpdater(UUID inventoryItem, string path, IHttpServer httpServer, bool dumpAssetToFile)
+        {
+            m_dumpAssetToFile = dumpAssetToFile;
+
+            inventoryItemID = inventoryItem;
+            uploaderPath = path;
+            httpListener = httpServer;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="data"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        public string uploaderCaps(byte[] data, string path, string param)
+        {
+            UUID inv = inventoryItemID;
+            string res = String.Empty;
+            LLSDAssetUploadComplete uploadComplete = new LLSDAssetUploadComplete();
+            UUID assetID = UUID.Zero;
+            handlerUpdateItem = OnUpLoad;
+            if (handlerUpdateItem != null)
+            {
+                assetID = handlerUpdateItem(inv, data);
+            }
+
+            uploadComplete.new_asset = assetID.ToString();
+            uploadComplete.new_inventory_item = inv;
+            uploadComplete.state = "complete";
+
+            res = LLSDHelpers.SerialiseLLSDReply(uploadComplete);
+
+            httpListener.RemoveStreamHandler("POST", uploaderPath);
+
+            if (m_dumpAssetToFile)
+            {
+                SaveAssetToFile("updateditem" + Util.RandomClass.Next(1, 1000) + ".dat", data);
+            }
+
+            return res;
+        }
+        ///Left this in and commented in case there are unforseen issues
+        //private void SaveAssetToFile(string filename, byte[] data)
+        //{
+        //    FileStream fs = File.Create(filename);
+        //    BinaryWriter bw = new BinaryWriter(fs);
+        //    bw.Write(data);
+        //    bw.Close();
+        //    fs.Close();
+        //}
+        private static 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();
+        }
+    }
+
+    /// <summary>
+    /// This class is a callback invoked when a client sends asset data to
+    /// a task inventory script update url
+    /// </summary>
+    public class TaskInventoryScriptUpdater
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        public event UpdateTaskScript OnUpLoad;
+
+        private UpdateTaskScript handlerUpdateTaskScript = null;
+
+        private string uploaderPath = String.Empty;
+        private UUID inventoryItemID;
+        private UUID primID;
+        private bool isScriptRunning;
+        private IHttpServer httpListener;
+        private bool m_dumpAssetToFile;
+
+        public TaskInventoryScriptUpdater(UUID inventoryItemID, UUID primID, int isScriptRunning,
+                                            string path, IHttpServer httpServer, bool dumpAssetToFile)
+        {
+            m_dumpAssetToFile = dumpAssetToFile;
+
+            this.inventoryItemID = inventoryItemID;
+            this.primID = primID;
+
+            // This comes in over the packet as an integer, but actually appears to be treated as a bool
+            this.isScriptRunning = (0 == isScriptRunning ? false : true);
+
+            uploaderPath = path;
+            httpListener = httpServer;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="data"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        public string uploaderCaps(byte[] data, string path, string param)
+        {
+            try
+            {
+                //                    m_log.InfoFormat("[CAPS]: " +
+                //                                     "TaskInventoryScriptUpdater received data: {0}, path: {1}, param: {2}",
+                //                                     data, path, param));
+
+                string res = String.Empty;
+                LLSDTaskScriptUploadComplete uploadComplete = new LLSDTaskScriptUploadComplete();
+
+                ArrayList errors = new ArrayList();
+                handlerUpdateTaskScript = OnUpLoad;
+                if (handlerUpdateTaskScript != null)
+                {
+                    handlerUpdateTaskScript(inventoryItemID, primID, isScriptRunning, data, ref errors);
+                }
+
+                uploadComplete.new_asset = inventoryItemID;
+                uploadComplete.compiled = errors.Count > 0 ? false : true;
+                uploadComplete.state = "complete";
+                uploadComplete.errors = new OSDArray();
+                uploadComplete.errors.Array = errors;
+
+                res = LLSDHelpers.SerialiseLLSDReply(uploadComplete);
+
+                httpListener.RemoveStreamHandler("POST", uploaderPath);
+
+                if (m_dumpAssetToFile)
+                {
+                    SaveAssetToFile("updatedtaskscript" + Util.RandomClass.Next(1, 1000) + ".dat", data);
+                }
+
+                //                    m_log.InfoFormat("[CAPS]: TaskInventoryScriptUpdater.uploaderCaps res: {0}", res);
+
+                return res;
+            }
+            catch (Exception e)
+            {
+                m_log.Error("[CAPS]: " + e.ToString());
+            }
+
+            // XXX Maybe this should be some meaningful error packet
+            return null;
+        }
+        ///Left this in and commented in case there are unforseen issues
+        //private void SaveAssetToFile(string filename, byte[] data)
+        //{
+        //    FileStream fs = File.Create(filename);
+        //    BinaryWriter bw = new BinaryWriter(fs);
+        //    bw.Write(data);
+        //    bw.Close();
+        //    fs.Close();
+        //}
+        private static 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 class BakedTextureUploader
+    {
+        public event UploadedBakedTexture OnUpLoad;
+        private UploadedBakedTexture handlerUpLoad = null;
+
+        private string uploaderPath = String.Empty;
+        private UUID newAssetID;
+        private IHttpServer httpListener;
+
+        public BakedTextureUploader(string path, IHttpServer httpServer)
+        {
+            newAssetID = UUID.Random();
+            uploaderPath = path;
+            httpListener = httpServer;
+            //                m_log.InfoFormat("[CAPS] baked texture upload starting for {0}",newAssetID);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="data"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        public string uploaderCaps(byte[] data, string path, string param)
+        {
+            handlerUpLoad = OnUpLoad;
+            if (handlerUpLoad != null)
+            {
+                Util.FireAndForget(delegate(object o) { handlerUpLoad(newAssetID, data); });
+            }
+
+            string res = String.Empty;
+            LLSDAssetUploadComplete uploadComplete = new LLSDAssetUploadComplete();
+            uploadComplete.new_asset = newAssetID.ToString();
+            uploadComplete.new_inventory_item = UUID.Zero;
+            uploadComplete.state = "complete";
+
+            res = LLSDHelpers.SerialiseLLSDReply(uploadComplete);
+
+            httpListener.RemoveStreamHandler("POST", uploaderPath);
+
+            //                m_log.InfoFormat("[CAPS] baked texture upload completed for {0}",newAssetID);
+
+            return res;
+        }
+    }
+
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCapsModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCapsModule.cs
new file mode 100644
index 0000000..14160ae
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCapsModule.cs
@@ -0,0 +1,91 @@
+/*
+ * 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 Mono.Addins;
+
+using OpenSim.Framework;
+using OpenSim.Region.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+
+[assembly: Addin("LindenCaps", "0.1")]
+[assembly: AddinDependency("OpenSim", "0.5")]
+namespace OpenSim.Region.ClientStack.Linden
+{
+
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
+    public class BunchOfCapsModule : INonSharedRegionModule
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private Scene m_Scene;
+
+        #region INonSharedRegionModule
+
+        public string Name { get { return "BunchOfCapsModule"; } }
+
+        public Type ReplaceableInterface { get { return null; } }
+
+        public void Initialise(IConfigSource source)
+        {
+        }
+
+        public void Close() { } 
+
+        public void AddRegion(Scene scene)
+        {
+            m_Scene = scene;
+            m_Scene.EventManager.OnRegisterCaps += OnRegisterCaps;
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+        }
+
+        public void PostInitialise() { }
+        #endregion 
+
+        private void OnRegisterCaps(UUID agentID, Caps caps)
+        {
+            new BunchOfCaps(m_Scene, caps);
+        }
+
+    }
+}
diff --git a/OpenSim/Region/CoreModules/Framework/EventQueue/EventQueueGetModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueGetModule.cs
index 05fe3ee..4a8bb53 100644
--- a/OpenSim/Region/CoreModules/Framework/EventQueue/EventQueueGetModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueGetModule.cs
@@ -33,6 +33,7 @@ using System.Reflection;
 using System.Threading;
 using log4net;
 using Nini.Config;
+using Mono.Addins;
 using OpenMetaverse;
 using OpenMetaverse.Messages.Linden;
 using OpenMetaverse.Packets;
@@ -45,7 +46,7 @@ using OpenSim.Region.Framework.Scenes;
 using BlockingLLSDQueue = OpenSim.Framework.BlockingQueue<OpenMetaverse.StructuredData.OSD>;
 using Caps=OpenSim.Framework.Capabilities.Caps;
 
-namespace OpenSim.Region.CoreModules.Framework.EventQueue
+namespace OpenSim.Region.ClientStack.Linden
 {
     public struct QueueItem
     {
@@ -53,6 +54,7 @@ namespace OpenSim.Region.CoreModules.Framework.EventQueue
         public OSDMap body;
     }
 
+    //[Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
     public class EventQueueGetModule : IEventQueue, IRegionModule
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
@@ -520,7 +522,7 @@ namespace OpenSim.Region.CoreModules.Framework.EventQueue
                 }
                 if (AvatarID != UUID.Zero)
                 {
-                    return ProcessQueue(request, AvatarID, m_scene.CapsModule.GetCapsHandlerForUser(AvatarID));
+                    return ProcessQueue(request, AvatarID, m_scene.CapsModule.GetCapsForUser(AvatarID));
                 }
                 else
                 {
@@ -715,5 +717,15 @@ namespace OpenSim.Region.CoreModules.Framework.EventQueue
             OSD item = EventQueueHelper.PlacesQuery(groupUpdate);
             Enqueue(item, avatarID);
         }
+
+        public OSD ScriptRunningEvent(UUID objectID, UUID itemID, bool running, bool mono)
+        {
+            return EventQueueHelper.ScriptRunningReplyEvent(objectID, itemID, running, mono);
+        }
+
+        public OSD BuildEvent(string eventName, OSD eventBody)
+        {
+            return EventQueueHelper.BuildEvent(eventName, eventBody);
+        }
     }
 }
diff --git a/OpenSim/Region/CoreModules/Framework/EventQueue/EventQueueHelper.cs b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueHelper.cs
index 0d7d16a..3f49aba 100644
--- a/OpenSim/Region/CoreModules/Framework/EventQueue/EventQueueHelper.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueHelper.cs
@@ -32,7 +32,7 @@ using OpenMetaverse.Packets;
 using OpenMetaverse.StructuredData;
 using OpenMetaverse.Messages.Linden;
 
-namespace OpenSim.Region.CoreModules.Framework.EventQueue
+namespace OpenSim.Region.ClientStack.Linden
 {
     public class EventQueueHelper
     {
@@ -61,7 +61,7 @@ namespace OpenSim.Region.CoreModules.Framework.EventQueue
 //            return result;
 //        }
 
-        public static OSD buildEvent(string eventName, OSD eventBody)
+        public static OSD BuildEvent(string eventName, OSD eventBody)
         {
             OSDMap llsdEvent = new OSDMap(2);
             llsdEvent.Add("message", new OSDString(eventName));
@@ -84,7 +84,7 @@ namespace OpenSim.Region.CoreModules.Framework.EventQueue
             OSDMap llsdBody = new OSDMap(1);
             llsdBody.Add("SimulatorInfo", arr);
 
-            return buildEvent("EnableSimulator", llsdBody);
+            return BuildEvent("EnableSimulator", llsdBody);
         }
 
         public static OSD DisableSimulator(ulong handle)
@@ -99,7 +99,7 @@ namespace OpenSim.Region.CoreModules.Framework.EventQueue
             OSDMap llsdBody = new OSDMap(0);
             //llsdBody.Add("SimulatorInfo", arr);
 
-            return buildEvent("DisableSimulator", llsdBody);
+            return BuildEvent("DisableSimulator", llsdBody);
         }
         
         public static OSD CrossRegion(ulong handle, Vector3 pos, Vector3 lookAt,
@@ -144,7 +144,7 @@ namespace OpenSim.Region.CoreModules.Framework.EventQueue
             llsdBody.Add("AgentData", agentDataArr);
             llsdBody.Add("RegionData", regionDataArr);
 
-            return buildEvent("CrossedRegion", llsdBody);
+            return BuildEvent("CrossedRegion", llsdBody);
         }
 
         public static OSD TeleportFinishEvent(
@@ -167,7 +167,7 @@ namespace OpenSim.Region.CoreModules.Framework.EventQueue
             OSDMap body = new OSDMap();
             body.Add("Info", infoArr);
 
-            return buildEvent("TeleportFinish", body);
+            return BuildEvent("TeleportFinish", body);
         }
 
         public static OSD ScriptRunningReplyEvent(UUID objectID, UUID itemID, bool running, bool mono)
@@ -184,7 +184,7 @@ namespace OpenSim.Region.CoreModules.Framework.EventQueue
             OSDMap body = new OSDMap();
             body.Add("Script", scriptArr);
             
-            return buildEvent("ScriptRunningReply", body);
+            return BuildEvent("ScriptRunningReply", body);
         }
 
         public static OSD EstablishAgentCommunication(UUID agentID, string simIpAndPort, string seedcap)
@@ -194,12 +194,12 @@ namespace OpenSim.Region.CoreModules.Framework.EventQueue
             body.Add("sim-ip-and-port", new OSDString(simIpAndPort));
             body.Add("seed-capability", new OSDString(seedcap));
 
-            return buildEvent("EstablishAgentCommunication", body);
+            return BuildEvent("EstablishAgentCommunication", body);
         }
 
         public static OSD KeepAliveEvent()
         {
-            return buildEvent("FAKEEVENT", new OSDMap());
+            return BuildEvent("FAKEEVENT", new OSDMap());
         }
 
         public static OSD AgentParams(UUID agentID, bool checkEstate, int godLevel, bool limitedToEstate)
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/GetMeshModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/GetMeshModule.cs
new file mode 100644
index 0000000..f2f765c
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/GetMeshModule.cs
@@ -0,0 +1,136 @@
+/*
+ * 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;
+using System.Collections.Specialized;
+using System.Reflection;
+using System.IO;
+using System.Web;
+using Mono.Addins;
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Capabilities.Handlers;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
+    public class GetMeshModule : INonSharedRegionModule
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        
+        private Scene m_scene;
+        private IAssetService m_AssetService;
+        private bool m_Enabled = true;
+        private string m_URL;
+
+        #region IRegionModuleBase Members
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig config = source.Configs["ClientStack.LindenCaps"];
+            if (config == null)
+                return;
+
+            m_URL = config.GetString("Cap_GetMesh", string.Empty);
+            // Cap doesn't exist
+            if (m_URL != string.Empty)
+                m_Enabled = true;
+        }
+
+        public void AddRegion(Scene pScene)
+        {
+            if (!m_Enabled)
+                return;
+
+            m_scene = pScene;
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            m_scene.EventManager.OnRegisterCaps -= RegisterCaps;
+            m_scene = null;
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            m_AssetService = m_scene.RequestModuleInterface<IAssetService>();
+            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+        }
+
+
+        public void Close() { }
+
+        public string Name { get { return "GetMeshModule"; } }
+
+        #endregion
+
+
+        public void RegisterCaps(UUID agentID, Caps caps)
+        {
+            UUID capID = UUID.Random();
+
+            //caps.RegisterHandler("GetTexture", new StreamHandler("GET", "/CAPS/" + capID, ProcessGetTexture));
+            if (m_URL == "localhost")
+            {
+                m_log.InfoFormat("[GETMESH]: /CAPS/{0} in region {1}", capID, m_scene.RegionInfo.RegionName);
+                GetMeshHandler gmeshHandler = new GetMeshHandler(m_AssetService);
+                IRequestHandler reqHandler = new RestHTTPHandler("GET", "/CAPS/" + UUID.Random(),
+                                                           delegate(Hashtable m_dhttpMethod)
+                                                           {
+                                                               return gmeshHandler.ProcessGetMesh(m_dhttpMethod, UUID.Zero, null);
+                                                           });
+
+                caps.RegisterHandler("GetMesh", reqHandler);
+            }
+            else
+            {
+                m_log.InfoFormat("[GETMESH]: {0} in region {1}", m_URL, m_scene.RegionInfo.RegionName);
+                caps.RegisterHandler("GetMesh", m_URL);
+            }
+        }
+
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/GetTextureModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/GetTextureModule.cs
new file mode 100644
index 0000000..564ef31
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/GetTextureModule.cs
@@ -0,0 +1,139 @@
+/*
+ * 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;
+using System.Collections.Specialized;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.Reflection;
+using System.IO;
+using System.Web;
+using log4net;
+using Nini.Config;
+using Mono.Addins;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenMetaverse.Imaging;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+using OpenSim.Capabilities.Handlers;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
+    public class GetTextureModule : INonSharedRegionModule
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private Scene m_scene;
+        private IAssetService m_assetService;
+
+        private bool m_Enabled = false;
+
+        // TODO: Change this to a config option
+        const string REDIRECT_URL = null;
+
+        private string m_URL;
+
+        #region ISharedRegionModule Members
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig config = source.Configs["ClientStack.LindenCaps"];
+            if (config == null)
+                return;
+
+            m_URL = config.GetString("Cap_GetTexture", string.Empty);
+            // Cap doesn't exist
+            if (m_URL != string.Empty)
+                m_Enabled = true;
+        }
+
+        public void AddRegion(Scene s)
+        {
+            if (!m_Enabled)
+                return;
+
+            m_scene = s;
+        }
+
+        public void RemoveRegion(Scene s)
+        {
+            m_scene.EventManager.OnRegisterCaps -= RegisterCaps;
+            m_scene = null;
+        }
+
+        public void RegionLoaded(Scene s)
+        {
+            if (!m_Enabled)
+                return;
+
+            m_assetService = m_scene.RequestModuleInterface<IAssetService>();
+            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+        }
+
+        public void PostInitialise()
+        {
+        }
+
+        public void Close() { }
+
+        public string Name { get { return "GetTextureModule"; } }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        #endregion
+
+        public void RegisterCaps(UUID agentID, Caps caps)
+        {
+            UUID capID = UUID.Random();
+
+            //caps.RegisterHandler("GetTexture", new StreamHandler("GET", "/CAPS/" + capID, ProcessGetTexture));
+            if (m_URL == "localhost")
+            {
+                m_log.InfoFormat("[GETTEXTURE]: /CAPS/{0} in region {1}", capID, m_scene.RegionInfo.RegionName);
+                caps.RegisterHandler("GetTexture", new GetTextureHandler("/CAPS/" + capID + "/", m_assetService));
+            }
+            else
+            {
+                m_log.InfoFormat("[GETTEXTURE]: {0} in region {1}", m_URL, m_scene.RegionInfo.RegionName);
+                caps.RegisterHandler("GetTexture", m_URL);
+            }
+        }
+
+    }
+}
diff --git a/OpenSim/Region/CoreModules/Avatar/Assets/NewFileAgentInventoryVariablePriceModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/NewFileAgentInventoryVariablePriceModule.cs
index 3d4c7b7..b7e79cc 100644
--- a/OpenSim/Region/CoreModules/Avatar/Assets/NewFileAgentInventoryVariablePriceModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/NewFileAgentInventoryVariablePriceModule.cs
@@ -45,7 +45,7 @@ using OpenSim.Services.Interfaces;
 using Caps = OpenSim.Framework.Capabilities.Caps;
 using OpenSim.Framework.Capabilities;
 
-namespace OpenSim.Region.CoreModules.Avatar.Assets
+namespace OpenSim.Region.ClientStack.Linden
 {
     [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
     public class NewFileAgentInventoryVariablePriceModule : INonSharedRegionModule
@@ -171,8 +171,8 @@ namespace OpenSim.Region.CoreModules.Avatar.Assets
             UUID parentFolder = llsdRequest.folder_id;
             string uploaderPath = Util.RandomClass.Next(5000, 8000).ToString("0000") + "/";
 
-            Caps.AssetUploader uploader =
-                new Caps.AssetUploader(assetName, assetDes, newAsset, newInvItem, parentFolder, llsdRequest.inventory_type,
+            AssetUploader uploader =
+                new AssetUploader(assetName, assetDes, newAsset, newInvItem, parentFolder, llsdRequest.inventory_type,
                                   llsdRequest.asset_type, capsBase + uploaderPath, MainServer.Instance, m_dumpAssetsToFile);
             MainServer.Instance.AddStreamHandler(
                 new BinaryStreamHandler("POST", capsBase + uploaderPath, uploader.uploaderCaps));
diff --git a/OpenSim/Region/CoreModules/Avatar/ObjectCaps/ObjectAdd.cs b/OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/ObjectAdd.cs
index a0d72ed..15139a3 100644
--- a/OpenSim/Region/CoreModules/Avatar/ObjectCaps/ObjectAdd.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/ObjectAdd.cs
@@ -39,7 +39,7 @@ using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 using Caps=OpenSim.Framework.Capabilities.Caps;
 
-namespace OpenSim.Region.CoreModules.Avatar.ObjectCaps
+namespace OpenSim.Region.ClientStack.Linden
 {
     public class ObjectAdd : IRegionModule
     {
diff --git a/OpenSim/Region/CoreModules/Avatar/ObjectCaps/UploadObjectAssetModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/UploadObjectAssetModule.cs
index 3114d7f..3809f84 100644
--- a/OpenSim/Region/CoreModules/Avatar/ObjectCaps/UploadObjectAssetModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/UploadObjectAssetModule.cs
@@ -49,7 +49,7 @@ using OSDMap = OpenMetaverse.StructuredData.OSDMap;
 using OpenSim.Framework.Capabilities;
 using ExtraParamType = OpenMetaverse.ExtraParamType;
 
-namespace OpenSim.Region.CoreModules.Avatar.ObjectCaps
+namespace OpenSim.Region.ClientStack.Linden
 {
     [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
     public class UploadObjectAssetModule : INonSharedRegionModule
diff --git a/OpenSim/Region/ClientStack/LindenUDP/IncomingPacket.cs b/OpenSim/Region/ClientStack/Linden/UDP/IncomingPacket.cs
index 90b3ede..90b3ede 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/IncomingPacket.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/IncomingPacket.cs
diff --git a/OpenSim/Region/ClientStack/LindenUDP/IncomingPacketHistoryCollection.cs b/OpenSim/Region/ClientStack/Linden/UDP/IncomingPacketHistoryCollection.cs
index 1f73a1d..1f73a1d 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/IncomingPacketHistoryCollection.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/IncomingPacketHistoryCollection.cs
diff --git a/OpenSim/Region/ClientStack/LindenUDP/J2KImage.cs b/OpenSim/Region/ClientStack/Linden/UDP/J2KImage.cs
index e9e2dca..e9e2dca 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/J2KImage.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/J2KImage.cs
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
index 43903ce..43903ce 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLImageManager.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLImageManager.cs
index 9e0db12..9e0db12 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLImageManager.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/LLImageManager.cs
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLUDPClient.cs
index ca5501d..ca5501d 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/LLUDPClient.cs
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLUDPServer.cs
index aff90c5..aff90c5 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/LLUDPServer.cs
diff --git a/OpenSim/Region/ClientStack/LindenUDP/OpenSimUDPBase.cs b/OpenSim/Region/ClientStack/Linden/UDP/OpenSimUDPBase.cs
index 6eebd9d..6eebd9d 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/OpenSimUDPBase.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/OpenSimUDPBase.cs
diff --git a/OpenSim/Region/ClientStack/LindenUDP/OutgoingPacket.cs b/OpenSim/Region/ClientStack/Linden/UDP/OutgoingPacket.cs
index 76c6c14..76c6c14 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/OutgoingPacket.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/OutgoingPacket.cs
diff --git a/OpenSim/Region/ClientStack/LindenUDP/Tests/BasicCircuitTests.cs b/OpenSim/Region/ClientStack/Linden/UDP/Tests/BasicCircuitTests.cs
index daab84f..daab84f 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/Tests/BasicCircuitTests.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/BasicCircuitTests.cs
diff --git a/OpenSim/Region/ClientStack/LindenUDP/Tests/MockScene.cs b/OpenSim/Region/ClientStack/Linden/UDP/Tests/MockScene.cs
index 34c21aa..34c21aa 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/Tests/MockScene.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/MockScene.cs
diff --git a/OpenSim/Region/ClientStack/LindenUDP/Tests/PacketHandlerTests.cs b/OpenSim/Region/ClientStack/Linden/UDP/Tests/PacketHandlerTests.cs
index 7d0757f..7d0757f 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/Tests/PacketHandlerTests.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/PacketHandlerTests.cs
diff --git a/OpenSim/Region/ClientStack/LindenUDP/Tests/TestLLPacketServer.cs b/OpenSim/Region/ClientStack/Linden/UDP/Tests/TestLLPacketServer.cs
index e995d65..e995d65 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/Tests/TestLLPacketServer.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/TestLLPacketServer.cs
diff --git a/OpenSim/Region/ClientStack/LindenUDP/Tests/TestLLUDPServer.cs b/OpenSim/Region/ClientStack/Linden/UDP/Tests/TestLLUDPServer.cs
index f98586d..f98586d 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/Tests/TestLLUDPServer.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/TestLLUDPServer.cs
diff --git a/OpenSim/Region/ClientStack/LindenUDP/ThrottleRates.cs b/OpenSim/Region/ClientStack/Linden/UDP/ThrottleRates.cs
index c9aac0b..c9aac0b 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/ThrottleRates.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/ThrottleRates.cs
diff --git a/OpenSim/Region/ClientStack/LindenUDP/TokenBucket.cs b/OpenSim/Region/ClientStack/Linden/UDP/TokenBucket.cs
index 29fd1a4..29fd1a4 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/TokenBucket.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/TokenBucket.cs
diff --git a/OpenSim/Region/ClientStack/LindenUDP/UnackedPacketCollection.cs b/OpenSim/Region/ClientStack/Linden/UDP/UnackedPacketCollection.cs
index 793aefe..793aefe 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/UnackedPacketCollection.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/UnackedPacketCollection.cs
diff --git a/OpenSim/Region/CoreModules/Avatar/Assets/GetMeshModule.cs b/OpenSim/Region/CoreModules/Avatar/Assets/GetMeshModule.cs
deleted file mode 100644
index fc1ddef..0000000
--- a/OpenSim/Region/CoreModules/Avatar/Assets/GetMeshModule.cs
+++ /dev/null
@@ -1,211 +0,0 @@
-/*
- * 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;
-using System.Collections.Specialized;
-using System.Reflection;
-using System.IO;
-using System.Web;
-using Mono.Addins;
-using log4net;
-using Nini.Config;
-using OpenMetaverse;
-using OpenMetaverse.StructuredData;
-using OpenSim.Framework;
-using OpenSim.Framework.Servers;
-using OpenSim.Framework.Servers.HttpServer;
-using OpenSim.Region.Framework.Interfaces;
-using OpenSim.Region.Framework.Scenes;
-using OpenSim.Services.Interfaces;
-using Caps = OpenSim.Framework.Capabilities.Caps;
-
-namespace OpenSim.Region.CoreModules.Avatar.Assets
-{
-    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
-    public class GetMeshModule : INonSharedRegionModule
-    {
-//        private static readonly ILog m_log =
-//            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-        
-        private Scene m_scene;
-        private IAssetService m_assetService;
-        private bool m_enabled = true;
-
-        #region IRegionModuleBase Members
-
-
-        public Type ReplaceableInterface
-        {
-            get { return null; }
-        }
-
-        public void Initialise(IConfigSource source)
-        {
-            IConfig meshConfig = source.Configs["Mesh"];
-            if (meshConfig == null)
-                return;
-
-            m_enabled = meshConfig.GetBoolean("AllowMeshUpload", true);
-        }
-
-        public void AddRegion(Scene pScene)
-        {
-            m_scene = pScene;
-        }
-
-        public void RemoveRegion(Scene scene)
-        {
-            
-            m_scene.EventManager.OnRegisterCaps -= RegisterCaps;
-            m_scene = null;
-        }
-
-        public void RegionLoaded(Scene scene)
-        {
-            
-            m_assetService = m_scene.RequestModuleInterface<IAssetService>();
-            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
-        }
-
-        #endregion
-
-
-        #region IRegionModule Members
-
-       
-
-        public void Close() { }
-
-        public string Name { get { return "GetMeshModule"; } }
-
-
-        public void RegisterCaps(UUID agentID, Caps caps)
-        {
-            if(!m_enabled)
-                return;
-
-            UUID capID = UUID.Random();
-
-//            m_log.Info("[GETMESH]: /CAPS/" + capID);
-
-            caps.RegisterHandler("GetMesh",
-                                 new RestHTTPHandler("GET", "/CAPS/" + capID,
-                                                       delegate(Hashtable m_dhttpMethod)
-                                                       {
-                                                           return ProcessGetMesh(m_dhttpMethod, agentID, caps);
-                                                       }));
-        }
-
-        #endregion
-
-        public Hashtable ProcessGetMesh(Hashtable request, UUID AgentId, Caps cap)
-        {
-            
-            Hashtable responsedata = new Hashtable();
-            responsedata["int_response_code"] = 400; //501; //410; //404;
-            responsedata["content_type"] = "text/plain";
-            responsedata["keepalive"] = false;
-            responsedata["str_response_string"] = "Request wasn't what was expected";
-
-            string meshStr = string.Empty;
-
-            if (request.ContainsKey("mesh_id"))
-                meshStr = request["mesh_id"].ToString();
-
-
-            UUID meshID = UUID.Zero;
-            if (!String.IsNullOrEmpty(meshStr) && UUID.TryParse(meshStr, out meshID))
-            {
-                if (m_assetService == null)
-                {
-                    responsedata["int_response_code"] = 404; //501; //410; //404;
-                    responsedata["content_type"] = "text/plain";
-                    responsedata["keepalive"] = false;
-                    responsedata["str_response_string"] = "The asset service is unavailable.  So is your mesh.";
-                    return responsedata;
-                }
-
-                AssetBase mesh;
-                // Only try to fetch locally cached textures. Misses are redirected
-                mesh = m_assetService.GetCached(meshID.ToString());
-                if (mesh != null)
-                {
-                    if (mesh.Type == (SByte)AssetType.Mesh) 
-                    {
-                        responsedata["str_response_string"] = Convert.ToBase64String(mesh.Data);
-                        responsedata["content_type"] = "application/vnd.ll.mesh";
-                        responsedata["int_response_code"] = 200;
-                    }
-                    // Optionally add additional mesh types here
-                    else
-                    {
-                        responsedata["int_response_code"] = 404; //501; //410; //404;
-                        responsedata["content_type"] = "text/plain";
-                        responsedata["keepalive"] = false;
-                        responsedata["str_response_string"] = "Unfortunately, this asset isn't a mesh.";
-                        return responsedata;
-                    }
-                }
-                else
-                {
-                    mesh = m_assetService.Get(meshID.ToString());
-                    if (mesh != null)
-                    {
-                        if (mesh.Type == (SByte)AssetType.Mesh) 
-                        {
-                            responsedata["str_response_string"] = Convert.ToBase64String(mesh.Data);
-                            responsedata["content_type"] = "application/vnd.ll.mesh";
-                            responsedata["int_response_code"] = 200;
-                        }
-                        // Optionally add additional mesh types here
-                        else
-                        {
-                            responsedata["int_response_code"] = 404; //501; //410; //404;
-                            responsedata["content_type"] = "text/plain";
-                            responsedata["keepalive"] = false;
-                            responsedata["str_response_string"] = "Unfortunately, this asset isn't a mesh.";
-                            return responsedata;
-                        }
-                    }
-
-                    else
-                    {
-                        responsedata["int_response_code"] = 404; //501; //410; //404;
-                        responsedata["content_type"] = "text/plain";
-                        responsedata["keepalive"] = false;
-                        responsedata["str_response_string"] = "Your Mesh wasn't found.  Sorry!";
-                        return responsedata;
-                    }
-                }
-
-            }
-
-            return responsedata;
-        }
-    }
-}
diff --git a/OpenSim/Region/CoreModules/Avatar/Assets/GetTextureModule.cs b/OpenSim/Region/CoreModules/Avatar/Assets/GetTextureModule.cs
deleted file mode 100644
index df4d561..0000000
--- a/OpenSim/Region/CoreModules/Avatar/Assets/GetTextureModule.cs
+++ /dev/null
@@ -1,402 +0,0 @@
-/*
- * 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;
-using System.Collections.Specialized;
-using System.Drawing;
-using System.Drawing.Imaging;
-using System.Reflection;
-using System.IO;
-using System.Web;
-using log4net;
-using Nini.Config;
-using OpenMetaverse;
-using OpenMetaverse.StructuredData;
-using OpenMetaverse.Imaging;
-using OpenSim.Framework;
-using OpenSim.Framework.Servers;
-using OpenSim.Framework.Servers.HttpServer;
-using OpenSim.Region.Framework.Interfaces;
-using OpenSim.Region.Framework.Scenes;
-using OpenSim.Services.Interfaces;
-using Caps = OpenSim.Framework.Capabilities.Caps;
-
-namespace OpenSim.Region.CoreModules.Avatar.ObjectCaps
-{
-    #region Stream Handler
-
-    public delegate byte[] StreamHandlerCallback(string path, Stream request, OSHttpRequest httpRequest, OSHttpResponse httpResponse);
-
-    public class StreamHandler : BaseStreamHandler
-    {
-        StreamHandlerCallback m_callback;
-
-        public StreamHandler(string httpMethod, string path, StreamHandlerCallback callback)
-            : base(httpMethod, path)
-        {
-            m_callback = callback;
-        }
-
-        public override byte[] Handle(string path, Stream request, OSHttpRequest httpRequest, OSHttpResponse httpResponse)
-        {
-            return m_callback(path, request, httpRequest, httpResponse);
-        }
-    }
-
-    #endregion Stream Handler
-
-    public class GetTextureModule : IRegionModule
-    {
-        private static readonly ILog m_log =
-            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-        private Scene m_scene;
-        private IAssetService m_assetService;
-
-        public const string DefaultFormat = "x-j2c";
-
-        // TODO: Change this to a config option
-        const string REDIRECT_URL = null;
-
-
-        #region IRegionModule Members
-
-        public void Initialise(Scene pScene, IConfigSource pSource)
-        {
-            m_scene = pScene;
-        }
-
-        public void PostInitialise()
-        {
-            m_assetService = m_scene.RequestModuleInterface<IAssetService>();
-            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
-        }
-
-        public void Close() { }
-
-        public string Name { get { return "GetTextureModule"; } }
-        public bool IsSharedModule { get { return false; } }
-
-        public void RegisterCaps(UUID agentID, Caps caps)
-        {
-            UUID capID = UUID.Random();
-
-//            m_log.InfoFormat("[GETTEXTURE]: /CAPS/{0} in region {1}", capID, m_scene.RegionInfo.RegionName);
-            caps.RegisterHandler("GetTexture", new StreamHandler("GET", "/CAPS/" + capID, ProcessGetTexture));
-        }
-
-        #endregion
-
-        private byte[] ProcessGetTexture(string path, Stream request, OSHttpRequest httpRequest, OSHttpResponse httpResponse)
-        {
-            //m_log.DebugFormat("[GETTEXTURE]: called in {0}", m_scene.RegionInfo.RegionName);
-
-            // Try to parse the texture ID from the request URL
-            NameValueCollection query = HttpUtility.ParseQueryString(httpRequest.Url.Query);
-            string textureStr = query.GetOne("texture_id");
-            string format = query.GetOne("format");
-
-            if (m_assetService == null)
-            {
-                m_log.Error("[GETTEXTURE]: Cannot fetch texture " + textureStr + " without an asset service");
-                httpResponse.StatusCode = (int)System.Net.HttpStatusCode.NotFound;
-                return null;
-            }
-
-            UUID textureID;
-            if (!String.IsNullOrEmpty(textureStr) && UUID.TryParse(textureStr, out textureID))
-            {
-                string[] formats;
-                if (format != null && format != string.Empty)
-                {
-                    formats = new string[1] { format.ToLower() };
-                }
-                else
-                {
-                    formats = WebUtil.GetPreferredImageTypes(httpRequest.Headers.Get("Accept"));
-                    if (formats.Length == 0)
-                        formats = new string[1] { DefaultFormat }; // default
-
-                }
-                // OK, we have an array with preferred formats, possibly with only one entry
-
-                httpResponse.StatusCode = (int)System.Net.HttpStatusCode.NotFound;
-                foreach (string f in formats)
-                {
-                    if (FetchTexture(httpRequest, httpResponse, textureID, f))
-                        break;
-                }
-
-            }
-            else
-            {
-                m_log.Warn("[GETTEXTURE]: Failed to parse a texture_id from GetTexture request: " + httpRequest.Url);
-            }
-
-            httpResponse.Send();
-            return null;
-        }
-
-        /// <summary>
-        /// 
-        /// </summary>
-        /// <param name="httpRequest"></param>
-        /// <param name="httpResponse"></param>
-        /// <param name="textureID"></param>
-        /// <param name="format"></param>
-        /// <returns>False for "caller try another codec"; true otherwise</returns>
-        private bool FetchTexture(OSHttpRequest httpRequest, OSHttpResponse httpResponse, UUID textureID, string format)
-        {
-//            m_log.DebugFormat("[GETTEXTURE]: {0} with requested format {1}", textureID, format);
-            AssetBase texture;
-
-            string fullID = textureID.ToString();
-            if (format != DefaultFormat)
-                fullID = fullID + "-" + format;
-
-            if (!String.IsNullOrEmpty(REDIRECT_URL))
-            {
-                // Only try to fetch locally cached textures. Misses are redirected
-                texture = m_assetService.GetCached(fullID);
-
-                if (texture != null)
-                {
-                    if (texture.Type != (sbyte)AssetType.Texture)
-                    {
-                        httpResponse.StatusCode = (int)System.Net.HttpStatusCode.NotFound;
-                        return true;
-                    }
-                    WriteTextureData(httpRequest, httpResponse, texture, format);
-                }
-                else
-                {
-                    string textureUrl = REDIRECT_URL + textureID.ToString();
-                    m_log.Debug("[GETTEXTURE]: Redirecting texture request to " + textureUrl);
-                    httpResponse.RedirectLocation = textureUrl;
-                    return true;
-                }
-            }
-            else // no redirect
-            {
-                // try the cache
-                texture = m_assetService.GetCached(fullID);
-
-                if (texture == null)
-                {
-                    //m_log.DebugFormat("[GETTEXTURE]: texture was not in the cache");
-
-                    // Fetch locally or remotely. Misses return a 404
-                    texture = m_assetService.Get(textureID.ToString());
-
-                    if (texture != null)
-                    {
-                        if (texture.Type != (sbyte)AssetType.Texture)
-                        {
-                            httpResponse.StatusCode = (int)System.Net.HttpStatusCode.NotFound;
-                            return true;
-                        }
-                        if (format == DefaultFormat)
-                        {
-                            WriteTextureData(httpRequest, httpResponse, texture, format);
-                            return true;
-                        }
-                        else
-                        {
-                            AssetBase newTexture = new AssetBase(texture.ID + "-" + format, texture.Name, (sbyte)AssetType.Texture, texture.Metadata.CreatorID);
-                            newTexture.Data = ConvertTextureData(texture, format);
-                            if (newTexture.Data.Length == 0)
-                                return false; // !!! Caller try another codec, please!
-
-                            newTexture.Flags = AssetFlags.Collectable;
-                            newTexture.Temporary = true;
-                            m_assetService.Store(newTexture);
-                            WriteTextureData(httpRequest, httpResponse, newTexture, format);
-                            return true;
-                        }
-                    }
-               }
-               else // it was on the cache
-               {
-                   //m_log.DebugFormat("[GETTEXTURE]: texture was in the cache");
-                   WriteTextureData(httpRequest, httpResponse, texture, format);
-                   return true;
-               }
-            }
-
-            // not found
-//            m_log.Warn("[GETTEXTURE]: Texture " + textureID + " not found");
-            httpResponse.StatusCode = (int)System.Net.HttpStatusCode.NotFound;
-            return true;
-        }
-
-        private void WriteTextureData(OSHttpRequest request, OSHttpResponse response, AssetBase texture, string format)
-        {
-            string range = request.Headers.GetOne("Range");
-            //m_log.DebugFormat("[GETTEXTURE]: Range {0}", range);
-            if (!String.IsNullOrEmpty(range)) // JP2's only
-            {
-                // Range request
-                int start, end;
-                if (TryParseRange(range, out start, out end))
-                {
-                    // Before clamping start make sure we can satisfy it in order to avoid
-                    // sending back the last byte instead of an error status
-                    if (start >= texture.Data.Length)
-                    {
-                        response.StatusCode = (int)System.Net.HttpStatusCode.RequestedRangeNotSatisfiable;
-                        return;
-                    }
-
-                    end = Utils.Clamp(end, 0, texture.Data.Length - 1);
-                    start = Utils.Clamp(start, 0, end);
-                    int len = end - start + 1;
-
-                    //m_log.Debug("Serving " + start + " to " + end + " of " + texture.Data.Length + " bytes for texture " + texture.ID);
-
-                    if (len < texture.Data.Length)
-                        response.StatusCode = (int)System.Net.HttpStatusCode.PartialContent;
-
-                    response.ContentLength = len;
-                    response.ContentType = texture.Metadata.ContentType;
-                    response.AddHeader("Content-Range", String.Format("bytes {0}-{1}/{2}", start, end, texture.Data.Length));
-
-                    response.Body.Write(texture.Data, start, len);
-                }
-                else
-                {
-                    m_log.Warn("[GETTEXTURE]: Malformed Range header: " + range);
-                    response.StatusCode = (int)System.Net.HttpStatusCode.BadRequest;
-                }
-            }
-            else // JP2's or other formats
-            {
-                // Full content request
-                response.StatusCode = (int)System.Net.HttpStatusCode.OK;
-                response.ContentLength = texture.Data.Length;
-                if (format == DefaultFormat)
-                    response.ContentType = texture.Metadata.ContentType;
-                else
-                    response.ContentType = "image/" + format;
-                response.Body.Write(texture.Data, 0, texture.Data.Length);
-            }
-        }
-
-        private bool TryParseRange(string header, out int start, out int end)
-        {
-            if (header.StartsWith("bytes="))
-            {
-                string[] rangeValues = header.Substring(6).Split('-');
-                if (rangeValues.Length == 2)
-                {
-                    if (Int32.TryParse(rangeValues[0], out start) && Int32.TryParse(rangeValues[1], out end))
-                        return true;
-                }
-            }
-
-            start = end = 0;
-            return false;
-        }
-
-
-        private byte[] ConvertTextureData(AssetBase texture, string format)
-        {
-            m_log.DebugFormat("[GETTEXTURE]: Converting texture {0} to {1}", texture.ID, format);
-            byte[] data = new byte[0];
-
-            MemoryStream imgstream = new MemoryStream();
-            Bitmap mTexture = new Bitmap(1, 1);
-            ManagedImage managedImage;
-            Image image = (Image)mTexture;
-
-            try
-            {
-                // Taking our jpeg2000 data, decoding it, then saving it to a byte array with regular data
-
-                imgstream = new MemoryStream();
-
-                // Decode image to System.Drawing.Image
-                if (OpenJPEG.DecodeToImage(texture.Data, out managedImage, out image))
-                {
-                    // Save to bitmap
-                    mTexture = new Bitmap(image);
-
-                    EncoderParameters myEncoderParameters = new EncoderParameters();
-                    myEncoderParameters.Param[0] = new EncoderParameter(Encoder.Quality, 95L);
-
-                    // Save bitmap to stream
-                    ImageCodecInfo codec = GetEncoderInfo("image/" + format);
-                    if (codec != null)
-                    {
-                        mTexture.Save(imgstream, codec, myEncoderParameters);
-                        // Write the stream to a byte array for output
-                        data = imgstream.ToArray();
-                    }
-                    else
-                        m_log.WarnFormat("[GETTEXTURE]: No such codec {0}", format);
-
-                }
-            }
-            catch (Exception e)
-            {
-                m_log.WarnFormat("[GETTEXTURE]: Unable to convert texture {0} to {1}: {2}", texture.ID, format, e.Message);
-            }
-            finally
-            {
-                // Reclaim memory, these are unmanaged resources
-                // If we encountered an exception, one or more of these will be null
-                if (mTexture != null)
-                    mTexture.Dispose();
-
-                if (image != null)
-                    image.Dispose();
-
-                if (imgstream != null)
-                {
-                    imgstream.Close();
-                    imgstream.Dispose();
-                }
-            }
-
-            return data;
-        }
-
-        // From msdn
-        private static ImageCodecInfo GetEncoderInfo(String mimeType)
-        {
-            ImageCodecInfo[] encoders;
-            encoders = ImageCodecInfo.GetImageEncoders();
-            for (int j = 0; j < encoders.Length; ++j)
-            {
-                if (encoders[j].MimeType == mimeType)
-                    return encoders[j];
-            }
-            return null;
-        }
-
-
-    }
-}
diff --git a/OpenSim/Region/CoreModules/Agent/Capabilities/CapabilitiesModule.cs b/OpenSim/Region/CoreModules/Framework/Caps/CapabilitiesModule.cs
index 1d8e70e..5e22c8c 100644
--- a/OpenSim/Region/CoreModules/Agent/Capabilities/CapabilitiesModule.cs
+++ b/OpenSim/Region/CoreModules/Framework/Caps/CapabilitiesModule.cs
@@ -31,6 +31,7 @@ using System.Collections.Generic;
 using System.Reflection;
 using log4net;
 using Nini.Config;
+using Mono.Addins;
 using OpenMetaverse;
 using OpenSim.Framework;
 using OpenSim.Framework.Console;
@@ -38,8 +39,9 @@ using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 using Caps=OpenSim.Framework.Capabilities.Caps;
 
-namespace OpenSim.Region.CoreModules.Agent.Capabilities
+namespace OpenSim.Region.CoreModules.Framework
 {
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
     public class CapabilitiesModule : INonSharedRegionModule, ICapabilitiesModule
     { 
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
@@ -49,7 +51,7 @@ namespace OpenSim.Region.CoreModules.Agent.Capabilities
         /// <summary>
         /// Each agent has its own capabilities handler.
         /// </summary>
-        protected Dictionary<UUID, Caps> m_capsHandlers = new Dictionary<UUID, Caps>();
+        protected Dictionary<UUID, Caps> m_capsObjects = new Dictionary<UUID, Caps>();
         
         protected Dictionary<UUID, string> capsPaths = new Dictionary<UUID, string>();
         protected Dictionary<UUID, Dictionary<ulong, string>> childrenSeeds 
@@ -93,19 +95,19 @@ namespace OpenSim.Region.CoreModules.Agent.Capabilities
             get { return null; }
         }
 
-        public void AddCapsHandler(UUID agentId)
+        public void CreateCaps(UUID agentId)
         {
             if (m_scene.RegionInfo.EstateSettings.IsBanned(agentId))
                 return;
 
             String capsObjectPath = GetCapsPath(agentId);
 
-            if (m_capsHandlers.ContainsKey(agentId))
+            if (m_capsObjects.ContainsKey(agentId))
             {
-                Caps oldCaps = m_capsHandlers[agentId];
+                Caps oldCaps = m_capsObjects[agentId];
                 
                 m_log.DebugFormat(
-                    "[CAPS]: Reregistering caps for agent {0}.  Old caps path {1}, new caps path {2}. ", 
+                    "[CAPS]: Recreating caps for agent {0}.  Old caps path {1}, new caps path {2}. ", 
                     agentId, oldCaps.CapsObjectPath, capsObjectPath);
                 // This should not happen. The caller code is confused. We need to fix that.
                 // CAPs can never be reregistered, or the client will be confused.
@@ -113,39 +115,29 @@ namespace OpenSim.Region.CoreModules.Agent.Capabilities
                 //return;
             }
 
-            Caps caps
-                = new Caps(m_scene,
-                    m_scene.AssetService, MainServer.Instance, m_scene.RegionInfo.ExternalHostName,
+            Caps caps = new Caps(MainServer.Instance, m_scene.RegionInfo.ExternalHostName,
                     (MainServer.Instance == null) ? 0: MainServer.Instance.Port,
-                    capsObjectPath, agentId, m_scene.DumpAssetsToFile, m_scene.RegionInfo.RegionName);
+                    capsObjectPath, agentId, m_scene.RegionInfo.RegionName);
 
-            caps.RegisterHandlers();
+            m_capsObjects[agentId] = caps;
 
             m_scene.EventManager.TriggerOnRegisterCaps(agentId, caps);
-
-            caps.AddNewInventoryItem = m_scene.AddUploadedInventoryItem;
-            caps.ItemUpdatedCall = m_scene.CapsUpdateInventoryItemAsset;
-            caps.TaskScriptUpdatedCall = m_scene.CapsUpdateTaskInventoryScriptAsset;
-            caps.CAPSFetchInventoryDescendents = m_scene.HandleFetchInventoryDescendentsCAPS;
-            caps.GetClient = m_scene.SceneContents.GetControllingClient;
-
-            m_capsHandlers[agentId] = caps;
         }
 
-        public void RemoveCapsHandler(UUID agentId)
+        public void RemoveCaps(UUID agentId)
         {
             if (childrenSeeds.ContainsKey(agentId))
             {
                 childrenSeeds.Remove(agentId);
             }
 
-            lock (m_capsHandlers)
+            lock (m_capsObjects)
             {
-                if (m_capsHandlers.ContainsKey(agentId))
+                if (m_capsObjects.ContainsKey(agentId))
                 {
-                    m_capsHandlers[agentId].DeregisterHandlers();
-                    m_scene.EventManager.TriggerOnDeregisterCaps(agentId, m_capsHandlers[agentId]);
-                    m_capsHandlers.Remove(agentId);
+                    m_capsObjects[agentId].DeregisterHandlers();
+                    m_scene.EventManager.TriggerOnDeregisterCaps(agentId, m_capsObjects[agentId]);
+                    m_capsObjects.Remove(agentId);
                 }
                 else
                 {
@@ -156,20 +148,20 @@ namespace OpenSim.Region.CoreModules.Agent.Capabilities
             }
         }
         
-        public Caps GetCapsHandlerForUser(UUID agentId)
+        public Caps GetCapsForUser(UUID agentId)
         {
-            lock (m_capsHandlers)
+            lock (m_capsObjects)
             {
-                if (m_capsHandlers.ContainsKey(agentId))
+                if (m_capsObjects.ContainsKey(agentId))
                 {
-                    return m_capsHandlers[agentId];
+                    return m_capsObjects[agentId];
                 }
             }
             
             return null;
         }
         
-        public void NewUserConnection(AgentCircuitData agent)
+        public void SetAgentCapsSeeds(AgentCircuitData agent)
         {
             capsPaths[agent.AgentID] = agent.CapsPath;
             childrenSeeds[agent.AgentID] 
@@ -239,7 +231,7 @@ namespace OpenSim.Region.CoreModules.Agent.Capabilities
             System.Text.StringBuilder caps = new System.Text.StringBuilder();
             caps.AppendFormat("Region {0}:\n", m_scene.RegionInfo.RegionName);
 
-            foreach (KeyValuePair<UUID, Caps> kvp in m_capsHandlers)
+            foreach (KeyValuePair<UUID, Caps> kvp in m_capsObjects)
             {
                 caps.AppendFormat("** User {0}:\n", kvp.Key);
                 for (IDictionaryEnumerator kvp2 = kvp.Value.CapsHandlers.CapsDetails.GetEnumerator(); kvp2.MoveNext(); )
diff --git a/OpenSim/Region/CoreModules/InterGrid/OpenGridProtocolModule.cs b/OpenSim/Region/CoreModules/InterGrid/OpenGridProtocolModule.cs
index 2dd7767..07999d1 100644
--- a/OpenSim/Region/CoreModules/InterGrid/OpenGridProtocolModule.cs
+++ b/OpenSim/Region/CoreModules/InterGrid/OpenGridProtocolModule.cs
@@ -575,7 +575,7 @@ namespace OpenSim.Region.CoreModules.InterGrid
             string derezAvatarPath = "/agent/" + AvatarRezCapUUID + "/rez_avatar/derez";
             // Get a reference to the user's cap so we can pull out the Caps Object Path
             Caps userCap 
-                = homeScene.CapsModule.GetCapsHandlerForUser(agentData.AgentID);
+                = homeScene.CapsModule.GetCapsForUser(agentData.AgentID);
 
             string rezHttpProtocol = "http://";
             string regionCapsHttpProtocol = "http://";
@@ -700,7 +700,7 @@ namespace OpenSim.Region.CoreModules.InterGrid
                 {
                     // Get a referenceokay -  to their Cap object so we can pull out the capobjectroot
                     Caps userCap 
-                        = homeScene.CapsModule.GetCapsHandlerForUser(userData.AgentID);
+                        = homeScene.CapsModule.GetCapsForUser(userData.AgentID);
 
                     //Update the circuit data in the region so this user is authorized
                     homeScene.UpdateCircuitData(userData);
diff --git a/OpenSim/Region/CoreModules/Resources/CoreModulePlugin.addin.xml b/OpenSim/Region/CoreModules/Resources/CoreModulePlugin.addin.xml
index a9d247a..a0009a8 100644
--- a/OpenSim/Region/CoreModules/Resources/CoreModulePlugin.addin.xml
+++ b/OpenSim/Region/CoreModules/Resources/CoreModulePlugin.addin.xml
@@ -17,7 +17,7 @@
         <RegionModule id="PrimCountModule" type="OpenSim.Region.CoreModules.World.Land.PrimCountModule" />
         <RegionModule id="ExportSerialisationModule" type="OpenSim.Region.CoreModules.World.Serialiser.SerialiserModule" />
         <RegionModule id="ArchiverModule" type="OpenSim.Region.CoreModules.World.Archiver.ArchiverModule" />
-        <RegionModule id="CapabilitiesModule" type="OpenSim.Region.CoreModules.Agent.Capabilities.CapabilitiesModule" />
+        <RegionModule id="CapabilitiesModule" type="OpenSim.Region.CoreModules.Framework.CapabilitiesModule" />
         <RegionModule id="TerrainModule" type="OpenSim.Region.CoreModules.World.Terrain.TerrainModule" />
         <RegionModule id="WorldMapModule" type="OpenSim.Region.CoreModules.World.WorldMap.WorldMapModule" />
         <RegionModule id="Warp3DImageModule" type="OpenSim.Region.CoreModules.World.Warp3DMap.Warp3DImageModule" />
diff --git a/OpenSim/Region/DataSnapshot/DataRequestHandler.cs b/OpenSim/Region/DataSnapshot/DataRequestHandler.cs
index 964e4b9..a505999 100644
--- a/OpenSim/Region/DataSnapshot/DataRequestHandler.cs
+++ b/OpenSim/Region/DataSnapshot/DataRequestHandler.cs
@@ -36,7 +36,7 @@ using OpenSim.Framework.Capabilities;
 using OpenSim.Framework.Servers;
 using OpenSim.Framework.Servers.HttpServer;
 using OpenSim.Region.Framework.Scenes;
-using Caps=OpenSim.Framework.Capabilities.Caps;
+using Caps = OpenSim.Framework.Capabilities.Caps;
 
 namespace OpenSim.Region.DataSnapshot
 {
diff --git a/OpenSim/Region/Framework/Interfaces/ICapabilitiesModule.cs b/OpenSim/Region/Framework/Interfaces/ICapabilitiesModule.cs
index 73bffa0..522c82d 100644
--- a/OpenSim/Region/Framework/Interfaces/ICapabilitiesModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/ICapabilitiesModule.cs
@@ -34,31 +34,27 @@ namespace OpenSim.Region.Framework.Interfaces
 {
     public interface ICapabilitiesModule
     {
-        void NewUserConnection(AgentCircuitData agent);
-        
         /// <summary>
         /// Add a caps handler for the given agent.  If the CAPS handler already exists for this agent,
         /// then it is replaced by a new CAPS handler.
-        ///
-        /// FIXME: On login this is called twice, once for the login and once when the connection is made.
-        /// This is somewhat innefficient and should be fixed.  The initial login creation is necessary
-        /// since the client asks for capabilities immediately after being informed of the seed.
         /// </summary>
         /// <param name="agentId"></param>
         /// <param name="capsObjectPath"></param>
-        void AddCapsHandler(UUID agentId);
+        void CreateCaps(UUID agentId);
         
         /// <summary>
         /// Remove the caps handler for a given agent.
         /// </summary>
         /// <param name="agentId"></param>
-        void RemoveCapsHandler(UUID agentId);
+        void RemoveCaps(UUID agentId);
         
         /// <summary>
         /// Will return null if the agent doesn't have a caps handler registered
         /// </summary>
         /// <param name="agentId"></param>
-        Caps GetCapsHandlerForUser(UUID agentId);
+        Caps GetCapsForUser(UUID agentId);
+
+        void SetAgentCapsSeeds(AgentCircuitData agent);
         
         Dictionary<ulong, string> GetChildrenSeeds(UUID agentID);
         
diff --git a/OpenSim/Region/Framework/Interfaces/IEventQueue.cs b/OpenSim/Region/Framework/Interfaces/IEventQueue.cs
index 81e4952..bfa5d17 100644
--- a/OpenSim/Region/Framework/Interfaces/IEventQueue.cs
+++ b/OpenSim/Region/Framework/Interfaces/IEventQueue.cs
@@ -57,5 +57,7 @@ namespace OpenSim.Region.Framework.Interfaces
                                                bool isModerator, bool textMute);
         void ParcelProperties(ParcelPropertiesMessage parcelPropertiesMessage, UUID avatarID);
         void GroupMembership(AgentGroupDataUpdatePacket groupUpdate, UUID avatarID);
+        OSD ScriptRunningEvent(UUID objectID, UUID itemID, bool running, bool mono);
+        OSD BuildEvent(string eventName, OSD eventBody);
     }
 }
diff --git a/OpenSim/Region/Framework/Scenes/Scene.cs b/OpenSim/Region/Framework/Scenes/Scene.cs
index 7c5e246..b537381 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.cs
@@ -3033,7 +3033,7 @@ namespace OpenSim.Region.Framework.Scenes
                     m_sceneGraph.removeUserCount(!childagentYN);
                     
                     if (CapsModule != null)
-                        CapsModule.RemoveCapsHandler(agentID);
+                        CapsModule.RemoveCaps(agentID);
 
                     // REFACTORING PROBLEM -- well not really a problem, but just to point out that whatever
                     // this method is doing is HORRIBLE!!!
@@ -3290,8 +3290,8 @@ namespace OpenSim.Region.Framework.Scenes
 
                 if (CapsModule != null)
                 {
-                    CapsModule.NewUserConnection(agent);
-                    CapsModule.AddCapsHandler(agent.AgentID);
+                    CapsModule.SetAgentCapsSeeds(agent);
+                    CapsModule.CreateCaps(agent.AgentID);
                 }
             }
             else
@@ -3309,7 +3309,7 @@ namespace OpenSim.Region.Framework.Scenes
                     sp.AdjustKnownSeeds();
                     
                     if (CapsModule != null)
-                        CapsModule.NewUserConnection(agent);
+                        CapsModule.SetAgentCapsSeeds(agent);
                 }
             }
 
diff --git a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsMessagingModule.cs b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsMessagingModule.cs
index 8c01d75..2bf8489 100644
--- a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsMessagingModule.cs
+++ b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsMessagingModule.cs
@@ -34,12 +34,9 @@ using Nini.Config;
 using OpenMetaverse;
 using OpenMetaverse.StructuredData;
 using OpenSim.Framework;
-using OpenSim.Region.CoreModules.Framework.EventQueue;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 
-using Caps = OpenSim.Framework.Capabilities.Caps;
-
 namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 {
     [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
@@ -472,7 +469,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
             if (queue != null)
             {
-                queue.Enqueue(EventQueueHelper.buildEvent("ChatterBoxSessionStartReply", bodyMap), remoteClient.AgentId);
+                queue.Enqueue(queue.BuildEvent("ChatterBoxSessionStartReply", bodyMap), remoteClient.AgentId);
             }
         }
 
diff --git a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsModule.cs b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsModule.cs
index a8dec63..1c791b9 100644
--- a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsModule.cs
+++ b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/GroupsModule.cs
@@ -39,13 +39,11 @@ using OpenMetaverse.StructuredData;
 
 using OpenSim.Framework;
 using OpenSim.Framework.Communications;
-using OpenSim.Region.CoreModules.Framework.EventQueue;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 
 using OpenSim.Services.Interfaces;
 
-using Caps = OpenSim.Framework.Capabilities.Caps;
 using DirFindFlags = OpenMetaverse.DirectoryManager.DirFindFlags;
 
 
@@ -1154,7 +1152,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
             if (queue != null)
             {
-                queue.Enqueue(EventQueueHelper.buildEvent("AgentGroupDataUpdate", llDataStruct), GetRequestingAgentID(remoteClient));
+                queue.Enqueue(queue.BuildEvent("AgentGroupDataUpdate", llDataStruct), GetRequestingAgentID(remoteClient));
             }
             
         }
diff --git a/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs b/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs
index 8629674..97ab411 100644
--- a/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs
+++ b/OpenSim/Region/ScriptEngine/XEngine/XEngine.cs
@@ -41,7 +41,6 @@ using log4net;
 using Nini.Config;
 using Amib.Threading;
 using OpenSim.Framework;
-using OpenSim.Region.CoreModules.Framework.EventQueue;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.ScriptEngine.Shared;
@@ -1283,7 +1282,7 @@ namespace OpenSim.Region.ScriptEngine.XEngine
             }
             else
             {
-                eq.Enqueue(EventQueueHelper.ScriptRunningReplyEvent(objectID, itemID, GetScriptState(itemID), true),
+                eq.Enqueue(eq.ScriptRunningEvent(objectID, itemID, GetScriptState(itemID), true),
                            controllingClient.AgentId);
             }
         }
diff --git a/OpenSim/Region/UserStatistics/WebStatsModule.cs b/OpenSim/Region/UserStatistics/WebStatsModule.cs
index a03cc4c..3139b8a 100644
--- a/OpenSim/Region/UserStatistics/WebStatsModule.cs
+++ b/OpenSim/Region/UserStatistics/WebStatsModule.cs
@@ -44,7 +44,6 @@ using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 using Mono.Data.SqliteClient;
 
-
 using Caps = OpenSim.Framework.Capabilities.Caps;
 
 using OSD = OpenMetaverse.StructuredData.OSD;