bad merge?

12 files changed, 2765 insertions, 805 deletions

diff --git a/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCaps.cs b/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/BunchOfCaps.cs
index 774202e..4e6d196 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;
@@ -55,14 +56,16 @@ using PermissionMask = OpenSim.Framework.PermissionMask;
 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);
 
@@ -88,6 +91,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/";
@@ -99,8 +103,10 @@ namespace OpenSim.Region.ClientStack.Linden
         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/";
-        /* 0102 - 0103 RESERVED */
+        private static readonly string m_getObjectCostPath = "0102/";
+        private static readonly string m_ResourceCostSelectedPath = "0103/";
         private static readonly string m_UpdateAgentInformationPath = "0500/";
+        private static readonly string m_animSetTaskUpdatePath = "0260/";
         
         // These are callbacks which will be setup by the scene so that we can update scene data when we
         // receive capability calls
@@ -115,12 +121,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)
             {
@@ -135,6 +179,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;
@@ -146,6 +221,8 @@ namespace OpenSim.Region.ClientStack.Linden
             ItemUpdatedCall = m_Scene.CapsUpdateInventoryItemAsset;
             TaskScriptUpdatedCall = m_Scene.CapsUpdateTaskInventoryScriptAsset;
             GetClient = m_Scene.SceneGraph.GetControllingClient;
+
+            m_FileAgentInventoryState = FileAgentInventoryState.idle;
         }
 
         /// <summary>
@@ -173,13 +250,31 @@ namespace OpenSim.Region.ClientStack.Linden
                 //m_capsHandlers["MapLayer"] =
                 //    new LLSDStreamhandler<OSDMapRequest, OSDMapLayerResponse>("POST",
                 //                                                                capsBase + m_mapLayerPath,
-                //                                                                GetMapLayer);
+                //                                                               GetMapLayer);
+
+                IRequestHandler getObjectPhysicsDataHandler
+                    = new RestStreamHandler(
+                        "POST", capsBase + m_getObjectPhysicsDataPath, GetObjectPhysicsData, "GetObjectPhysicsData", null);
+                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);
+   
+
                 IRequestHandler req
                     = new RestStreamHandler(
                         "POST", capsBase + m_notecardTaskUpdatePath, ScriptTaskInventory, "UpdateScript", null);
 
                 m_HostCapsObj.RegisterHandler("UpdateScriptTaskInventory", req);
                 m_HostCapsObj.RegisterHandler("UpdateScriptTask", req);
+
+//                IRequestHandler animSetRequestHandler
+//                    = new RestStreamHandler(
+//                        "POST", capsBase + m_animSetTaskUpdatePath, AnimSetTaskInventory, "UpdateScript", null);
+
+//                m_HostCapsObj.RegisterHandler("UpdateAnimSetTaskInventory", animSetRequestHandler);
             }
             catch (Exception e)
             {
@@ -191,7 +286,6 @@ namespace OpenSim.Region.ClientStack.Linden
         {
             try
             {
-                // I don't think this one works...
                 m_HostCapsObj.RegisterHandler(
                     "NewFileAgentInventory",
                     new LLSDStreamhandler<LLSDAssetUploadRequest, LLSDAssetUploadResponse>(
@@ -206,13 +300,11 @@ namespace OpenSim.Region.ClientStack.Linden
                         "POST", capsBase + m_notecardUpdatePath, NoteCardAgentInventory, "Update*", null);
 
                 m_HostCapsObj.RegisterHandler("UpdateNotecardAgentInventory", req);
+                m_HostCapsObj.RegisterHandler("UpdateAnimSetAgentInventory", req);
                 m_HostCapsObj.RegisterHandler("UpdateScriptAgentInventory", req);
                 m_HostCapsObj.RegisterHandler("UpdateScriptAgent", req);
 
-                IRequestHandler getObjectPhysicsDataHandler 
-                    = new RestStreamHandler(
-                        "POST", capsBase + m_getObjectPhysicsDataPath, GetObjectPhysicsData, "GetObjectPhysicsData", null);
-                m_HostCapsObj.RegisterHandler("GetObjectPhysicsData", getObjectPhysicsDataHandler);
+    
 
                 IRequestHandler UpdateAgentInformationHandler
                     = new RestStreamHandler(
@@ -271,6 +363,9 @@ namespace OpenSim.Region.ClientStack.Linden
 //            m_log.DebugFormat(
 //                "[CAPS]: Received SEED caps request in {0} for agent {1}", m_regionName, m_HostCapsObj.AgentID);
 
+            if (!m_HostCapsObj.WaitForActivation())
+                return string.Empty;
+
             if (!m_Scene.CheckClient(m_HostCapsObj.AgentID, httpRequest.RemoteIPEndPoint))
             {
                 m_log.WarnFormat(
@@ -400,62 +495,178 @@ 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 == "animatn" ||    // this is the asset name actually used by viewers
+                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(
@@ -473,10 +684,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;
         }
 
@@ -488,8 +711,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);
@@ -497,6 +726,34 @@ 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 = (sbyte)InventoryType.Sound;
@@ -511,6 +768,12 @@ namespace OpenSim.Region.ClientStack.Linden
                 inType = (sbyte)InventoryType.Animation;
                 assType = (sbyte)AssetType.Animation;
             }
+            else if (inventoryType == "animset")
+            {
+                inType = (sbyte)CustomInventoryType.AnimationSet;
+                assType = (sbyte)CustomAssetType.AnimationSet;
+                m_log.Debug("got animset upload request");
+            }
             else if (inventoryType == "wearable")
             {
                 inType = (sbyte)InventoryType.Wearable;
@@ -526,6 +789,7 @@ namespace OpenSim.Region.ClientStack.Linden
             }
             else if (inventoryType == "object")
             {
+<<<<<<< HEAD
                 inType = (sbyte)InventoryType.Object;
                 assType = (sbyte)AssetType.Object;
 
@@ -612,73 +876,255 @@ namespace OpenSim.Region.ClientStack.Linden
                 {
                     clientInv.SendBulkUpdateInventory(foldersToUpdate.ToArray(), itemsToUpdate.ToArray());
                 }
-
-                for (int i = 0; i < mesh_list.Count; i++)
+=======
+                if (assetType == "mesh") // this code for now is for mesh models uploads only
                 {
-                    PrimitiveBaseShape pbs = PrimitiveBaseShape.CreateBox();
+                    inType = (sbyte)InventoryType.Object;
+                    assType = (sbyte)AssetType.Object;
+>>>>>>> avn/ubitvar
 
-                    Primitive.TextureEntry textureEntry
-                        = new Primitive.TextureEntry(Primitive.TextureEntry.WHITE_TEXTURE);
-                    OSDMap inner_instance_list = (OSDMap)instance_list[i];
+                    List<Vector3> positions = new List<Vector3>();
+                    List<Quaternion> rotations = new List<Quaternion>();
+                    OSDMap request = (OSDMap)OSDParser.DeserializeLLSDXml(data);
+
+                    // compare and get updated information
+/* does nothing still we do need something to avoid special viewer to upload something diferent from the cost estimation
+                    bool mismatchError = true;
+
+                    while (mismatchError)
+                    {
+                        mismatchError = false;
+                    }
 
-                    OSDArray face_list = (OSDArray)inner_instance_list["face_list"];
-                    for (uint face = 0; face < face_list.Count; face++)
+                    if (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();
+                        error = "Upload and fee estimation information don't match";
+                        lock (m_ModelCost)
+                            m_FileAgentInventoryState = FileAgentInventoryState.idle;
 
-                        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();
+                        return;
+                    }
+*/
+                    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(imagerot != 0)
-                            f.Rotation = imagerot;
+                    // create and store texture assets
+                    bool doTextInv = (!istest && m_enableModelUploadTextureToInventory &&
+                                    texturesFolder != UUID.Zero);
 
-                        if(offsets != 0)
-                            f.OffsetU = offsets;
 
-                        if (offsett != 0)
-                            f.OffsetV = offsett;
+                    List<UUID> textures = new List<UUID>();
 
-                        if (scales != 0)
-                            f.RepeatU = scales;
+                   
+//                    if (doTextInv)
+                        m_Scene.TryGetClient(m_HostCapsObj.AgentID, out client);
 
-                        if (scalet != 0)
-                            f.RepeatV = scalet;
+                    if(client == null) // don't put textures in inventory if there is no client
+                        doTextInv = false;
 
-                        if (textures.Count > textureNum)
-                            f.TextureID = textures[textureNum];
-                        else
-                            f.TextureID = Primitive.TextureEntry.WHITE_TEXTURE;
+                    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 | PermissionMask.Export);
+
+                            texitem.BasePermissions = (uint)PermissionMask.All | (uint)PermissionMask.Export;
+                            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>();
+                    List<bool> meshAvatarSkeletons = new List<bool>();
+                    List<bool> meshAvatarColliders = new List<bool>();
+
+                    bool curAvSkeleton;
+                    bool curAvCollider;
+                    for (int i = 0; i < mesh_list.Count; i++)
+                    {
+                        curAvSkeleton = false;
+                        curAvCollider = false;
 
-                        textureEntry.FaceTextures[face] = f;
+                        // we do need to parse the mesh now
+                        OSD osd = OSDParser.DeserializeLLSDBinary(mesh_list[i]);
+                        if (osd is OSDMap)
+                        {
+                            OSDMap mosd = (OSDMap)osd;
+                            if (mosd.ContainsKey("skeleton"))
+                            {
+                                OSDMap skeleton = (OSDMap)mosd["skeleton"];
+                                int sksize = skeleton["size"].AsInteger();
+                                if (sksize > 0)
+                                    curAvSkeleton = true;
+                            }
+                        }
+
+                        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);
+                        meshAvatarSkeletons.Add(curAvSkeleton);
+                        meshAvatarColliders.Add(curAvCollider);
+
+                        // test code 
+                        if (curAvSkeleton && client != null)
+                        {
+                            string name = assetName;
+                            if (name.Length > 25)
+                                name = name.Substring(0, 24);
+                            name += "_Mesh#" + i.ToString();
+                            InventoryItemBase meshitem = new InventoryItemBase();
+                            meshitem.Owner = m_HostCapsObj.AgentID;
+                            meshitem.CreatorId = creatorIDstr;
+                            meshitem.CreatorData = String.Empty;
+                            meshitem.ID = UUID.Random();
+                            meshitem.AssetID = meshAsset.FullID;
+                            meshitem.Description = "mesh ";
+                            meshitem.Name = name;
+                            meshitem.AssetType = (int)AssetType.Mesh;
+                            meshitem.InvType = (int)InventoryType.Mesh;
+                            //                            meshitem.Folder = UUID.Zero; // send to default
+
+                            meshitem.Folder = parentFolder; // dont let it go to folder Meshes that viewers dont show
+
+                            // 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.
+                            meshitem.CurrentPermissions
+                                = (uint)(PermissionMask.Move | PermissionMask.Copy | PermissionMask.Modify | PermissionMask.Transfer);
+
+                            meshitem.BasePermissions = (uint)PermissionMask.All;
+                            meshitem.EveryOnePermissions = 0;
+                            meshitem.NextPermissions = (uint)PermissionMask.All;
+                            meshitem.CreationDate = Util.UnixTimeSinceEpoch();
+
+                            m_Scene.AddInventoryItem(client, meshitem);
+                            meshitem = null;
+                        }
                     }
 
-                    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];
 
-                    AssetBase meshAsset = new AssetBase(UUID.Random(), assetName, (sbyte)AssetType.Mesh, "");
-                    meshAsset.Data = mesh_list[i].AsBinary();
-                    m_assetService.Store(meshAsset);
+                        // skip prims that are 2 small
+                        Vector3 scale = inner_instance_list["scale"].AsVector3();
 
-                    pbs.SculptEntry = true;
-                    pbs.SculptTexture = meshAsset.FullID;
-                    pbs.SculptType = (byte)SculptType.Mesh;
-                    pbs.SculptData = meshAsset.Data;
+                        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;
 
-                    Vector3 position = inner_instance_list["position"].AsVector3();
-                    Vector3 scale = inner_instance_list["scale"].AsVector3();
-                    Quaternion rotation = inner_instance_list["rotation"].AsQuaternion();
+                            if (offsett != 0)
+                                f.OffsetV = offsett;
+
+                            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;
+                        }
+
+                        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"];
@@ -693,24 +1139,49 @@ 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;
+                        prim.EveryoneMask = 0;
+                        prim.GroupMask = 0;
+
+                        if (restrictPerms)
+                        {
+                            prim.BaseMask = (uint)(PermissionMask.Move | PermissionMask.Modify);
+                            prim.OwnerMask = (uint)(PermissionMask.Move | PermissionMask.Modify);
+                            prim.NextOwnerMask = 0;
+                        }
+                        else
+                        {
+                            prim.BaseMask = (uint)PermissionMask.All | (uint)PermissionMask.Export;
+                            prim.OwnerMask = (uint)PermissionMask.All | (uint)PermissionMask.Export;
+                            prim.NextOwnerMask = (uint)PermissionMask.Transfer;
+                        }
 
-                    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;
@@ -718,52 +1189,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);
+                    }
 
-                Vector3 rootPos = positions[0];
+                    Vector3 rootPos = positions[0];
 
-                if (grp.Parts.Length > 1)
-                {
-                    // Fix first link number
-                    grp.RootPart.LinkNum++;
+                    if (grp.Parts.Length > 1)
+                    {
+                        // Fix first link number
+                        grp.RootPart.LinkNum++;
 
-                    Quaternion rootRotConj = Quaternion.Conjugate(rotations[0]);
-                    Quaternion tmprot;
-                    Vector3 offset;
+                        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;
+                        // fix children rotations and positions
+                        for (int i = 1; i < rotations.Count; i++)
+                        {
+                            tmprot = rotations[i];
+                            tmprot = rootRotConj * tmprot;
+
+                            grp.Parts[i].RotationOffset = tmprot;
 
-                        grp.Parts[i].RotationOffset = tmprot;
+                            offset = positions[i] - rootPos;
 
-                        offset = positions[i] - rootPos;
+                            offset *= rootRotConj;
+                            grp.Parts[i].OffsetPosition = offset;
+                        }
 
-                        offset *= rootRotConj;
-                        grp.Parts[i].OffsetPosition = offset;
+                        grp.AbsolutePosition = rootPos;
+                        grp.UpdateGroupRotationR(rotations[0]);
+                    }
+                    else
+                    {
+                        grp.AbsolutePosition = rootPos;
+                        grp.UpdateGroupRotationR(rotations[0]);
                     }
 
-                    grp.AbsolutePosition = rootPos;
-                    grp.UpdateGroupRotationR(rotations[0]);
+                    data = ASCIIEncoding.ASCII.GetBytes(SceneObjectSerializer.ToOriginalXmlFormat(grp));
                 }
-                else
+
+                else // not a mesh model
                 {
-                    grp.AbsolutePosition = rootPos;
-                    grp.UpdateGroupRotationR(rotations[0]);
+                    m_log.ErrorFormat("[CAPS Asset Upload] got unsuported assetType for object upload");
+                    return;
                 }
-
-                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)
@@ -771,11 +1254,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;
@@ -783,18 +1272,61 @@ 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 | PermissionMask.Export);
 
-            item.BasePermissions = (uint)PermissionMask.All | (uint)PermissionMask.Export;
-            item.EveryOnePermissions = 0;
-            item.NextPermissions = (uint)PermissionMask.All;
+            if (inType == (sbyte)CustomInventoryType.AnimationSet)
+            {
+                AnimationSet.setCreateItemPermitions(item);
+            }
+
+            else if (restrictPerms)
+            {
+                item.BasePermissions = (uint)(PermissionMask.Move | PermissionMask.Modify);
+                item.CurrentPermissions = (uint)(PermissionMask.Move | PermissionMask.Modify);
+                item.EveryOnePermissions = 0;
+                item.NextPermissions = 0;
+            }
+            else
+            {
+                item.BasePermissions = (uint)PermissionMask.All | (uint)PermissionMask.Export;
+                item.CurrentPermissions = (uint)PermissionMask.All | (uint)PermissionMask.Export;
+                item.EveryOnePermissions = 0;
+                item.NextPermissions = (uint)PermissionMask.Transfer;
+            }
+
             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>
@@ -995,6 +1527,131 @@ namespace OpenSim.Region.ClientStack.Linden
             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;
+                    }
+                    else
+                    {
+                        OSDMap object_data = new OSDMap();
+                        object_data["linked_set_resource_cost"] = 0;
+                        object_data["resource_cost"] = 0;
+                        object_data["physics_cost"] = 0;
+                        object_data["linked_set_physics_cost"] = 0;
+
+                        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 string UpdateAgentInformation(string request, string path,
                 string param, IOSHttpRequest httpRequest,
                 IOSHttpResponse httpResponse)
@@ -1015,6 +1672,10 @@ namespace OpenSim.Region.ClientStack.Linden
 
     public class AssetUploader
     {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+
         public event UpLoadedAsset OnUpLoad;
         private UpLoadedAsset handlerUpLoad = null;
 
@@ -1029,10 +1690,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;
@@ -1044,6 +1716,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>
@@ -1058,12 +1742,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
@@ -1080,12 +1766,50 @@ 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..546bcd9
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/BunchOfCaps/MeshCost.cs
@@ -0,0 +1,703 @@
+// 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 
+        // avatarSkeleton if mesh includes a avatar skeleton
+        // useAvatarCollider if we should use physics mesh for avatar
+        public bool MeshModelCost(LLSDAssetResource resources, int basicCost, out int totalcost,
+            LLSDAssetUploadResponseData meshcostdata, out string error, ref string warning)
+        {
+            totalcost = 0;
+            error = string.Empty;
+
+            bool avatarSkeleton = false;
+            
+            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;
+
+            bool curskeleton;
+            bool curAvatarPhys;
+
+            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 curskeleton, out curAvatarPhys, out error))
+                    {
+                        return false;
+                    }
+
+                    if (curskeleton)
+                    {
+                        if (avatarSkeleton)
+                        {
+                            error = "model can only contain a avatar skeleton";
+                            return false;
+                        }
+                        avatarSkeleton = true;
+                    }
+                    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 bool skeleton, out bool avatarPhys, 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;
+
+            skeleton = false;
+            avatarPhys = false;
+
+            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("skeleton"))
+            {
+                tmpmap = (OSDMap)map["skeleton"];
+                if (tmpmap.ContainsKey("offset") && tmpmap.ContainsKey("size"))
+                {
+                    int sksize = tmpmap["size"].AsInteger();
+                    if(sksize > 0)
+                        skeleton = true;
+                }               
+            }
+
+            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 9b9f6a7..5fb028c 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueGetModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueGetModule.cs
@@ -78,7 +78,6 @@ namespace OpenSim.Region.ClientStack.Linden
         private Dictionary<UUID, int> m_ids = new Dictionary<UUID, int>();
 
         private Dictionary<UUID, Queue<OSD>> queues = new Dictionary<UUID, Queue<OSD>>();
-        private Dictionary<UUID, UUID> m_QueueUUIDAvatarMapping = new Dictionary<UUID, UUID>();
         private Dictionary<UUID, UUID> m_AvatarQueueUUIDMapping = new Dictionary<UUID, UUID>();
             
         #region INonSharedRegionModule methods
@@ -178,6 +177,7 @@ namespace OpenSim.Region.ClientStack.Linden
         }
 
         /// <summary>
+<<<<<<< HEAD
         ///  Always returns a valid queue
         /// </summary>
         /// <param name="agentId"></param>
@@ -201,6 +201,8 @@ namespace OpenSim.Region.ClientStack.Linden
         }
 
         /// <summary>
+=======
+>>>>>>> avn/ubitvar
         /// May return a null queue
         /// </summary>
         /// <param name="agentId"></param>
@@ -263,28 +265,13 @@ namespace OpenSim.Region.ClientStack.Linden
             lock (queues)
                 queues.Remove(agentID);
 
-            List<UUID> removeitems = new List<UUID>();
             lock (m_AvatarQueueUUIDMapping)
                 m_AvatarQueueUUIDMapping.Remove(agentID);
 
-            UUID searchval = UUID.Zero;
-
-            removeitems.Clear();
-            
-            lock (m_QueueUUIDAvatarMapping)
+            lock (m_ids)
             {
-                foreach (UUID ky in m_QueueUUIDAvatarMapping.Keys)
-                {
-                    searchval = m_QueueUUIDAvatarMapping[ky];
-
-                    if (searchval == agentID)
-                    {
-                        removeitems.Add(ky);
-                    }
-                }
-
-                foreach (UUID ky in removeitems)
-                    m_QueueUUIDAvatarMapping.Remove(ky);
+                if (!m_ids.ContainsKey(agentID))
+                    m_ids.Remove(agentID);
             }
 
             // m_log.DebugFormat("[EVENTQUEUE]: Deleted queues for {0} in region {1}", agentID, m_scene.RegionInfo.RegionName);
@@ -303,61 +290,107 @@ namespace OpenSim.Region.ClientStack.Linden
         public void OnRegisterCaps(UUID agentID, Caps caps)
         {
             // Register an event queue for the client
+<<<<<<< HEAD
 
             if (DebugLevel > 0)
                 m_log.DebugFormat(
                     "[EVENTQUEUE]: OnRegisterCaps: agentID {0} caps {1} region {2}",
                     agentID, caps, m_scene.RegionInfo.RegionName);
-
-            // Let's instantiate a Queue for this agent right now
-            TryGetQueue(agentID);
+=======
+            m_log.DebugFormat(
+                "[EVENTQUEUE]: OnRegisterCaps: agentID {0} caps {1} region {2}",
+                agentID, caps, m_scene.RegionInfo.RegionName);
+>>>>>>> avn/ubitvar
 
             UUID eventQueueGetUUID;
+            Queue<OSD> queue;
+            Random rnd = new Random(Environment.TickCount);
+            int nrnd = rnd.Next(30000000);
+            if (nrnd < 0)
+                nrnd = -nrnd;
 
-            lock (m_AvatarQueueUUIDMapping)
+            lock (queues)
             {
-                // Reuse open queues.  The client does!
-                if (m_AvatarQueueUUIDMapping.ContainsKey(agentID))
+                if (queues.ContainsKey(agentID))
+                    queue = queues[agentID];
+                else
+                    queue = null;
+
+                if (queue == null)
                 {
-                    //m_log.DebugFormat("[EVENTQUEUE]: Found Existing UUID!");
-                    eventQueueGetUUID = m_AvatarQueueUUIDMapping[agentID];
+                    queue = new Queue<OSD>();
+                    queues[agentID] = queue;
+
+                    // push markers to handle old responses still waiting
+                    // this will cost at most viewer getting two forced noevents
+                    // even being a new queue better be safe 
+                    queue.Enqueue(null);
+                    queue.Enqueue(null); // one should be enough
+                    
+                    lock (m_AvatarQueueUUIDMapping)
+                    {
+                        eventQueueGetUUID = UUID.Random();
+                        if (m_AvatarQueueUUIDMapping.ContainsKey(agentID))
+                        {
+                            // oops this should not happen ?
+                            m_log.DebugFormat("[EVENTQUEUE]: Found Existing UUID without a queue");
+                            eventQueueGetUUID = m_AvatarQueueUUIDMapping[agentID];
+                        }
+                        m_AvatarQueueUUIDMapping.Add(agentID, eventQueueGetUUID);
+                    }
+                    lock (m_ids)
+                    {
+                        if (!m_ids.ContainsKey(agentID))
+                            m_ids.Add(agentID, nrnd);
+                        else
+                            m_ids[agentID] = nrnd;
+                    }
                 }
                 else
                 {
-                    eventQueueGetUUID = UUID.Random();
-                    //m_log.DebugFormat("[EVENTQUEUE]: Using random UUID!");
+                    // push markers to handle old responses still waiting
+                    // this will cost at most viewer getting two forced noevents
+                    // even being a new queue better be safe 
+                    queue.Enqueue(null);
+                    queue.Enqueue(null); // one should be enough
+
+                    // reuse or not to reuse TODO FIX
+                    lock (m_AvatarQueueUUIDMapping)
+                    {
+                        // Reuse open queues.  The client does!
+                        // Its reuse caps path not queues those are been reused already
+                        if (m_AvatarQueueUUIDMapping.ContainsKey(agentID))
+                        {
+                            m_log.DebugFormat("[EVENTQUEUE]: Found Existing UUID!");
+                            eventQueueGetUUID = m_AvatarQueueUUIDMapping[agentID];
+                        }
+                        else
+                        {
+                            eventQueueGetUUID = UUID.Random();
+                            m_AvatarQueueUUIDMapping.Add(agentID, eventQueueGetUUID);
+                            m_log.DebugFormat("[EVENTQUEUE]: Using random UUID!");
+                        }
+                    }
+                    lock (m_ids)
+                    {
+                        // change to negative numbers so they are changed at end of sending first marker
+                        // old data on a queue may be sent on a response for a new caps
+                        // but at least will be sent with coerent IDs
+                        if (!m_ids.ContainsKey(agentID))
+                            m_ids.Add(agentID, -nrnd); // should not happen
+                        else
+                            m_ids[agentID] = -m_ids[agentID];
+                    }
                 }
             }
 
-            lock (m_QueueUUIDAvatarMapping)
-            {
-                if (!m_QueueUUIDAvatarMapping.ContainsKey(eventQueueGetUUID))
-                    m_QueueUUIDAvatarMapping.Add(eventQueueGetUUID, agentID);
-            }
-
-            lock (m_AvatarQueueUUIDMapping)
-            {
-                if (!m_AvatarQueueUUIDMapping.ContainsKey(agentID))
-                    m_AvatarQueueUUIDMapping.Add(agentID, eventQueueGetUUID);
-            }
-
             caps.RegisterPollHandler(
                 "EventQueueGet",
                 new PollServiceEventArgs(null, GenerateEqgCapPath(eventQueueGetUUID), HasEvents, GetEvents, NoEvents, agentID, SERVER_EQ_TIME_NO_EVENTS));
-
-            Random rnd = new Random(Environment.TickCount);
-            lock (m_ids)
-            {
-                if (!m_ids.ContainsKey(agentID))
-                    m_ids.Add(agentID, rnd.Next(30000000));
-            }
         }
 
         public bool HasEvents(UUID requestID, UUID agentID)
         {
-            // Don't use this, because of race conditions at agent closing time
-            //Queue<OSD> queue = TryGetQueue(agentID);
-
             Queue<OSD> queue = GetQueue(agentID);
             if (queue != null)
                 lock (queue)
@@ -366,7 +399,8 @@ namespace OpenSim.Region.ClientStack.Linden
                     return queue.Count > 0;
                 }
 
-            return false;
+            //m_log.WarnFormat("POLLED FOR EVENTS BY {0} unknown agent", agentID);
+            return true;
         }
 
         /// <summary>
@@ -395,55 +429,65 @@ namespace OpenSim.Region.ClientStack.Linden
                 return NoEvents(requestID, pAgentId);
             }
 
-            OSD element;
+            OSD element = null;;
+            OSDArray array = new OSDArray();
+            int thisID = 0;
+            bool negativeID = false;
+
             lock (queue)
             {
                 if (queue.Count == 0)
                     return NoEvents(requestID, pAgentId);
-                element = queue.Dequeue(); // 15s timeout
-            }
-
-            int thisID = 0;
-            lock (m_ids)
-                thisID = m_ids[pAgentId];
-
-            OSDArray array = new OSDArray();
-            if (element == null) // didn't have an event in 15s
-            {
-                // Send it a fake event to keep the client polling!   It doesn't like 502s like the proxys say!
-                array.Add(EventQueueHelper.KeepAliveEvent());
-                //m_log.DebugFormat("[EVENTQUEUE]: adding fake event for {0} in region {1}", pAgentId, m_scene.RegionInfo.RegionName);
-            }
-            else
-            {
-                if (DebugLevel > 0)
-                    LogOutboundDebugMessage(element, pAgentId);
 
-                array.Add(element);
+                lock (m_ids)
+                    thisID = m_ids[pAgentId];
 
-                lock (queue)
+                if (thisID < 0)
                 {
-                    while (queue.Count > 0)
-                    {
-                        element = queue.Dequeue();
+                    negativeID = true;
+                    thisID = -thisID;
+                }
+               
+                while (queue.Count > 0)
+                {
+                    element = queue.Dequeue();
+                    // add elements until a marker is found
+                    // so they get into a response
+                    if (element == null)
+                        break;
+                    if (DebugLevel > 0)
+                        LogOutboundDebugMessage(element, pAgentId);
+                    array.Add(element);
+                    thisID++;
+                }
+            }
 
-                        if (DebugLevel > 0)
-                            LogOutboundDebugMessage(element, pAgentId);
+            OSDMap events = null;
 
-                        array.Add(element);
-                        thisID++;
-                    }
-                }
+            if (array.Count > 0)
+            {
+                events = new OSDMap();
+                events.Add("events", array);
+                events.Add("id", new OSDInteger(thisID));
             }
 
-            OSDMap events = new OSDMap();
-            events.Add("events", array);
+            if (negativeID && element == null)
+            {
+                Random rnd = new Random(Environment.TickCount);
+                thisID = rnd.Next(30000000);
+                if (thisID < 0)
+                    thisID = -thisID;
+            }
 
-            events.Add("id", new OSDInteger(thisID));
             lock (m_ids)
             {
                 m_ids[pAgentId] = thisID + 1;
             }
+
+            // if there where no elements before a marker send a NoEvents
+            if (array.Count == 0)
+                return NoEvents(requestID, pAgentId);
+          
             Hashtable responsedata = new Hashtable();
             responsedata["int_response_code"] = 200;
             responsedata["content_type"] = "application/xml";
@@ -461,260 +505,12 @@ namespace OpenSim.Region.ClientStack.Linden
             responsedata["content_type"] = "text/plain";
             responsedata["keepalive"] = false;
             responsedata["reusecontext"] = false;
-            responsedata["str_response_string"] = "Upstream error: ";
-            responsedata["error_status_text"] = "Upstream error:";
+            responsedata["str_response_string"] = "<llsd></llsd>";
+            responsedata["error_status_text"] = "<llsd></llsd>";
             responsedata["http_protocol_version"] = "HTTP/1.0";
             return responsedata;
         }
-
-//        public Hashtable ProcessQueue(Hashtable request, UUID agentID, Caps caps)
-//        {
-//            // TODO: this has to be redone to not busy-wait (and block the thread),
-//            // TODO: as soon as we have a non-blocking way to handle HTTP-requests.
-//
-////            if (m_log.IsDebugEnabled)
-////            {
-////                String debug = "[EVENTQUEUE]: Got request for agent {0} in region {1} from thread {2}: [  ";
-////                foreach (object key in request.Keys)
-////                {
-////                    debug += key.ToString() + "=" + request[key].ToString() + "  ";
-////                }
-////                m_log.DebugFormat(debug + "  ]", agentID, m_scene.RegionInfo.RegionName, System.Threading.Thread.CurrentThread.Name);
-////            }
-//
-//            Queue<OSD> queue = TryGetQueue(agentID);
-//            OSD element;
-//
-//            lock (queue)
-//                element = queue.Dequeue(); // 15s timeout
-//
-//            Hashtable responsedata = new Hashtable();
-//
-//            int thisID = 0;
-//            lock (m_ids)
-//                thisID = m_ids[agentID];
-//
-//            if (element == null)
-//            {
-//                //m_log.ErrorFormat("[EVENTQUEUE]: Nothing to process in " + m_scene.RegionInfo.RegionName);
-//                if (thisID == -1) // close-request
-//                {
-//                    m_log.ErrorFormat("[EVENTQUEUE]: 404 in " + m_scene.RegionInfo.RegionName);
-//                    responsedata["int_response_code"] = 404; //501; //410; //404;
-//                    responsedata["content_type"] = "text/plain";
-//                    responsedata["keepalive"] = false;
-//                    responsedata["str_response_string"] = "Closed EQG";
-//                    return responsedata;
-//                }
-//                responsedata["int_response_code"] = 502;
-//                responsedata["content_type"] = "text/plain";
-//                responsedata["keepalive"] = false;
-//                responsedata["str_response_string"] = "Upstream error: ";
-//                responsedata["error_status_text"] = "Upstream error:";
-//                responsedata["http_protocol_version"] = "HTTP/1.0";
-//                return responsedata;
-//            }
-//
-//            OSDArray array = new OSDArray();
-//            if (element == null) // didn't have an event in 15s
-//            {
-//                // Send it a fake event to keep the client polling!   It doesn't like 502s like the proxys say!
-//                array.Add(EventQueueHelper.KeepAliveEvent());
-//                //m_log.DebugFormat("[EVENTQUEUE]: adding fake event for {0} in region {1}", agentID, m_scene.RegionInfo.RegionName);
-//            }
-//            else
-//            {
-//                array.Add(element);
-//
-//                if (element is OSDMap)
-//                {
-//                    OSDMap ev = (OSDMap)element;
-//                    m_log.DebugFormat(
-//                        "[EVENT QUEUE GET MODULE]: Eq OUT {0} to {1}",
-//                        ev["message"], m_scene.GetScenePresence(agentID).Name);
-//                }
-//
-//                lock (queue)
-//                {
-//                    while (queue.Count > 0)
-//                    {
-//                        element = queue.Dequeue();
-//
-//                        if (element is OSDMap)
-//                        {
-//                            OSDMap ev = (OSDMap)element;
-//                            m_log.DebugFormat(
-//                                "[EVENT QUEUE GET MODULE]: Eq OUT {0} to {1}",
-//                                ev["message"], m_scene.GetScenePresence(agentID).Name);
-//                        }
-//
-//                        array.Add(element);
-//                        thisID++;
-//                    }
-//                }
-//            }
-//
-//            OSDMap events = new OSDMap();
-//            events.Add("events", array);
-//
-//            events.Add("id", new OSDInteger(thisID));
-//            lock (m_ids)
-//            {
-//                m_ids[agentID] = thisID + 1;
-//            }
-//
-//            responsedata["int_response_code"] = 200;
-//            responsedata["content_type"] = "application/xml";
-//            responsedata["keepalive"] = false;
-//            responsedata["str_response_string"] = OSDParser.SerializeLLSDXmlString(events);
-//
-//            m_log.DebugFormat("[EVENTQUEUE]: sending response for {0} in region {1}: {2}", agentID, m_scene.RegionInfo.RegionName, responsedata["str_response_string"]);
-//
-//            return responsedata;
-//        }
-
-//        public Hashtable EventQueuePath2(Hashtable request)
-//        {
-//            string capuuid = (string)request["uri"]; //path.Replace("/CAPS/EQG/","");
-//            // pull off the last "/" in the path.
-//            Hashtable responsedata = new Hashtable();
-//            capuuid = capuuid.Substring(0, capuuid.Length - 1);
-//            capuuid = capuuid.Replace("/CAPS/EQG/", "");
-//            UUID AvatarID = UUID.Zero;
-//            UUID capUUID = UUID.Zero;
-//
-//            // parse the path and search for the avatar with it registered
-//            if (UUID.TryParse(capuuid, out capUUID))
-//            {
-//                lock (m_QueueUUIDAvatarMapping)
-//                {
-//                    if (m_QueueUUIDAvatarMapping.ContainsKey(capUUID))
-//                    {
-//                        AvatarID = m_QueueUUIDAvatarMapping[capUUID];
-//                    }
-//                }
-//                
-//                if (AvatarID != UUID.Zero)
-//                {
-//                    return ProcessQueue(request, AvatarID, m_scene.CapsModule.GetCapsForUser(AvatarID));
-//                }
-//                else
-//                {
-//                    responsedata["int_response_code"] = 404;
-//                    responsedata["content_type"] = "text/plain";
-//                    responsedata["keepalive"] = false;
-//                    responsedata["str_response_string"] = "Not Found";
-//                    responsedata["error_status_text"] = "Not Found";
-//                    responsedata["http_protocol_version"] = "HTTP/1.0";
-//                    return responsedata;
-//                    // return 404
-//                }
-//            }
-//            else
-//            {
-//                responsedata["int_response_code"] = 404;
-//                responsedata["content_type"] = "text/plain";
-//                responsedata["keepalive"] = false;
-//                responsedata["str_response_string"] = "Not Found";
-//                responsedata["error_status_text"] = "Not Found";
-//                responsedata["http_protocol_version"] = "HTTP/1.0";
-//                return responsedata;
-//                // return 404
-//            }
-//        }
-
-        public OSD EventQueueFallBack(string path, OSD request, string endpoint)
-        {
-            // This is a fallback element to keep the client from loosing EventQueueGet
-            // Why does CAPS fail sometimes!?
-            m_log.Warn("[EVENTQUEUE]: In the Fallback handler!   We lost the Queue in the rest handler!");
-            string capuuid = path.Replace("/CAPS/EQG/","");
-            capuuid = capuuid.Substring(0, capuuid.Length - 1);
-
-//            UUID AvatarID = UUID.Zero;
-            UUID capUUID = UUID.Zero;
-            if (UUID.TryParse(capuuid, out capUUID))
-            {
-/* Don't remove this yet code cleaners!
- * Still testing this!
- * 
-                lock (m_QueueUUIDAvatarMapping)
-                {
-                    if (m_QueueUUIDAvatarMapping.ContainsKey(capUUID))
-                    {
-                        AvatarID = m_QueueUUIDAvatarMapping[capUUID];
-                    }
-                }
-                
-                 
-                if (AvatarID != UUID.Zero)
-                {
-                    // Repair the CAP!
-                    //OpenSim.Framework.Capabilities.Caps caps = m_scene.GetCapsHandlerForUser(AvatarID);
-                    //string capsBase = "/CAPS/EQG/";
-                    //caps.RegisterHandler("EventQueueGet",
-                                //new RestHTTPHandler("POST", capsBase + capUUID.ToString() + "/",
-                                                      //delegate(Hashtable m_dhttpMethod)
-                                                      //{
-                                                      //    return ProcessQueue(m_dhttpMethod, AvatarID, caps);
-                                                      //}));
-                    // start new ID sequence.
-                    Random rnd = new Random(System.Environment.TickCount);
-                    lock (m_ids)
-                    {
-                        if (!m_ids.ContainsKey(AvatarID))
-                            m_ids.Add(AvatarID, rnd.Next(30000000));
-                    }
-
-
-                    int thisID = 0;
-                    lock (m_ids)
-                        thisID = m_ids[AvatarID];
-
-                    BlockingLLSDQueue queue = GetQueue(AvatarID);
-                    OSDArray array = new OSDArray();
-                    LLSD element = queue.Dequeue(15000); // 15s timeout
-                    if (element == null)
-                    {
-                        
-                        array.Add(EventQueueHelper.KeepAliveEvent());
-                    }
-                    else
-                    {
-                        array.Add(element);
-                        while (queue.Count() > 0)
-                        {
-                            array.Add(queue.Dequeue(1));
-                            thisID++;
-                        }
-                    }
-                    OSDMap events = new OSDMap();
-                    events.Add("events", array);
-
-                    events.Add("id", new LLSDInteger(thisID));
-                    
-                    lock (m_ids)
-                    {
-                        m_ids[AvatarID] = thisID + 1;
-                    }
-                    
-                    return events;
-                }
-                else
-                {
-                    return new LLSD();
-                }
-* 
-*/
-            }
-            else
-            {
-                //return new LLSD();
-            }
-            
-            return new OSDString("shutdown404!");
-        }
-
+ 
         public void DisableSimulator(ulong handle, UUID avatarID)
         {
             OSD item = EventQueueHelper.DisableSimulator(handle);
@@ -723,9 +519,14 @@ namespace OpenSim.Region.ClientStack.Linden
 
         public virtual void EnableSimulator(ulong handle, IPEndPoint endPoint, UUID avatarID, int regionSizeX, int regionSizeY)
         {
+<<<<<<< HEAD
             if (DebugLevel > 0)
                 m_log.DebugFormat("{0} EnableSimulator. handle={1}, endPoint={2}, avatarID={3}",
                     LogHeader, handle, endPoint, avatarID, regionSizeX, regionSizeY);
+=======
+            m_log.DebugFormat("{0} EnableSimulator. handle={1}, avatarID={2}, regionSize={3},{4}>",
+                LogHeader, handle, avatarID, regionSizeX, regionSizeY);
+>>>>>>> avn/ubitvar
 
             OSD item = EventQueueHelper.EnableSimulator(handle, endPoint, regionSizeX, regionSizeY);
             Enqueue(item, avatarID);
@@ -734,10 +535,15 @@ namespace OpenSim.Region.ClientStack.Linden
         public virtual void EstablishAgentCommunication(UUID avatarID, IPEndPoint endPoint, string capsPath,
                                 ulong regionHandle, int regionSizeX, int regionSizeY) 
         {
+<<<<<<< HEAD
             if (DebugLevel > 0)
                 m_log.DebugFormat("{0} EstablishAgentCommunication. handle={1}, endPoint={2}, avatarID={3}",
                     LogHeader, regionHandle, endPoint, avatarID, regionSizeX, regionSizeY);
 
+=======
+            m_log.DebugFormat("{0} EstablishAgentCommunication. handle={1}, avatarID={2}, regionSize={3},{4}>",
+                LogHeader, regionHandle, avatarID, regionSizeX, regionSizeY);
+>>>>>>> avn/ubitvar
             OSD item = EventQueueHelper.EstablishAgentCommunication(avatarID, endPoint.ToString(), capsPath, regionHandle, regionSizeX, regionSizeY);
             Enqueue(item, avatarID);
         }
@@ -747,9 +553,14 @@ namespace OpenSim.Region.ClientStack.Linden
                                         uint locationID, uint flags, string capsURL, 
                                         UUID avatarID, int regionSizeX, int regionSizeY)
         {
+<<<<<<< HEAD
             if (DebugLevel > 0)
                 m_log.DebugFormat("{0} TeleportFinishEvent. handle={1}, endPoint={2}, avatarID={3}",
                     LogHeader, regionHandle, regionExternalEndPoint, avatarID, regionSizeX, regionSizeY);
+=======
+            m_log.DebugFormat("{0} TeleportFinishEvent. handle={1}, avatarID={2}, regionSize={3},{4}>",
+                LogHeader, regionHandle, avatarID, regionSizeX, regionSizeY);
+>>>>>>> avn/ubitvar
 
             OSD item = EventQueueHelper.TeleportFinishEvent(regionHandle, simAccess, regionExternalEndPoint,
                                                             locationID, flags, capsURL, avatarID, regionSizeX, regionSizeY);
@@ -760,9 +571,14 @@ namespace OpenSim.Region.ClientStack.Linden
                                 IPEndPoint newRegionExternalEndPoint,
                                 string capsURL, UUID avatarID, UUID sessionID, int regionSizeX, int regionSizeY)
         {
+<<<<<<< HEAD
             if (DebugLevel > 0)
                 m_log.DebugFormat("{0} CrossRegion. handle={1}, avatarID={2}, regionSize={3},{4}>",
                     LogHeader, handle, avatarID, regionSizeX, regionSizeY);
+=======
+            m_log.DebugFormat("{0} CrossRegion. handle={1}, avatarID={2}, regionSize={3},{4}>",
+                LogHeader, handle, avatarID, regionSizeX, regionSizeY);
+>>>>>>> avn/ubitvar
 
             OSD item = EventQueueHelper.CrossRegion(handle, pos, lookAt, newRegionExternalEndPoint,
                                                     capsURL, avatarID, sessionID, regionSizeX, regionSizeY);
@@ -827,4 +643,4 @@ namespace OpenSim.Region.ClientStack.Linden
             Enqueue(item, avatarID);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueHelper.cs b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueHelper.cs
index 384af74..8b7e4c1 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueHelper.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueHelper.cs
@@ -77,8 +77,13 @@ namespace OpenSim.Region.ClientStack.Linden
             llsdSimInfo.Add("Handle", new OSDBinary(ulongToByteArray(handle)));
             llsdSimInfo.Add("IP", new OSDBinary(endPoint.Address.GetAddressBytes()));
             llsdSimInfo.Add("Port", new OSDInteger(endPoint.Port));
+<<<<<<< HEAD
             llsdSimInfo.Add("RegionSizeX", OSD.FromUInteger((uint) regionSizeX));
             llsdSimInfo.Add("RegionSizeY", OSD.FromUInteger((uint) regionSizeY));
+=======
+            llsdSimInfo.Add("RegionSizeX", OSD.FromUInteger((uint)regionSizeX));
+            llsdSimInfo.Add("RegionSizeY", OSD.FromUInteger((uint)regionSizeY));
+>>>>>>> avn/ubitvar
 
             OSDArray arr = new OSDArray(1);
             arr.Add(llsdSimInfo);
@@ -157,6 +162,12 @@ namespace OpenSim.Region.ClientStack.Linden
                         uint locationID, uint flags, string capsURL, UUID agentID,
                         int regionSizeX, int regionSizeY)
         {
+            // 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?
@@ -165,7 +176,12 @@ 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));
+<<<<<<< HEAD
             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));
+>>>>>>> avn/ubitvar
             info.Add("RegionSizeX", OSD.FromUInteger((uint)regionSizeX));
             info.Add("RegionSizeY", OSD.FromUInteger((uint)regionSizeY));
 
@@ -204,8 +220,8 @@ namespace OpenSim.Region.ClientStack.Linden
                                   {"sim-ip-and-port", new OSDString(simIpAndPort)},
                                   {"seed-capability", new OSDString(seedcap)},
                                   {"region-handle", OSD.FromULong(regionHandle)},
-                                  {"region-size-x", OSD.FromInteger(regionSizeX)},
-                                  {"region-size-y", OSD.FromInteger(regionSizeY)}
+                                  {"region-size-x", OSD.FromUInteger((uint)regionSizeX)},
+                                  {"region-size-y", OSD.FromUInteger((uint)regionSizeY)}
                               };
 
             return BuildEvent("EstablishAgentCommunication", body);
@@ -412,7 +428,7 @@ namespace OpenSim.Region.ClientStack.Linden
         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;
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/GetMeshModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/GetMeshModule.cs
index f57d857..91efe8a 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,12 +60,51 @@ namespace OpenSim.Region.ClientStack.Linden
         private IAssetService m_AssetService;
         private bool m_Enabled = true;
         private string m_URL;
+<<<<<<< HEAD
         private string m_URL2;
         private string m_RedirectURL = null;
         private string m_RedirectURL2 = null;
+=======
+       
+        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>();
+>>>>>>> avn/ubitvar
 
         #region Region Module interfaceBase Members
 
+        ~GetMeshModule()
+        {
+            foreach (Thread t in m_workerThreads)
+                Watchdog.AbortThread(t.ManagedThreadId);
+
+        }
+
         public Type ReplaceableInterface
         {
             get { return null; }
@@ -87,8 +129,12 @@ namespace OpenSim.Region.ClientStack.Linden
             if (m_URL2 != string.Empty)
             {
                 m_Enabled = true;
+<<<<<<< HEAD
                 m_RedirectURL2 = config.GetString("GetMesh2RedirectURL");
             }
+=======
+         
+>>>>>>> avn/ubitvar
         }
 
         public void AddRegion(Scene pScene)
@@ -97,6 +143,8 @@ namespace OpenSim.Region.ClientStack.Linden
                 return;
 
             m_scene = pScene;
+            
+            m_assetService = pScene.AssetService;
         }
 
         public void RemoveRegion(Scene scene)
@@ -105,6 +153,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;
         }
 
@@ -115,6 +166,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);
+                }
+            }
+
         }
 
 
@@ -124,9 +196,147 @@ 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)
+        {
+            UUID user = p.UUID;
+            int imagethrottle = p.ControllingClient.GetAgentThrottleSilent((int)ThrottleOutPacketType.Asset);
+            PollServiceMeshEventArgs args;
+            if (m_pollservices.TryGetValue(user, out args))
+            {
+                args.UpdateThrottle(imagethrottle, p);
+            }
+        }
+
+        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(string uri, UUID pId, Scene scene) :
+                base(null, uri, 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)
         {
+<<<<<<< HEAD
             UUID capID = UUID.Random();
             bool getMeshRegistered = false;
 
@@ -140,6 +350,35 @@ namespace OpenSim.Region.ClientStack.Linden
                 caps.RegisterHandler(
                     "GetMesh",
                     new GetMeshHandler("/CAPS/" + capID + "/", m_AssetService, "GetMesh", agentID.ToString(), m_RedirectURL));
+=======
+//            UUID capID = UUID.Random();
+            if (m_URL == "localhost")
+            {
+                string capUrl = "/CAPS/" + UUID.Random() + "/";
+
+                // Register this as a poll service           
+                PollServiceMeshEventArgs args = new PollServiceMeshEventArgs(capUrl, agentID, m_scene);
+
+                args.Type = PollServiceEventArgs.EventType.Mesh;
+                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("GetMesh", String.Format("{0}://{1}:{2}{3}", protocol, hostName, port, capUrl));
+                m_pollservices[agentID] = args;
+                m_capsDict[agentID] = capUrl;
+
+
+           
+>>>>>>> avn/ubitvar
             }
             else
             {
@@ -164,6 +403,177 @@ namespace OpenSim.Region.ClientStack.Linden
                 caps.RegisterHandler("GetMesh2", m_URL2);
             }
         }
+        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.Asset;
+                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);
+                        UpdateThrottle(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));
+
+                float udp = 1.0f - CapThrottleDistributon;
+                if(udp < 0.7f)
+                    udp = 0.7f;
+                UDPSetThrottle = (int) ((float)pimagethrottle * udp);
+                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 bb932f2..b9396b7 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,16 +50,44 @@ 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 bool send503;
+        }
+
+        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;
+
+        private string m_Url = "localhost";
+
+        private static OpenMetaverse.BlockingQueue<aPollRequest> m_queue =
+                new OpenMetaverse.BlockingQueue<aPollRequest>();
 
+<<<<<<< HEAD
         // TODO: Change this to a config option
         private string m_RedirectURL = null;
+=======
+        private Dictionary<UUID,PollServiceTextureEventArgs> m_pollservices = new Dictionary<UUID,PollServiceTextureEventArgs>();
+>>>>>>> avn/ubitvar
 
         private string m_URL;
 
@@ -72,6 +96,7 @@ namespace OpenSim.Region.ClientStack.Linden
         public void Initialise(IConfigSource source)
         {
             IConfig config = source.Configs["ClientStack.LindenCaps"];
+<<<<<<< HEAD
             if (config == null)
                 return;
 
@@ -82,32 +107,100 @@ namespace OpenSim.Region.ClientStack.Linden
                 m_Enabled = true;
                 m_RedirectURL = config.GetString("GetTextureRedirectURL");
             }
+=======
+            if (config != null)
+                m_Url = config.GetString("Cap_GetTexture", "localhost");
+>>>>>>> avn/ubitvar
         }
 
         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()
@@ -125,28 +218,306 @@ namespace OpenSim.Region.ClientStack.Linden
 
         #endregion
 
-        public void RegisterCaps(UUID agentID, Caps caps)
+        ~GetTextureModule()
         {
-            UUID capID = UUID.Random();
+            foreach (Thread t in m_workerThreads)
+                Watchdog.AbortThread(t.ManagedThreadId);
 
-            //caps.RegisterHandler("GetTexture", new StreamHandler("GET", "/CAPS/" + capID, ProcessGetTexture));
-            if (m_URL == "localhost")
+        }
+
+        private class PollServiceTextureEventArgs : PollServiceEventArgs
+        {
+            private List<Hashtable> requests =
+                    new List<Hashtable>();
+            private Dictionary<UUID, aPollResponse> responses =
+                    new Dictionary<UUID, aPollResponse>();
+
+            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)              
             {
+<<<<<<< HEAD
 //                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_RedirectURL));
+=======
+                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;
+                    reqinfo.send503 = false;
+                    
+                    lock (responses)
+                    {
+                        if (responses.Count > 0)
+                        {
+                            if (m_queue.Count >= 4)
+                            {
+                                // Never allow more than 4 fetches to wait
+                                reqinfo.send503 = true;
+                            }
+                        }
+                    }
+                    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;
+                };
+>>>>>>> avn/ubitvar
             }
-            else
+
+            public void Process(aPollRequest requestinfo)
             {
-//                m_log.DebugFormat("[GETTEXTURE]: {0} in region {1}", m_URL, m_scene.RegionInfo.RegionName);
+                Hashtable response;
+
+                UUID requestID = requestinfo.reqID;
+
+                if (requestinfo.send503)
+                {
+                    response = new Hashtable();
+
+
+                    response["int_response_code"] = 503;
+                    response["str_response_string"] = "Throttled";
+                    response["content_type"] = "text/plain";
+                    response["keepalive"] = false;
+                    response["reusecontext"] = false;
+
+                    Hashtable headers = new Hashtable();
+                    headers["Retry-After"] = 30;
+                    response["headers"] = headers;
+                    
+                    lock (responses)
+                        responses[requestID] = new aPollResponse() {bytes = 0, response = response};
+
+                    return;
+                }
+
+                // 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)
+        {
+            if (m_Url == "localhost")
+            {
+                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";
+                }
                 IExternalCapsModule handler = m_scene.RequestModuleInterface<IExternalCapsModule>();
                 if (handler != null)
+<<<<<<< HEAD
                     handler.RegisterExternalUserCapsHandler(agentID,caps,"GetTexture", m_URL);
+=======
+                    handler.RegisterExternalUserCapsHandler(agentID, caps, "GetTexture", capUrl);
+>>>>>>> avn/ubitvar
                 else
-                    caps.RegisterHandler("GetTexture", m_URL);
+                    caps.RegisterHandler("GetTexture", String.Format("{0}://{1}:{2}{3}", protocol, hostName, port, capUrl));
+                m_pollservices[agentID] = args;
+                m_capsDict[agentID] = capUrl;
+            }
+            else
+            {
+                caps.RegisterHandler("GetTexture", m_Url);
             }
         }
 
+        private void DeregisterCaps(UUID agentID, Caps caps)
+        {
+            PollServiceTextureEventArgs args;
+
+            MainServer.Instance.RemoveHTTPHandler("", m_URL);
+            m_capsDict.Remove(agentID);
+
+            if (m_pollservices.TryGetValue(agentID, out args))
+            {
+                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))
+                {
+                    // This is any error response
+                    if (response.bytes == 0)
+                        return true;
+
+                    // 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 45d33cd..1b68603 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(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"] = 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();
@@ -148,4 +148,4 @@ namespace OpenSim.Region.ClientStack.Linden
             return responsedata;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/NewFileAgentInventoryVariablePriceModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/NewFileAgentInventoryVariablePriceModule.cs
deleted file mode 100644
index f69a0bb..0000000
--- a/OpenSim/Region/ClientStack/Linden/Caps/NewFileAgentInventoryVariablePriceModule.cs
+++ /dev/null
@@ -1,297 +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;
-using PermissionMask = OpenSim.Framework.PermissionMask;
-
-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 a133a69..5196368 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/SimulatorFeaturesModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/SimulatorFeaturesModule.cs
index e258bcb..54542c9 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/SimulatorFeaturesModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/SimulatorFeaturesModule.cs
@@ -155,8 +155,13 @@ namespace OpenSim.Region.ClientStack.Linden
                 m_features["MeshRezEnabled"] = true;
                 m_features["MeshUploadEnabled"] = true;
                 m_features["MeshXferEnabled"] = true;
+
                 m_features["PhysicsMaterialsEnabled"] = true;
+<<<<<<< HEAD
 
+=======
+   
+>>>>>>> avn/ubitvar
                 OSDMap typesMap = new OSDMap();
                 typesMap["convex"] = true;
                 typesMap["none"] = true;
@@ -164,6 +169,7 @@ namespace OpenSim.Region.ClientStack.Linden
                 m_features["PhysicsShapeTypes"] = typesMap;
 
                 // Extra information for viewers that want to use it
+<<<<<<< HEAD
                 // TODO: Take these out of here into their respective modules, like map-server-url
                 OSDMap extrasMap;
                 if(m_features.ContainsKey("OpenSimExtras"))
@@ -173,6 +179,15 @@ namespace OpenSim.Region.ClientStack.Linden
                 else
                     extrasMap = new OSDMap();
 
+=======
+                
+                OSDMap extrasMap = new OSDMap();
+
+                extrasMap["AvatarSkeleton"] = true;
+                extrasMap["AnimationSet"] = true;
+
+                // TODO: Take these out of here into their respective modules, like map-server-url
+>>>>>>> avn/ubitvar
                 if (m_SearchURL != string.Empty)
                     extrasMap["search-server-url"] = m_SearchURL;
                 if (!string.IsNullOrEmpty(m_DestinationGuideURL))
@@ -184,8 +199,13 @@ namespace OpenSim.Region.ClientStack.Linden
                 if (m_GridName != string.Empty)
                     extrasMap["GridName"] = m_GridName;
 
+<<<<<<< HEAD
                 if (extrasMap.Count > 0)
                     m_features["OpenSimExtras"] = extrasMap;
+=======
+                m_features["OpenSimExtras"] = extrasMap;
+
+>>>>>>> avn/ubitvar
             }
         }
 
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/UploadBakedTextureModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/UploadBakedTextureModule.cs
index 8cdebcd..c27d101 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/UploadBakedTextureModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/UploadBakedTextureModule.cs
@@ -67,6 +67,8 @@ namespace OpenSim.Region.ClientStack.Linden
 
         private IBakedTextureModule m_BakedTextureModule;
 
+        private IBakedTextureModule m_BakedTextureModule;
+
         public void Initialise(IConfigSource source)
         {
             IConfig appearanceConfig = source.Configs["Appearance"];
@@ -89,7 +91,11 @@ namespace OpenSim.Region.ClientStack.Linden
             s.EventManager.OnRemovePresence -= DeRegisterPresence;
             m_BakedTextureModule = null;
             m_scene = null;
+<<<<<<< HEAD
         }
+=======
+        }     
+>>>>>>> avn/ubitvar
 
        
 
@@ -103,6 +109,7 @@ namespace OpenSim.Region.ClientStack.Linden
 
         private void DeRegisterPresence(UUID agentId)
         {
+<<<<<<< HEAD
             ScenePresence presence = null;
             if (m_scene.TryGetScenePresence(agentId, out presence))
             {
@@ -261,8 +268,162 @@ namespace OpenSim.Region.ClientStack.Linden
                     }
                 }
             }
+=======
+//            ScenePresence presence = null;
+//            if (m_scene.TryGetScenePresence(agentId, out presence))
+            {
+//                presence.ControllingClient.OnSetAppearance -= CaptureAppearanceSettings;
+            }
+
+>>>>>>> avn/ubitvar
+        }
+
+        private void RegisterNewPresence(ScenePresence presence)
+        {
+//           presence.ControllingClient.OnSetAppearance += CaptureAppearanceSettings;
         }
 
+/* not in use. work done in AvatarFactoryModule ValidateBakedTextureCache() and UpdateBakedTextureCache()
+                private void CaptureAppearanceSettings(IClientAPI remoteClient, Primitive.TextureEntry textureEntry, byte[] visualParams, Vector3 avSize, WearableCacheItem[] cacheItems)
+                {
+                    // if cacheItems.Length > 0 viewer is giving us current textures information.
+                    // baked ones should had been uploaded and in assets cache as local itens
+
+
+                    if (cacheItems.Length == 0)
+                        return;  // no textures information, nothing to do
+
+                    ScenePresence p = null;
+                    if (!m_scene.TryGetScenePresence(remoteClient.AgentId, out p))
+                        return; // what are we doing if there is no presence to cache for?
+
+                    if (p.IsDeleted)
+                        return; // does this really work?
+
+                    int maxCacheitemsLoop = cacheItems.Length;
+                    if (maxCacheitemsLoop > 20)
+                    {
+                        maxCacheitemsLoop = AvatarWearable.MAX_WEARABLES;
+                        m_log.WarnFormat("[CACHEDBAKES]: Too Many Cache items Provided {0}, the max is {1}.  Truncating!", cacheItems.Length, AvatarWearable.MAX_WEARABLES);
+                    }
+
+                    m_BakedTextureModule = m_scene.RequestModuleInterface<IBakedTextureModule>();
+
+
+                    // some nice debug
+                    m_log.Debug("[Cacheitems]: " + cacheItems.Length);
+                    for (int iter = 0; iter < maxCacheitemsLoop; iter++)
+                    {
+                        m_log.Debug("[Cacheitems] {" + iter + "/" + cacheItems[iter].TextureIndex + "}: c-" + cacheItems[iter].CacheId + ", t-" +
+                                          cacheItems[iter].TextureID);
+                    }
+
+                    // p.Appearance.WearableCacheItems is in memory primary cashID to textures mapper
+
+                    WearableCacheItem[] existingitems = p.Appearance.WearableCacheItems;
+
+                    if (existingitems == null)
+                    {
+                        if (m_BakedTextureModule != null)
+                        {
+                            WearableCacheItem[] savedcache = null;
+                            try
+                            {
+                                if (p.Appearance.WearableCacheItemsDirty)
+                                {
+                                    savedcache = m_BakedTextureModule.Get(p.UUID);
+                                    p.Appearance.WearableCacheItems = savedcache;
+                                    p.Appearance.WearableCacheItemsDirty = false;
+                                }
+                            }
+
+                            catch (Exception)
+                            {
+                                // The service logs a sufficient error message.
+                            }
+
+
+                            if (savedcache != null)
+                                existingitems = savedcache;
+                        }
+                    }
+
+                    // Existing items null means it's a fully new appearance
+                    if (existingitems == null)
+                    {
+                        for (int i = 0; i < maxCacheitemsLoop; i++)
+                        {
+                            if (textureEntry.FaceTextures.Length > cacheItems[i].TextureIndex)
+                            {
+                                Primitive.TextureEntryFace face = textureEntry.FaceTextures[cacheItems[i].TextureIndex];
+                                if (face == null)
+                                {
+                                    textureEntry.CreateFace(cacheItems[i].TextureIndex);
+                                    textureEntry.FaceTextures[cacheItems[i].TextureIndex].TextureID =
+                                        AppearanceManager.DEFAULT_AVATAR_TEXTURE;
+                                    continue;
+                                }
+                                cacheItems[i].TextureID = face.TextureID;
+                                if (m_scene.AssetService != null)
+                                    cacheItems[i].TextureAsset =
+                                        m_scene.AssetService.GetCached(cacheItems[i].TextureID.ToString());
+                            }
+                            else
+                            {
+                                m_log.WarnFormat("[CACHEDBAKES]: Invalid Texture Index Provided, Texture doesn't exist or hasn't been uploaded yet {0}, the max is {1}.  Skipping!", cacheItems[i].TextureIndex, textureEntry.FaceTextures.Length);
+                            }
+                        }
+                    }
+                    else
+                    {               
+                        for (int i = 0; i < maxCacheitemsLoop; i++)
+                        {
+                            if (textureEntry.FaceTextures.Length > cacheItems[i].TextureIndex)
+                            {
+                                Primitive.TextureEntryFace face = textureEntry.FaceTextures[cacheItems[i].TextureIndex];
+                                if (face == null)
+                                {
+                                    textureEntry.CreateFace(cacheItems[i].TextureIndex);
+                                    textureEntry.FaceTextures[cacheItems[i].TextureIndex].TextureID =
+                                        AppearanceManager.DEFAULT_AVATAR_TEXTURE;
+                                    continue;
+                                }
+                                cacheItems[i].TextureID =
+                                    face.TextureID;
+                            }
+                            else
+                            {
+                                m_log.WarnFormat("[CACHEDBAKES]: Invalid Texture Index Provided, Texture doesn't exist or hasn't been uploaded yet {0}, the max is {1}.  Skipping!", cacheItems[i].TextureIndex, textureEntry.FaceTextures.Length);
+                            }
+                        }
+
+                        for (int i = 0; i < maxCacheitemsLoop; i++)
+                        {
+                            if (cacheItems[i].TextureAsset == null)
+                            {
+                                cacheItems[i].TextureAsset =
+                                    m_scene.AssetService.GetCached(cacheItems[i].TextureID.ToString());
+                            }
+                        }
+                    }
+                    p.Appearance.WearableCacheItems = cacheItems;
+
+                    if (m_BakedTextureModule != null)
+                    {
+                        m_BakedTextureModule.Store(remoteClient.AgentId, cacheItems);
+                        p.Appearance.WearableCacheItemsDirty = true;
+
+                    }
+                    else
+                        p.Appearance.WearableCacheItemsDirty = false;
+
+                    for (int iter = 0; iter < maxCacheitemsLoop; iter++)
+                    {
+                        m_log.Debug("[CacheitemsLeaving] {" + iter + "/" + cacheItems[iter].TextureIndex + "}: c-" + cacheItems[iter].CacheId + ", t-" +
+                                          cacheItems[iter].TextureID);
+                    }
+                }
+        */
         public void PostInitialise()
         {
         }
@@ -283,6 +444,7 @@ namespace OpenSim.Region.ClientStack.Linden
             UploadBakedTextureHandler avatarhandler = new UploadBakedTextureHandler(
                 caps, m_scene.AssetService, m_persistBakedTextures);
 
+<<<<<<< HEAD
            
             
             caps.RegisterHandler(
@@ -297,6 +459,28 @@ namespace OpenSim.Region.ClientStack.Linden
            
             
 
+=======
+            //caps.RegisterHandler("GetTexture", new StreamHandler("GET", "/CAPS/" + capID, ProcessGetTexture));
+            if (m_URL == "localhost")
+            {
+                UploadBakedTextureHandler avatarhandler = new UploadBakedTextureHandler(
+                    caps, m_scene.AssetService, m_persistBakedTextures);
+
+                caps.RegisterHandler(
+                    "UploadBakedTexture",
+                    new RestStreamHandler(
+                        "POST",
+                        "/CAPS/" + caps.CapsObjectPath + m_uploadBakedTexturePath,
+                        avatarhandler.UploadBakedTexture,
+                        "UploadBakedTexture",
+                        agentID.ToString()));
+                
+            }
+            else
+            {
+                caps.RegisterHandler("UploadBakedTexture", m_URL);
+            }
+>>>>>>> avn/ubitvar
         }
     }
 }
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/WebFetchInvDescModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/WebFetchInvDescModule.cs
index 025ffea..92f8c51 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/WebFetchInvDescModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/WebFetchInvDescModule.cs
@@ -34,9 +34,7 @@ using log4net;
 using Nini.Config;
 using Mono.Addins;
 using OpenMetaverse;
-using OpenMetaverse.StructuredData;
 using OpenSim.Framework;
-using OpenSim.Framework.Monitoring;
 using OpenSim.Framework.Servers;
 using OpenSim.Framework.Servers.HttpServer;
 using OpenSim.Region.Framework.Interfaces;
@@ -45,6 +43,9 @@ using OpenSim.Framework.Capabilities;
 using OpenSim.Services.Interfaces;
 using Caps = OpenSim.Framework.Capabilities.Caps;
 using OpenSim.Capabilities.Handlers;
+using OpenSim.Framework.Monitoring;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
 
 namespace OpenSim.Region.ClientStack.Linden
 {
@@ -63,7 +64,11 @@ namespace OpenSim.Region.ClientStack.Linden
             public List<UUID> folders;
         }
 
+<<<<<<< HEAD
          private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+=======
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+>>>>>>> avn/ubitvar
 
         /// <summary>
         /// Control whether requests will be processed asynchronously.
@@ -312,7 +317,8 @@ namespace OpenSim.Region.ClientStack.Linden
                         {
                             if (!reqinfo.folders.Contains(folderID))
                             {
-                                //TODO: Port COF handling from Avination
+                                if (sp.COF != UUID.Zero && sp.COF == folderID)
+                                    highPriority = true;
                                 reqinfo.folders.Add(folderID);
                             }
                         }