10 files changed, 2428 insertions, 552 deletions

diff --git a/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCaps.cs b/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCaps.cs
index cc69645..f6146a9 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCaps.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCaps.cs
@@ -26,6 +26,7 @@
  */
 
 using System;
+using System.Timers;
 using System.Collections;
 using System.Collections.Generic;
 using System.IO;
@@ -53,14 +54,16 @@ using OSDMap = OpenMetaverse.StructuredData.OSDMap;
 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);
+        string assetName, string description, UUID assetID, UUID inventoryItem, UUID parentFolder,
+        byte[] data, string inventoryType, string assetType,
+        int cost, UUID texturesFolder, int nreqtextures, int nreqmeshs, int nreqinstances,
+        bool IsAtestUpload, ref string error);
 
     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 NewInventoryItem(UUID userID, InventoryItemBase item, uint cost);
 
     public delegate void NewAsset(AssetBase asset);
 
@@ -86,6 +89,7 @@ namespace OpenSim.Region.ClientStack.Linden
 
         private Scene m_Scene;
         private Caps m_HostCapsObj;
+        private ModelCost m_ModelCost;
 
         private static readonly string m_requestPath = "0000/";
         // private static readonly string m_mapLayerPath = "0001/";
@@ -96,7 +100,10 @@ namespace OpenSim.Region.ClientStack.Linden
         //        private static readonly string m_fetchInventoryPath = "0006/";
         private static readonly string m_copyFromNotecardPath = "0007/";
         // private static readonly string m_remoteParcelRequestPath = "0009/";// This is in the LandManagementModule.
-
+        private static readonly string m_getObjectPhysicsDataPath = "0101/";
+        private static readonly string m_getObjectCostPath = "0102/";
+        private static readonly string m_ResourceCostSelectedPath = "0103/";
+        
 
         // These are callbacks which will be setup by the scene so that we can update scene data when we
         // receive capability calls
@@ -111,12 +118,50 @@ namespace OpenSim.Region.ClientStack.Linden
         private IAssetService m_assetService;
         private bool m_dumpAssetsToFile = false;
         private string m_regionName;
+
         private int m_levelUpload = 0;
 
+        private bool m_enableFreeTestUpload = false; // allows "TEST-" prefix hack
+        private bool m_ForceFreeTestUpload = false; // forces all uploads to be test
+
+        private bool m_enableModelUploadTextureToInventory = false; // place uploaded textures also in inventory
+                                                                    // may not be visible till relog
+        
+        private bool m_RestrictFreeTestUploadPerms = false; // reduces also the permitions. Needs a creator defined!!
+        private UUID m_testAssetsCreatorID = UUID.Zero;
+
+        private float m_PrimScaleMin = 0.001f;
+
+        private enum FileAgentInventoryState : int
+        {
+            idle = 0,
+            processRequest = 1,
+            waitUpload = 2,
+            processUpload = 3
+        }
+        private FileAgentInventoryState m_FileAgentInventoryState = FileAgentInventoryState.idle;
+        
         public BunchOfCaps(Scene scene, Caps caps)
         {
             m_Scene = scene;
             m_HostCapsObj = caps;
+
+            // create a model upload cost provider
+            m_ModelCost = new ModelCost();
+            // tell it about scene object limits
+            m_ModelCost.NonPhysicalPrimScaleMax = m_Scene.m_maxNonphys;
+            m_ModelCost.PhysicalPrimScaleMax = m_Scene.m_maxPhys;
+            
+//            m_ModelCost.ObjectLinkedPartsMax = ??
+//            m_ModelCost.PrimScaleMin = ??
+
+            m_PrimScaleMin = m_ModelCost.PrimScaleMin;
+            float modelTextureUploadFactor = m_ModelCost.ModelTextureCostFactor;
+            float modelUploadFactor = m_ModelCost.ModelMeshCostFactor;
+            float modelMinUploadCostFactor = m_ModelCost.ModelMinCostFactor;
+            float modelPrimCreationCost = m_ModelCost.primCreationCost;
+            float modelMeshByteCost = m_ModelCost.bytecost;
+
             IConfigSource config = m_Scene.Config;
             if (config != null)
             {
@@ -131,6 +176,37 @@ namespace OpenSim.Region.ClientStack.Linden
                 {
                     m_persistBakedTextures = appearanceConfig.GetBoolean("PersistBakedTextures", m_persistBakedTextures);
                 }
+                // economy for model upload
+                IConfig EconomyConfig = config.Configs["Economy"];
+                if (EconomyConfig != null)
+                {
+                    modelUploadFactor = EconomyConfig.GetFloat("MeshModelUploadCostFactor", modelUploadFactor);
+                    modelTextureUploadFactor = EconomyConfig.GetFloat("MeshModelUploadTextureCostFactor", modelTextureUploadFactor);
+                    modelMinUploadCostFactor = EconomyConfig.GetFloat("MeshModelMinCostFactor", modelMinUploadCostFactor);
+                    // next 2 are normalized so final cost is afected by modelUploadFactor above and normal cost
+                    modelPrimCreationCost = EconomyConfig.GetFloat("ModelPrimCreationCost", modelPrimCreationCost);
+                    modelMeshByteCost = EconomyConfig.GetFloat("ModelMeshByteCost", modelMeshByteCost);
+
+                    m_enableModelUploadTextureToInventory = EconomyConfig.GetBoolean("MeshModelAllowTextureToInventory", m_enableModelUploadTextureToInventory);
+
+                    m_RestrictFreeTestUploadPerms = EconomyConfig.GetBoolean("m_RestrictFreeTestUploadPerms", m_RestrictFreeTestUploadPerms);
+                    m_enableFreeTestUpload = EconomyConfig.GetBoolean("AllowFreeTestUpload", m_enableFreeTestUpload);
+                    m_ForceFreeTestUpload = EconomyConfig.GetBoolean("ForceFreeTestUpload", m_ForceFreeTestUpload);
+                    string testcreator = EconomyConfig.GetString("TestAssetsCreatorID", "");
+                    if (testcreator != "")
+                    {
+                        UUID id;
+                        UUID.TryParse(testcreator, out id);
+                        if (id != null)
+                            m_testAssetsCreatorID = id;
+                    }
+
+                    m_ModelCost.ModelMeshCostFactor = modelUploadFactor;
+                    m_ModelCost.ModelTextureCostFactor = modelTextureUploadFactor;
+                    m_ModelCost.ModelMinCostFactor = modelMinUploadCostFactor;
+                    m_ModelCost.primCreationCost = modelPrimCreationCost;
+                    m_ModelCost.bytecost = modelMeshByteCost;
+                }
             }
 
             m_assetService = m_Scene.AssetService;
@@ -142,6 +218,8 @@ namespace OpenSim.Region.ClientStack.Linden
             ItemUpdatedCall = m_Scene.CapsUpdateInventoryItemAsset;
             TaskScriptUpdatedCall = m_Scene.CapsUpdateTaskInventoryScriptAsset;
             GetClient = m_Scene.SceneGraph.GetControllingClient;
+
+            m_FileAgentInventoryState = FileAgentInventoryState.idle;
         }
 
         /// <summary>
@@ -187,7 +265,6 @@ namespace OpenSim.Region.ClientStack.Linden
         {
             try
             {
-                // I don't think this one works...
                 m_HostCapsObj.RegisterHandler(
                     "NewFileAgentInventory",
                     new LLSDStreamhandler<LLSDAssetUploadRequest, LLSDAssetUploadResponse>(
@@ -204,6 +281,12 @@ namespace OpenSim.Region.ClientStack.Linden
                 m_HostCapsObj.RegisterHandler("UpdateNotecardAgentInventory", req);
                 m_HostCapsObj.RegisterHandler("UpdateScriptAgentInventory", req);
                 m_HostCapsObj.RegisterHandler("UpdateScriptAgent", req);
+                IRequestHandler getObjectPhysicsDataHandler = new RestStreamHandler("POST", capsBase + m_getObjectPhysicsDataPath, GetObjectPhysicsData);
+                m_HostCapsObj.RegisterHandler("GetObjectPhysicsData", getObjectPhysicsDataHandler);
+                IRequestHandler getObjectCostHandler = new RestStreamHandler("POST", capsBase + m_getObjectCostPath, GetObjectCost);
+                m_HostCapsObj.RegisterHandler("GetObjectCost", getObjectCostHandler);
+                IRequestHandler ResourceCostSelectedHandler = new RestStreamHandler("POST", capsBase + m_ResourceCostSelectedPath, ResourceCostSelected);
+                m_HostCapsObj.RegisterHandler("ResourceCostSelected", ResourceCostSelectedHandler);       
 
                 m_HostCapsObj.RegisterHandler(
                     "CopyInventoryFromNotecard",
@@ -386,62 +469,176 @@ namespace OpenSim.Region.ClientStack.Linden
             //m_log.Debug("[CAPS]: NewAgentInventoryRequest Request is: " + llsdRequest.ToString());
             //m_log.Debug("asset upload request via CAPS" + llsdRequest.inventory_type + " , " + llsdRequest.asset_type);
 
+            // start by getting the client
+            IClientAPI client = null;
+            m_Scene.TryGetClient(m_HostCapsObj.AgentID, out client);
+
+            // check current state so we only have one service at a time
+            lock (m_ModelCost)
+            {
+                switch (m_FileAgentInventoryState)
+                {
+                    case FileAgentInventoryState.processRequest:
+                    case FileAgentInventoryState.processUpload:
+                        LLSDAssetUploadError resperror = new LLSDAssetUploadError();
+                        resperror.message = "Uploader busy processing previus request";
+                        resperror.identifier = UUID.Zero;
+
+                        LLSDAssetUploadResponse errorResponse = new LLSDAssetUploadResponse();
+                        errorResponse.uploader = "";
+                        errorResponse.state = "error";
+                        errorResponse.error = resperror;
+                        return errorResponse;
+                        break;
+                    case FileAgentInventoryState.waitUpload:
+                        // todo stop current uploader server
+                        break;
+                    case FileAgentInventoryState.idle:
+                    default:
+                        break;
+                }
+
+                m_FileAgentInventoryState = FileAgentInventoryState.processRequest;
+            }
+
+            int cost = 0;
+            int nreqtextures = 0;
+            int nreqmeshs= 0;
+            int nreqinstances = 0;
+            bool IsAtestUpload = false;
+
+            string assetName = llsdRequest.name;
+
+            LLSDAssetUploadResponseData meshcostdata = new LLSDAssetUploadResponseData();
+
             if (llsdRequest.asset_type == "texture" ||
                 llsdRequest.asset_type == "animation" ||
+                llsdRequest.asset_type == "mesh" ||
                 llsdRequest.asset_type == "sound")
             {
                 ScenePresence avatar = null;
-                IClientAPI client = null;
                 m_Scene.TryGetScenePresence(m_HostCapsObj.AgentID, out avatar);
 
                 // check user level
                 if (avatar != null)
                 {
-                    client = avatar.ControllingClient;
-
                     if (avatar.UserLevel < m_levelUpload)
                     {
-                        if (client != null)
-                            client.SendAgentAlertMessage("Unable to upload asset. Insufficient permissions.", false);
+                        LLSDAssetUploadError resperror = new LLSDAssetUploadError();
+                        resperror.message = "Insufficient permissions to upload";
+                        resperror.identifier = UUID.Zero;
 
                         LLSDAssetUploadResponse errorResponse = new LLSDAssetUploadResponse();
                         errorResponse.uploader = "";
                         errorResponse.state = "error";
+                        errorResponse.error = resperror;
+                        lock (m_ModelCost)
+                            m_FileAgentInventoryState = FileAgentInventoryState.idle;
                         return errorResponse;
                     }
                 }
 
-                // check funds
+                // check test upload and funds
                 if (client != null)
                 {
                     IMoneyModule mm = m_Scene.RequestModuleInterface<IMoneyModule>();
 
+                    int baseCost = 0;
                     if (mm != null)
+                        baseCost = mm.UploadCharge;
+
+                    string warning = String.Empty;
+
+                    if (llsdRequest.asset_type == "mesh")
                     {
-                        if (!mm.UploadCovered(client.AgentId, mm.UploadCharge))
+                        string error;
+                        int modelcost;
+                        
+                        if (!m_ModelCost.MeshModelCost(llsdRequest.asset_resources, baseCost, out modelcost,
+                            meshcostdata, out error, ref warning))
                         {
-                            client.SendAgentAlertMessage("Unable to upload asset. Insufficient funds.", false);
+                            LLSDAssetUploadError resperror = new LLSDAssetUploadError();
+                            resperror.message = error;
+                            resperror.identifier = UUID.Zero;
 
                             LLSDAssetUploadResponse errorResponse = new LLSDAssetUploadResponse();
                             errorResponse.uploader = "";
                             errorResponse.state = "error";
+                            errorResponse.error = resperror;
+
+                            lock (m_ModelCost)
+                                m_FileAgentInventoryState = FileAgentInventoryState.idle;
                             return errorResponse;
                         }
+                        cost = modelcost;
+                    }
+                    else
+                    {
+                        cost = baseCost;
+                    }
+
+                    if (cost > 0 && mm != null)
+                    {
+                        // check for test upload
+
+                        if (m_ForceFreeTestUpload) // all are test
+                        {
+                            if (!(assetName.Length > 5 && assetName.StartsWith("TEST-"))) // has normal name lets change it
+                                assetName = "TEST-" + assetName;
+
+                            IsAtestUpload = true;
+                        }
+
+                        else if (m_enableFreeTestUpload) // only if prefixed with "TEST-"
+                        {
+
+                            IsAtestUpload = (assetName.Length > 5 && assetName.StartsWith("TEST-"));
+                        }
+
+
+                        if(IsAtestUpload) // let user know, still showing cost estimation
+                            warning += "Upload will have no cost, for testing purposes only. Other uses are prohibited. Items will not work after 48 hours or on other regions";
+
+                        // check funds
+                        else
+                        {
+                            if (!mm.UploadCovered(client.AgentId, (int)cost))
+                            {
+                                LLSDAssetUploadError resperror = new LLSDAssetUploadError();
+                                resperror.message = "Insuficient funds";
+                                resperror.identifier = UUID.Zero;
+
+                                LLSDAssetUploadResponse errorResponse = new LLSDAssetUploadResponse();
+                                errorResponse.uploader = "";
+                                errorResponse.state = "error";
+                                errorResponse.error = resperror;
+                                lock (m_ModelCost)
+                                    m_FileAgentInventoryState = FileAgentInventoryState.idle;
+                                return errorResponse;
+                            }
+                        }
                     }
+
+                    if (client != null && warning != String.Empty)
+                        client.SendAgentAlertMessage(warning, true);
                 }
             }
-
-            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");
+            UUID texturesFolder = UUID.Zero;
+
+            if(!IsAtestUpload && m_enableModelUploadTextureToInventory)
+                texturesFolder = llsdRequest.texture_folder_id;
 
             AssetUploader uploader =
                 new AssetUploader(assetName, assetDes, newAsset, newInvItem, parentFolder, llsdRequest.inventory_type,
-                                  llsdRequest.asset_type, capsBase + uploaderPath, m_HostCapsObj.HttpListener, m_dumpAssetsToFile);
+                        llsdRequest.asset_type, capsBase + uploaderPath, m_HostCapsObj.HttpListener, m_dumpAssetsToFile, cost,
+                        texturesFolder, nreqtextures, nreqmeshs, nreqinstances, IsAtestUpload);
 
             m_HostCapsObj.HttpListener.AddStreamHandler(
                 new BinaryStreamHandler(
@@ -459,10 +656,22 @@ namespace OpenSim.Region.ClientStack.Linden
             string uploaderURL = protocol + m_HostCapsObj.HostName + ":" + m_HostCapsObj.Port.ToString() + capsBase +
                                  uploaderPath;
 
+
             LLSDAssetUploadResponse uploadResponse = new LLSDAssetUploadResponse();
             uploadResponse.uploader = uploaderURL;
             uploadResponse.state = "upload";
+            uploadResponse.upload_price = (int)cost;
+
+            if (llsdRequest.asset_type == "mesh")
+            {
+                uploadResponse.data = meshcostdata;
+            }
+
             uploader.OnUpLoad += UploadCompleteHandler;
+
+            lock (m_ModelCost)
+                m_FileAgentInventoryState = FileAgentInventoryState.waitUpload;
+
             return uploadResponse;
         }
 
@@ -474,8 +683,14 @@ namespace OpenSim.Region.ClientStack.Linden
         /// <param name="data"></param>
         public void UploadCompleteHandler(string assetName, string assetDescription, UUID assetID,
                                           UUID inventoryItem, UUID parentFolder, byte[] data, string inventoryType,
-                                          string assetType)
+                                          string assetType, int cost,
+                                          UUID texturesFolder, int nreqtextures, int nreqmeshs, int nreqinstances,
+                                          bool IsAtestUpload, ref string error)
         {
+
+            lock (m_ModelCost)
+                m_FileAgentInventoryState = FileAgentInventoryState.processUpload;
+
             m_log.DebugFormat(
                 "[BUNCH OF CAPS]: Uploaded asset {0} for inventory item {1}, inv type {2}, asset type {3}",
                 assetID, inventoryItem, inventoryType, assetType);
@@ -483,117 +698,247 @@ namespace OpenSim.Region.ClientStack.Linden
             sbyte assType = 0;
             sbyte inType = 0;
 
+            IClientAPI client = null;
+
+            UUID owner_id = m_HostCapsObj.AgentID;
+            UUID creatorID;
+
+            bool istest = IsAtestUpload && m_enableFreeTestUpload && (cost > 0);
+
+            bool restrictPerms = m_RestrictFreeTestUploadPerms && istest;
+
+            if (istest && m_testAssetsCreatorID != UUID.Zero)
+                creatorID = m_testAssetsCreatorID;
+            else
+                creatorID = owner_id;
+
+            string creatorIDstr = creatorID.ToString();
+
+            IMoneyModule mm = m_Scene.RequestModuleInterface<IMoneyModule>();
+            if (mm != null)
+            {
+                // make sure client still has enougth credit
+                if (!mm.UploadCovered(m_HostCapsObj.AgentID, (int)cost))
+                {
+                    error = "Insufficient funds.";
+                    return;
+                }
+            }
+
+            // strings to types
             if (inventoryType == "sound")
             {
-                inType = 1;
-                assType = 1;
+                inType = (sbyte)InventoryType.Sound;
+                assType = (sbyte)AssetType.Sound;
             }
             else if (inventoryType == "animation")
             {
-                inType = 19;
-                assType = 20;
+                inType = (sbyte)InventoryType.Animation;
+                assType = (sbyte)AssetType.Animation;
             }
             else if (inventoryType == "wearable")
             {
-                inType = 18;
+                inType = (sbyte)InventoryType.Wearable;
                 switch (assetType)
                 {
                     case "bodypart":
-                        assType = 13;
+                        assType = (sbyte)AssetType.Bodypart;
                         break;
                     case "clothing":
-                        assType = 5;
+                        assType = (sbyte)AssetType.Clothing;
                         break;
                 }
             }
             else if (inventoryType == "object")
             {
-                inType = (sbyte)InventoryType.Object;
-                assType = (sbyte)AssetType.Object;
-
-                List<Vector3> positions = new List<Vector3>();
-                List<Quaternion> rotations = new List<Quaternion>();
-                OSDMap request = (OSDMap)OSDParser.DeserializeLLSDXml(data);
-                OSDArray instance_list = (OSDArray)request["instance_list"];
-                OSDArray mesh_list = (OSDArray)request["mesh_list"];
-                OSDArray texture_list = (OSDArray)request["texture_list"];
-                SceneObjectGroup grp = null;
-
-                List<UUID> textures = new List<UUID>();
-                for (int i = 0; i < texture_list.Count; i++)
+                if (assetType == "mesh") // this code for now is for mesh models uploads only
                 {
-                    AssetBase textureAsset = new AssetBase(UUID.Random(), assetName, (sbyte)AssetType.Texture, "");
-                    textureAsset.Data = texture_list[i].AsBinary();
-                    m_assetService.Store(textureAsset);
-                    textures.Add(textureAsset.FullID);
-                }
+                    inType = (sbyte)InventoryType.Object;
+                    assType = (sbyte)AssetType.Object;
 
-                for (int i = 0; i < mesh_list.Count; i++)
-                {
-                    PrimitiveBaseShape pbs = PrimitiveBaseShape.CreateBox();
+                    List<Vector3> positions = new List<Vector3>();
+                    List<Quaternion> rotations = new List<Quaternion>();
+                    OSDMap request = (OSDMap)OSDParser.DeserializeLLSDXml(data);
+
+                    // compare and get updated information
 
-                    Primitive.TextureEntry textureEntry
-                        = new Primitive.TextureEntry(Primitive.TextureEntry.WHITE_TEXTURE);
-                    OSDMap inner_instance_list = (OSDMap)instance_list[i];
+                    bool mismatchError = true;
 
-                    OSDArray face_list = (OSDArray)inner_instance_list["face_list"];
-                    for (uint face = 0; face < face_list.Count; face++)
+                    while (mismatchError)
                     {
-                        OSDMap faceMap = (OSDMap)face_list[(int)face];
-                        Primitive.TextureEntryFace f = pbs.Textures.CreateFace(face);
-                        if(faceMap.ContainsKey("fullbright"))
-                            f.Fullbright = faceMap["fullbright"].AsBoolean();
-                        if (faceMap.ContainsKey ("diffuse_color"))
-                            f.RGBA = faceMap["diffuse_color"].AsColor4();
+                        mismatchError = false;
+                    }
 
-                        int textureNum = faceMap["image"].AsInteger();
-                        float imagerot = faceMap["imagerot"].AsInteger();
-                        float offsets = (float)faceMap["offsets"].AsReal();
-                        float offsett = (float)faceMap["offsett"].AsReal();
-                        float scales = (float)faceMap["scales"].AsReal();
-                        float scalet = (float)faceMap["scalet"].AsReal();
+                    if (mismatchError)
+                    {
+                        error = "Upload and fee estimation information don't match";
+                        lock (m_ModelCost)
+                            m_FileAgentInventoryState = FileAgentInventoryState.idle;
 
-                        if(imagerot != 0)
-                            f.Rotation = imagerot;
+                        return;
+                    }
 
-                        if(offsets != 0)
-                            f.OffsetU = offsets;
+                    OSDArray instance_list = (OSDArray)request["instance_list"];
+                    OSDArray mesh_list = (OSDArray)request["mesh_list"];
+                    OSDArray texture_list = (OSDArray)request["texture_list"];
+                    SceneObjectGroup grp = null;
 
-                        if (offsett != 0)
-                            f.OffsetV = offsett;
+                    // create and store texture assets
+                    bool doTextInv = (!istest && m_enableModelUploadTextureToInventory &&
+                                    texturesFolder != UUID.Zero);
 
-                        if (scales != 0)
-                            f.RepeatU = scales;
 
-                        if (scalet != 0)
-                            f.RepeatV = scalet;
+                    List<UUID> textures = new List<UUID>();
 
-                        if (textures.Count > textureNum)
-                            f.TextureID = textures[textureNum];
-                        else
-                            f.TextureID = Primitive.TextureEntry.WHITE_TEXTURE;
+                   
+                    if (doTextInv)
+                        m_Scene.TryGetClient(m_HostCapsObj.AgentID, out client);
+
+                    if(client == null) // don't put textures in inventory if there is no client
+                        doTextInv = false;
 
-                        textureEntry.FaceTextures[face] = f;
+                    for (int i = 0; i < texture_list.Count; i++)
+                    {
+                        AssetBase textureAsset = new AssetBase(UUID.Random(), assetName, (sbyte)AssetType.Texture, creatorIDstr);
+                        textureAsset.Data = texture_list[i].AsBinary();
+                        if (istest)
+                            textureAsset.Local = true;
+                        m_assetService.Store(textureAsset);
+                        textures.Add(textureAsset.FullID);
+
+                        if (doTextInv)
+                        {
+                            string name = assetName;
+                            if (name.Length > 25)
+                                name = name.Substring(0, 24);
+                            name += "_Texture#" + i.ToString();
+                            InventoryItemBase texitem = new InventoryItemBase();
+                            texitem.Owner = m_HostCapsObj.AgentID;
+                            texitem.CreatorId = creatorIDstr;
+                            texitem.CreatorData = String.Empty;
+                            texitem.ID = UUID.Random();
+                            texitem.AssetID = textureAsset.FullID;
+                            texitem.Description = "mesh model texture";
+                            texitem.Name = name;
+                            texitem.AssetType = (int)AssetType.Texture;
+                            texitem.InvType = (int)InventoryType.Texture;
+                            texitem.Folder = texturesFolder;
+
+                            texitem.CurrentPermissions
+                                = (uint)(PermissionMask.Move | PermissionMask.Copy | PermissionMask.Modify | PermissionMask.Transfer);
+
+                            texitem.BasePermissions = (uint)PermissionMask.All;
+                            texitem.EveryOnePermissions = 0;
+                            texitem.NextPermissions = (uint)PermissionMask.All;
+                            texitem.CreationDate = Util.UnixTimeSinceEpoch();
+
+                            m_Scene.AddInventoryItem(client, texitem);
+                            texitem = null;
+                        }
+                    }
+
+                    // create and store meshs assets
+                    List<UUID> meshAssets = new List<UUID>();
+                    for (int i = 0; i < mesh_list.Count; i++)
+                    {
+                        AssetBase meshAsset = new AssetBase(UUID.Random(), assetName, (sbyte)AssetType.Mesh, creatorIDstr);
+                        meshAsset.Data = mesh_list[i].AsBinary();
+                        if (istest)
+                            meshAsset.Local = true;
+                        m_assetService.Store(meshAsset);
+                        meshAssets.Add(meshAsset.FullID);
                     }
 
-                    pbs.TextureEntry = textureEntry.GetBytes();
+                    int skipedMeshs = 0;
+                    // build prims from instances
+                    for (int i = 0; i < instance_list.Count; i++)
+                    {
+                        OSDMap inner_instance_list = (OSDMap)instance_list[i];
+
+                        // skip prims that are 2 small
+                        Vector3 scale = inner_instance_list["scale"].AsVector3();
+
+                        if (scale.X < m_PrimScaleMin || scale.Y < m_PrimScaleMin || scale.Z < m_PrimScaleMin)
+                        {
+                            skipedMeshs++;
+                            continue;
+                        }
+
+                        PrimitiveBaseShape pbs = PrimitiveBaseShape.CreateBox();
+
+                        Primitive.TextureEntry textureEntry
+                            = new Primitive.TextureEntry(Primitive.TextureEntry.WHITE_TEXTURE);
+
+
+                        OSDArray face_list = (OSDArray)inner_instance_list["face_list"];
+                        for (uint face = 0; face < face_list.Count; face++)
+                        {
+                            OSDMap faceMap = (OSDMap)face_list[(int)face];
+                            Primitive.TextureEntryFace f = pbs.Textures.CreateFace(face);
+                            if (faceMap.ContainsKey("fullbright"))
+                                f.Fullbright = faceMap["fullbright"].AsBoolean();
+                            if (faceMap.ContainsKey("diffuse_color"))
+                                f.RGBA = faceMap["diffuse_color"].AsColor4();
+
+                            int textureNum = faceMap["image"].AsInteger();
+                            float imagerot = faceMap["imagerot"].AsInteger();
+                            float offsets = (float)faceMap["offsets"].AsReal();
+                            float offsett = (float)faceMap["offsett"].AsReal();
+                            float scales = (float)faceMap["scales"].AsReal();
+                            float scalet = (float)faceMap["scalet"].AsReal();
+
+                            if (imagerot != 0)
+                                f.Rotation = imagerot;
+
+                            if (offsets != 0)
+                                f.OffsetU = offsets;
 
-                    AssetBase meshAsset = new AssetBase(UUID.Random(), assetName, (sbyte)AssetType.Mesh, "");
-                    meshAsset.Data = mesh_list[i].AsBinary();
-                    m_assetService.Store(meshAsset);
+                            if (offsett != 0)
+                                f.OffsetV = offsett;
 
-                    pbs.SculptEntry = true;
-                    pbs.SculptTexture = meshAsset.FullID;
-                    pbs.SculptType = (byte)SculptType.Mesh;
-                    pbs.SculptData = meshAsset.Data;
+                            if (scales != 0)
+                                f.RepeatU = scales;
+
+                            if (scalet != 0)
+                                f.RepeatV = scalet;
+
+                            if (textures.Count > textureNum)
+                                f.TextureID = textures[textureNum];
+                            else
+                                f.TextureID = Primitive.TextureEntry.WHITE_TEXTURE;
+
+                            textureEntry.FaceTextures[face] = f;
+                        }
 
-                    Vector3 position = inner_instance_list["position"].AsVector3();
-                    Vector3 scale = inner_instance_list["scale"].AsVector3();
-                    Quaternion rotation = inner_instance_list["rotation"].AsQuaternion();
+                        pbs.TextureEntry = textureEntry.GetBytes();
+
+                        bool hasmesh = false;
+                        if (inner_instance_list.ContainsKey("mesh")) // seems to happen always but ...
+                        {
+                            int meshindx = inner_instance_list["mesh"].AsInteger();
+                            if (meshAssets.Count > meshindx)
+                            {
+                                pbs.SculptEntry = true;
+                                pbs.SculptType = (byte)SculptType.Mesh;
+                                pbs.SculptTexture = meshAssets[meshindx]; // actual asset UUID after meshs suport introduction
+                                // data will be requested from asset on rez (i hope)
+                                hasmesh = true;
+                            }
+                        }
+
+                        Vector3 position = inner_instance_list["position"].AsVector3();
+                        Quaternion rotation = inner_instance_list["rotation"].AsQuaternion();
+
+                        // for now viwers do send fixed defaults
+                        // but this may change
+//                        int physicsShapeType = inner_instance_list["physics_shape_type"].AsInteger();
+                        byte physicsShapeType = (byte)PhysShapeType.prim; // default for mesh is simple convex
+                        if(hasmesh)
+                            physicsShapeType = (byte) PhysShapeType.convex; // default for mesh is simple convex
+//                        int material = inner_instance_list["material"].AsInteger();
+                        byte material = (byte)Material.Wood;
 
 // no longer used - begin ------------------------
-//                    int physicsShapeType = inner_instance_list["physics_shape_type"].AsInteger();
-//                    int material = inner_instance_list["material"].AsInteger();
 //                    int mesh = inner_instance_list["mesh"].AsInteger();
 
 //                    OSDMap permissions = (OSDMap)inner_instance_list["permissions"];
@@ -608,24 +953,42 @@ namespace OpenSim.Region.ClientStack.Linden
 //                    UUID owner_id = permissions["owner_id"].AsUUID();
 //                    int owner_mask = permissions["owner_mask"].AsInteger();
 // no longer used - end ------------------------
+                       
+
+                        SceneObjectPart prim
+                            = new SceneObjectPart(owner_id, pbs, position, Quaternion.Identity, Vector3.Zero);
+
+                        prim.Scale = scale;
+                        rotations.Add(rotation);
+                        positions.Add(position);
+                        prim.UUID = UUID.Random();
+                        prim.CreatorID = creatorID;
+                        prim.OwnerID = owner_id;
+                        prim.GroupID = UUID.Zero;
+                        prim.LastOwnerID = creatorID;
+                        prim.CreationDate = Util.UnixTimeSinceEpoch();
+                        
+                        if (grp == null)
+                            prim.Name = assetName;
+                        else
+                            prim.Name = assetName + "#" + i.ToString();
 
-                      UUID owner_id = m_HostCapsObj.AgentID;
+                        if (restrictPerms)
+                        {
+                            prim.BaseMask = (uint)(PermissionMask.Move | PermissionMask.Modify);
+                            prim.EveryoneMask = 0;
+                            prim.GroupMask = 0;
+                            prim.NextOwnerMask = 0;
+                            prim.OwnerMask = (uint)(PermissionMask.Move | PermissionMask.Modify);
+                        }
 
-                    SceneObjectPart prim
-                        = new SceneObjectPart(owner_id, pbs, position, Quaternion.Identity, Vector3.Zero);
+                        if(istest)
+                            prim.Description = "For testing only. Other uses are prohibited";
+                        else
+                            prim.Description = "";
 
-                    prim.Scale = scale;
-                    prim.OffsetPosition = position;
-                    rotations.Add(rotation);
-                    positions.Add(position);
-                    prim.UUID = UUID.Random();
-                    prim.CreatorID = owner_id;
-                    prim.OwnerID = owner_id;
-                    prim.GroupID = UUID.Zero;
-                    prim.LastOwnerID = prim.OwnerID;
-                    prim.CreationDate = Util.UnixTimeSinceEpoch();
-                    prim.Name = assetName;
-                    prim.Description = "";
+                        prim.Material = material;
+                        prim.PhysicsShapeType = physicsShapeType;
 
 //                    prim.BaseMask = (uint)base_mask;
 //                    prim.EveryoneMask = (uint)everyone_mask;
@@ -633,37 +996,64 @@ namespace OpenSim.Region.ClientStack.Linden
 //                    prim.NextOwnerMask = (uint)next_owner_mask;
 //                    prim.OwnerMask = (uint)owner_mask;
 
-                    if (grp == null)
-                        grp = new SceneObjectGroup(prim);
-                    else
-                        grp.AddPart(prim);
-                }
+                        if (grp == null)
+                        {
+                            grp = new SceneObjectGroup(prim);
+                            grp.LastOwnerID = creatorID;
+                        }
+                        else
+                            grp.AddPart(prim);
+                    }
 
-                // Fix first link number
-                if (grp.Parts.Length > 1)
-                    grp.RootPart.LinkNum++;
+                    Vector3 rootPos = positions[0];
 
-                Vector3 rootPos = positions[0];
-                grp.AbsolutePosition = rootPos;
-                for (int i = 0; i < positions.Count; i++)
-                {
-                    Vector3 offset = positions[i] - rootPos;
-                    grp.Parts[i].OffsetPosition = offset;
+                    if (grp.Parts.Length > 1)
+                    {
+                        // Fix first link number
+                        grp.RootPart.LinkNum++;
+
+                        Quaternion rootRotConj = Quaternion.Conjugate(rotations[0]);
+                        Quaternion tmprot;
+                        Vector3 offset;
+
+                        // fix children rotations and positions
+                        for (int i = 1; i < rotations.Count; i++)
+                        {
+                            tmprot = rotations[i];
+                            tmprot = rootRotConj * tmprot;
+
+                            grp.Parts[i].RotationOffset = tmprot;
+
+                            offset = positions[i] - rootPos;
+
+                            offset *= rootRotConj;
+                            grp.Parts[i].OffsetPosition = offset;
+                        }
+
+                        grp.AbsolutePosition = rootPos;
+                        grp.UpdateGroupRotationR(rotations[0]);
+                    }
+                    else
+                    {
+                        grp.AbsolutePosition = rootPos;
+                        grp.UpdateGroupRotationR(rotations[0]);
+                    }
+
+                    data = ASCIIEncoding.ASCII.GetBytes(SceneObjectSerializer.ToOriginalXmlFormat(grp));
                 }
 
-                for (int i = 0; i < rotations.Count; i++)
+                else // not a mesh model
                 {
-                    if (i != 0)
-                        grp.Parts[i].RotationOffset = rotations[i];
+                    m_log.ErrorFormat("[CAPS Asset Upload] got unsuported assetType for object upload");
+                    return;
                 }
-
-                grp.UpdateGroupRotationR(rotations[0]);
-                data = ASCIIEncoding.ASCII.GetBytes(SceneObjectSerializer.ToOriginalXmlFormat(grp));
             }
 
             AssetBase asset;
-            asset = new AssetBase(assetID, assetName, assType, m_HostCapsObj.AgentID.ToString());
+            asset = new AssetBase(assetID, assetName, assType, creatorIDstr);
             asset.Data = data;
+            if (istest)
+                asset.Local = true;
             if (AddNewAsset != null)
                 AddNewAsset(asset);
             else if (m_assetService != null)
@@ -671,11 +1061,17 @@ namespace OpenSim.Region.ClientStack.Linden
 
             InventoryItemBase item = new InventoryItemBase();
             item.Owner = m_HostCapsObj.AgentID;
-            item.CreatorId = m_HostCapsObj.AgentID.ToString();
+            item.CreatorId = creatorIDstr;
             item.CreatorData = String.Empty;
             item.ID = inventoryItem;
             item.AssetID = asset.FullID;
-            item.Description = assetDescription;
+            if (istest)
+            {
+                item.Description = "For testing only. Other uses are prohibited";
+                item.Flags = (uint) (InventoryItemFlags.SharedSingleReference);
+            }
+            else
+                item.Description = assetDescription;
             item.Name = assetName;
             item.AssetType = assType;
             item.InvType = inType;
@@ -683,18 +1079,60 @@ namespace OpenSim.Region.ClientStack.Linden
 
             // If we set PermissionMask.All then when we rez the item the next permissions will replace the current
             // (owner) permissions.  This becomes a problem if next permissions are changed.
-            item.CurrentPermissions
-                = (uint)(PermissionMask.Move | PermissionMask.Copy | PermissionMask.Modify | PermissionMask.Transfer);
 
-            item.BasePermissions = (uint)PermissionMask.All;
-            item.EveryOnePermissions = 0;
-            item.NextPermissions = (uint)PermissionMask.All;
+            if (restrictPerms)
+            {
+                item.CurrentPermissions
+                    = (uint)(PermissionMask.Move | PermissionMask.Modify);
+
+                item.BasePermissions = (uint)(PermissionMask.Move | PermissionMask.Modify);
+                item.EveryOnePermissions = 0;
+                item.NextPermissions = 0;
+            }
+            else
+            {
+                item.CurrentPermissions
+                    = (uint)(PermissionMask.Move | PermissionMask.Copy | PermissionMask.Modify | PermissionMask.Transfer);
+
+                item.BasePermissions = (uint)PermissionMask.All;
+                item.EveryOnePermissions = 0;
+                item.NextPermissions = (uint)PermissionMask.All;
+            }
+
             item.CreationDate = Util.UnixTimeSinceEpoch();
 
+            m_Scene.TryGetClient(m_HostCapsObj.AgentID, out client);
+
             if (AddNewInventoryItem != null)
             {
-                AddNewInventoryItem(m_HostCapsObj.AgentID, item);
+                if (istest)
+                {
+                    m_Scene.AddInventoryItem(client, item);
+/*
+                    AddNewInventoryItem(m_HostCapsObj.AgentID, item, 0);
+                    if (client != null)
+                        client.SendAgentAlertMessage("Upload will have no cost, for personal test purposes only. Other uses are forbiden. Items may not work on a another region" , true);
+ */
+                }
+                else
+                {
+                    AddNewInventoryItem(m_HostCapsObj.AgentID, item, (uint)cost);
+//                    if (client != null)
+//                    {
+//                        // let users see anything..  i don't so far
+//                        string str;
+//                        if (cost > 0)
+//                            // dont remember where is money unit name to put here
+//                            str = "Upload complete. charged " + cost.ToString() + "$";
+//                        else
+//                            str = "Upload complete";
+//                        client.SendAgentAlertMessage(str, true);
+//                    }
+                }
             }
+
+            lock (m_ModelCost)
+                m_FileAgentInventoryState = FileAgentInventoryState.idle;
         }
 
         /// <summary>
@@ -855,10 +1293,159 @@ namespace OpenSim.Region.ClientStack.Linden
             response["int_response_code"] = 200;
             return LLSDHelpers.SerialiseLLSDReply(response);
         }
+
+        public string GetObjectPhysicsData(string request, string path,
+                string param, IOSHttpRequest httpRequest,
+                IOSHttpResponse httpResponse)
+        {
+            OSDMap req = (OSDMap)OSDParser.DeserializeLLSDXml(request);
+            OSDMap resp = new OSDMap();
+            OSDArray object_ids = (OSDArray)req["object_ids"];
+
+            for (int i = 0 ; i < object_ids.Count ; i++)
+            {
+                UUID uuid = object_ids[i].AsUUID();
+
+                SceneObjectPart obj = m_Scene.GetSceneObjectPart(uuid);
+                if (obj != null)
+                {
+                    OSDMap object_data = new OSDMap();
+
+                    object_data["PhysicsShapeType"] = obj.PhysicsShapeType;
+                    object_data["Density"] = obj.Density;
+                    object_data["Friction"] = obj.Friction;
+                    object_data["Restitution"] = obj.Bounciness;
+                    object_data["GravityMultiplier"] = obj.GravityModifier;
+
+                    resp[uuid.ToString()] = object_data;
+                }
+            }
+
+            string response = OSDParser.SerializeLLSDXmlString(resp);
+            return response;
+        }
+
+        public string GetObjectCost(string request, string path,
+                string param, IOSHttpRequest httpRequest,
+                IOSHttpResponse httpResponse)
+        {          
+            OSDMap req = (OSDMap)OSDParser.DeserializeLLSDXml(request);
+            OSDMap resp = new OSDMap();
+
+            OSDArray object_ids = (OSDArray)req["object_ids"];
+
+            for (int i = 0; i < object_ids.Count; i++)
+            {
+                UUID uuid = object_ids[i].AsUUID();
+                                
+                SceneObjectPart part = m_Scene.GetSceneObjectPart(uuid);
+
+                if (part != null)
+                {
+                    SceneObjectGroup grp = part.ParentGroup;
+                    if (grp != null)
+                    {
+                        float linksetCost;
+                        float linksetPhysCost;
+                        float partCost;
+                        float partPhysCost;
+
+                        grp.GetResourcesCosts(part, out linksetCost, out linksetPhysCost, out partCost, out  partPhysCost);
+
+                        OSDMap object_data = new OSDMap();
+                        object_data["linked_set_resource_cost"] = linksetCost;
+                        object_data["resource_cost"] = partCost;
+                        object_data["physics_cost"] = partPhysCost;
+                        object_data["linked_set_physics_cost"] = linksetPhysCost;
+
+                        resp[uuid.ToString()] = object_data;
+                    }
+                }
+            }
+
+            string response = OSDParser.SerializeLLSDXmlString(resp);
+            return response; 
+        }
+
+        public string ResourceCostSelected(string request, string path,
+                string param, IOSHttpRequest httpRequest,
+                IOSHttpResponse httpResponse)
+        {
+            OSDMap req = (OSDMap)OSDParser.DeserializeLLSDXml(request);
+            OSDMap resp = new OSDMap();
+
+
+            float phys=0;
+            float stream=0;
+            float simul=0;
+
+            if (req.ContainsKey("selected_roots"))
+            {
+                OSDArray object_ids = (OSDArray)req["selected_roots"];
+
+                // should go by SOG suming costs for all parts
+                // ll v3 works ok with several objects select we get the list and adds ok
+                // FS calls per object so results are wrong guess fs bug
+                for (int i = 0; i < object_ids.Count; i++)
+                {
+                    UUID uuid = object_ids[i].AsUUID();
+                    float Physc;
+                    float simulc;
+                    float streamc;
+
+                    SceneObjectGroup grp = m_Scene.GetGroupByPrim(uuid);
+                    if (grp != null)
+                    {
+                        grp.GetSelectedCosts(out Physc, out streamc, out simulc);
+                        phys += Physc;
+                        stream += streamc;
+                        simul += simulc;
+                    }
+                }
+            }
+            else if (req.ContainsKey("selected_prims"))
+            {
+                OSDArray object_ids = (OSDArray)req["selected_prims"];
+
+                // don't see in use in any of the 2 viewers
+                // guess it should be for edit linked but... nothing
+                // should go to SOP per part
+                for (int i = 0; i < object_ids.Count; i++)
+                {
+                    UUID uuid = object_ids[i].AsUUID();
+
+                    SceneObjectPart part = m_Scene.GetSceneObjectPart(uuid);
+                    if (part != null)
+                    {
+                        phys += part.PhysicsCost;
+                        stream += part.StreamingCost;
+                        simul += part.SimulationCost;
+                    }
+                }
+            }
+
+            if (simul != 0)
+            {
+                OSDMap object_data = new OSDMap();
+
+                object_data["physics"] = phys;
+                object_data["streaming"] = stream;
+                object_data["simulation"] = simul;
+
+                resp["selected"] = object_data;
+            }
+
+            string response = OSDParser.SerializeLLSDXmlString(resp);
+            return response; 
+        }
     }
 
     public class AssetUploader
     {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+
         public event UpLoadedAsset OnUpLoad;
         private UpLoadedAsset handlerUpLoad = null;
 
@@ -873,10 +1460,21 @@ namespace OpenSim.Region.ClientStack.Linden
 
         private string m_invType = String.Empty;
         private string m_assetType = String.Empty;
+        private int m_cost;
+        private string m_error = String.Empty;
+        
+        private Timer m_timeoutTimer = new Timer();
+        private UUID m_texturesFolder;
+        private int m_nreqtextures;
+        private int m_nreqmeshs;
+        private int m_nreqinstances;
+        private bool m_IsAtestUpload;
 
         public AssetUploader(string assetName, string description, UUID assetID, UUID inventoryItem,
                                 UUID parentFolderID, string invType, string assetType, string path,
-                                IHttpServer httpServer, bool dumpAssetsToFile)
+                                IHttpServer httpServer, bool dumpAssetsToFile,
+                                int totalCost, UUID texturesFolder, int nreqtextures, int nreqmeshs, int nreqinstances,
+                                bool IsAtestUpload)
         {
             m_assetName = assetName;
             m_assetDes = description;
@@ -888,6 +1486,18 @@ namespace OpenSim.Region.ClientStack.Linden
             m_assetType = assetType;
             m_invType = invType;
             m_dumpAssetsToFile = dumpAssetsToFile;
+            m_cost = totalCost;
+
+            m_texturesFolder = texturesFolder;
+            m_nreqtextures = nreqtextures;
+            m_nreqmeshs = nreqmeshs;
+            m_nreqinstances = nreqinstances;
+            m_IsAtestUpload = IsAtestUpload;
+
+            m_timeoutTimer.Elapsed += TimedOut;
+            m_timeoutTimer.Interval = 120000;
+            m_timeoutTimer.AutoReset = false;
+            m_timeoutTimer.Start();
         }
 
         /// <summary>
@@ -902,12 +1512,14 @@ namespace OpenSim.Region.ClientStack.Linden
             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);
-
+*/
+            m_timeoutTimer.Stop();
             httpListener.RemoveStreamHandler("POST", uploaderPath);
 
             // TODO: probably make this a better set of extensions here
@@ -924,12 +1536,49 @@ namespace OpenSim.Region.ClientStack.Linden
             handlerUpLoad = OnUpLoad;
             if (handlerUpLoad != null)
             {
-                handlerUpLoad(m_assetName, m_assetDes, newAssetID, inv, parentFolder, data, m_invType, m_assetType);
+                handlerUpLoad(m_assetName, m_assetDes, newAssetID, inv, parentFolder, data, m_invType, m_assetType,
+                    m_cost, m_texturesFolder, m_nreqtextures, m_nreqmeshs, m_nreqinstances, m_IsAtestUpload, ref m_error);
+            }
+            if (m_IsAtestUpload)
+            {
+                LLSDAssetUploadError resperror = new LLSDAssetUploadError();
+                resperror.message = "Upload SUCESSEFULL for testing purposes only. Other uses are prohibited. Item will not work after 48 hours or on other regions";
+                resperror.identifier = inv;
+
+                uploadComplete.error = resperror;
+                uploadComplete.state = "Upload4Testing";
             }
+            else
+            {
+                if (m_error == String.Empty)
+                {
+                    uploadComplete.new_asset = newAssetID.ToString();
+                    uploadComplete.new_inventory_item = inv;
+                    //                if (m_texturesFolder != UUID.Zero)
+                    //                    uploadComplete.new_texture_folder_id = m_texturesFolder;
+                    uploadComplete.state = "complete";
+                }
+                else
+                {
+                    LLSDAssetUploadError resperror = new LLSDAssetUploadError();
+                    resperror.message = m_error;
+                    resperror.identifier = inv;
 
+                    uploadComplete.error = resperror;
+                    uploadComplete.state = "failed";
+                }
+            }
+
+            res = LLSDHelpers.SerialiseLLSDReply(uploadComplete);
             return res;
         }
 
+        private void TimedOut(object sender, ElapsedEventArgs args)
+        {
+            m_log.InfoFormat("[CAPS]: Removing URL and handler for timed out mesh upload");
+            httpListener.RemoveStreamHandler("POST", uploaderPath);
+        }
+
         ///Left this in and commented in case there are unforseen issues
         //private void SaveAssetToFile(string filename, byte[] data)
         //{
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/MeshCost.cs b/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/MeshCost.cs
new file mode 100644
index 0000000..4a3fae6
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/MeshCost.cs
@@ -0,0 +1,671 @@
+// Proprietary code of Avination Virtual Limited
+// (c) 2012 Melanie Thielker, Leal Duarte
+//
+
+using System;
+using System.IO;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+
+using OpenSim.Framework;
+using OpenSim.Region.Framework;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Framework.Capabilities;
+
+using ComponentAce.Compression.Libs.zlib;
+
+using OSDArray = OpenMetaverse.StructuredData.OSDArray;
+using OSDMap = OpenMetaverse.StructuredData.OSDMap;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+    public struct ModelPrimLimits
+    {
+        
+    }
+
+    public class ModelCost
+    {
+
+        // upload fee defaults
+        // fees are normalized to 1.0
+        // this parameters scale them to basic cost ( so 1.0 translates to 10 )
+
+        public float ModelMeshCostFactor = 0.0f; // scale total cost relative to basic (excluding textures)
+        public float ModelTextureCostFactor = 1.0f; // scale textures fee to basic.
+        public float ModelMinCostFactor = 0.0f; // 0.5f; // minimum total model free excluding textures
+
+        // itens costs in normalized values
+        // ie will be multiplied by basicCost and factors above
+        public float primCreationCost = 0.002f;  // extra cost for each prim creation overhead
+        // weigthed size to normalized cost
+        public float bytecost = 1e-5f;
+
+        // mesh upload fees based on compressed data sizes
+        // several data sections are counted more that once
+        // to promote user optimization
+        // following parameters control how many extra times they are added
+        // to global size.
+        // LOD meshs
+        const float medSizeWth = 1f; // 2x
+        const float lowSizeWth = 1.5f; // 2.5x
+        const float lowestSizeWth = 2f; // 3x
+        // favor potencially physical optimized meshs versus automatic decomposition
+        const float physMeshSizeWth = 6f; // counts  7x
+        const float physHullSizeWth = 8f; // counts  9x      
+
+        // stream cost area factors 
+        // more or less like SL
+        const float highLodFactor = 17.36f;
+        const float midLodFactor = 277.78f;
+        const float lowLodFactor = 1111.11f;
+
+        // physics cost is below, identical to SL, assuming shape type convex
+        // server cost is below identical to SL assuming non scripted non physical object
+
+        // internal
+        const int bytesPerCoord = 6; // 3 coords, 2 bytes per each
+
+        // control prims dimensions
+        public float PrimScaleMin = 0.001f;
+        public float NonPhysicalPrimScaleMax = 256f;
+        public float PhysicalPrimScaleMax = 10f;
+        public int ObjectLinkedPartsMax = 512;
+
+        // storage for a single mesh asset cost parameters       
+        private class ameshCostParam
+        {
+            // LOD sizes for size dependent streaming cost
+            public int highLODSize;
+            public int medLODSize;
+            public int lowLODSize;
+            public int lowestLODSize;
+            // normalized fee based on compressed data sizes
+            public float costFee;
+            // physics cost
+            public float physicsCost;
+        }
+
+        // calculates a mesh model costs
+        // returns false on error, with a reason on parameter error
+        // resources input LLSD request
+        // basicCost input region assets upload cost
+        // totalcost returns model total upload fee
+        // meshcostdata returns detailed costs for viewer 
+        public bool MeshModelCost(LLSDAssetResource resources, int basicCost, out int totalcost, 
+            LLSDAssetUploadResponseData meshcostdata, out string error, ref string warning)
+        {
+            totalcost = 0;
+            error = string.Empty;
+            
+            if (resources == null ||
+                resources.instance_list == null ||
+                resources.instance_list.Array.Count == 0)
+            {
+                error = "missing model information.";
+                return false;
+            }
+
+            int numberInstances = resources.instance_list.Array.Count;
+
+            if( numberInstances > ObjectLinkedPartsMax )
+            {
+                error = "Model whould have more than " + ObjectLinkedPartsMax.ToString() + " linked prims";
+                return false;
+            }
+
+            meshcostdata.model_streaming_cost = 0.0;
+            meshcostdata.simulation_cost = 0.0;
+            meshcostdata.physics_cost = 0.0;
+            meshcostdata.resource_cost = 0.0;
+
+            meshcostdata.upload_price_breakdown.mesh_instance = 0;
+            meshcostdata.upload_price_breakdown.mesh_physics = 0;
+            meshcostdata.upload_price_breakdown.mesh_streaming = 0;
+            meshcostdata.upload_price_breakdown.model = 0;
+
+            int itmp;
+
+            // textures cost
+            if (resources.texture_list != null && resources.texture_list.Array.Count > 0)
+            {
+                float textures_cost = (float)(resources.texture_list.Array.Count * basicCost);
+                textures_cost *= ModelTextureCostFactor;
+
+                itmp = (int)(textures_cost + 0.5f); // round
+                meshcostdata.upload_price_breakdown.texture = itmp;
+                totalcost += itmp;
+            }
+
+            // meshs assets cost
+            float meshsfee = 0;
+            int numberMeshs = 0;
+            bool haveMeshs = false;
+            List<ameshCostParam> meshsCosts = new List<ameshCostParam>();
+
+            if (resources.mesh_list != null && resources.mesh_list.Array.Count > 0)
+            {
+                numberMeshs = resources.mesh_list.Array.Count;
+                
+                for (int i = 0; i < numberMeshs; i++)
+                {
+                    ameshCostParam curCost = new ameshCostParam();
+                    byte[] data = (byte[])resources.mesh_list.Array[i];
+
+                    if (!MeshCost(data, curCost, out error))
+                    {
+                        return false;
+                    }
+                    meshsCosts.Add(curCost);
+                    meshsfee += curCost.costFee;
+                }
+                haveMeshs = true;
+            }
+
+            // instances (prims) cost
+            
+
+            int mesh;
+            int skipedSmall = 0;
+            for (int i = 0; i < numberInstances; i++)
+            {
+                Hashtable inst = (Hashtable)resources.instance_list.Array[i];
+
+                ArrayList ascale = (ArrayList)inst["scale"];
+                Vector3 scale;
+                double tmp;
+                tmp = (double)ascale[0];
+                scale.X = (float)tmp;
+                tmp = (double)ascale[1];
+                scale.Y = (float)tmp;
+                tmp = (double)ascale[2];
+                scale.Z = (float)tmp;
+
+                if (scale.X < PrimScaleMin || scale.Y < PrimScaleMin || scale.Z < PrimScaleMin)
+                {
+                    skipedSmall++;
+                    continue;
+                }
+
+                if (scale.X > NonPhysicalPrimScaleMax || scale.Y > NonPhysicalPrimScaleMax || scale.Z > NonPhysicalPrimScaleMax)
+                {
+                    error = "Model contains parts with sides larger than " + NonPhysicalPrimScaleMax.ToString() + "m. Please ajust scale";
+                    return false;
+                }
+
+                if (haveMeshs && inst.ContainsKey("mesh"))
+                {
+                    mesh = (int)inst["mesh"];
+
+                    if (mesh >= numberMeshs)
+                    {
+                        error = "Incoerent model information.";
+                        return false;
+                    }
+
+                    // streamming cost
+
+                    float sqdiam = scale.LengthSquared();
+
+                    ameshCostParam curCost = meshsCosts[mesh];
+                    float mesh_streaming = streamingCost(curCost, sqdiam);
+
+                    meshcostdata.model_streaming_cost += mesh_streaming;
+                    meshcostdata.physics_cost += curCost.physicsCost;
+                }
+                else // instance as no mesh ??
+                {
+                    // to do later if needed
+                    meshcostdata.model_streaming_cost += 0.5f;
+                    meshcostdata.physics_cost += 1.0f;
+                }
+
+                // assume unscripted and static prim server cost
+                meshcostdata.simulation_cost += 0.5f;
+                // charge for prims creation
+                meshsfee += primCreationCost;
+            }
+
+            if (skipedSmall > 0)
+            {
+                if (skipedSmall > numberInstances / 2)
+                {
+                    error = "Model contains too many prims smaller than " + PrimScaleMin.ToString() +
+                        "m minimum allowed size. Please check scalling";
+                    return false;
+                }
+                else
+                    warning += skipedSmall.ToString() + " of the requested " +numberInstances.ToString() +
+                        " model prims will not upload because they are smaller than " + PrimScaleMin.ToString() +
+                        "m minimum allowed size. Please check scalling ";
+            }
+
+            if (meshcostdata.physics_cost <= meshcostdata.model_streaming_cost)
+                meshcostdata.resource_cost = meshcostdata.model_streaming_cost;
+            else
+                meshcostdata.resource_cost = meshcostdata.physics_cost;
+
+            if (meshcostdata.resource_cost < meshcostdata.simulation_cost)
+                meshcostdata.resource_cost = meshcostdata.simulation_cost;
+
+            // scale cost
+            // at this point a cost of 1.0 whould mean basic cost
+            meshsfee *= ModelMeshCostFactor;
+
+            if (meshsfee < ModelMinCostFactor)
+                meshsfee = ModelMinCostFactor;
+
+            // actually scale it to basic cost
+            meshsfee *= (float)basicCost;
+
+            meshsfee += 0.5f; // rounding
+
+            totalcost += (int)meshsfee;
+
+            // breakdown prices
+            // don't seem to be in use so removed code for now
+            
+            return true;
+        }
+
+        // single mesh asset cost
+        private bool MeshCost(byte[] data, ameshCostParam cost, out string error)
+        {
+            cost.highLODSize = 0;
+            cost.medLODSize = 0;
+            cost.lowLODSize = 0;
+            cost.lowestLODSize = 0;
+            cost.physicsCost = 0.0f;
+            cost.costFee = 0.0f;
+
+            error = string.Empty;
+
+            if (data == null || data.Length == 0)
+            {
+                error = "Missing model information.";
+                return false;
+            }
+
+            OSD meshOsd = null;
+            int start = 0;
+
+            error = "Invalid model data";
+
+            using (MemoryStream ms = new MemoryStream(data))
+            {
+                try
+                {
+                    OSD osd = OSDParser.DeserializeLLSDBinary(ms);
+                    if (osd is OSDMap)
+                        meshOsd = (OSDMap)osd;
+                    else
+                        return false;
+                }
+                catch (Exception e)
+                {
+                    return false;
+                }
+                start = (int)ms.Position;
+            }
+
+            OSDMap map = (OSDMap)meshOsd;
+            OSDMap tmpmap;
+
+            int highlod_size = 0;
+            int medlod_size = 0;
+            int lowlod_size = 0;
+            int lowestlod_size = 0;
+            int skin_size = 0;
+
+            int hulls_size = 0;
+            int phys_nhulls;
+            int phys_hullsvertices = 0;
+
+            int physmesh_size = 0;
+            int phys_ntriangles = 0;
+
+            int submesh_offset = -1;
+
+            if (map.ContainsKey("physics_convex"))
+            {
+                tmpmap = (OSDMap)map["physics_convex"];
+                if (tmpmap.ContainsKey("offset"))
+                    submesh_offset = tmpmap["offset"].AsInteger() + start;
+                if (tmpmap.ContainsKey("size"))
+                    hulls_size = tmpmap["size"].AsInteger();
+            }
+
+            if (submesh_offset < 0 || hulls_size == 0)
+            {
+                error = "Missing physics_convex block";
+                return false;
+            }
+
+            if (!hulls(data, submesh_offset, hulls_size, out phys_hullsvertices, out phys_nhulls))
+            {
+                error = "Bad physics_convex block";
+                return false;
+            }
+
+            submesh_offset = -1;
+            
+            // only look for LOD meshs sizes
+
+            if (map.ContainsKey("high_lod"))
+            {
+                tmpmap = (OSDMap)map["high_lod"];
+                // see at least if there is a offset for this one
+                if (tmpmap.ContainsKey("offset"))
+                    submesh_offset = tmpmap["offset"].AsInteger() + start;
+                if (tmpmap.ContainsKey("size"))
+                    highlod_size = tmpmap["size"].AsInteger();
+            }
+
+            if (submesh_offset < 0 || highlod_size <= 0)
+            {
+                error = "Missing high_lod block";
+                return false;
+            }
+
+            bool haveprev = true;
+
+            if (map.ContainsKey("medium_lod"))
+            {
+                tmpmap = (OSDMap)map["medium_lod"];
+                if (tmpmap.ContainsKey("size"))
+                    medlod_size = tmpmap["size"].AsInteger();
+                else
+                    haveprev = false;
+            }
+
+            if (haveprev && map.ContainsKey("low_lod"))
+            {
+                tmpmap = (OSDMap)map["low_lod"];
+                if (tmpmap.ContainsKey("size"))
+                    lowlod_size = tmpmap["size"].AsInteger();
+                else
+                    haveprev = false;
+            }
+
+            if (haveprev && map.ContainsKey("lowest_lod"))
+            {
+                tmpmap = (OSDMap)map["lowest_lod"];
+                if (tmpmap.ContainsKey("size"))
+                    lowestlod_size = tmpmap["size"].AsInteger();
+            }
+
+            if (map.ContainsKey("skin"))
+            {
+                tmpmap = (OSDMap)map["skin"];
+                if (tmpmap.ContainsKey("size"))
+                    skin_size = tmpmap["size"].AsInteger();
+            }
+
+            cost.highLODSize = highlod_size;
+            cost.medLODSize = medlod_size;
+            cost.lowLODSize = lowlod_size;
+            cost.lowestLODSize = lowestlod_size;
+
+            submesh_offset = -1;
+
+            tmpmap = null;
+            if(map.ContainsKey("physics_mesh"))
+                tmpmap = (OSDMap)map["physics_mesh"];
+            else if (map.ContainsKey("physics_shape")) // old naming
+                tmpmap = (OSDMap)map["physics_shape"];
+
+            if(tmpmap != null)
+            {
+                if (tmpmap.ContainsKey("offset"))
+                    submesh_offset = tmpmap["offset"].AsInteger() + start;
+                if (tmpmap.ContainsKey("size"))
+                    physmesh_size = tmpmap["size"].AsInteger();
+
+                if (submesh_offset >= 0 || physmesh_size > 0)
+                {
+
+                    if (!submesh(data, submesh_offset, physmesh_size, out phys_ntriangles))
+                    {
+                        error = "Model data parsing error";
+                        return false;
+                    }
+                }
+            }
+
+            // upload is done in convex shape type so only one hull
+            phys_hullsvertices++;
+            cost.physicsCost = 0.04f * phys_hullsvertices;
+
+            float sfee;
+            
+            sfee = data.Length; // start with total compressed data size
+
+            // penalize lod meshs that should be more builder optimized
+            sfee += medSizeWth * medlod_size;
+            sfee += lowSizeWth * lowlod_size;
+            sfee += lowestSizeWth * lowlod_size;
+
+            // physics
+            // favor potencial optimized meshs versus automatic decomposition
+            if (physmesh_size != 0)
+                sfee += physMeshSizeWth * (physmesh_size + hulls_size / 4); // reduce cost of mandatory convex hull
+            else
+                sfee += physHullSizeWth * hulls_size;
+
+            // bytes to money
+            sfee *= bytecost;
+           
+            cost.costFee = sfee;
+            return true;
+        }
+
+        // parses a LOD or physics mesh component
+        private bool submesh(byte[] data, int offset, int size, out int ntriangles)
+        {
+            ntriangles = 0;
+
+            OSD decodedMeshOsd = new OSD();
+            byte[] meshBytes = new byte[size];
+            System.Buffer.BlockCopy(data, offset, meshBytes, 0, size);
+            try
+            {
+                using (MemoryStream inMs = new MemoryStream(meshBytes))
+                {
+                    using (MemoryStream outMs = new MemoryStream())
+                    {
+                        using (ZOutputStream zOut = new ZOutputStream(outMs))
+                        {
+                            byte[] readBuffer = new byte[4096];
+                            int readLen = 0;
+                            while ((readLen = inMs.Read(readBuffer, 0, readBuffer.Length)) > 0)
+                            {
+                                zOut.Write(readBuffer, 0, readLen);
+                            }
+                            zOut.Flush();
+                            outMs.Seek(0, SeekOrigin.Begin);
+
+                            byte[] decompressedBuf = outMs.GetBuffer();
+                            decodedMeshOsd = OSDParser.DeserializeLLSDBinary(decompressedBuf);
+                        }
+                    }
+                }
+            }
+            catch (Exception e)
+            {
+                return false;
+            }
+
+            OSDArray decodedMeshOsdArray = null;
+            if ((!decodedMeshOsd is OSDArray))
+                return false;
+
+            byte[] dummy;
+
+            decodedMeshOsdArray = (OSDArray)decodedMeshOsd;
+            foreach (OSD subMeshOsd in decodedMeshOsdArray)
+            {
+                if (subMeshOsd is OSDMap)
+                {
+                    OSDMap subtmpmap = (OSDMap)subMeshOsd;
+                    if (subtmpmap.ContainsKey("NoGeometry") && ((OSDBoolean)subtmpmap["NoGeometry"]))
+                        continue;
+
+                    if (!subtmpmap.ContainsKey("Position"))
+                        return false;
+
+                    if (subtmpmap.ContainsKey("TriangleList"))
+                    {
+                        dummy = subtmpmap["TriangleList"].AsBinary();
+                        ntriangles += dummy.Length / bytesPerCoord;
+                    }
+                    else
+                        return false;
+                }
+            }
+
+            return true;
+        }
+
+        // parses convex hulls component
+        private bool hulls(byte[] data, int offset, int size, out int nvertices, out int nhulls)
+        {
+            nvertices = 0;
+            nhulls = 1;
+
+            OSD decodedMeshOsd = new OSD();
+            byte[] meshBytes = new byte[size];
+            System.Buffer.BlockCopy(data, offset, meshBytes, 0, size);
+            try
+            {
+                using (MemoryStream inMs = new MemoryStream(meshBytes))
+                {
+                    using (MemoryStream outMs = new MemoryStream())
+                    {
+                        using (ZOutputStream zOut = new ZOutputStream(outMs))
+                        {
+                            byte[] readBuffer = new byte[4096];
+                            int readLen = 0;
+                            while ((readLen = inMs.Read(readBuffer, 0, readBuffer.Length)) > 0)
+                            {
+                                zOut.Write(readBuffer, 0, readLen);
+                            }
+                            zOut.Flush();
+                            outMs.Seek(0, SeekOrigin.Begin);
+
+                            byte[] decompressedBuf = outMs.GetBuffer();
+                            decodedMeshOsd = OSDParser.DeserializeLLSDBinary(decompressedBuf);
+                        }
+                    }
+                }
+            }
+            catch (Exception e)
+            {
+                return false;
+            }
+
+            OSDMap cmap = (OSDMap)decodedMeshOsd;
+            if (cmap == null)
+                return false;
+
+            byte[] dummy;
+
+            // must have one of this
+            if (cmap.ContainsKey("BoundingVerts"))
+            {
+                dummy = cmap["BoundingVerts"].AsBinary();
+                nvertices = dummy.Length / bytesPerCoord;
+            }
+            else
+                return false;
+
+/* upload is done with convex shape type
+            if (cmap.ContainsKey("HullList"))
+            {
+                dummy = cmap["HullList"].AsBinary();
+                nhulls += dummy.Length;
+            }
+
+
+            if (cmap.ContainsKey("Positions"))
+            {
+                dummy = cmap["Positions"].AsBinary();
+                nvertices = dummy.Length / bytesPerCoord;
+            }
+ */
+
+            return true;
+        }
+
+        // returns streaming cost from on mesh LODs sizes in curCost and square of prim size length 
+        private float streamingCost(ameshCostParam curCost, float sqdiam)
+        {
+            // compute efective areas
+            float ma = 262144f;
+
+            float mh = sqdiam * highLodFactor;
+            if (mh > ma)
+                mh = ma;
+            float mm = sqdiam * midLodFactor;
+            if (mm > ma)
+                mm = ma;
+
+            float ml = sqdiam * lowLodFactor;
+            if (ml > ma)
+                ml = ma;
+
+            float mlst = ma;
+
+            mlst -= ml;
+            ml -= mm;
+            mm -= mh;
+
+            if (mlst < 1.0f)
+                mlst = 1.0f;
+            if (ml < 1.0f)
+                ml = 1.0f;
+            if (mm < 1.0f)
+                mm = 1.0f;
+            if (mh < 1.0f)
+                mh = 1.0f;
+
+            ma = mlst + ml + mm + mh;
+
+            // get LODs compressed sizes
+            // giving 384 bytes bonus
+            int lst = curCost.lowestLODSize - 384;
+            int l = curCost.lowLODSize - 384;
+            int m = curCost.medLODSize - 384;
+            int h = curCost.highLODSize - 384;
+
+            // use previus higher LOD size on missing ones
+            if (m <= 0)
+                m = h;
+            if (l <= 0)
+                l = m;
+            if (lst <= 0)
+                lst = l;
+
+            // force minumum sizes
+            if (lst < 16)
+                lst = 16;
+            if (l < 16)
+                l = 16;
+            if (m < 16)
+                m = 16;
+            if (h < 16)
+                h = 16;
+
+            // compute cost weighted by relative effective areas
+            float cost = (float)lst * mlst + (float)l * ml + (float)m * mm + (float)h * mh;
+            cost /= ma;
+
+            cost *= 0.004f; // overall tunning parameter
+
+            return cost;
+        }
+    }
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueGetModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueGetModule.cs
index 4d2c0f2..986a665 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueGetModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueGetModule.cs
@@ -353,7 +353,7 @@ namespace OpenSim.Region.ClientStack.Linden
             // TODO: Add EventQueueGet name/description for diagnostics
             MainServer.Instance.AddPollServiceHTTPHandler(
                 eventQueueGetPath,
-                new PollServiceEventArgs(null, HasEvents, GetEvents, NoEvents, agentID));
+                new PollServiceEventArgs(null, HasEvents, GetEvents, NoEvents, agentID, 1000));
 
 //            m_log.DebugFormat(
 //                "[EVENT QUEUE GET MODULE]: Registered EQG handler {0} for {1} in {2}",
@@ -395,7 +395,7 @@ namespace OpenSim.Region.ClientStack.Linden
             }
         }
 
-        public Hashtable GetEvents(UUID requestID, UUID pAgentId, string request)
+        public Hashtable GetEvents(UUID requestID, UUID pAgentId)
         {
             if (DebugLevel >= 2)
                 m_log.DebugFormat("POLLED FOR EQ MESSAGES BY {0} in {1}", pAgentId, m_scene.RegionInfo.RegionName);
@@ -807,5 +807,13 @@ namespace OpenSim.Region.ClientStack.Linden
         {
             return EventQueueHelper.BuildEvent(eventName, eventBody);
         }
+
+        public void partPhysicsProperties(uint localID, byte physhapetype,
+                        float density, float friction, float bounce, float gravmod,UUID avatarID)
+        {
+            OSD item = EventQueueHelper.partPhysicsProperties(localID, physhapetype,
+                        density, friction, bounce, gravmod);
+            Enqueue(item, avatarID);
+        }
     }
 }
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueHelper.cs b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueHelper.cs
index 3f49aba..7dcf137 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueHelper.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueHelper.cs
@@ -151,6 +151,12 @@ namespace OpenSim.Region.ClientStack.Linden
             ulong regionHandle, byte simAccess, IPEndPoint regionExternalEndPoint,
             uint locationID, uint flags, string capsURL, UUID agentID)
         {
+            // not sure why flags get overwritten here
+            if ((flags & (uint)TeleportFlags.IsFlying) != 0)
+                flags = (uint)TeleportFlags.ViaLocation | (uint)TeleportFlags.IsFlying;
+            else
+                flags = (uint)TeleportFlags.ViaLocation;
+
             OSDMap info = new OSDMap();
             info.Add("AgentID", OSD.FromUUID(agentID));
             info.Add("LocationID", OSD.FromInteger(4)); // TODO what is this?
@@ -159,7 +165,8 @@ namespace OpenSim.Region.ClientStack.Linden
             info.Add("SimAccess", OSD.FromInteger(simAccess));
             info.Add("SimIP", OSD.FromBinary(regionExternalEndPoint.Address.GetAddressBytes()));
             info.Add("SimPort", OSD.FromInteger(regionExternalEndPoint.Port));
-            info.Add("TeleportFlags", OSD.FromULong(1L << 4)); // AgentManager.TeleportFlags.ViaLocation
+//            info.Add("TeleportFlags", OSD.FromULong(1L << 4)); // AgentManager.TeleportFlags.ViaLocation
+            info.Add("TeleportFlags", OSD.FromUInteger(flags));
 
             OSDArray infoArr = new OSDArray();
             infoArr.Add(info);
@@ -395,5 +402,25 @@ namespace OpenSim.Region.ClientStack.Linden
             return message;
         }
 
+        public static OSD partPhysicsProperties(uint localID, byte physhapetype,
+                        float density, float friction, float bounce, float gravmod)
+        {
+            
+            OSDMap physinfo = new OSDMap(6);
+            physinfo["LocalID"] = localID;
+            physinfo["Density"] = density;
+            physinfo["Friction"] = friction;
+            physinfo["GravityMultiplier"] = gravmod;
+            physinfo["Restitution"] = bounce;
+            physinfo["PhysicsShapeType"] = (int)physhapetype;
+
+            OSDArray array = new OSDArray(1);
+            array.Add(physinfo);
+
+            OSDMap llsdBody = new OSDMap(1);
+            llsdBody.Add("ObjectData", array);
+
+            return BuildEvent("ObjectPhysicsProperties", llsdBody);
+        }
     }
 }
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/GetMeshModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/GetMeshModule.cs
index 8e1f63a..6b33561 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/GetMeshModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/GetMeshModule.cs
@@ -27,11 +27,14 @@
 
 using System;
 using System.Collections;
+using System.Collections.Generic;
 using System.Collections.Specialized;
 using System.Reflection;
 using System.IO;
+using System.Threading;
 using System.Web;
 using Mono.Addins;
+using OpenSim.Framework.Monitoring;
 using log4net;
 using Nini.Config;
 using OpenMetaverse;
@@ -57,9 +60,45 @@ namespace OpenSim.Region.ClientStack.Linden
         private IAssetService m_AssetService;
         private bool m_Enabled = true;
         private string m_URL;
+       
+        struct aPollRequest
+        {
+            public PollServiceMeshEventArgs thepoll;
+            public UUID reqID;
+            public Hashtable request;
+        }
+
+        public class aPollResponse
+        {
+            public Hashtable response;
+            public int bytes;
+            public int lod;
+        }
+
+
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private static GetMeshHandler m_getMeshHandler;
+
+        private IAssetService m_assetService = null;
+
+        private Dictionary<UUID, string> m_capsDict = new Dictionary<UUID, string>();
+        private static Thread[] m_workerThreads = null;
+
+        private static OpenMetaverse.BlockingQueue<aPollRequest> m_queue =
+                new OpenMetaverse.BlockingQueue<aPollRequest>();
+
+        private Dictionary<UUID, PollServiceMeshEventArgs> m_pollservices = new Dictionary<UUID, PollServiceMeshEventArgs>();
 
         #region Region Module interfaceBase Members
 
+        ~GetMeshModule()
+        {
+            foreach (Thread t in m_workerThreads)
+                Watchdog.AbortThread(t.ManagedThreadId);
+
+        }
+
         public Type ReplaceableInterface
         {
             get { return null; }
@@ -75,6 +114,7 @@ namespace OpenSim.Region.ClientStack.Linden
             // Cap doesn't exist
             if (m_URL != string.Empty)
                 m_Enabled = true;
+         
         }
 
         public void AddRegion(Scene pScene)
@@ -83,6 +123,8 @@ namespace OpenSim.Region.ClientStack.Linden
                 return;
 
             m_scene = pScene;
+            
+            m_assetService = pScene.AssetService;
         }
 
         public void RemoveRegion(Scene scene)
@@ -91,6 +133,9 @@ namespace OpenSim.Region.ClientStack.Linden
                 return;
 
             m_scene.EventManager.OnRegisterCaps -= RegisterCaps;
+            m_scene.EventManager.OnDeregisterCaps -= DeregisterCaps;
+            m_scene.EventManager.OnThrottleUpdate -= ThrottleUpdate;
+            
             m_scene = null;
         }
 
@@ -101,6 +146,27 @@ namespace OpenSim.Region.ClientStack.Linden
 
             m_AssetService = m_scene.RequestModuleInterface<IAssetService>();
             m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+            // We'll reuse the same handler for all requests.
+            m_getMeshHandler = new GetMeshHandler(m_assetService);
+            m_scene.EventManager.OnDeregisterCaps += DeregisterCaps;
+            m_scene.EventManager.OnThrottleUpdate += ThrottleUpdate;
+
+            if (m_workerThreads == null)
+            {
+                m_workerThreads = new Thread[2];
+
+                for (uint i = 0; i < 2; i++)
+                {
+                    m_workerThreads[i] = Watchdog.StartThread(DoMeshRequests,
+                            String.Format("MeshWorkerThread{0}", i),
+                            ThreadPriority.Normal,
+                            false,
+                            false,
+                            null,
+                            int.MaxValue);
+                }
+            }
+
         }
 
 
@@ -110,25 +176,212 @@ namespace OpenSim.Region.ClientStack.Linden
 
         #endregion
 
+        private void DoMeshRequests()
+        {
+            while (true)
+            {
+                aPollRequest poolreq = m_queue.Dequeue();
+
+                poolreq.thepoll.Process(poolreq);
+            }
+        }
+
+        // Now we know when the throttle is changed by the client in the case of a root agent or by a neighbor region in the case of a child agent.
+        public void ThrottleUpdate(ScenePresence p)
+        {
+            byte[] throttles = p.ControllingClient.GetThrottlesPacked(1);
+            UUID user = p.UUID;
+            int imagethrottle = ExtractTaskThrottle(throttles);
+            PollServiceMeshEventArgs args;
+            if (m_pollservices.TryGetValue(user, out args))
+            {
+                args.UpdateThrottle(imagethrottle, p);
+            }
+        }
+
+        private int ExtractTaskThrottle(byte[] pthrottles)
+        {
+
+            byte[] adjData;
+            int pos = 0;
+
+            if (!BitConverter.IsLittleEndian)
+            {
+                byte[] newData = new byte[7 * 4];
+                Buffer.BlockCopy(pthrottles, 0, newData, 0, 7 * 4);
+
+                for (int i = 0; i < 7; i++)
+                    Array.Reverse(newData, i * 4, 4);
+
+                adjData = newData;
+            }
+            else
+            {
+                adjData = pthrottles;
+            }
+
+            // 0.125f converts from bits to bytes
+            //int resend = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); 
+            //pos += 4;
+            // int land = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); 
+            //pos += 4;
+            // int wind = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); 
+            // pos += 4;
+            // int cloud = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); 
+            // pos += 4;
+            pos += 16;
+             int task = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); 
+            // pos += 4;
+            //int texture = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); //pos += 4;
+            //int asset = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f);
+            return task;
+        }
+
+        private class PollServiceMeshEventArgs : PollServiceEventArgs
+        {
+            private List<Hashtable> requests =
+                    new List<Hashtable>();
+            private Dictionary<UUID, aPollResponse> responses =
+                    new Dictionary<UUID, aPollResponse>();
+
+            private Scene m_scene;
+            private MeshCapsDataThrottler m_throttler;
+            public PollServiceMeshEventArgs(UUID pId, Scene scene) :
+                base(null, null, null, null, pId, int.MaxValue)
+            {
+                m_scene = scene;
+                m_throttler = new MeshCapsDataThrottler(100000, 1400000, 10000, scene, pId);
+                // x is request id, y is userid
+                HasEvents = (x, y) =>
+                {
+                    lock (responses)
+                    {
+                        bool ret = m_throttler.hasEvents(x, responses);
+                        m_throttler.ProcessTime();
+                        return ret;
+
+                    }
+                };
+                GetEvents = (x, y) =>
+                {
+                    lock (responses)
+                    {
+                        try
+                        {
+                            return responses[x].response;
+                        }
+                        finally
+                        {
+                            m_throttler.ProcessTime();
+                            responses.Remove(x);
+                        }
+                    }
+                };
+                // x is request id, y is request data hashtable
+                Request = (x, y) =>
+                {
+                    aPollRequest reqinfo = new aPollRequest();
+                    reqinfo.thepoll = this;
+                    reqinfo.reqID = x;
+                    reqinfo.request = y;
+
+                    m_queue.Enqueue(reqinfo);
+                };
+
+                // this should never happen except possible on shutdown
+                NoEvents = (x, y) =>
+                {
+                    /*
+                                        lock (requests)
+                                        {
+                                            Hashtable request = requests.Find(id => id["RequestID"].ToString() == x.ToString());
+                                            requests.Remove(request);
+                                        }
+                    */
+                    Hashtable response = new Hashtable();
+
+                    response["int_response_code"] = 500;
+                    response["str_response_string"] = "Script timeout";
+                    response["content_type"] = "text/plain";
+                    response["keepalive"] = false;
+                    response["reusecontext"] = false;
+
+                    return response;
+                };
+            }
+
+            public void Process(aPollRequest requestinfo)
+            {
+                Hashtable response;
+
+                UUID requestID = requestinfo.reqID;
+
+                // If the avatar is gone, don't bother to get the texture
+                if (m_scene.GetScenePresence(Id) == null)
+                {
+                    response = new Hashtable();
+
+                    response["int_response_code"] = 500;
+                    response["str_response_string"] = "Script timeout";
+                    response["content_type"] = "text/plain";
+                    response["keepalive"] = false;
+                    response["reusecontext"] = false;
+
+                    lock (responses)
+                        responses[requestID] = new aPollResponse() { bytes = 0, response = response, lod = 0 };
+
+                    return;
+                }
+
+                response = m_getMeshHandler.Handle(requestinfo.request);
+                lock (responses)
+                {
+                    responses[requestID] = new aPollResponse()
+                    {
+                        bytes = (int)response["int_bytes"],
+                        lod = (int)response["int_lod"],
+                        response = response
+                    };
+
+                }
+                m_throttler.ProcessTime();
+            }
+
+            internal void UpdateThrottle(int pimagethrottle, ScenePresence p)
+            {
+                m_throttler.UpdateThrottle(pimagethrottle, p);
+            }
+        }
 
         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.DebugFormat("[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(),
-                        httpMethod => gmeshHandler.ProcessGetMesh(httpMethod, UUID.Zero, null),
-                        "GetMesh",
-                        agentID.ToString());
+                string capUrl = "/CAPS/" + UUID.Random() + "/";
+
+                // Register this as a poll service           
+                PollServiceMeshEventArgs args = new PollServiceMeshEventArgs(agentID, m_scene);
+
+                args.Type = PollServiceEventArgs.EventType.Mesh;
+                MainServer.Instance.AddPollServiceHTTPHandler(capUrl, args);
 
-                caps.RegisterHandler("GetMesh", reqHandler);
+                string hostName = m_scene.RegionInfo.ExternalHostName;
+                uint port = (MainServer.Instance == null) ? 0 : MainServer.Instance.Port;
+                string protocol = "http";
+
+                if (MainServer.Instance.UseSSL)
+                {
+                    hostName = MainServer.Instance.SSLCommonName;
+                    port = MainServer.Instance.SSLPort;
+                    protocol = "https";
+                }
+                caps.RegisterHandler("GetMesh", String.Format("{0}://{1}:{2}{3}", protocol, hostName, port, capUrl));
+                m_pollservices.Add(agentID, args);
+                m_capsDict[agentID] = capUrl;
+
+
+           
             }
             else
             {
@@ -136,6 +389,171 @@ namespace OpenSim.Region.ClientStack.Linden
                 caps.RegisterHandler("GetMesh", m_URL);
             }
         }
+        private void DeregisterCaps(UUID agentID, Caps caps)
+        {
+            string capUrl;
+            PollServiceMeshEventArgs args;
+            if (m_capsDict.TryGetValue(agentID, out capUrl))
+            {
+                MainServer.Instance.RemoveHTTPHandler("", capUrl);
+                m_capsDict.Remove(agentID);
+            }
+            if (m_pollservices.TryGetValue(agentID, out args))
+            {
+                m_pollservices.Remove(agentID);
+            }
+        }
+
+        internal sealed class MeshCapsDataThrottler
+        {
+
+            private volatile int currenttime = 0;
+            private volatile int lastTimeElapsed = 0;
+            private volatile int BytesSent = 0;
+            private int Lod3 = 0;
+            private int Lod2 = 0;
+            private int Lod1 = 0;
+            private int UserSetThrottle = 0;
+            private int UDPSetThrottle = 0;
+            private int CapSetThrottle = 0;
+            private float CapThrottleDistributon = 0.30f;
+            private readonly Scene m_scene;
+            private ThrottleOutPacketType Throttle;
+            private readonly UUID User;
+            
+            public MeshCapsDataThrottler(int pBytes, int max, int min, Scene pScene, UUID puser)
+            {
+                ThrottleBytes = pBytes;
+                lastTimeElapsed = Util.EnvironmentTickCount();
+                Throttle = ThrottleOutPacketType.Task;
+                m_scene = pScene;
+                User = puser;
+            }
+
+
+            public bool hasEvents(UUID key, Dictionary<UUID, aPollResponse> responses)
+            {
+                const float ThirtyPercent = 0.30f;
+                const float FivePercent = 0.05f;
+                PassTime();
+                // Note, this is called IN LOCK
+                bool haskey = responses.ContainsKey(key);
+
+                if (responses.Count > 2)
+                {
+                    SplitThrottle(ThirtyPercent);
+                }
+                else
+                {
+                    SplitThrottle(FivePercent);
+                }
+
+                if (!haskey)
+                {
+                    return false;
+                }
+                aPollResponse response;
+                if (responses.TryGetValue(key, out response))
+                {
+                    float LOD3Over = (((ThrottleBytes*CapThrottleDistributon)%50000) + 1);
+                    float LOD2Over = (((ThrottleBytes*CapThrottleDistributon)%10000) + 1);
+                    // Normal
+                    if (BytesSent + response.bytes <= ThrottleBytes)
+                    {
+                        BytesSent += response.bytes;
+                       
+                        return true;
+                    }
+                    // Lod3 Over Throttle protection to keep things processing even when the throttle bandwidth is set too little.
+                    else if (response.bytes > ThrottleBytes && Lod3 <= ((LOD3Over < 1)? 1: LOD3Over) )
+                    {
+                        Interlocked.Increment(ref Lod3);
+                        BytesSent += response.bytes;
+                       
+                        return true;
+                    }
+                    // Lod2 Over Throttle protection to keep things processing even when the throttle bandwidth is set too little.
+                    else if (response.bytes > ThrottleBytes && Lod2 <= ((LOD2Over < 1) ? 1 : LOD2Over))
+                    {
+                        Interlocked.Increment(ref Lod2);
+                        BytesSent += response.bytes;
+                       
+                        return true;
+                    }
+                    else
+                    {
+                        return false;
+                    }
+                }
+
+                return haskey;
+            }
+            public void SubtractBytes(int bytes,int lod)
+            {
+                BytesSent -= bytes;
+            }
+            private void SplitThrottle(float percentMultiplier)
+            {
+
+                if (CapThrottleDistributon != percentMultiplier) // don't switch it if it's already set at the % multipler
+                {
+                    CapThrottleDistributon = percentMultiplier;
+                    ScenePresence p;
+                    if (m_scene.TryGetScenePresence(User, out p)) // If we don't get a user they're not here anymore.
+                    {
+                        AlterThrottle(UserSetThrottle, p);
+                    }
+                }
+            }
+           
+            public void ProcessTime()
+            {
+                PassTime();
+            }
+
+
+            private void PassTime()
+            {
+                currenttime = Util.EnvironmentTickCount();
+                int timeElapsed = Util.EnvironmentTickCountSubtract(currenttime, lastTimeElapsed);
+                //processTimeBasedActions(responses);
+                if (currenttime - timeElapsed >= 1000)
+                {
+                    lastTimeElapsed = Util.EnvironmentTickCount();
+                    BytesSent -= ThrottleBytes;
+                    if (BytesSent < 0) BytesSent = 0;
+                    if (BytesSent < ThrottleBytes)
+                    {
+                        Lod3 = 0;
+                        Lod2 = 0;
+                        Lod1 = 0;
+                    }
+                }
+            }
+            private void AlterThrottle(int setting, ScenePresence p)
+            {
+                p.ControllingClient.SetAgentThrottleSilent((int)Throttle,setting);
+            }
+
+            public int ThrottleBytes
+            {
+                get { return CapSetThrottle; }
+                set { CapSetThrottle = value; }
+            }
+
+            internal void UpdateThrottle(int pimagethrottle, ScenePresence p)
+            {
+                // Client set throttle !
+                UserSetThrottle = pimagethrottle;
+                CapSetThrottle = (int)(pimagethrottle*CapThrottleDistributon);
+                UDPSetThrottle = (int) (pimagethrottle*(100 - CapThrottleDistributon));
+                if (CapSetThrottle < 4068)
+                    CapSetThrottle = 4068;  // at least two discovery mesh
+                p.ControllingClient.SetAgentThrottleSilent((int) Throttle, UDPSetThrottle);
+                ProcessTime();
+
+            }
+        }
 
     }
 }
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/GetTextureModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/GetTextureModule.cs
index 13415f8..dd87671 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/GetTextureModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/GetTextureModule.cs
@@ -27,18 +27,13 @@
 
 using System;
 using System.Collections;
-using System.Collections.Specialized;
-using System.Drawing;
-using System.Drawing.Imaging;
+using System.Collections.Generic;
 using System.Reflection;
-using System.IO;
-using System.Web;
+using System.Threading;
 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;
@@ -47,6 +42,7 @@ using OpenSim.Region.Framework.Scenes;
 using OpenSim.Services.Interfaces;
 using Caps = OpenSim.Framework.Capabilities.Caps;
 using OpenSim.Capabilities.Handlers;
+using OpenSim.Framework.Monitoring;
 
 namespace OpenSim.Region.ClientStack.Linden
 {
@@ -54,57 +50,131 @@ namespace OpenSim.Region.ClientStack.Linden
     [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "GetTextureModule")]
     public class GetTextureModule : INonSharedRegionModule
     {
-//        private static readonly ILog m_log =
-//            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-        
+
+        struct aPollRequest
+        {
+            public PollServiceTextureEventArgs thepoll;
+            public UUID reqID;
+            public Hashtable request;
+        }
+
+        public class aPollResponse
+        {
+            public Hashtable response;
+            public int bytes;
+        }
+
+
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
         private Scene m_scene;
-        private IAssetService m_assetService;
 
-        private bool m_Enabled = false;
+        private static GetTextureHandler m_getTextureHandler;
+
+        private IAssetService m_assetService = null;
+
+        private Dictionary<UUID, string> m_capsDict = new Dictionary<UUID, string>();
+        private static Thread[] m_workerThreads = null;
 
-        // TODO: Change this to a config option
-        const string REDIRECT_URL = null;
+        private static OpenMetaverse.BlockingQueue<aPollRequest> m_queue =
+                new OpenMetaverse.BlockingQueue<aPollRequest>();
 
-        private string m_URL;
+        private Dictionary<UUID,PollServiceTextureEventArgs> m_pollservices = new Dictionary<UUID,PollServiceTextureEventArgs>();
 
         #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;
+            m_assetService = s.AssetService;
         }
 
         public void RemoveRegion(Scene s)
         {
-            if (!m_Enabled)
-                return;
-
             m_scene.EventManager.OnRegisterCaps -= RegisterCaps;
+            m_scene.EventManager.OnDeregisterCaps -= DeregisterCaps;
+            m_scene.EventManager.OnThrottleUpdate -= ThrottleUpdate;
             m_scene = null;
         }
 
         public void RegionLoaded(Scene s)
         {
-            if (!m_Enabled)
-                return;
+            // We'll reuse the same handler for all requests.
+            m_getTextureHandler = new GetTextureHandler(m_assetService);
 
-            m_assetService = m_scene.RequestModuleInterface<IAssetService>();
             m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+            m_scene.EventManager.OnDeregisterCaps += DeregisterCaps;
+            m_scene.EventManager.OnThrottleUpdate += ThrottleUpdate;
+
+            if (m_workerThreads == null)
+            {
+                m_workerThreads = new Thread[2];
+
+                for (uint i = 0; i < 2; i++)
+                {
+                    m_workerThreads[i] = Watchdog.StartThread(DoTextureRequests,
+                            String.Format("TextureWorkerThread{0}", i),
+                            ThreadPriority.Normal,
+                            false,
+                            false,
+                            null,
+                            int.MaxValue);
+                }
+            }
+        }
+        private int ExtractImageThrottle(byte[] pthrottles)
+        {
+       
+            byte[] adjData;
+            int pos = 0;
+
+            if (!BitConverter.IsLittleEndian)
+            {
+                byte[] newData = new byte[7 * 4];
+                Buffer.BlockCopy(pthrottles, 0, newData, 0, 7 * 4);
+
+                for (int i = 0; i < 7; i++)
+                    Array.Reverse(newData, i * 4, 4);
+
+                adjData = newData;
+            }
+            else
+            {
+                adjData = pthrottles;
+            }
+
+            // 0.125f converts from bits to bytes
+            //int resend = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); 
+            //pos += 4;
+           // int land = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); 
+            //pos += 4;
+           // int wind = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); 
+           // pos += 4;
+           // int cloud = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); 
+           // pos += 4;
+           // int task = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); 
+           // pos += 4;
+            pos = pos + 20;
+            int texture = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f); //pos += 4;
+            //int asset = (int)(BitConverter.ToSingle(adjData, pos) * 0.125f);
+            return texture;
+        }
+
+        // Now we know when the throttle is changed by the client in the case of a root agent or by a neighbor region in the case of a child agent.
+        public void ThrottleUpdate(ScenePresence p)
+        {
+            byte[] throttles = p.ControllingClient.GetThrottlesPacked(1);
+            UUID user = p.UUID;
+            int imagethrottle = ExtractImageThrottle(throttles);
+            PollServiceTextureEventArgs args;
+            if (m_pollservices.TryGetValue(user,out args))
+            {
+                args.UpdateThrottle(imagethrottle);
+            }
         }
 
         public void PostInitialise()
@@ -122,24 +192,250 @@ namespace OpenSim.Region.ClientStack.Linden
 
         #endregion
 
-        public void RegisterCaps(UUID agentID, Caps caps)
+        ~GetTextureModule()
+        {
+            foreach (Thread t in m_workerThreads)
+                Watchdog.AbortThread(t.ManagedThreadId);
+
+        }
+
+        private class PollServiceTextureEventArgs : PollServiceEventArgs
         {
-            UUID capID = UUID.Random();
+            private List<Hashtable> requests =
+                    new List<Hashtable>();
+            private Dictionary<UUID, aPollResponse> responses =
+                    new Dictionary<UUID, aPollResponse>();
 
-            //caps.RegisterHandler("GetTexture", new StreamHandler("GET", "/CAPS/" + capID, ProcessGetTexture));
-            if (m_URL == "localhost")
+            private Scene m_scene;
+            private CapsDataThrottler m_throttler = new CapsDataThrottler(100000, 1400000,10000);
+            public PollServiceTextureEventArgs(UUID pId, Scene scene) :
+                    base(null, null, null, null, pId, int.MaxValue)              
             {
-//                m_log.DebugFormat("[GETTEXTURE]: /CAPS/{0} in region {1}", capID, m_scene.RegionInfo.RegionName);
-                caps.RegisterHandler(
-                    "GetTexture",
-                    new GetTextureHandler("/CAPS/" + capID + "/", m_assetService, "GetTexture", agentID.ToString()));
+                m_scene = scene;
+                // x is request id, y is userid
+                HasEvents = (x, y) =>
+                {
+                    lock (responses)
+                    {
+                        bool ret = m_throttler.hasEvents(x, responses);
+                        m_throttler.ProcessTime();
+                        return ret;
+
+                    }
+                };
+                GetEvents = (x, y) =>
+                {
+                    lock (responses)
+                    {
+                        try
+                        {
+                            return responses[x].response;
+                        }
+                        finally
+                        {
+                            responses.Remove(x);
+                        }
+                    }
+                };
+                // x is request id, y is request data hashtable
+                Request = (x, y) =>
+                {
+                    aPollRequest reqinfo = new aPollRequest();
+                    reqinfo.thepoll = this;
+                    reqinfo.reqID = x;
+                    reqinfo.request = y;
+                    
+                    m_queue.Enqueue(reqinfo);
+                };
+
+                // this should never happen except possible on shutdown
+                NoEvents = (x, y) =>
+                {
+/*
+                    lock (requests)
+                    {
+                        Hashtable request = requests.Find(id => id["RequestID"].ToString() == x.ToString());
+                        requests.Remove(request);
+                    }
+*/
+                    Hashtable response = new Hashtable();
+
+                    response["int_response_code"] = 500;
+                    response["str_response_string"] = "Script timeout";
+                    response["content_type"] = "text/plain";
+                    response["keepalive"] = false;
+                    response["reusecontext"] = false;
+
+                    return response;
+                };
             }
-            else
+
+            public void Process(aPollRequest requestinfo)
+            {
+                Hashtable response;
+
+                UUID requestID = requestinfo.reqID;
+
+                // If the avatar is gone, don't bother to get the texture
+                if (m_scene.GetScenePresence(Id) == null)
+                {
+                    response = new Hashtable();
+
+                    response["int_response_code"] = 500;
+                    response["str_response_string"] = "Script timeout";
+                    response["content_type"] = "text/plain";
+                    response["keepalive"] = false;
+                    response["reusecontext"] = false;
+                    
+                    lock (responses)
+                        responses[requestID] = new aPollResponse() {bytes = 0, response = response};
+
+                    return;
+                }
+                
+                response = m_getTextureHandler.Handle(requestinfo.request);
+                lock (responses)
+                {
+                    responses[requestID] = new aPollResponse()
+                                               {
+                                                   bytes = (int) response["int_bytes"],
+                                                   response = response
+                                               };
+                   
+                } 
+                m_throttler.ProcessTime();
+            }
+
+            internal void UpdateThrottle(int pimagethrottle)
+            {
+                m_throttler.ThrottleBytes = pimagethrottle;
+            }
+        }
+
+        private void RegisterCaps(UUID agentID, Caps caps)
+        {
+            string capUrl = "/CAPS/" + UUID.Random() + "/";
+
+            // Register this as a poll service           
+            PollServiceTextureEventArgs args = new PollServiceTextureEventArgs(agentID, m_scene);
+            
+            args.Type = PollServiceEventArgs.EventType.Texture;
+            MainServer.Instance.AddPollServiceHTTPHandler(capUrl, args);
+
+            string hostName = m_scene.RegionInfo.ExternalHostName;
+            uint port = (MainServer.Instance == null) ? 0 : MainServer.Instance.Port;
+            string protocol = "http";
+            
+            if (MainServer.Instance.UseSSL)
+            {
+                hostName = MainServer.Instance.SSLCommonName;
+                port = MainServer.Instance.SSLPort;
+                protocol = "https";
+            }
+            caps.RegisterHandler("GetTexture", String.Format("{0}://{1}:{2}{3}", protocol, hostName, port, capUrl));
+            m_pollservices.Add(agentID, args);
+            m_capsDict[agentID] = capUrl;
+        }
+
+        private void DeregisterCaps(UUID agentID, Caps caps)
+        {
+            string capUrl;
+            PollServiceTextureEventArgs args;
+            if (m_capsDict.TryGetValue(agentID, out capUrl))
+            {
+                MainServer.Instance.RemoveHTTPHandler("", capUrl);
+                m_capsDict.Remove(agentID);
+            }
+            if (m_pollservices.TryGetValue(agentID, out args))
             {
-//                m_log.DebugFormat("[GETTEXTURE]: {0} in region {1}", m_URL, m_scene.RegionInfo.RegionName);
-                caps.RegisterHandler("GetTexture", m_URL);
+                m_pollservices.Remove(agentID);
             }
         }
 
+        private void DoTextureRequests()
+        {
+            while (true)
+            {
+                aPollRequest poolreq = m_queue.Dequeue();
+
+                poolreq.thepoll.Process(poolreq);
+            }
+        }
+        internal sealed class CapsDataThrottler
+        {
+
+            private volatile int currenttime = 0;
+            private volatile int lastTimeElapsed = 0;
+            private volatile int BytesSent = 0;
+            private int oversizedImages = 0;
+            public CapsDataThrottler(int pBytes, int max, int min)
+            {
+                ThrottleBytes = pBytes;
+                lastTimeElapsed = Util.EnvironmentTickCount();
+            }
+            public bool hasEvents(UUID key, Dictionary<UUID, GetTextureModule.aPollResponse> responses)
+            {
+                PassTime();
+                // Note, this is called IN LOCK
+                bool haskey = responses.ContainsKey(key);
+                if (!haskey)
+                {
+                    return false;
+                }
+                GetTextureModule.aPollResponse response;
+                if (responses.TryGetValue(key, out response))
+                {
+
+                    // Normal
+                    if (BytesSent + response.bytes <= ThrottleBytes)
+                    {
+                        BytesSent += response.bytes;
+                        //TimeBasedAction timeBasedAction = new TimeBasedAction { byteRemoval = response.bytes, requestId = key, timeMS = currenttime + 1000, unlockyn = false };
+                        //m_actions.Add(timeBasedAction);
+                        return true;
+                    }
+                    // Big textures
+                    else if (response.bytes > ThrottleBytes && oversizedImages <= ((ThrottleBytes % 50000) + 1))
+                    {
+                        Interlocked.Increment(ref oversizedImages);
+                        BytesSent += response.bytes;
+                        //TimeBasedAction timeBasedAction = new TimeBasedAction { byteRemoval = response.bytes, requestId = key, timeMS = currenttime + (((response.bytes % ThrottleBytes)+1)*1000) , unlockyn = false };
+                        //m_actions.Add(timeBasedAction);
+                        return true;
+                    }
+                    else
+                    {
+                        return false;
+                    }
+                }
+
+                return haskey;
+            }
+            public void ProcessTime()
+            {
+                PassTime();
+            }
+
+
+            private void PassTime()
+            {
+                currenttime = Util.EnvironmentTickCount();
+                int timeElapsed = Util.EnvironmentTickCountSubtract(currenttime, lastTimeElapsed);
+                //processTimeBasedActions(responses);
+                if (Util.EnvironmentTickCountSubtract(currenttime, timeElapsed) >= 1000)
+                {
+                    lastTimeElapsed = Util.EnvironmentTickCount();
+                    BytesSent -= ThrottleBytes;
+                    if (BytesSent < 0) BytesSent = 0;
+                    if (BytesSent < ThrottleBytes)
+                    {
+                        oversizedImages = 0;
+                    }
+                }
+            }
+            public int ThrottleBytes;
+        }
     }
+
+    
 }
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/MeshUploadFlagModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/MeshUploadFlagModule.cs
index 33b1f77..60c1814 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/MeshUploadFlagModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/MeshUploadFlagModule.cs
@@ -129,15 +129,15 @@ namespace OpenSim.Region.ClientStack.Linden
 //            m_log.DebugFormat("[MESH UPLOAD FLAG MODULE]: MeshUploadFlag request");
 
             OSDMap data = new OSDMap();
-            ScenePresence sp = m_scene.GetScenePresence(m_agentID);
-            data["username"] = sp.Firstname + "." + sp.Lastname;
-            data["display_name_next_update"] = new OSDDate(DateTime.Now);
-            data["legacy_first_name"] = sp.Firstname;
+//          ScenePresence sp = m_scene.GetScenePresence(m_agentID);
+//          data["username"] = sp.Firstname + "." + sp.Lastname;
+//          data["display_name_next_update"] = new OSDDate(DateTime.Now);
+//          data["legacy_first_name"] = sp.Firstname;
             data["mesh_upload_status"] = "valid";
-            data["display_name"] = sp.Firstname + " " + sp.Lastname;
-            data["legacy_last_name"] = sp.Lastname;
-            data["id"] = m_agentID;
-            data["is_display_name_default"] = true;
+//          data["display_name"] = sp.Firstname + " " + sp.Lastname;
+//          data["legacy_last_name"] = sp.Lastname;
+//          data["id"] = m_agentID;
+//          data["is_display_name_default"] = true;
 
             //Send back data
             Hashtable responsedata = new Hashtable();
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/NewFileAgentInventoryVariablePriceModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/NewFileAgentInventoryVariablePriceModule.cs
deleted file mode 100644
index 5529550..0000000
--- a/OpenSim/Region/ClientStack/Linden/Caps/NewFileAgentInventoryVariablePriceModule.cs
+++ /dev/null
@@ -1,296 +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;
-using OpenSim.Framework.Capabilities;
-
-namespace OpenSim.Region.ClientStack.Linden
-{
-    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "NewFileAgentInventoryVariablePriceModule")]
-    public class NewFileAgentInventoryVariablePriceModule : INonSharedRegionModule
-    {
-//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-        
-        private Scene m_scene;
-//        private IAssetService m_assetService;
-        private bool m_dumpAssetsToFile = false;
-        private bool m_enabled = true;
-        private int  m_levelUpload = 0;
-
-        #region Region Module interfaceBase 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);
-            m_levelUpload = meshConfig.GetInt("LevelUpload", 0);
-        }
-
-        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 Region Module interface
-
-       
-
-        public void Close() { }
-
-        public string Name { get { return "NewFileAgentInventoryVariablePriceModule"; } }
-
-
-        public void RegisterCaps(UUID agentID, Caps caps)
-        {
-            if(!m_enabled)
-                return;
-
-            UUID capID = UUID.Random();
-
-//            m_log.Debug("[NEW FILE AGENT INVENTORY VARIABLE PRICE]: /CAPS/" + capID);
-            caps.RegisterHandler(
-                "NewFileAgentInventoryVariablePrice",
-                new LLSDStreamhandler<LLSDAssetUploadRequest, LLSDNewFileAngentInventoryVariablePriceReplyResponse>(
-                    "POST",
-                    "/CAPS/" + capID.ToString(),
-                    req => NewAgentInventoryRequest(req, agentID),
-                    "NewFileAgentInventoryVariablePrice",
-                    agentID.ToString()));         
-        }
-
-        #endregion
-
-        public LLSDNewFileAngentInventoryVariablePriceReplyResponse NewAgentInventoryRequest(LLSDAssetUploadRequest llsdRequest, UUID agentID)
-        {
-            //TODO:  The Mesh uploader uploads many types of content. If you're going to implement a Money based limit
-            // you need to be aware of this
-
-            //if (llsdRequest.asset_type == "texture" ||
-           //     llsdRequest.asset_type == "animation" ||
-           //     llsdRequest.asset_type == "sound")
-           // {
-                // check user level
-
-            ScenePresence avatar = null;
-            IClientAPI client = null;
-            m_scene.TryGetScenePresence(agentID, out avatar);
-
-            if (avatar != null)
-            {
-                client = avatar.ControllingClient;
-
-                if (avatar.UserLevel < m_levelUpload)
-                {
-                    if (client != null)
-                        client.SendAgentAlertMessage("Unable to upload asset. Insufficient permissions.", false);
-
-                    LLSDNewFileAngentInventoryVariablePriceReplyResponse errorResponse = new LLSDNewFileAngentInventoryVariablePriceReplyResponse();
-                    errorResponse.rsvp = "";
-                    errorResponse.state = "error";
-                    return errorResponse;
-                }
-            }
-
-            // check funds
-            IMoneyModule mm = m_scene.RequestModuleInterface<IMoneyModule>();
-
-            if (mm != null)
-            {
-                if (!mm.UploadCovered(agentID, mm.UploadCharge))
-                {
-                    if (client != null)
-                        client.SendAgentAlertMessage("Unable to upload asset. Insufficient funds.", false);
-
-                    LLSDNewFileAngentInventoryVariablePriceReplyResponse errorResponse = new LLSDNewFileAngentInventoryVariablePriceReplyResponse();
-                    errorResponse.rsvp = "";
-                    errorResponse.state = "error";
-                    return errorResponse;
-                }
-            }
-
-           // }
-
-            string assetName = llsdRequest.name;
-            string assetDes = llsdRequest.description;
-            string capsBase = "/CAPS/NewFileAgentInventoryVariablePrice/";
-            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, MainServer.Instance, m_dumpAssetsToFile);
-
-            MainServer.Instance.AddStreamHandler(
-                new BinaryStreamHandler(
-                    "POST",
-                    capsBase + uploaderPath,
-                    uploader.uploaderCaps,
-                    "NewFileAgentInventoryVariablePrice",
-                    agentID.ToString()));
-
-            string protocol = "http://";
-
-            if (MainServer.Instance.UseSSL)
-                protocol = "https://";
-
-            string uploaderURL = protocol + m_scene.RegionInfo.ExternalHostName + ":" + MainServer.Instance.Port.ToString() + capsBase +
-                                 uploaderPath;
-
-
-            LLSDNewFileAngentInventoryVariablePriceReplyResponse uploadResponse = new LLSDNewFileAngentInventoryVariablePriceReplyResponse();
-            
-            uploadResponse.rsvp = uploaderURL;
-            uploadResponse.state = "upload";
-            uploadResponse.resource_cost = 0;
-            uploadResponse.upload_price = 0;
-
-            uploader.OnUpLoad += //UploadCompleteHandler;
-                
-                delegate(
-                string passetName, string passetDescription, UUID passetID,
-                UUID pinventoryItem, UUID pparentFolder, byte[] pdata, string pinventoryType,
-                string passetType)
-               {
-                   UploadCompleteHandler(passetName, passetDescription,  passetID,
-                                          pinventoryItem, pparentFolder, pdata,  pinventoryType,
-                                          passetType,agentID);
-               };
-
-            return uploadResponse;
-        }
-
-        public void UploadCompleteHandler(string assetName, string assetDescription, UUID assetID,
-                                          UUID inventoryItem, UUID parentFolder, byte[] data, string inventoryType,
-                                          string assetType,UUID AgentID)
-        {
-//            m_log.DebugFormat(
-//                "[NEW FILE AGENT INVENTORY VARIABLE PRICE MODULE]: Upload complete for {0}", inventoryItem);
-
-            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;
-                }
-            }
-            else if (inventoryType == "mesh")
-            {
-                inType = (sbyte)InventoryType.Mesh; 
-                assType = (sbyte)AssetType.Mesh;
-            }
-
-            AssetBase asset;
-            asset = new AssetBase(assetID, assetName, assType, AgentID.ToString());
-            asset.Data = data;
-    
-            if (m_scene.AssetService != null)
-                m_scene.AssetService.Store(asset);
-
-            InventoryItemBase item = new InventoryItemBase();
-            item.Owner = AgentID;
-            item.CreatorId = AgentID.ToString();
-            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.Move | PermissionMask.Copy | PermissionMask.Modify | PermissionMask.Transfer);
-            item.BasePermissions = (uint)PermissionMask.All;
-            item.EveryOnePermissions = 0;
-            item.NextPermissions = (uint)PermissionMask.All;
-            item.CreationDate = Util.UnixTimeSinceEpoch();
-            m_scene.AddInventoryItem(item);
-        }
-    }
-}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/RegionConsoleModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/RegionConsoleModule.cs
index 17c7270..fcac182 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/RegionConsoleModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/RegionConsoleModule.cs
@@ -64,6 +64,8 @@ namespace OpenSim.Region.ClientStack.Linden
         private Commands m_commands = new Commands();
         public ICommands Commands { get { return m_commands; } }
 
+        public event ConsoleMessage OnConsoleMessage;
+
         public void Initialise(IConfigSource source)
         {
             m_commands.AddCommand( "Help", false, "help", "help [<item>]", "Display help on a particular command or on a list of commands in a category", Help);
@@ -102,7 +104,7 @@ namespace OpenSim.Region.ClientStack.Linden
 
         public void RegisterCaps(UUID agentID, Caps caps)
         {
-            if (!m_scene.RegionInfo.EstateSettings.IsEstateManagerOrOwner(agentID))
+            if (!m_scene.RegionInfo.EstateSettings.IsEstateManagerOrOwner(agentID) && !m_scene.Permissions.IsGod(agentID))
                 return;
 
             UUID capID = UUID.Random();
@@ -118,6 +120,11 @@ namespace OpenSim.Region.ClientStack.Linden
             OSD osd = OSD.FromString(message);
 
             m_eventQueue.Enqueue(EventQueueHelper.BuildEvent("SimConsoleResponse", osd), agentID);
+
+            ConsoleMessage handlerConsoleMessage = OnConsoleMessage;
+
+            if (handlerConsoleMessage != null)
+                handlerConsoleMessage( agentID, message);
         }
 
         public bool RunCommand(string command, UUID invokerID)
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/WebFetchInvDescModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/WebFetchInvDescModule.cs
index 6890f4a..04cd474 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/WebFetchInvDescModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/WebFetchInvDescModule.cs
@@ -27,18 +27,22 @@
 
 using System;
 using System.Collections;
+using System.Collections.Generic;
 using System.Reflection;
+using System.Threading;
 using log4net;
 using Nini.Config;
 using Mono.Addins;
 using OpenMetaverse;
 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;
+using OpenSim.Framework.Monitoring;
 
 namespace OpenSim.Region.ClientStack.Linden
 {
@@ -48,67 +52,72 @@ namespace OpenSim.Region.ClientStack.Linden
     [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "WebFetchInvDescModule")]
     public class WebFetchInvDescModule : INonSharedRegionModule
     {
-//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        struct aPollRequest
+        {
+            public PollServiceInventoryEventArgs thepoll;
+            public UUID reqID;
+            public Hashtable request;
+        }
+
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         private Scene m_scene;
 
         private IInventoryService m_InventoryService;
         private ILibraryService m_LibraryService;
 
-        private bool m_Enabled;
+        private static WebFetchInvDescHandler m_webFetchHandler;
 
-        private string m_fetchInventoryDescendents2Url;
-        private string m_webFetchInventoryDescendentsUrl;
+        private Dictionary<UUID, string> m_capsDict = new Dictionary<UUID, string>();
+        private static Thread[] m_workerThreads = null;
 
-        private WebFetchInvDescHandler m_webFetchHandler;
+        private static OpenMetaverse.BlockingQueue<aPollRequest> m_queue =
+                new OpenMetaverse.BlockingQueue<aPollRequest>();
 
         #region ISharedRegionModule Members
 
         public void Initialise(IConfigSource source)
         {
-            IConfig config = source.Configs["ClientStack.LindenCaps"];
-            if (config == null)
-                return;
-
-            m_fetchInventoryDescendents2Url = config.GetString("Cap_FetchInventoryDescendents2", string.Empty);
-            m_webFetchInventoryDescendentsUrl = config.GetString("Cap_WebFetchInventoryDescendents", string.Empty);
-
-            if (m_fetchInventoryDescendents2Url != string.Empty || m_webFetchInventoryDescendentsUrl != string.Empty)
-            {
-                m_Enabled = true;
-            }
         }
 
         public void AddRegion(Scene s)
         {
-            if (!m_Enabled)
-                return;
-
             m_scene = s;
         }
 
         public void RemoveRegion(Scene s)
         {
-            if (!m_Enabled)
-                return;
-
             m_scene.EventManager.OnRegisterCaps -= RegisterCaps;
+            m_scene.EventManager.OnDeregisterCaps -= DeregisterCaps;
             m_scene = null;
         }
 
         public void RegionLoaded(Scene s)
         {
-            if (!m_Enabled)
-                return;
-
             m_InventoryService = m_scene.InventoryService;
             m_LibraryService = m_scene.LibraryService;
 
             // We'll reuse the same handler for all requests.
-            if (m_fetchInventoryDescendents2Url == "localhost" || m_webFetchInventoryDescendentsUrl == "localhost")
-                m_webFetchHandler = new WebFetchInvDescHandler(m_InventoryService, m_LibraryService);
+            m_webFetchHandler = new WebFetchInvDescHandler(m_InventoryService, m_LibraryService);
 
             m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+            m_scene.EventManager.OnDeregisterCaps += DeregisterCaps;
+
+            if (m_workerThreads == null)
+            {
+                m_workerThreads = new Thread[2];
+
+                for (uint i = 0; i < 2; i++)
+                {
+                    m_workerThreads[i] = Watchdog.StartThread(DoInventoryRequests,
+                            String.Format("InventoryWorkerThread{0}", i),
+                            ThreadPriority.Normal,
+                            false,
+                            true,
+                            null,
+                            int.MaxValue);
+                }
+            }
         }
 
         public void PostInitialise()
@@ -126,43 +135,130 @@ namespace OpenSim.Region.ClientStack.Linden
 
         #endregion
 
-        private void RegisterCaps(UUID agentID, Caps caps)
+        ~WebFetchInvDescModule()
         {
-            if (m_webFetchInventoryDescendentsUrl != "")
-                RegisterFetchCap(agentID, caps, "WebFetchInventoryDescendents", m_webFetchInventoryDescendentsUrl);
-
-            if (m_fetchInventoryDescendents2Url != "")
-                RegisterFetchCap(agentID, caps, "FetchInventoryDescendents2", m_fetchInventoryDescendents2Url);
+            foreach (Thread t in m_workerThreads)
+                Watchdog.AbortThread(t.ManagedThreadId);               
         }
 
-        private void RegisterFetchCap(UUID agentID, Caps caps, string capName, string url)
+        private class PollServiceInventoryEventArgs : PollServiceEventArgs
         {
-            string capUrl;
+            private Dictionary<UUID, Hashtable> responses =
+                    new Dictionary<UUID, Hashtable>();
+
+            public PollServiceInventoryEventArgs(UUID pId) :
+                    base(null, null, null, null, pId, int.MaxValue)
+            {
+                HasEvents = (x, y) => { lock (responses) return responses.ContainsKey(x); };
+                GetEvents = (x, y) =>
+                {
+                    lock (responses)
+                    {
+                        try
+                        {
+                            return responses[x];
+                        }
+                        finally
+                        {
+                            responses.Remove(x);
+                        }
+                    }
+                };
+
+                Request = (x, y) =>
+                {
+                    aPollRequest reqinfo = new aPollRequest();
+                    reqinfo.thepoll = this;
+                    reqinfo.reqID = x;
+                    reqinfo.request = y;
+
+                    m_queue.Enqueue(reqinfo);
+                };
+
+                NoEvents = (x, y) =>
+                {
+/*
+                    lock (requests)
+                    {
+                        Hashtable request = requests.Find(id => id["RequestID"].ToString() == x.ToString());
+                        requests.Remove(request);
+                    }
+*/
+                    Hashtable response = new Hashtable();
+
+                    response["int_response_code"] = 500;
+                    response["str_response_string"] = "Script timeout";
+                    response["content_type"] = "text/plain";
+                    response["keepalive"] = false;
+                    response["reusecontext"] = false;
+
+                    return response;
+                };
+            }
 
-            if (url == "localhost")
+            public void Process(aPollRequest requestinfo)
             {
-                capUrl = "/CAPS/" + UUID.Random();
+                UUID requestID = requestinfo.reqID;
+
+                Hashtable response = new Hashtable();
+
+                response["int_response_code"] = 200;
+                response["content_type"] = "text/plain";
+                response["keepalive"] = false;
+                response["reusecontext"] = false;
 
-                IRequestHandler reqHandler
-                    = new RestStreamHandler(
-                        "POST",
-                        capUrl,
-                        m_webFetchHandler.FetchInventoryDescendentsRequest,
-                        "FetchInventoryDescendents2",
-                        agentID.ToString());
+                response["str_response_string"] = m_webFetchHandler.FetchInventoryDescendentsRequest(
+                    requestinfo.request["body"].ToString(), String.Empty, String.Empty, null, null);
 
-                caps.RegisterHandler(capName, reqHandler);
+                lock (responses)
+                    responses[requestID] = response; 
             }
-            else
+        }
+
+        private void RegisterCaps(UUID agentID, Caps caps)
+        {
+            string capUrl = "/CAPS/" + UUID.Random() + "/";
+
+            // Register this as a poll service          
+            PollServiceInventoryEventArgs args = new PollServiceInventoryEventArgs(agentID);
+            
+            args.Type = PollServiceEventArgs.EventType.Inventory;
+            MainServer.Instance.AddPollServiceHTTPHandler(capUrl, args);
+
+            string hostName = m_scene.RegionInfo.ExternalHostName;
+            uint port = (MainServer.Instance == null) ? 0 : MainServer.Instance.Port;
+            string protocol = "http";
+            
+            if (MainServer.Instance.UseSSL)
             {
-                capUrl = url;
+                hostName = MainServer.Instance.SSLCommonName;
+                port = MainServer.Instance.SSLPort;
+                protocol = "https";
+            }
+            caps.RegisterHandler("FetchInventoryDescendents2", String.Format("{0}://{1}:{2}{3}", protocol, hostName, port, capUrl));
+
+            m_capsDict[agentID] = capUrl;
+        }
 
-                caps.RegisterHandler(capName, capUrl);
+        private void DeregisterCaps(UUID agentID, Caps caps)
+        {
+            string capUrl;
+
+            if (m_capsDict.TryGetValue(agentID, out capUrl))
+            {
+                MainServer.Instance.RemoveHTTPHandler("", capUrl);
+                m_capsDict.Remove(agentID);
             }
+        }
 
-//            m_log.DebugFormat(
-//                "[WEB FETCH INV DESC MODULE]: Registered capability {0} at {1} in region {2} for {3}",
-//                capName, capUrl, m_scene.RegionInfo.RegionName, agentID);
+        private void DoInventoryRequests()
+        {
+            while (true)
+            {
+                aPollRequest poolreq = m_queue.Dequeue();
+
+                poolreq.thepoll.Process(poolreq);
+            }
         }
     }
-}
\ No newline at end of file
+}