10 files changed, 349 insertions, 127 deletions

diff --git a/OpenSim/Capabilities/Caps.cs b/OpenSim/Capabilities/Caps.cs
index bc6f6f9..241fef3 100644
--- a/OpenSim/Capabilities/Caps.cs
+++ b/OpenSim/Capabilities/Caps.cs
@@ -30,6 +30,7 @@ using System.Collections;
 using System.Collections.Generic;
 using System.IO;
 using System.Reflection;
+using System.Threading;
 using log4net;
 using Nini.Config;
 using OpenMetaverse;
@@ -68,6 +69,7 @@ namespace OpenSim.Framework.Capabilities
         private IHttpServer m_httpListener;
         private UUID m_agentID;
         private string m_regionName;
+        private ManualResetEvent m_capsActive = new ManualResetEvent(false);
 
         public UUID AgentID
         {
@@ -171,5 +173,16 @@ namespace OpenSim.Framework.Capabilities
                 }
             }
         }
+
+        public void Activate()
+        {
+            m_capsActive.Set();
+        }
+
+        public bool WaitForActivation()
+        {
+            // Wait for 30s. If that elapses, return false and run without caps
+            return m_capsActive.WaitOne(30000);
+        }
     }
 }
diff --git a/OpenSim/Capabilities/Handlers/GetMesh/GetMeshHandler.cs b/OpenSim/Capabilities/Handlers/GetMesh/GetMeshHandler.cs
index 720640e..ec574a3 100644
--- a/OpenSim/Capabilities/Handlers/GetMesh/GetMeshHandler.cs
+++ b/OpenSim/Capabilities/Handlers/GetMesh/GetMeshHandler.cs
@@ -45,16 +45,54 @@ namespace OpenSim.Capabilities.Handlers
 {
     public class GetMeshHandler 
     {
-//        private static readonly ILog m_log =
-//            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly ILog m_log =
+                   LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
         
         private IAssetService m_assetService;
 
+        public const string DefaultFormat = "vnd.ll.mesh";
+        
         public GetMeshHandler(IAssetService assService)
         {
             m_assetService = assService;
         }
+        public Hashtable Handle(Hashtable request)
+        {
+            Hashtable ret = new Hashtable();
+            ret["int_response_code"] = (int)System.Net.HttpStatusCode.NotFound;
+            ret["content_type"] = "text/plain";
+            ret["keepalive"] = false;
+            ret["reusecontext"] = false;
+            ret["int_bytes"] = 0;
+            ret["int_lod"] = 0;
+            string MeshStr = (string)request["mesh_id"];
+            
+
+            //m_log.DebugFormat("[GETMESH]: called {0}", MeshStr);
+
+            if (m_assetService == null)
+            {
+                m_log.Error("[GETMESH]: Cannot fetch mesh " + MeshStr + " without an asset service");
+            }
+
+            UUID meshID;
+            if (!String.IsNullOrEmpty(MeshStr) && UUID.TryParse(MeshStr, out meshID))
+            {
+                //                m_log.DebugFormat("[GETMESH]: Received request for mesh id {0}", meshID);
 
+               
+                ret = ProcessGetMesh(request, UUID.Zero, null);
+                       
+                
+            }
+            else
+            {
+                m_log.Warn("[GETMESH]: Failed to parse a mesh_id from GetMesh request: " + (string)request["uri"]);
+            }
+
+            
+            return ret;
+        }
         public Hashtable ProcessGetMesh(Hashtable request, UUID AgentId, Caps cap)
         {
             Hashtable responsedata = new Hashtable();
@@ -62,6 +100,9 @@ namespace OpenSim.Capabilities.Handlers
             responsedata["content_type"] = "text/plain";
             responsedata["keepalive"] = false;
             responsedata["str_response_string"] = "Request wasn't what was expected";
+            responsedata["reusecontext"] = false;
+            responsedata["int_lod"] = 0;
+            responsedata["int_bytes"] = 0;
 
             string meshStr = string.Empty;
 
@@ -77,6 +118,7 @@ namespace OpenSim.Capabilities.Handlers
                     responsedata["content_type"] = "text/plain";
                     responsedata["keepalive"] = false;
                     responsedata["str_response_string"] = "The asset service is unavailable.  So is your mesh.";
+                    responsedata["reusecontext"] = false;
                     return responsedata;
                 }
 
@@ -86,9 +128,100 @@ namespace OpenSim.Capabilities.Handlers
                 {
                     if (mesh.Type == (SByte)AssetType.Mesh)
                     {
-                        responsedata["str_response_string"] = Convert.ToBase64String(mesh.Data);
-                        responsedata["content_type"] = "application/vnd.ll.mesh";
-                        responsedata["int_response_code"] = 200;
+
+                        Hashtable headers = new Hashtable();
+                        responsedata["headers"] = headers;
+
+                        string range = String.Empty;
+
+                        if (((Hashtable)request["headers"])["range"] != null)
+                            range = (string)((Hashtable)request["headers"])["range"];
+
+                        else if (((Hashtable)request["headers"])["Range"] != null)
+                            range = (string)((Hashtable)request["headers"])["Range"];
+
+                        if (!String.IsNullOrEmpty(range)) // Mesh Asset LOD // Physics
+                        {
+                             // Range request
+                            int start, end;
+                            if (TryParseRange(range, out start, out end))
+                            {
+                                 // Before clamping start make sure we can satisfy it in order to avoid
+                    // sending back the last byte instead of an error status
+                                if (start >= mesh.Data.Length)
+                                {
+                                    responsedata["int_response_code"] = 404; //501; //410; //404;
+                                    responsedata["content_type"] = "text/plain";
+                                    responsedata["keepalive"] = false;
+                                    responsedata["str_response_string"] = "This range doesnt exist.";
+                                    responsedata["reusecontext"] = false;
+                                    responsedata["int_lod"] = 3;
+                                    return responsedata;
+                                }
+                                else
+                                {
+                                    end = Utils.Clamp(end, 0, mesh.Data.Length - 1);
+                                    start = Utils.Clamp(start, 0, end);
+                                    int len = end - start + 1;
+
+                                    //m_log.Debug("Serving " + start + " to " + end + " of " + texture.Data.Length + " bytes for texture " + texture.ID);
+
+                                    if (start > 20000)
+                                    {
+                                        responsedata["int_lod"] = 3;
+                                    }
+                                    else if (start < 4097)
+                                    {
+                                        responsedata["int_lod"] = 1;
+                                    }
+                                    else
+                                    {
+                                        responsedata["int_lod"] = 2;
+                                    }
+
+                                    
+                                    if (start == 0 && len == mesh.Data.Length) // well redudante maybe
+                                    {
+                                        responsedata["int_response_code"] = (int) System.Net.HttpStatusCode.OK;
+                                        responsedata["bin_response_data"] = mesh.Data;
+                                        responsedata["int_bytes"] = mesh.Data.Length;
+                                        responsedata["reusecontext"] = false;
+                                        responsedata["int_lod"] = 3;
+                                        
+                                    }
+                                    else
+                                    {
+                                        responsedata["int_response_code"] =
+                                            (int) System.Net.HttpStatusCode.PartialContent;
+                                        headers["Content-Range"] = String.Format("bytes {0}-{1}/{2}", start, end,
+                                                                                 mesh.Data.Length);
+
+                                        byte[] d = new byte[len];
+                                        Array.Copy(mesh.Data, start, d, 0, len);
+                                        responsedata["bin_response_data"] = d;
+                                        responsedata["int_bytes"] = len;
+                                        responsedata["reusecontext"] = false;
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                m_log.Warn("[GETMESH]: Failed to parse a range from GetMesh request, sending full asset: " + (string)request["uri"]);
+                                responsedata["str_response_string"] = Convert.ToBase64String(mesh.Data);
+                                responsedata["content_type"] = "application/vnd.ll.mesh";
+                                responsedata["int_response_code"] = 200;
+                                responsedata["reusecontext"] = false;
+                                responsedata["int_lod"] = 3;
+                            }
+                        }
+                        else
+                        {
+                            responsedata["str_response_string"] = Convert.ToBase64String(mesh.Data);
+                            responsedata["content_type"] = "application/vnd.ll.mesh";
+                            responsedata["int_response_code"] = 200;
+                            responsedata["reusecontext"] = false;
+                            responsedata["int_lod"] = 3;
+                        }
                     }
                     // Optionally add additional mesh types here
                     else
@@ -97,6 +230,8 @@ namespace OpenSim.Capabilities.Handlers
                         responsedata["content_type"] = "text/plain";
                         responsedata["keepalive"] = false;
                         responsedata["str_response_string"] = "Unfortunately, this asset isn't a mesh.";
+                        responsedata["reusecontext"] = false;
+                        responsedata["int_lod"] = 1;
                         return responsedata;
                     }
                 }
@@ -106,11 +241,28 @@ namespace OpenSim.Capabilities.Handlers
                     responsedata["content_type"] = "text/plain";
                     responsedata["keepalive"] = false;
                     responsedata["str_response_string"] = "Your Mesh wasn't found.  Sorry!";
+                    responsedata["reusecontext"] = false;
+                    responsedata["int_lod"] = 0;
                     return responsedata;
                 }
             }
 
             return responsedata;
         }
+        private bool TryParseRange(string header, out int start, out int end)
+        {
+            if (header.StartsWith("bytes="))
+            {
+                string[] rangeValues = header.Substring(6).Split('-');
+                if (rangeValues.Length == 2)
+                {
+                    if (Int32.TryParse(rangeValues[0], out start) && Int32.TryParse(rangeValues[1], out end))
+                        return true;
+                }
+            }
+
+            start = end = 0;
+            return false;
+        }
     }
 }
\ No newline at end of file
diff --git a/OpenSim/Capabilities/Handlers/GetTexture/GetTextureHandler.cs b/OpenSim/Capabilities/Handlers/GetTexture/GetTextureHandler.cs
index b497fde..aa6203b 100644
--- a/OpenSim/Capabilities/Handlers/GetTexture/GetTextureHandler.cs
+++ b/OpenSim/Capabilities/Handlers/GetTexture/GetTextureHandler.cs
@@ -47,36 +47,36 @@ using Caps = OpenSim.Framework.Capabilities.Caps;
 
 namespace OpenSim.Capabilities.Handlers
 {
-    public class GetTextureHandler : BaseStreamHandler
+    public class GetTextureHandler
     {
         private static readonly ILog m_log =
             LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
         private IAssetService m_assetService;
 
         public const string DefaultFormat = "x-j2c";
 
-        // TODO: Change this to a config option
-        const string REDIRECT_URL = null;
-
-        public GetTextureHandler(string path, IAssetService assService, string name, string description)
-            : base("GET", path, name, description)
+        public GetTextureHandler(IAssetService assService)
         {
             m_assetService = assService;
         }
 
-        public override byte[] Handle(string path, Stream request, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        public Hashtable Handle(Hashtable request)
         {
-            // Try to parse the texture ID from the request URL
-            NameValueCollection query = HttpUtility.ParseQueryString(httpRequest.Url.Query);
-            string textureStr = query.GetOne("texture_id");
-            string format = query.GetOne("format");
+            Hashtable ret = new Hashtable();
+            ret["int_response_code"] = (int)System.Net.HttpStatusCode.NotFound;
+            ret["content_type"] = "text/plain";
+            ret["keepalive"] = false;
+            ret["reusecontext"] = false;
+            ret["int_bytes"] = 0;
+            string textureStr = (string)request["texture_id"];
+            string format = (string)request["format"];
 
             //m_log.DebugFormat("[GETTEXTURE]: called {0}", textureStr);
 
             if (m_assetService == null)
             {
                 m_log.Error("[GETTEXTURE]: Cannot fetch texture " + textureStr + " without an asset service");
-                httpResponse.StatusCode = (int)System.Net.HttpStatusCode.NotFound;
             }
 
             UUID textureID;
@@ -91,30 +91,41 @@ namespace OpenSim.Capabilities.Handlers
                 }
                 else
                 {
-                    formats = WebUtil.GetPreferredImageTypes(httpRequest.Headers.Get("Accept"));
+                    formats = new string[1] { DefaultFormat }; // default
+                    if (((Hashtable)request["headers"])["Accept"] != null)
+                        formats = WebUtil.GetPreferredImageTypes((string)((Hashtable)request["headers"])["Accept"]);
                     if (formats.Length == 0)
                         formats = new string[1] { DefaultFormat }; // default
 
                 }
                 // OK, we have an array with preferred formats, possibly with only one entry
-
-                httpResponse.StatusCode = (int)System.Net.HttpStatusCode.NotFound;
+                bool foundtexture = false;
                 foreach (string f in formats)
                 {
-                    if (FetchTexture(httpRequest, httpResponse, textureID, f))
+                    foundtexture = FetchTexture(request, ret, textureID, f);
+                    if (foundtexture)
                         break;
                 }
+                if (!foundtexture)
+                {
+                    ret["int_response_code"] = 404;
+                    ret["error_status_text"] = "not found";
+                    ret["str_response_string"] = "not found";
+                    ret["content_type"] = "text/plain";
+                    ret["keepalive"] = false;
+                    ret["reusecontext"] = false;
+                    ret["int_bytes"] = 0;
+                }
             }
             else
             {
-                m_log.Warn("[GETTEXTURE]: Failed to parse a texture_id from GetTexture request: " + httpRequest.Url);
+                m_log.Warn("[GETTEXTURE]: Failed to parse a texture_id from GetTexture request: " + (string)request["uri"]);
             }
 
 //            m_log.DebugFormat(
 //                "[GETTEXTURE]: For texture {0} sending back response {1}, data length {2}",
 //                textureID, httpResponse.StatusCode, httpResponse.ContentLength);
-
-            return null;
+            return ret;
         }
 
         /// <summary>
@@ -125,7 +136,7 @@ namespace OpenSim.Capabilities.Handlers
         /// <param name="textureID"></param>
         /// <param name="format"></param>
         /// <returns>False for "caller try another codec"; true otherwise</returns>
-        private bool FetchTexture(IOSHttpRequest httpRequest, IOSHttpResponse httpResponse, UUID textureID, string format)
+        private bool FetchTexture(Hashtable request, Hashtable response, UUID textureID, string format)
         {
 //            m_log.DebugFormat("[GETTEXTURE]: {0} with requested format {1}", textureID, format);
             AssetBase texture;
@@ -134,84 +145,69 @@ namespace OpenSim.Capabilities.Handlers
             if (format != DefaultFormat)
                 fullID = fullID + "-" + format;
 
-            if (!String.IsNullOrEmpty(REDIRECT_URL))
+            // try the cache
+            texture = m_assetService.GetCached(fullID);
+
+            if (texture == null)
             {
-                // Only try to fetch locally cached textures. Misses are redirected
-                texture = m_assetService.GetCached(fullID);
+                //m_log.DebugFormat("[GETTEXTURE]: texture was not in the cache");
+
+                // Fetch locally or remotely. Misses return a 404
+                texture = m_assetService.Get(textureID.ToString());
 
                 if (texture != null)
                 {
                     if (texture.Type != (sbyte)AssetType.Texture)
+                        return true;
+
+                    if (format == DefaultFormat)
                     {
-                        httpResponse.StatusCode = (int)System.Net.HttpStatusCode.NotFound;
+                        WriteTextureData(request, response, texture, format);
                         return true;
                     }
-                    WriteTextureData(httpRequest, httpResponse, texture, format);
-                }
-                else
-                {
-                    string textureUrl = REDIRECT_URL + textureID.ToString();
-                    m_log.Debug("[GETTEXTURE]: Redirecting texture request to " + textureUrl);
-                    httpResponse.RedirectLocation = textureUrl;
-                    return true;
-                }
-            }
-            else // no redirect
-            {
-                // try the cache
-                texture = m_assetService.GetCached(fullID);
-
-                if (texture == null)
-                {
-//                    m_log.DebugFormat("[GETTEXTURE]: texture was not in the cache");
-
-                    // Fetch locally or remotely. Misses return a 404
-                    texture = m_assetService.Get(textureID.ToString());
-
-                    if (texture != null)
+                    else
                     {
-                        if (texture.Type != (sbyte)AssetType.Texture)
-                        {
-                            httpResponse.StatusCode = (int)System.Net.HttpStatusCode.NotFound;
-                            return true;
-                        }
-                        if (format == DefaultFormat)
-                        {
-                            WriteTextureData(httpRequest, httpResponse, texture, format);
-                            return true;
-                        }
-                        else
-                        {
-                            AssetBase newTexture = new AssetBase(texture.ID + "-" + format, texture.Name, (sbyte)AssetType.Texture, texture.Metadata.CreatorID);
-                            newTexture.Data = ConvertTextureData(texture, format);
-                            if (newTexture.Data.Length == 0)
-                                return false; // !!! Caller try another codec, please!
-
-                            newTexture.Flags = AssetFlags.Collectable;
-                            newTexture.Temporary = true;
-                            m_assetService.Store(newTexture);
-                            WriteTextureData(httpRequest, httpResponse, newTexture, format);
-                            return true;
-                        }
+                        AssetBase newTexture = new AssetBase(texture.ID + "-" + format, texture.Name, (sbyte)AssetType.Texture, texture.Metadata.CreatorID);
+                        newTexture.Data = ConvertTextureData(texture, format);
+                        if (newTexture.Data.Length == 0)
+                            return false; // !!! Caller try another codec, please!
+
+                        newTexture.Flags = AssetFlags.Collectable;
+                        newTexture.Temporary = true;
+                        m_assetService.Store(newTexture);
+                        WriteTextureData(request, response, newTexture, format);
+                        return true;
                     }
-               }
-               else // it was on the cache
-               {
-//                   m_log.DebugFormat("[GETTEXTURE]: texture was in the cache");
-                   WriteTextureData(httpRequest, httpResponse, texture, format);
-                   return true;
-               }
-            }
-
+                }
+           }
+           else // it was on the cache
+           {
+               //m_log.DebugFormat("[GETTEXTURE]: texture was in the cache");
+               WriteTextureData(request, response, texture, format);
+               return true;
+           }
+
+            //response = new Hashtable();
+
+           
+            //WriteTextureData(request,response,null,format);
             // not found
-//            m_log.Warn("[GETTEXTURE]: Texture " + textureID + " not found");
-            httpResponse.StatusCode = (int)System.Net.HttpStatusCode.NotFound;
-            return true;
+            //m_log.Warn("[GETTEXTURE]: Texture " + textureID + " not found");
+            return false;
         }
 
-        private void WriteTextureData(IOSHttpRequest request, IOSHttpResponse response, AssetBase texture, string format)
+        private void WriteTextureData(Hashtable request, Hashtable response, AssetBase texture, string format)
         {
-            string range = request.Headers.GetOne("Range");
+            Hashtable headers = new Hashtable();
+            response["headers"] = headers;
+
+            string range = String.Empty;
+
+            if (((Hashtable)request["headers"])["range"] != null)
+                range = (string)((Hashtable)request["headers"])["range"];
+
+            else if (((Hashtable)request["headers"])["Range"] != null)
+                range = (string)((Hashtable)request["headers"])["Range"];
 
             if (!String.IsNullOrEmpty(range)) // JP2's only
             {
@@ -239,10 +235,8 @@ namespace OpenSim.Capabilities.Handlers
                         // However, if we return PartialContent (or OK) instead, the viewer will display that resolution.
 
 //                        response.StatusCode = (int)System.Net.HttpStatusCode.RequestedRangeNotSatisfiable;
-//                        response.AddHeader("Content-Range", String.Format("bytes */{0}", texture.Data.Length));
-//                        response.StatusCode = (int)System.Net.HttpStatusCode.OK;
-                        response.StatusCode = (int)System.Net.HttpStatusCode.PartialContent;
-                        response.ContentType = texture.Metadata.ContentType;
+                        // viewers don't seem to handle RequestedRangeNotSatisfiable and keep retrying with same parameters
+                        response["int_response_code"] = (int)System.Net.HttpStatusCode.NotFound;
                     }
                     else
                     {
@@ -257,41 +251,46 @@ namespace OpenSim.Capabilities.Handlers
 
 //                        m_log.Debug("Serving " + start + " to " + end + " of " + texture.Data.Length + " bytes for texture " + texture.ID);
 
-                        // Always return PartialContent, even if the range covered the entire data length
-                        // We were accidentally sending back 404 before in this situation
-                        // https://issues.apache.org/bugzilla/show_bug.cgi?id=51878 supports sending 206 even if the
-                        // entire range is requested, and viewer 3.2.2 (and very probably earlier) seems fine with this.
-                        //
-                        // We also do not want to send back OK even if the whole range was satisfiable since this causes
-                        // HTTP textures on at least Imprudence 1.4.0-beta2 to never display the final texture quality.
-//                        if (end > maxEnd)
-//                            response.StatusCode = (int)System.Net.HttpStatusCode.OK;
-//                        else
-                        response.StatusCode = (int)System.Net.HttpStatusCode.PartialContent;
-
-                        response.ContentLength = len;
-                        response.ContentType = texture.Metadata.ContentType;
-                        response.AddHeader("Content-Range", String.Format("bytes {0}-{1}/{2}", start, end, texture.Data.Length));
-    
-                        response.Body.Write(texture.Data, start, len);
+                        response["content-type"] = texture.Metadata.ContentType;
+
+                        if (start == 0 && len == texture.Data.Length) // well redudante maybe
+                        {
+                            response["int_response_code"] = (int)System.Net.HttpStatusCode.OK;
+                            response["bin_response_data"] = texture.Data;
+                            response["int_bytes"] = texture.Data.Length;
+                        }
+                        else
+                        {
+                            response["int_response_code"] = (int)System.Net.HttpStatusCode.PartialContent;
+                            headers["Content-Range"] = String.Format("bytes {0}-{1}/{2}", start, end, texture.Data.Length);
+
+                            byte[] d = new byte[len];
+                            Array.Copy(texture.Data, start, d, 0, len);
+                            response["bin_response_data"] = d;
+                            response["int_bytes"] = len;
+                        }
+//                        response.Body.Write(texture.Data, start, len);
                     }
                 }
                 else
                 {
                     m_log.Warn("[GETTEXTURE]: Malformed Range header: " + range);
-                    response.StatusCode = (int)System.Net.HttpStatusCode.BadRequest;
+                    response["int_response_code"] = (int)System.Net.HttpStatusCode.BadRequest;
                 }
             }
             else // JP2's or other formats
             {
                 // Full content request
-                response.StatusCode = (int)System.Net.HttpStatusCode.OK;
-                response.ContentLength = texture.Data.Length;
+                response["int_response_code"] = (int)System.Net.HttpStatusCode.OK;
                 if (format == DefaultFormat)
-                    response.ContentType = texture.Metadata.ContentType;
+                    response["content_type"] = texture.Metadata.ContentType;
                 else
-                    response.ContentType = "image/" + format;
-                response.Body.Write(texture.Data, 0, texture.Data.Length);
+                    response["content_type"] = "image/" + format;
+                
+                response["bin_response_data"] = texture.Data;
+                response["int_bytes"] = texture.Data.Length;
+
+//                response.Body.Write(texture.Data, 0, texture.Data.Length);
             }
 
 //            if (response.StatusCode < 200 || response.StatusCode > 299)
@@ -423,4 +422,4 @@ namespace OpenSim.Capabilities.Handlers
             return null;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Capabilities/Handlers/GetTexture/GetTextureServerConnector.cs b/OpenSim/Capabilities/Handlers/GetTexture/GetTextureServerConnector.cs
index 71cf033..bf66acb 100644
--- a/OpenSim/Capabilities/Handlers/GetTexture/GetTextureServerConnector.cs
+++ b/OpenSim/Capabilities/Handlers/GetTexture/GetTextureServerConnector.cs
@@ -33,6 +33,7 @@ using OpenSim.Framework.Servers.HttpServer;
 using OpenSim.Server.Handlers.Base;
 using OpenMetaverse;
 
+/*
 namespace OpenSim.Capabilities.Handlers
 {
     public class GetTextureServerConnector : ServiceConnector
@@ -63,7 +64,8 @@ namespace OpenSim.Capabilities.Handlers
                 throw new Exception(String.Format("Failed to load AssetService from {0}; config is {1}", assetService, m_ConfigName));
 
             server.AddStreamHandler(
-                new GetTextureHandler("/CAPS/GetTexture/" /*+ UUID.Random() */, m_AssetService, "GetTexture", null));
+                new GetTextureHandler("/CAPS/GetTexture/", m_AssetService, "GetTexture", null));
         }
     }
-}
\ No newline at end of file
+}
+*/
diff --git a/OpenSim/Capabilities/Handlers/GetTexture/Tests/GetTextureHandlerTests.cs b/OpenSim/Capabilities/Handlers/GetTexture/Tests/GetTextureHandlerTests.cs
index d4d6d10..217a265 100644
--- a/OpenSim/Capabilities/Handlers/GetTexture/Tests/GetTextureHandlerTests.cs
+++ b/OpenSim/Capabilities/Handlers/GetTexture/Tests/GetTextureHandlerTests.cs
@@ -39,6 +39,7 @@ using OpenSim.Region.Framework.Scenes;
 using OpenSim.Tests.Common;
 using OpenSim.Tests.Common.Mock;
 
+/*
 namespace OpenSim.Capabilities.Handlers.GetTexture.Tests
 {
     [TestFixture]
@@ -60,4 +61,5 @@ namespace OpenSim.Capabilities.Handlers.GetTexture.Tests
             Assert.That(resp.StatusCode, Is.EqualTo((int)System.Net.HttpStatusCode.NotFound));
         }
     }
-}
\ No newline at end of file
+}
+*/
diff --git a/OpenSim/Capabilities/Handlers/UploadBakedTexture/UploadBakedTextureHandler.cs b/OpenSim/Capabilities/Handlers/UploadBakedTexture/UploadBakedTextureHandler.cs
index 8849a59..5536564 100644
--- a/OpenSim/Capabilities/Handlers/UploadBakedTexture/UploadBakedTextureHandler.cs
+++ b/OpenSim/Capabilities/Handlers/UploadBakedTexture/UploadBakedTextureHandler.cs
@@ -27,6 +27,7 @@
 
 using System;
 using System.Collections;
+using System.Collections.Generic;
 using System.Collections.Specialized;
 using System.Drawing;
 using System.Drawing.Imaging;
@@ -50,6 +51,7 @@ namespace OpenSim.Capabilities.Handlers
 {
     public class UploadBakedTextureHandler
     {
+      
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         private Caps m_HostCapsObj;
@@ -79,9 +81,9 @@ namespace OpenSim.Capabilities.Handlers
             {
                 string capsBase = "/CAPS/" + m_HostCapsObj.CapsObjectPath;
                 string uploaderPath = Util.RandomClass.Next(5000, 8000).ToString("0000");
-
+                
                 BakedTextureUploader uploader =
-                    new BakedTextureUploader(capsBase + uploaderPath, m_HostCapsObj.HttpListener);
+                    new BakedTextureUploader(capsBase + uploaderPath, m_HostCapsObj.HttpListener, m_HostCapsObj.AgentID);
                 uploader.OnUpLoad += BakedTextureUploaded;
 
                 m_HostCapsObj.HttpListener.AddStreamHandler(
@@ -117,7 +119,7 @@ namespace OpenSim.Capabilities.Handlers
         /// <param name="data"></param>
         private void BakedTextureUploaded(UUID assetID, byte[] data)
         {
-//            m_log.DebugFormat("[UPLOAD BAKED TEXTURE HANDLER]: Received baked texture {0}", assetID.ToString());
+            m_log.DebugFormat("[UPLOAD BAKED TEXTURE HANDLER]: Received baked texture {0}", assetID.ToString());
 
             AssetBase asset;
             asset = new AssetBase(assetID, "Baked Texture", (sbyte)AssetType.Texture, m_HostCapsObj.AgentID.ToString());
@@ -125,6 +127,7 @@ namespace OpenSim.Capabilities.Handlers
             asset.Temporary = true;
             asset.Local = !m_persistBakedTextures; // Local assets aren't persisted, non-local are
             m_assetService.Store(asset);
+            
         }
     }
 
@@ -137,15 +140,19 @@ namespace OpenSim.Capabilities.Handlers
         private string uploaderPath = String.Empty;
         private UUID newAssetID;
         private IHttpServer httpListener;
+        private UUID AgentId = UUID.Zero;
 
-        public BakedTextureUploader(string path, IHttpServer httpServer)
+        public BakedTextureUploader(string path, IHttpServer httpServer, UUID uUID)
         {
             newAssetID = UUID.Random();
             uploaderPath = path;
             httpListener = httpServer;
+            AgentId = uUID;
             //                m_log.InfoFormat("[CAPS] baked texture upload starting for {0}",newAssetID);
         }
 
+       
+
         /// <summary>
         /// Handle raw uploaded baked texture data.
         /// </summary>
diff --git a/OpenSim/Capabilities/Handlers/WebFetchInventoryDescendents/WebFetchInvDescHandler.cs b/OpenSim/Capabilities/Handlers/WebFetchInventoryDescendents/WebFetchInvDescHandler.cs
index 9a6ca86..11a2698 100644
--- a/OpenSim/Capabilities/Handlers/WebFetchInventoryDescendents/WebFetchInvDescHandler.cs
+++ b/OpenSim/Capabilities/Handlers/WebFetchInventoryDescendents/WebFetchInvDescHandler.cs
@@ -435,4 +435,4 @@ namespace OpenSim.Capabilities.Handlers
             return llsdItem;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Capabilities/LLSDAssetUploadComplete.cs b/OpenSim/Capabilities/LLSDAssetUploadComplete.cs
index ab6cee5..ae8eb09 100644
--- a/OpenSim/Capabilities/LLSDAssetUploadComplete.cs
+++ b/OpenSim/Capabilities/LLSDAssetUploadComplete.cs
@@ -30,12 +30,15 @@ using OpenMetaverse;
 
 namespace OpenSim.Framework.Capabilities
 {
+
     [LLSDType("MAP")]
     public class LLSDAssetUploadComplete
     {
         public string new_asset = String.Empty;
         public UUID new_inventory_item = UUID.Zero;
+//        public UUID new_texture_folder_id = UUID.Zero;
         public string state = String.Empty;
+        public LLSDAssetUploadError error = null;
         //public bool success = false;
 
         public LLSDAssetUploadComplete()
diff --git a/OpenSim/Capabilities/LLSDAssetUploadRequest.cs b/OpenSim/Capabilities/LLSDAssetUploadRequest.cs
index 6e66f0a..6779cc1 100644
--- a/OpenSim/Capabilities/LLSDAssetUploadRequest.cs
+++ b/OpenSim/Capabilities/LLSDAssetUploadRequest.cs
@@ -31,14 +31,27 @@ using OpenMetaverse;
 namespace OpenSim.Framework.Capabilities
 {
     [OSDMap]
+    public class LLSDAssetResource
+    {
+        public OSDArray instance_list = new OSDArray();
+        public OSDArray texture_list = new OSDArray();
+        public OSDArray mesh_list = new OSDArray();
+        public string metric = String.Empty;
+    }
+
+    [OSDMap]
     public class LLSDAssetUploadRequest
     {
         public string asset_type = String.Empty;
         public string description = String.Empty;
         public UUID folder_id = UUID.Zero;
+        public UUID texture_folder_id = UUID.Zero;
+        public int next_owner_mask = 0;
+        public int group_mask = 0;
+        public int everyone_mask = 0;
         public string inventory_type = String.Empty;
         public string name = String.Empty;
-
+        public LLSDAssetResource asset_resources = new LLSDAssetResource();
         public LLSDAssetUploadRequest()
         {
         }
diff --git a/OpenSim/Capabilities/LLSDAssetUploadResponse.cs b/OpenSim/Capabilities/LLSDAssetUploadResponse.cs
index 0d6f7f9..7c4bc97 100644
--- a/OpenSim/Capabilities/LLSDAssetUploadResponse.cs
+++ b/OpenSim/Capabilities/LLSDAssetUploadResponse.cs
@@ -26,20 +26,51 @@
  */
 
 using System;
+using OpenMetaverse;
 
 namespace OpenSim.Framework.Capabilities
 {
     [OSDMap]
+    public class LLSDAssetUploadError
+    {
+        public string message = String.Empty;
+        public UUID identifier = UUID.Zero;
+    }
+
+    [OSDMap]
+    public class LLSDAssetUploadResponsePricebrkDown
+    {
+        public int mesh_streaming;
+        public int mesh_physics;
+        public int mesh_instance;
+        public int texture;
+        public int model;
+    }
+
+    [OSDMap]
+    public class LLSDAssetUploadResponseData
+    {
+        public double resource_cost;
+        public double model_streaming_cost;
+        public double simulation_cost;
+        public double physics_cost;
+        public LLSDAssetUploadResponsePricebrkDown upload_price_breakdown = new LLSDAssetUploadResponsePricebrkDown();
+    }
+
+    [OSDMap]
     public class LLSDAssetUploadResponse
     {
         public string uploader = String.Empty;
         public string state = String.Empty;
-
+        public int upload_price = 0;
+        public LLSDAssetUploadResponseData data = null;
+        public LLSDAssetUploadError error = null;
         public LLSDAssetUploadResponse()
         {
         }
     }
 
+
     [OSDMap]
     public class LLSDNewFileAngentInventoryVariablePriceReplyResponse
     {