Merge remote-tracking branch 'os/master'

46 files changed, 5599 insertions, 0 deletions

diff --git a/OpenSim/Capabilities/Caps.cs b/OpenSim/Capabilities/Caps.cs
new file mode 100644
index 0000000..049afab
--- /dev/null
+++ b/OpenSim/Capabilities/Caps.cs
@@ -0,0 +1,259 @@
+/*
+ * 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.Generic;
+using System.IO;
+using System.Reflection;
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Services.Interfaces;
+
+// using OpenSim.Region.Framework.Interfaces;
+
+namespace OpenSim.Framework.Capabilities
+{
+    /// <summary>
+    /// XXX Probably not a particularly nice way of allow us to get the scene presence from the scene (chiefly so that
+    /// we can popup a message on the user's client if the inventory service has permanently failed).  But I didn't want
+    /// to just pass the whole Scene into CAPS.
+    /// </summary>
+    public delegate IClientAPI GetClientDelegate(UUID agentID);
+
+    public class Caps
+    {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private string m_httpListenerHostName;
+        private uint m_httpListenPort;
+
+        /// <summary>
+        /// This is the uuid portion of every CAPS path.  It is used to make capability urls private to the requester.
+        /// </summary>
+        private string m_capsObjectPath;
+        public string CapsObjectPath { get { return m_capsObjectPath; } }
+
+        private CapsHandlers m_capsHandlers;
+
+        private Dictionary<string, PollServiceEventArgs> m_pollServiceHandlers 
+            = new Dictionary<string, PollServiceEventArgs>();
+
+        private Dictionary<string, string> m_externalCapsHandlers = new Dictionary<string, string>();
+
+        private IHttpServer m_httpListener;
+        private UUID m_agentID;
+        private string m_regionName;
+
+        public UUID AgentID
+        {
+            get { return m_agentID; }
+        }
+
+        public string RegionName
+        {
+            get { return m_regionName; }
+        }
+
+        public string HostName
+        {
+            get { return m_httpListenerHostName; }
+        }
+
+        public uint Port
+        {
+            get { return m_httpListenPort; }
+        }
+
+        public IHttpServer HttpListener
+        {
+            get { return m_httpListener; }
+        }
+
+        public bool SSLCaps
+        {
+            get { return m_httpListener.UseSSL; }
+        }
+
+        public string SSLCommonName
+        {
+            get { return m_httpListener.SSLCommonName; }
+        }
+
+        public CapsHandlers CapsHandlers
+        {
+            get { return m_capsHandlers; }
+        }
+
+        public Dictionary<string, string> ExternalCapsHandlers
+        {
+            get { return m_externalCapsHandlers; }
+        }
+
+        public Caps(IHttpServer httpServer, string httpListen, uint httpPort, string capsPath,
+                    UUID agent, string regionName)
+        {
+            m_capsObjectPath = capsPath;
+            m_httpListener = httpServer;
+            m_httpListenerHostName = httpListen;
+
+            m_httpListenPort = httpPort;
+
+            if (httpServer != null && httpServer.UseSSL)
+            {
+                m_httpListenPort = httpServer.SSLPort;
+                httpListen = httpServer.SSLCommonName;
+                httpPort = httpServer.SSLPort;
+            }
+
+            m_agentID = agent;
+            m_capsHandlers = new CapsHandlers(httpServer, httpListen, httpPort, (httpServer == null) ? false : httpServer.UseSSL);
+            m_regionName = regionName;
+        }
+
+        /// <summary>
+        /// Register a handler.  This allows modules to register handlers.
+        /// </summary>
+        /// <param name="capName"></param>
+        /// <param name="handler"></param>
+        public void RegisterHandler(string capName, IRequestHandler handler)
+        {
+            //m_log.DebugFormat("[CAPS]: Registering handler for \"{0}\": path {1}", capName, handler.Path);
+            m_capsHandlers[capName] = handler;
+        }
+
+        public void RegisterPollHandler(string capName, PollServiceEventArgs pollServiceHandler)
+        {
+//            m_log.DebugFormat(
+//                "[CAPS]: Registering handler with name {0}, url {1} for {2}", 
+//                capName, pollServiceHandler.Url, m_agentID, m_regionName);
+
+            m_pollServiceHandlers.Add(capName, pollServiceHandler);
+
+            m_httpListener.AddPollServiceHTTPHandler(pollServiceHandler.Url, pollServiceHandler);
+
+//            uint port = (MainServer.Instance == null) ? 0 : MainServer.Instance.Port;
+//            string protocol = "http";
+//            string hostName = m_httpListenerHostName;
+//            
+//            if (MainServer.Instance.UseSSL)
+//            {
+//                hostName = MainServer.Instance.SSLCommonName;
+//                port = MainServer.Instance.SSLPort;
+//                protocol = "https";
+//            }
+
+//            RegisterHandler(
+//                capName, String.Format("{0}://{1}:{2}{3}", protocol, hostName, port, pollServiceHandler.Url));
+        }
+
+        /// <summary>
+        /// Register an external handler. The service for this capability is somewhere else
+        /// given by the URL.
+        /// </summary>
+        /// <param name="capsName"></param>
+        /// <param name="url"></param>
+        public void RegisterHandler(string capsName, string url)
+        {
+            m_externalCapsHandlers.Add(capsName, url);
+        }
+
+        /// <summary>
+        /// Remove all CAPS service handlers.
+        /// </summary>
+        public void DeregisterHandlers()
+        {
+            foreach (string capsName in m_capsHandlers.Caps)
+            {
+                m_capsHandlers.Remove(capsName);
+            }
+
+            foreach (PollServiceEventArgs handler in m_pollServiceHandlers.Values)
+            {
+                m_httpListener.RemovePollServiceHTTPHandler("", handler.Url);
+            }
+        }
+
+        public bool TryGetPollHandler(string name, out PollServiceEventArgs pollHandler)
+        {
+            return m_pollServiceHandlers.TryGetValue(name, out pollHandler);
+        }
+
+        public Dictionary<string, PollServiceEventArgs> GetPollHandlers()
+        {
+            return new Dictionary<string, PollServiceEventArgs>(m_pollServiceHandlers);
+        }
+
+        /// <summary>
+        /// Return an LLSD-serializable Hashtable describing the
+        /// capabilities and their handler details.
+        /// </summary>
+        /// <param name="excludeSeed">If true, then exclude the seed cap.</param>
+        public Hashtable GetCapsDetails(bool excludeSeed, List<string> requestedCaps)
+        {
+            Hashtable caps = CapsHandlers.GetCapsDetails(excludeSeed, requestedCaps);
+
+            lock (m_pollServiceHandlers)
+            {
+                foreach (KeyValuePair <string, PollServiceEventArgs> kvp in m_pollServiceHandlers)
+                {
+                    if (!requestedCaps.Contains(kvp.Key))
+                        continue;
+
+                        string hostName = m_httpListenerHostName;
+                        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("FetchInventoryDescendents2", String.Format("{0}://{1}:{2}{3}", protocol, hostName, port, capUrl));
+
+                        caps[kvp.Key] = string.Format("{0}://{1}:{2}{3}", protocol, hostName, port, kvp.Value.Url);
+                }
+            }
+
+            // Add the external too
+            foreach (KeyValuePair<string, string> kvp in ExternalCapsHandlers)
+            {
+                if (!requestedCaps.Contains(kvp.Key))
+                    continue;
+
+                caps[kvp.Key] = kvp.Value;
+            }
+
+            return caps;
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/CapsHandlers.cs b/OpenSim/Capabilities/CapsHandlers.cs
new file mode 100644
index 0000000..890df90
--- /dev/null
+++ b/OpenSim/Capabilities/CapsHandlers.cs
@@ -0,0 +1,200 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System.Collections;
+using System.Collections.Generic;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+
+namespace OpenSim.Framework.Capabilities
+{
+    /// <summary>
+    /// CapsHandlers is a cap handler container but also takes
+    /// care of adding and removing cap handlers to and from the
+    /// supplied BaseHttpServer.
+    /// </summary>
+    public class CapsHandlers
+    {
+        private Dictionary<string, IRequestHandler> m_capsHandlers = new Dictionary<string, IRequestHandler>();
+        private IHttpServer m_httpListener;
+        private string m_httpListenerHostName;
+        private uint m_httpListenerPort;
+        private bool m_useSSL = false;
+
+        /// <summary></summary>
+        /// CapsHandlers is a cap handler container but also takes
+        /// care of adding and removing cap handlers to and from the
+        /// supplied BaseHttpServer.
+        /// </summary>
+        /// <param name="httpListener">base HTTP server</param>
+        /// <param name="httpListenerHostname">host name of the HTTP server</param>
+        /// <param name="httpListenerPort">HTTP port</param>
+        public CapsHandlers(BaseHttpServer httpListener, string httpListenerHostname, uint httpListenerPort)
+            : this(httpListener,httpListenerHostname,httpListenerPort, false)
+        {
+        }
+
+        /// <summary></summary>
+        /// CapsHandlers is a cap handler container but also takes
+        /// care of adding and removing cap handlers to and from the
+        /// supplied BaseHttpServer.
+        /// </summary>
+        /// <param name="httpListener">base HTTP server</param>
+        /// <param name="httpListenerHostname">host name of the HTTP
+        /// server</param>
+        /// <param name="httpListenerPort">HTTP port</param>
+        public CapsHandlers(IHttpServer httpListener, string httpListenerHostname, uint httpListenerPort, bool https)
+        {
+            m_httpListener = httpListener;
+            m_httpListenerHostName = httpListenerHostname;
+            m_httpListenerPort = httpListenerPort;
+            m_useSSL = https;
+            if (httpListener != null && m_useSSL)
+            {
+                m_httpListenerHostName = httpListener.SSLCommonName;
+                m_httpListenerPort = httpListener.SSLPort;
+            }
+        }
+
+        /// <summary>
+        /// Remove the cap handler for a capability.
+        /// </summary>
+        /// <param name="capsName">name of the capability of the cap
+        /// handler to be removed</param>
+        public void Remove(string capsName)
+        {
+            lock (m_capsHandlers)
+            {
+                m_httpListener.RemoveStreamHandler("POST", m_capsHandlers[capsName].Path);
+                m_httpListener.RemoveStreamHandler("GET", m_capsHandlers[capsName].Path);
+                m_capsHandlers.Remove(capsName);
+            }
+        }
+
+        public bool ContainsCap(string cap)
+        {
+            lock (m_capsHandlers)
+                return m_capsHandlers.ContainsKey(cap);
+        }
+
+        /// <summary>
+        /// The indexer allows us to treat the CapsHandlers object
+        /// in an intuitive dictionary like way.
+        /// </summary>
+        /// <remarks>
+        /// The indexer will throw an exception when you try to
+        /// retrieve a cap handler for a cap that is not contained in
+        /// CapsHandlers.
+        /// </remarks>
+        public IRequestHandler this[string idx]
+        {
+            get
+            {
+                lock (m_capsHandlers)
+                    return m_capsHandlers[idx];
+            }
+
+            set
+            {
+                lock (m_capsHandlers)
+                {
+                    if (m_capsHandlers.ContainsKey(idx))
+                    {
+                        m_httpListener.RemoveStreamHandler("POST", m_capsHandlers[idx].Path);
+                        m_capsHandlers.Remove(idx);
+                    }
+    
+                    if (null == value) return;
+    
+                    m_capsHandlers[idx] = value;
+                    m_httpListener.AddStreamHandler(value);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Return the list of cap names for which this CapsHandlers
+        /// object contains cap handlers.
+        /// </summary>
+        public string[] Caps
+        {
+            get
+            {
+                lock (m_capsHandlers)
+                {
+                    string[] __keys = new string[m_capsHandlers.Keys.Count];
+                    m_capsHandlers.Keys.CopyTo(__keys, 0);
+                    return __keys;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Return an LLSD-serializable Hashtable describing the
+        /// capabilities and their handler details.
+        /// </summary>
+        /// <param name="excludeSeed">If true, then exclude the seed cap.</param>
+        public Hashtable GetCapsDetails(bool excludeSeed, List<string> requestedCaps)
+        {
+            Hashtable caps = new Hashtable();
+            string protocol = "http://";
+            
+            if (m_useSSL)
+                protocol = "https://";
+
+            string baseUrl = protocol + m_httpListenerHostName + ":" + m_httpListenerPort.ToString();
+
+            lock (m_capsHandlers)
+            {
+                foreach (string capsName in m_capsHandlers.Keys)
+                {
+                    if (excludeSeed && "SEED" == capsName)
+                        continue;
+
+                    if (requestedCaps != null && !requestedCaps.Contains(capsName))
+                        continue;
+
+                    caps[capsName] = baseUrl + m_capsHandlers[capsName].Path;
+                }
+            }
+
+            return caps;
+        }
+
+        /// <summary>
+        /// Returns a copy of the dictionary of all the HTTP cap handlers
+        /// </summary>
+        /// <returns>
+        /// The dictionary copy.  The key is the capability name, the value is the HTTP handler.
+        /// </returns>
+        public Dictionary<string, IRequestHandler> GetCapsHandlers()
+        {
+            lock (m_capsHandlers)
+                return new Dictionary<string, IRequestHandler>(m_capsHandlers);
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/Handlers/AvatarPickerSearch/AvatarPickerSearchHandler.cs b/OpenSim/Capabilities/Handlers/AvatarPickerSearch/AvatarPickerSearchHandler.cs
new file mode 100644
index 0000000..426174d
--- /dev/null
+++ b/OpenSim/Capabilities/Handlers/AvatarPickerSearch/AvatarPickerSearchHandler.cs
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.IO;
+using System.Reflection;
+using System.Web;
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Framework.Capabilities;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+//using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+
+namespace OpenSim.Capabilities.Handlers
+{
+    public class AvatarPickerSearchHandler : BaseStreamHandler
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private IPeople m_PeopleService;
+
+        public AvatarPickerSearchHandler(string path, IPeople peopleService, string name, string description)
+            : base("GET", path, name, description)
+        {
+            m_PeopleService = peopleService;
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream request, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            // Try to parse the texture ID from the request URL
+            NameValueCollection query = HttpUtility.ParseQueryString(httpRequest.Url.Query);
+            string names = query.GetOne("names");
+            string psize = query.GetOne("page_size");
+            string pnumber = query.GetOne("page");
+
+            if (m_PeopleService == null)
+                return FailureResponse(names, (int)System.Net.HttpStatusCode.InternalServerError, httpResponse);
+
+            if (string.IsNullOrEmpty(names) || names.Length < 3)
+                return FailureResponse(names, (int)System.Net.HttpStatusCode.BadRequest, httpResponse);
+
+            m_log.DebugFormat("[AVATAR PICKER SEARCH]: search for {0}", names);
+
+            int page_size = (string.IsNullOrEmpty(psize) ? 500 : Int32.Parse(psize));
+            int page_number = (string.IsNullOrEmpty(pnumber) ? 1 : Int32.Parse(pnumber));
+            
+            // Full content request
+            httpResponse.StatusCode = (int)System.Net.HttpStatusCode.OK;
+            //httpResponse.ContentLength = ??;
+            httpResponse.ContentType = "application/llsd+xml";
+
+            List<UserData> users = m_PeopleService.GetUserData(names, page_size, page_number);
+
+            LLSDAvatarPicker osdReply = new LLSDAvatarPicker();
+            osdReply.next_page_url = httpRequest.RawUrl;
+            foreach (UserData u in users)
+                osdReply.agents.Array.Add(ConvertUserData(u));
+
+            string reply = LLSDHelpers.SerialiseLLSDReply(osdReply);
+            return System.Text.Encoding.UTF8.GetBytes(reply);
+        }
+
+        private LLSDPerson ConvertUserData(UserData user)
+        {
+            LLSDPerson p = new LLSDPerson();
+            p.legacy_first_name = user.FirstName;
+            p.legacy_last_name = user.LastName;
+            p.display_name = user.FirstName + " " + user.LastName;
+            if (user.LastName.StartsWith("@"))
+                p.username = user.FirstName.ToLower() + user.LastName.ToLower();
+            else
+                p.username = user.FirstName.ToLower() + "." + user.LastName.ToLower();
+            p.id = user.Id;
+            p.is_display_name_default = false;
+            return p;
+        }
+
+        private byte[] FailureResponse(string names, int statuscode, IOSHttpResponse httpResponse)
+        {
+            m_log.Error("[AVATAR PICKER SEARCH]: Error searching for " + names);
+            httpResponse.StatusCode = (int)System.Net.HttpStatusCode.NotFound;
+            return System.Text.Encoding.UTF8.GetBytes(string.Empty);
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/Handlers/FetchInventory/FetchInvDescHandler.cs b/OpenSim/Capabilities/Handlers/FetchInventory/FetchInvDescHandler.cs
new file mode 100644
index 0000000..7197049
--- /dev/null
+++ b/OpenSim/Capabilities/Handlers/FetchInventory/FetchInvDescHandler.cs
@@ -0,0 +1,848 @@
+/*
+ * 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.Generic;
+using System.Linq;
+using System.Reflection;
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Framework.Capabilities;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+
+namespace OpenSim.Capabilities.Handlers
+{
+    public class FetchInvDescHandler 
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IInventoryService m_InventoryService;
+        private ILibraryService m_LibraryService;
+        private IScene m_Scene;
+//        private object m_fetchLock = new Object();
+
+        public FetchInvDescHandler(IInventoryService invService, ILibraryService libService, IScene s) 
+        {
+            m_InventoryService = invService;
+            m_LibraryService = libService;
+            m_Scene = s;
+        }
+
+        
+        public string FetchInventoryDescendentsRequest(string request, string path, string param, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            //m_log.DebugFormat("[XXX]: FetchInventoryDescendentsRequest in {0}, {1}", (m_Scene == null) ? "none" : m_Scene.Name, request);
+
+            // nasty temporary hack here, the linden client falsely
+            // identifies the uuid 00000000-0000-0000-0000-000000000000
+            // as a string which breaks us
+            //
+            // correctly mark it as a uuid
+            //
+            request = request.Replace("<string>00000000-0000-0000-0000-000000000000</string>", "<uuid>00000000-0000-0000-0000-000000000000</uuid>");
+    
+            // another hack <integer>1</integer> results in a
+            // System.ArgumentException: Object type System.Int32 cannot
+            // be converted to target type: System.Boolean
+            //
+            request = request.Replace("<key>fetch_folders</key><integer>0</integer>", "<key>fetch_folders</key><boolean>0</boolean>");
+            request = request.Replace("<key>fetch_folders</key><integer>1</integer>", "<key>fetch_folders</key><boolean>1</boolean>");
+    
+            Hashtable hash = new Hashtable();
+            try
+            {
+                hash = (Hashtable)LLSD.LLSDDeserialize(Utils.StringToBytes(request));
+            }
+            catch (LLSD.LLSDParseException e)
+            {
+                m_log.ErrorFormat("[WEB FETCH INV DESC HANDLER]: Fetch error: {0}{1}" + e.Message, e.StackTrace);
+                m_log.Error("Request: " + request);
+            }
+    
+            ArrayList foldersrequested = (ArrayList)hash["folders"];
+    
+            string response = "";
+            string bad_folders_response = "";
+
+            List<LLSDFetchInventoryDescendents> folders = new List<LLSDFetchInventoryDescendents>();
+            for (int i = 0; i < foldersrequested.Count; i++)
+            {
+                Hashtable inventoryhash = (Hashtable)foldersrequested[i];
+
+                LLSDFetchInventoryDescendents llsdRequest = new LLSDFetchInventoryDescendents();
+
+                try
+                {
+                    LLSDHelpers.DeserialiseOSDMap(inventoryhash, llsdRequest);
+                }
+                catch (Exception e)
+                {
+                    m_log.Debug("[WEB FETCH INV DESC HANDLER]: caught exception doing OSD deserialize" + e);
+                    continue;
+                }
+
+                // Filter duplicate folder ids that bad viewers may send
+                if (folders.Find(f => f.folder_id == llsdRequest.folder_id) == null)
+                    folders.Add(llsdRequest);
+
+            }
+
+            if (folders.Count > 0)
+            {
+                List<UUID> bad_folders = new List<UUID>();
+                List<InventoryCollectionWithDescendents> invcollSet = Fetch(folders, bad_folders);
+                //m_log.DebugFormat("[XXX]: Got {0} folders from a request of {1}", invcollSet.Count, folders.Count);
+
+                if (invcollSet == null)
+                {
+                    m_log.DebugFormat("[WEB FETCH INV DESC HANDLER]: Multiple folder fetch failed. Trying old protocol.");
+#pragma warning disable 0612
+                    return FetchInventoryDescendentsRequest(foldersrequested, httpRequest, httpResponse);
+#pragma warning restore 0612
+                }
+
+                string inventoryitemstr = string.Empty;
+                foreach (InventoryCollectionWithDescendents icoll in invcollSet)
+                {
+                    LLSDInventoryDescendents reply = ToLLSD(icoll.Collection, icoll.Descendents);
+
+                    inventoryitemstr = LLSDHelpers.SerialiseLLSDReply(reply);
+                    inventoryitemstr = inventoryitemstr.Replace("<llsd><map><key>folders</key><array>", "");
+                    inventoryitemstr = inventoryitemstr.Replace("</array></map></llsd>", "");
+
+                    response += inventoryitemstr;
+                }
+
+                //m_log.DebugFormat("[WEB FETCH INV DESC HANDLER]: Bad folders {0}", string.Join(", ", bad_folders));
+                foreach (UUID bad in bad_folders)
+                    bad_folders_response += "<uuid>" + bad + "</uuid>";
+            }
+
+            if (response.Length == 0)
+            {
+                /* Viewers expect a bad_folders array when not available */
+                if (bad_folders_response.Length != 0)
+                {
+                    response = "<llsd><map><key>bad_folders</key><array>" + bad_folders_response + "</array></map></llsd>";
+                }
+                else
+                {
+                    response = "<llsd><map><key>folders</key><array /></map></llsd>";
+                }
+            }
+            else
+            {
+                if (bad_folders_response.Length != 0)
+                {
+                    response = "<llsd><map><key>folders</key><array>" + response + "</array><key>bad_folders</key><array>" + bad_folders_response + "</array></map></llsd>";
+                }
+                else
+                {
+                    response = "<llsd><map><key>folders</key><array>" + response + "</array></map></llsd>";
+                }
+            }
+
+            //m_log.DebugFormat("[WEB FETCH INV DESC HANDLER]: Replying to CAPS fetch inventory request for {0} folders. Item count {1}", folders.Count, item_count);
+            //m_log.Debug("[WEB FETCH INV DESC HANDLER] " + response);
+
+            return response;
+
+        }
+
+        /// <summary>
+        /// Construct an LLSD reply packet to a CAPS inventory request
+        /// </summary>
+        /// <param name="invFetch"></param>
+        /// <returns></returns>
+        private LLSDInventoryDescendents FetchInventoryReply(LLSDFetchInventoryDescendents invFetch)
+        {
+            LLSDInventoryDescendents reply = new LLSDInventoryDescendents();
+            LLSDInventoryFolderContents contents = new LLSDInventoryFolderContents();
+            contents.agent_id = invFetch.owner_id;
+            contents.owner_id = invFetch.owner_id;
+            contents.folder_id = invFetch.folder_id;
+
+            reply.folders.Array.Add(contents);
+            InventoryCollection inv = new InventoryCollection();
+            inv.Folders = new List<InventoryFolderBase>();
+            inv.Items = new List<InventoryItemBase>();
+            int version = 0;
+            int descendents = 0;
+
+#pragma warning disable 0612
+            inv = Fetch(
+                    invFetch.owner_id, invFetch.folder_id, invFetch.owner_id,
+                    invFetch.fetch_folders, invFetch.fetch_items, invFetch.sort_order, out version, out descendents);
+#pragma warning restore 0612
+
+            if (inv != null && inv.Folders != null)
+            {
+                foreach (InventoryFolderBase invFolder in inv.Folders)
+                {
+                    contents.categories.Array.Add(ConvertInventoryFolder(invFolder));
+                }
+
+                descendents += inv.Folders.Count;
+            }
+
+            if (inv != null && inv.Items != null)
+            {
+                foreach (InventoryItemBase invItem in inv.Items)
+                {
+                    contents.items.Array.Add(ConvertInventoryItem(invItem));
+                }
+            }
+
+            contents.descendents = descendents;
+            contents.version = version;
+
+            //m_log.DebugFormat(
+            //    "[WEB FETCH INV DESC HANDLER]: Replying to request for folder {0} (fetch items {1}, fetch folders {2}) with {3} items and {4} folders for agent {5}",
+            //    invFetch.folder_id,
+            //    invFetch.fetch_items,
+            //    invFetch.fetch_folders,
+            //    contents.items.Array.Count,
+            //    contents.categories.Array.Count,
+            //    invFetch.owner_id);
+
+            return reply;
+        }
+
+        private LLSDInventoryDescendents ToLLSD(InventoryCollection inv, int descendents)
+        {
+            LLSDInventoryDescendents reply = new LLSDInventoryDescendents();
+            LLSDInventoryFolderContents contents = new LLSDInventoryFolderContents();
+            contents.agent_id = inv.OwnerID;
+            contents.owner_id = inv.OwnerID;
+            contents.folder_id = inv.FolderID;
+
+            reply.folders.Array.Add(contents);
+
+            if (inv.Folders != null)
+            {
+                foreach (InventoryFolderBase invFolder in inv.Folders)
+                {
+                    contents.categories.Array.Add(ConvertInventoryFolder(invFolder));
+                }
+
+                descendents += inv.Folders.Count;
+            }
+
+            if (inv.Items != null)
+            {
+                foreach (InventoryItemBase invItem in inv.Items)
+                {
+                    contents.items.Array.Add(ConvertInventoryItem(invItem));
+                }
+            }
+
+            contents.descendents = descendents;
+            contents.version = inv.Version;
+
+            return reply;
+        }
+        /// <summary>
+        /// Old style. Soon to be deprecated.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="httpRequest"></param>
+        /// <param name="httpResponse"></param>
+        /// <returns></returns>
+        [Obsolete]
+        private string FetchInventoryDescendentsRequest(ArrayList foldersrequested, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            //m_log.DebugFormat("[WEB FETCH INV DESC HANDLER]: Received request for {0} folders", foldersrequested.Count);
+
+            string response = "";
+            string bad_folders_response = "";
+
+            for (int i = 0; i < foldersrequested.Count; i++)
+            {
+                string inventoryitemstr = "";
+                Hashtable inventoryhash = (Hashtable)foldersrequested[i];
+
+                LLSDFetchInventoryDescendents llsdRequest = new LLSDFetchInventoryDescendents();
+
+                try
+                {
+                    LLSDHelpers.DeserialiseOSDMap(inventoryhash, llsdRequest);
+                }
+                catch (Exception e)
+                {
+                    m_log.Debug("[WEB FETCH INV DESC HANDLER]: caught exception doing OSD deserialize" + e);
+                }
+
+                LLSDInventoryDescendents reply = FetchInventoryReply(llsdRequest);
+
+                if (null == reply)
+                {
+                    bad_folders_response += "<uuid>" + llsdRequest.folder_id.ToString() + "</uuid>";
+                }
+                else
+                {
+                    inventoryitemstr = LLSDHelpers.SerialiseLLSDReply(reply);
+                    inventoryitemstr = inventoryitemstr.Replace("<llsd><map><key>folders</key><array>", "");
+                    inventoryitemstr = inventoryitemstr.Replace("</array></map></llsd>", "");
+                }
+
+                response += inventoryitemstr;
+            }
+
+            if (response.Length == 0)
+            {
+                /* Viewers expect a bad_folders array when not available */
+                if (bad_folders_response.Length != 0)
+                {
+                    response = "<llsd><map><key>bad_folders</key><array>" + bad_folders_response + "</array></map></llsd>";
+                }
+                else
+                {
+                    response = "<llsd><map><key>folders</key><array /></map></llsd>";
+                }
+            }
+            else
+            {
+                if (bad_folders_response.Length != 0)
+                {
+                    response = "<llsd><map><key>folders</key><array>" + response + "</array><key>bad_folders</key><array>" + bad_folders_response + "</array></map></llsd>";
+                }
+                else
+                {
+                    response = "<llsd><map><key>folders</key><array>" + response + "</array></map></llsd>";
+                }
+            }
+
+            //                m_log.DebugFormat("[WEB FETCH INV DESC HANDLER]: Replying to CAPS fetch inventory request");
+            //m_log.Debug("[WEB FETCH INV DESC HANDLER] "+response);
+
+            return response;
+
+            //            }
+        }
+
+        /// <summary>
+        /// Handle the caps inventory descendents fetch.
+        /// </summary>
+        /// <param name="agentID"></param>
+        /// <param name="folderID"></param>
+        /// <param name="ownerID"></param>
+        /// <param name="fetchFolders"></param>
+        /// <param name="fetchItems"></param>
+        /// <param name="sortOrder"></param>
+        /// <param name="version"></param>
+        /// <returns>An empty InventoryCollection if the inventory look up failed</returns>
+        [Obsolete]
+        private InventoryCollection Fetch(
+            UUID agentID, UUID folderID, UUID ownerID,
+            bool fetchFolders, bool fetchItems, int sortOrder, out int version, out int descendents)
+        {
+            //m_log.DebugFormat(
+            //    "[WEB FETCH INV DESC HANDLER]: Fetching folders ({0}), items ({1}) from {2} for agent {3}",
+            //    fetchFolders, fetchItems, folderID, agentID);
+
+            // FIXME MAYBE: We're not handling sortOrder!
+
+            version = 0;
+            descendents = 0;
+
+            InventoryFolderImpl fold;
+            if (m_LibraryService != null && m_LibraryService.LibraryRootFolder != null && agentID == m_LibraryService.LibraryRootFolder.Owner)
+            {
+                if ((fold = m_LibraryService.LibraryRootFolder.FindFolder(folderID)) != null)
+                {
+                    InventoryCollection ret = new InventoryCollection();
+                    ret.Folders = new List<InventoryFolderBase>();
+                    ret.Items = fold.RequestListOfItems();
+                    descendents = ret.Folders.Count + ret.Items.Count;
+
+                    return ret;
+                }
+            }
+
+            InventoryCollection contents = new InventoryCollection();
+
+            if (folderID != UUID.Zero)
+            {
+                InventoryCollection fetchedContents = m_InventoryService.GetFolderContent(agentID, folderID);
+
+                if (fetchedContents == null)
+                {
+                    m_log.WarnFormat("[WEB FETCH INV DESC HANDLER]: Could not get contents of folder {0} for user {1}", folderID, agentID);
+                    return contents;
+                }
+                contents = fetchedContents;
+                InventoryFolderBase containingFolder = new InventoryFolderBase();
+                containingFolder.ID = folderID;
+                containingFolder.Owner = agentID;
+                containingFolder = m_InventoryService.GetFolder(containingFolder);
+
+                if (containingFolder != null)
+                {
+                    //m_log.DebugFormat(
+                    //    "[WEB FETCH INV DESC HANDLER]: Retrieved folder {0} {1} for agent id {2}",
+                    //    containingFolder.Name, containingFolder.ID, agentID);
+
+                    version = containingFolder.Version;
+
+                    if (fetchItems)
+                    {
+                        List<InventoryItemBase> itemsToReturn = contents.Items;
+                        List<InventoryItemBase> originalItems = new List<InventoryItemBase>(itemsToReturn);
+
+                        // descendents must only include the links, not the linked items we add
+                        descendents = originalItems.Count;
+
+                        // Add target items for links in this folder before the links themselves.
+                        foreach (InventoryItemBase item in originalItems)
+                        {
+                            if (item.AssetType == (int)AssetType.Link)
+                            {
+                                InventoryItemBase linkedItem = m_InventoryService.GetItem(new InventoryItemBase(item.AssetID));
+
+                                // Take care of genuinely broken links where the target doesn't exist
+                                // HACK: Also, don't follow up links that just point to other links.  In theory this is legitimate,
+                                // but no viewer has been observed to set these up and this is the lazy way of avoiding cycles
+                                // rather than having to keep track of every folder requested in the recursion.
+                                if (linkedItem != null && linkedItem.AssetType != (int)AssetType.Link)
+                                    itemsToReturn.Insert(0, linkedItem);
+                            }
+                        }
+
+                        // Now scan for folder links and insert the items they target and those links at the head of the return data
+                        foreach (InventoryItemBase item in originalItems)
+                        {
+                            if (item.AssetType == (int)AssetType.LinkFolder)
+                            {
+                                InventoryCollection linkedFolderContents = m_InventoryService.GetFolderContent(ownerID, item.AssetID);
+                                List<InventoryItemBase> links = linkedFolderContents.Items;
+
+                                itemsToReturn.InsertRange(0, links);
+
+                                foreach (InventoryItemBase link in linkedFolderContents.Items)
+                                {
+                                    // Take care of genuinely broken links where the target doesn't exist
+                                    // HACK: Also, don't follow up links that just point to other links.  In theory this is legitimate,
+                                    // but no viewer has been observed to set these up and this is the lazy way of avoiding cycles
+                                    // rather than having to keep track of every folder requested in the recursion.
+                                    if (link != null)
+                                    {
+//                                        m_log.DebugFormat(
+//                                            "[WEB FETCH INV DESC HANDLER]: Adding item {0} {1} from folder {2} linked from {3}",
+//                                            link.Name, (AssetType)link.AssetType, item.AssetID, containingFolder.Name);
+
+                                        InventoryItemBase linkedItem
+                                            = m_InventoryService.GetItem(new InventoryItemBase(link.AssetID));
+
+                                        if (linkedItem != null)
+                                            itemsToReturn.Insert(0, linkedItem);
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+//                    foreach (InventoryItemBase item in contents.Items)
+//                    {
+//                        m_log.DebugFormat(
+//                            "[WEB FETCH INV DESC HANDLER]: Returning item {0}, type {1}, parent {2} in {3} {4}",
+//                            item.Name, (AssetType)item.AssetType, item.Folder, containingFolder.Name, containingFolder.ID);
+//                    }
+
+                    // =====
+
+//
+//                        foreach (InventoryItemBase linkedItem in linkedItemsToAdd)
+//                        {
+//                            m_log.DebugFormat(
+//                                "[WEB FETCH INV DESC HANDLER]: Inserted linked item {0} for link in folder {1} for agent {2}",
+//                                linkedItem.Name, folderID, agentID);
+//
+//                            contents.Items.Add(linkedItem);
+//                        }
+//
+//                        // If the folder requested contains links, then we need to send those folders first, otherwise the links
+//                        // will be broken in the viewer.
+//                        HashSet<UUID> linkedItemFolderIdsToSend = new HashSet<UUID>();
+//                        foreach (InventoryItemBase item in contents.Items)
+//                        {
+//                            if (item.AssetType == (int)AssetType.Link)
+//                            {
+//                                InventoryItemBase linkedItem = m_InventoryService.GetItem(new InventoryItemBase(item.AssetID));
+//
+//                                // Take care of genuinely broken links where the target doesn't exist
+//                                // HACK: Also, don't follow up links that just point to other links.  In theory this is legitimate,
+//                                // but no viewer has been observed to set these up and this is the lazy way of avoiding cycles
+//                                // rather than having to keep track of every folder requested in the recursion.
+//                                if (linkedItem != null && linkedItem.AssetType != (int)AssetType.Link)
+//                                {
+//                                    // We don't need to send the folder if source and destination of the link are in the same
+//                                    // folder.
+//                                    if (linkedItem.Folder != containingFolder.ID)
+//                                        linkedItemFolderIdsToSend.Add(linkedItem.Folder);
+//                                }
+//                            }
+//                        }
+//    
+//                        foreach (UUID linkedItemFolderId in linkedItemFolderIdsToSend)
+//                        {
+//                            m_log.DebugFormat(
+//                                "[WEB FETCH INV DESC HANDLER]: Recursively fetching folder {0} linked by item in folder {1} for agent {2}",
+//                                linkedItemFolderId, folderID, agentID);
+//
+//                            int dummyVersion;
+//                            InventoryCollection linkedCollection
+//                                = Fetch(
+//                                    agentID, linkedItemFolderId, ownerID, fetchFolders, fetchItems, sortOrder, out dummyVersion);
+//
+//                            InventoryFolderBase linkedFolder = new InventoryFolderBase(linkedItemFolderId);
+//                            linkedFolder.Owner = agentID;
+//                            linkedFolder = m_InventoryService.GetFolder(linkedFolder);
+//
+////                            contents.Folders.AddRange(linkedCollection.Folders);
+//
+//                            contents.Folders.Add(linkedFolder);
+//                            contents.Items.AddRange(linkedCollection.Items);
+//                        }
+//                    }
+                }
+            }
+            else
+            {
+                // Lost items don't really need a version
+                version = 1;
+            }
+
+            return contents;
+
+        }
+
+        private void AddLibraryFolders(List<LLSDFetchInventoryDescendents> fetchFolders, List<InventoryCollectionWithDescendents> result)
+        {
+            InventoryFolderImpl fold;
+            if (m_LibraryService != null && m_LibraryService.LibraryRootFolder != null)
+            {
+                List<LLSDFetchInventoryDescendents> libfolders = fetchFolders.FindAll(f => f.owner_id == m_LibraryService.LibraryRootFolder.Owner);
+                fetchFolders.RemoveAll(f => libfolders.Contains(f));
+
+                //m_log.DebugFormat("[XXX]: Found {0} library folders in request", libfolders.Count);
+
+                foreach (LLSDFetchInventoryDescendents f in libfolders)
+                {
+                    if ((fold = m_LibraryService.LibraryRootFolder.FindFolder(f.folder_id)) != null)
+                    {
+                        InventoryCollectionWithDescendents ret = new InventoryCollectionWithDescendents();
+                        ret.Collection = new InventoryCollection();
+                        ret.Collection.Folders = new List<InventoryFolderBase>();
+                        ret.Collection.Items = fold.RequestListOfItems();
+                        ret.Collection.OwnerID = m_LibraryService.LibraryRootFolder.Owner;
+                        ret.Collection.FolderID = f.folder_id;
+                        ret.Collection.Version = fold.Version;
+
+                        ret.Descendents = ret.Collection.Items.Count;
+                        result.Add(ret);
+
+                        //m_log.DebugFormat("[XXX]: Added libfolder {0} ({1}) {2}", ret.Collection.FolderID, ret.Collection.OwnerID);
+                    }
+                }
+            }
+        }
+
+        private List<InventoryCollectionWithDescendents> Fetch(List<LLSDFetchInventoryDescendents> fetchFolders, List<UUID> bad_folders)
+        {
+            //m_log.DebugFormat(
+            //    "[WEB FETCH INV DESC HANDLER]: Fetching {0} folders for owner {1}", fetchFolders.Count, fetchFolders[0].owner_id);
+
+            // FIXME MAYBE: We're not handling sortOrder!
+
+            List<InventoryCollectionWithDescendents> result = new List<InventoryCollectionWithDescendents>();
+
+            AddLibraryFolders(fetchFolders, result);
+
+            // Filter folder Zero right here. Some viewers (Firestorm) send request for folder Zero, which doesn't make sense
+            // and can kill the sim (all root folders have parent_id Zero)
+            LLSDFetchInventoryDescendents zero = fetchFolders.Find(f => f.folder_id == UUID.Zero);
+            if (zero != null)
+            {
+                fetchFolders.Remove(zero);
+                BadFolder(zero, null, bad_folders);
+            }
+
+            if (fetchFolders.Count > 0)
+            {
+                UUID[] fids = new UUID[fetchFolders.Count];
+                int i = 0;
+                foreach (LLSDFetchInventoryDescendents f in fetchFolders)
+                    fids[i++] = f.folder_id;
+
+                //m_log.DebugFormat("[XXX]: {0}", string.Join(",", fids));
+
+                InventoryCollection[] fetchedContents = m_InventoryService.GetMultipleFoldersContent(fetchFolders[0].owner_id, fids);
+
+                if (fetchedContents == null || (fetchedContents != null && fetchedContents.Length == 0))
+                {
+                    m_log.WarnFormat("[WEB FETCH INV DESC HANDLER]: Could not get contents of multiple folders for user {0}", fetchFolders[0].owner_id);
+                    foreach (LLSDFetchInventoryDescendents freq in fetchFolders)
+                        BadFolder(freq, null, bad_folders);
+                    return null;
+                }
+
+                i = 0;
+                // Do some post-processing. May need to fetch more from inv server for links
+                foreach (InventoryCollection contents in fetchedContents)
+                {
+                    // Find the original request
+                    LLSDFetchInventoryDescendents freq = fetchFolders[i++];
+
+                    InventoryCollectionWithDescendents coll = new InventoryCollectionWithDescendents();
+                    coll.Collection = contents;
+
+                    if (BadFolder(freq, contents, bad_folders))
+                        continue;
+
+                    // Next: link management
+                    ProcessLinks(freq, coll);
+
+                    result.Add(coll);
+                }
+            }
+
+            return result;
+        }
+
+        private bool BadFolder(LLSDFetchInventoryDescendents freq, InventoryCollection contents, List<UUID> bad_folders)
+        {
+            bool bad = false;
+            if (contents == null)
+            {
+                bad_folders.Add(freq.folder_id);
+                bad = true;
+            }
+
+            // The inventory server isn't sending FolderID in the collection...
+            // Must fetch it individually
+            else if (contents.FolderID == UUID.Zero)
+            {
+                InventoryFolderBase containingFolder = new InventoryFolderBase();
+                containingFolder.ID = freq.folder_id;
+                containingFolder.Owner = freq.owner_id;
+                containingFolder = m_InventoryService.GetFolder(containingFolder);
+
+                if (containingFolder != null)
+                {
+                    contents.FolderID = containingFolder.ID;
+                    contents.OwnerID = containingFolder.Owner;
+                    contents.Version = containingFolder.Version;
+                }
+                else
+                {
+                    // Was it really a request for folder Zero?
+                    // This is an overkill, but Firestorm really asks for folder Zero.
+                    // I'm leaving the code here for the time being, but commented.
+                    if (freq.folder_id == UUID.Zero)
+                    {
+                        //coll.Collection.OwnerID = freq.owner_id;
+                        //coll.Collection.FolderID = contents.FolderID;
+                        //containingFolder = m_InventoryService.GetRootFolder(freq.owner_id);
+                        //if (containingFolder != null)
+                        //{
+                        //    m_log.WarnFormat("[WEB FETCH INV DESC HANDLER]: Request for parent of folder {0}", containingFolder.ID);
+                        //    coll.Collection.Folders.Clear();
+                        //    coll.Collection.Folders.Add(containingFolder);
+                        //    if (m_LibraryService != null && m_LibraryService.LibraryRootFolder != null)
+                        //    {
+                        //        InventoryFolderBase lib = new InventoryFolderBase(m_LibraryService.LibraryRootFolder.ID, m_LibraryService.LibraryRootFolder.Owner);
+                        //        lib.Name = m_LibraryService.LibraryRootFolder.Name;
+                        //        lib.Type = m_LibraryService.LibraryRootFolder.Type;
+                        //        lib.Version = m_LibraryService.LibraryRootFolder.Version;
+                        //        coll.Collection.Folders.Add(lib);
+                        //    }
+                        //    coll.Collection.Items.Clear();
+                        //}
+                    }
+                    else
+                    {
+                        m_log.WarnFormat("[WEB FETCH INV DESC HANDLER]: Unable to fetch folder {0}", freq.folder_id);
+                        bad_folders.Add(freq.folder_id);
+                    }
+                    bad = true;
+                }
+            }
+
+            return bad;
+        }
+
+        private void ProcessLinks(LLSDFetchInventoryDescendents freq, InventoryCollectionWithDescendents coll)
+        {
+            InventoryCollection contents = coll.Collection;
+
+            if (freq.fetch_items && contents.Items != null)
+            {
+                List<InventoryItemBase> itemsToReturn = contents.Items;
+
+                // descendents must only include the links, not the linked items we add
+                coll.Descendents = itemsToReturn.Count;
+
+                // Add target items for links in this folder before the links themselves.
+                List<UUID> itemIDs = new List<UUID>();
+                List<UUID> folderIDs = new List<UUID>();
+                foreach (InventoryItemBase item in itemsToReturn)
+                {
+                    //m_log.DebugFormat("[XXX]:   {0} {1}", item.Name, item.AssetType);
+                    if (item.AssetType == (int)AssetType.Link)
+                        itemIDs.Add(item.AssetID);
+
+                    else if (item.AssetType == (int)AssetType.LinkFolder)
+                        folderIDs.Add(item.AssetID);
+                }
+
+                //m_log.DebugFormat("[XXX]: folder {0} has {1} links and {2} linkfolders", contents.FolderID, itemIDs.Count, folderIDs.Count);
+
+                // Scan for folder links and insert the items they target and those links at the head of the return data
+                if (folderIDs.Count > 0)
+                {
+                    InventoryCollection[] linkedFolders = m_InventoryService.GetMultipleFoldersContent(coll.Collection.OwnerID, folderIDs.ToArray());
+                    foreach (InventoryCollection linkedFolderContents in linkedFolders)
+                    {
+                        if (linkedFolderContents == null)
+                            continue;
+
+                        List<InventoryItemBase> links = linkedFolderContents.Items;
+
+                        itemsToReturn.InsertRange(0, links);
+
+                    }
+                }
+
+                if (itemIDs.Count > 0)
+                {
+                    InventoryItemBase[] linked = m_InventoryService.GetMultipleItems(freq.owner_id, itemIDs.ToArray());
+                    if (linked == null)
+                    {
+                        // OMG!!! One by one!!! This is fallback code, in case the backend isn't updated
+                        m_log.WarnFormat("[WEB FETCH INV DESC HANDLER]: GetMultipleItems failed. Falling back to fetching inventory items one by one.");
+                        linked = new InventoryItemBase[itemIDs.Count];
+                        int i = 0;
+                        InventoryItemBase item = new InventoryItemBase();
+                        item.Owner = freq.owner_id;
+                        foreach (UUID id in itemIDs)
+                        {
+                            item.ID = id;
+                            linked[i++] = m_InventoryService.GetItem(item);
+                        }
+                    }
+
+                    //m_log.DebugFormat("[WEB FETCH INV DESC HANDLER]: Processing folder {0}. Existing items:", freq.folder_id);
+                    //foreach (InventoryItemBase item in itemsToReturn)
+                    //    m_log.DebugFormat("[XXX]: {0} {1} {2}", item.Name, item.AssetType, item.Folder);
+
+                    if (linked != null)
+                    {
+                        foreach (InventoryItemBase linkedItem in linked)
+                        {
+                            // Take care of genuinely broken links where the target doesn't exist
+                            // HACK: Also, don't follow up links that just point to other links.  In theory this is legitimate,
+                            // but no viewer has been observed to set these up and this is the lazy way of avoiding cycles
+                            // rather than having to keep track of every folder requested in the recursion.
+                            if (linkedItem != null && linkedItem.AssetType != (int)AssetType.Link)
+                            {
+                                itemsToReturn.Insert(0, linkedItem);
+                                //m_log.DebugFormat("[WEB FETCH INV DESC HANDLER]: Added {0} {1} {2}", linkedItem.Name, linkedItem.AssetType, linkedItem.Folder);
+                            }
+                        }
+                    }
+                }
+            }
+
+        }
+
+        /// <summary>
+        /// Convert an internal inventory folder object into an LLSD object.
+        /// </summary>
+        /// <param name="invFolder"></param>
+        /// <returns></returns>
+        private LLSDInventoryFolder ConvertInventoryFolder(InventoryFolderBase invFolder)
+        {
+            LLSDInventoryFolder llsdFolder = new LLSDInventoryFolder();
+            llsdFolder.folder_id = invFolder.ID;
+            llsdFolder.parent_id = invFolder.ParentID;
+            llsdFolder.name = invFolder.Name;
+            llsdFolder.type = invFolder.Type;
+            llsdFolder.preferred_type = -1;
+
+            return llsdFolder;
+        }
+
+        /// <summary>
+        /// Convert an internal inventory item object into an LLSD object.
+        /// </summary>
+        /// <param name="invItem"></param>
+        /// <returns></returns>
+        private LLSDInventoryItem ConvertInventoryItem(InventoryItemBase invItem)
+        {
+            LLSDInventoryItem llsdItem = new LLSDInventoryItem();
+            llsdItem.asset_id = invItem.AssetID;
+            llsdItem.created_at = invItem.CreationDate;
+            llsdItem.desc = invItem.Description;
+            llsdItem.flags = (int)invItem.Flags;
+            llsdItem.item_id = invItem.ID;
+            llsdItem.name = invItem.Name;
+            llsdItem.parent_id = invItem.Folder;
+            llsdItem.type = invItem.AssetType;
+            llsdItem.inv_type = invItem.InvType;
+
+            llsdItem.permissions = new LLSDPermissions();
+            llsdItem.permissions.creator_id = invItem.CreatorIdAsUuid;
+            llsdItem.permissions.base_mask = (int)invItem.CurrentPermissions;
+            llsdItem.permissions.everyone_mask = (int)invItem.EveryOnePermissions;
+            llsdItem.permissions.group_id = invItem.GroupID;
+            llsdItem.permissions.group_mask = (int)invItem.GroupPermissions;
+            llsdItem.permissions.is_owner_group = invItem.GroupOwned;
+            llsdItem.permissions.next_owner_mask = (int)invItem.NextPermissions;
+            llsdItem.permissions.owner_id = invItem.Owner;
+            llsdItem.permissions.owner_mask = (int)invItem.CurrentPermissions;
+            llsdItem.sale_info = new LLSDSaleInfo();
+            llsdItem.sale_info.sale_price = invItem.SalePrice;
+            llsdItem.sale_info.sale_type = invItem.SaleType;
+
+            return llsdItem;
+        }
+    }
+
+    class InventoryCollectionWithDescendents
+    {
+        public InventoryCollection Collection;
+        public int Descendents;
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/Handlers/FetchInventory/FetchInvDescServerConnector.cs b/OpenSim/Capabilities/Handlers/FetchInventory/FetchInvDescServerConnector.cs
new file mode 100644
index 0000000..9dcfaa4
--- /dev/null
+++ b/OpenSim/Capabilities/Handlers/FetchInventory/FetchInvDescServerConnector.cs
@@ -0,0 +1,82 @@
+/*
+ * 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 Nini.Config;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+using OpenMetaverse;
+
+namespace OpenSim.Capabilities.Handlers
+{
+    public class FetchInvDescServerConnector : ServiceConnector
+    {
+        private IInventoryService m_InventoryService;
+        private ILibraryService m_LibraryService;
+        private string m_ConfigName = "CapsService";
+
+        public FetchInvDescServerConnector(IConfigSource config, IHttpServer server, string configName) :
+                base(config, server, configName)
+        {
+            if (configName != String.Empty)
+                m_ConfigName = configName;
+
+            IConfig serverConfig = config.Configs[m_ConfigName];
+            if (serverConfig == null)
+                throw new Exception(String.Format("No section '{0}' in config file", m_ConfigName));
+
+            string invService = serverConfig.GetString("InventoryService", String.Empty);
+
+            if (invService == String.Empty)
+                throw new Exception("No InventoryService in config file");
+
+            Object[] args = new Object[] { config };
+            m_InventoryService =
+                    ServerUtils.LoadPlugin<IInventoryService>(invService, args);
+
+            if (m_InventoryService == null)
+                throw new Exception(String.Format("Failed to load InventoryService from {0}; config is {1}", invService, m_ConfigName));
+
+            string libService = serverConfig.GetString("LibraryService", String.Empty);
+            m_LibraryService =
+                    ServerUtils.LoadPlugin<ILibraryService>(libService, args);
+
+            FetchInvDescHandler webFetchHandler = new FetchInvDescHandler(m_InventoryService, m_LibraryService, null);
+            IRequestHandler reqHandler
+                = new RestStreamHandler(
+                    "POST",
+                    "/CAPS/WebFetchInvDesc/" /*+ UUID.Random()*/,
+                    webFetchHandler.FetchInventoryDescendentsRequest,
+                    "FetchInvDescendents",
+                    null);
+            server.AddStreamHandler(reqHandler);
+        }
+
+    }
+}
diff --git a/OpenSim/Capabilities/Handlers/FetchInventory/FetchInventory2Handler.cs b/OpenSim/Capabilities/Handlers/FetchInventory/FetchInventory2Handler.cs
new file mode 100644
index 0000000..c904392
--- /dev/null
+++ b/OpenSim/Capabilities/Handlers/FetchInventory/FetchInventory2Handler.cs
@@ -0,0 +1,141 @@
+/*
+ * 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.Reflection;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Framework.Capabilities;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Services.Interfaces;
+using OSDArray = OpenMetaverse.StructuredData.OSDArray;
+using OSDMap = OpenMetaverse.StructuredData.OSDMap;
+
+using log4net;
+
+namespace OpenSim.Capabilities.Handlers
+{
+    public class FetchInventory2Handler
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IInventoryService m_inventoryService;
+        private UUID m_agentID;
+
+        public FetchInventory2Handler(IInventoryService invService, UUID agentId)
+        {
+            m_inventoryService = invService;
+            m_agentID = agentId;
+        }
+
+        public string FetchInventoryRequest(string request, string path, string param, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            //m_log.DebugFormat("[FETCH INVENTORY HANDLER]: Received FetchInventory capability request {0}", request);
+
+            OSDMap requestmap = (OSDMap)OSDParser.DeserializeLLSDXml(Utils.StringToBytes(request));
+            OSDArray itemsRequested = (OSDArray)requestmap["items"];
+
+            string reply;
+            LLSDFetchInventory llsdReply = new LLSDFetchInventory();
+
+            UUID[] itemIDs = new UUID[itemsRequested.Count];
+            int i = 0;
+            foreach (OSDMap osdItemId in itemsRequested)
+            {
+                itemIDs[i++] = osdItemId["item_id"].AsUUID();
+            }
+
+            InventoryItemBase[] items = m_inventoryService.GetMultipleItems(m_agentID, itemIDs);
+
+            if (items == null)
+            {
+                // OMG!!! One by one!!! This is fallback code, in case the backend isn't updated
+                m_log.WarnFormat("[FETCH INVENTORY HANDLER]: GetMultipleItems failed. Falling back to fetching inventory items one by one.");
+                items = new InventoryItemBase[itemsRequested.Count];
+                i = 0;
+                InventoryItemBase item = new InventoryItemBase();
+                item.Owner = m_agentID;
+                foreach (UUID id in itemIDs)
+                {
+                    item.ID = id;
+                    items[i++] = m_inventoryService.GetItem(item);
+                }
+            }
+
+            foreach (InventoryItemBase item in items)
+            {
+                if (item != null)
+                {
+                    // We don't know the agent that this request belongs to so we'll use the agent id of the item
+                    // which will be the same for all items.
+                    llsdReply.agent_id = item.Owner;
+
+                    llsdReply.items.Array.Add(ConvertInventoryItem(item));
+                }
+            }
+
+            reply = LLSDHelpers.SerialiseLLSDReply(llsdReply);
+
+            return reply;
+        }
+
+        /// <summary>
+        /// Convert an internal inventory item object into an LLSD object.
+        /// </summary>
+        /// <param name="invItem"></param>
+        /// <returns></returns>
+        private LLSDInventoryItem ConvertInventoryItem(InventoryItemBase invItem)
+        {
+            LLSDInventoryItem llsdItem = new LLSDInventoryItem();
+            llsdItem.asset_id = invItem.AssetID;
+            llsdItem.created_at = invItem.CreationDate;
+            llsdItem.desc = invItem.Description;
+            llsdItem.flags = (int)invItem.Flags;
+            llsdItem.item_id = invItem.ID;
+            llsdItem.name = invItem.Name;
+            llsdItem.parent_id = invItem.Folder;
+            llsdItem.type = invItem.AssetType;
+            llsdItem.inv_type = invItem.InvType;
+
+            llsdItem.permissions = new LLSDPermissions();
+            llsdItem.permissions.creator_id = invItem.CreatorIdAsUuid;
+            llsdItem.permissions.base_mask = (int)invItem.CurrentPermissions;
+            llsdItem.permissions.everyone_mask = (int)invItem.EveryOnePermissions;
+            llsdItem.permissions.group_id = invItem.GroupID;
+            llsdItem.permissions.group_mask = (int)invItem.GroupPermissions;
+            llsdItem.permissions.is_owner_group = invItem.GroupOwned;
+            llsdItem.permissions.next_owner_mask = (int)invItem.NextPermissions;
+            llsdItem.permissions.owner_id = invItem.Owner;
+            llsdItem.permissions.owner_mask = (int)invItem.CurrentPermissions;
+            llsdItem.sale_info = new LLSDSaleInfo();
+            llsdItem.sale_info.sale_price = invItem.SalePrice;
+            llsdItem.sale_info.sale_type = invItem.SaleType;
+
+            return llsdItem;
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/Handlers/FetchInventory/Tests/FetchInventory2HandlerTests.cs b/OpenSim/Capabilities/Handlers/FetchInventory/Tests/FetchInventory2HandlerTests.cs
new file mode 100644
index 0000000..8af3c64
--- /dev/null
+++ b/OpenSim/Capabilities/Handlers/FetchInventory/Tests/FetchInventory2HandlerTests.cs
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Text.RegularExpressions;
+using log4net;
+using log4net.Config;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenSim.Capabilities.Handlers;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using OpenSim.Tests.Common;
+
+namespace OpenSim.Capabilities.Handlers.FetchInventory.Tests
+{
+    [TestFixture]
+    public class FetchInventory2HandlerTests : OpenSimTestCase
+    {
+        private UUID m_userID = UUID.Random();
+        private Scene m_scene;
+        private UUID m_rootFolderID;
+        private UUID m_notecardsFolder;
+        private UUID m_objectsFolder;
+
+        private void Init()
+        {
+            // Create an inventory that looks like this:
+            //
+            // /My Inventory
+            //   <other system folders>
+            //   /Objects
+            //      Object 1
+            //      Object 2
+            //      Object 3
+            //   /Notecards
+            //      Notecard 1
+            //      Notecard 2
+            //      Notecard 3
+            //      Notecard 4
+            //      Notecard 5
+
+            m_scene = new SceneHelpers().SetupScene();
+
+            m_scene.InventoryService.CreateUserInventory(m_userID);
+
+            m_rootFolderID = m_scene.InventoryService.GetRootFolder(m_userID).ID;
+
+            InventoryFolderBase of = m_scene.InventoryService.GetFolderForType(m_userID, FolderType.Object);
+            m_objectsFolder = of.ID;
+
+            // Add 3 objects
+            InventoryItemBase item;
+            for (int i = 1; i <= 3; i++)
+            {
+                item = new InventoryItemBase(new UUID("b0000000-0000-0000-0000-0000000000b" + i), m_userID);
+                item.AssetID = UUID.Random();
+                item.AssetType = (int)AssetType.Object;
+                item.Folder = m_objectsFolder;
+                item.Name = "Object " + i;
+                m_scene.InventoryService.AddItem(item);
+            }
+
+            InventoryFolderBase ncf = m_scene.InventoryService.GetFolderForType(m_userID, FolderType.Notecard);
+            m_notecardsFolder = ncf.ID;
+
+            // Add 5 notecards
+            for (int i = 1; i <= 5; i++)
+            {
+                item = new InventoryItemBase(new UUID("10000000-0000-0000-0000-00000000000" + i), m_userID);
+                item.AssetID = UUID.Random();
+                item.AssetType = (int)AssetType.Notecard;
+                item.Folder = m_notecardsFolder;
+                item.Name = "Notecard " + i;
+                m_scene.InventoryService.AddItem(item);
+            }
+
+        }
+
+        [Test]
+        public void Test_001_RequestOne()
+        {
+            TestHelpers.InMethod();
+
+            Init();
+
+            FetchInventory2Handler handler = new FetchInventory2Handler(m_scene.InventoryService, m_userID);
+            TestOSHttpRequest req = new TestOSHttpRequest();
+            TestOSHttpResponse resp = new TestOSHttpResponse();
+
+            string request = "<llsd><map><key>items</key><array><map><key>item_id</key><uuid>";
+            request += "10000000-0000-0000-0000-000000000001"; // Notecard 1
+            request += "</uuid></map></array></map></llsd>";
+            
+            string llsdresponse = handler.FetchInventoryRequest(request, "/FETCH", string.Empty, req, resp);
+
+            Assert.That(llsdresponse != null, Is.True, "Incorrect null response");
+            Assert.That(llsdresponse != string.Empty, Is.True, "Incorrect empty response");
+            Assert.That(llsdresponse.Contains(m_userID.ToString()), Is.True, "Response should contain userID");
+
+            Assert.That(llsdresponse.Contains("10000000-0000-0000-0000-000000000001"), Is.True, "Response does not contain item uuid");
+            Assert.That(llsdresponse.Contains("Notecard 1"), Is.True, "Response does not contain item Name");
+            Console.WriteLine(llsdresponse);
+        }
+
+        [Test]
+        public void Test_002_RequestMany()
+        {
+            TestHelpers.InMethod();
+
+            Init();
+
+            FetchInventory2Handler handler = new FetchInventory2Handler(m_scene.InventoryService, m_userID);
+            TestOSHttpRequest req = new TestOSHttpRequest();
+            TestOSHttpResponse resp = new TestOSHttpResponse();
+
+            string request = "<llsd><map><key>items</key><array>";
+            request += "<map><key>item_id</key><uuid>10000000-0000-0000-0000-000000000001</uuid></map>"; // Notecard 1
+            request += "<map><key>item_id</key><uuid>10000000-0000-0000-0000-000000000002</uuid></map>"; // Notecard 2
+            request += "<map><key>item_id</key><uuid>10000000-0000-0000-0000-000000000003</uuid></map>"; // Notecard 3
+            request += "<map><key>item_id</key><uuid>10000000-0000-0000-0000-000000000004</uuid></map>"; // Notecard 4
+            request += "<map><key>item_id</key><uuid>10000000-0000-0000-0000-000000000005</uuid></map>"; // Notecard 5
+            request += "</array></map></llsd>";
+
+            string llsdresponse = handler.FetchInventoryRequest(request, "/FETCH", string.Empty, req, resp);
+
+            Assert.That(llsdresponse != null, Is.True, "Incorrect null response");
+            Assert.That(llsdresponse != string.Empty, Is.True, "Incorrect empty response");
+            Assert.That(llsdresponse.Contains(m_userID.ToString()), Is.True, "Response should contain userID");
+
+            Console.WriteLine(llsdresponse);
+            Assert.That(llsdresponse.Contains("10000000-0000-0000-0000-000000000001"), Is.True, "Response does not contain notecard 1");
+            Assert.That(llsdresponse.Contains("10000000-0000-0000-0000-000000000002"), Is.True, "Response does not contain notecard 2");
+            Assert.That(llsdresponse.Contains("10000000-0000-0000-0000-000000000003"), Is.True, "Response does not contain notecard 3");
+            Assert.That(llsdresponse.Contains("10000000-0000-0000-0000-000000000004"), Is.True, "Response does not contain notecard 4");
+            Assert.That(llsdresponse.Contains("10000000-0000-0000-0000-000000000005"), Is.True, "Response does not contain notecard 5");
+        }
+
+    }
+
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/Handlers/FetchInventory/Tests/FetchInventoryDescendents2HandlerTests.cs b/OpenSim/Capabilities/Handlers/FetchInventory/Tests/FetchInventoryDescendents2HandlerTests.cs
new file mode 100644
index 0000000..2d5531a
--- /dev/null
+++ b/OpenSim/Capabilities/Handlers/FetchInventory/Tests/FetchInventoryDescendents2HandlerTests.cs
@@ -0,0 +1,292 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Text.RegularExpressions;
+using log4net;
+using log4net.Config;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenSim.Capabilities.Handlers;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using OpenSim.Tests.Common;
+
+namespace OpenSim.Capabilities.Handlers.FetchInventory.Tests
+{
+    [TestFixture]
+    public class FetchInventoryDescendents2HandlerTests : OpenSimTestCase
+    {
+        private UUID m_userID = UUID.Zero;
+        private Scene m_scene;
+        private UUID m_rootFolderID;
+        private int m_rootDescendents;
+        private UUID m_notecardsFolder;
+        private UUID m_objectsFolder;
+
+        private void Init()
+        {
+            // Create an inventory that looks like this:
+            //
+            // /My Inventory
+            //   <other system folders>
+            //   /Objects
+            //      Some Object
+            //   /Notecards
+            //      Notecard 1
+            //      Notecard 2
+            //   /Test Folder
+            //      Link to notecard  -> /Notecards/Notecard 2
+            //      Link to Objects folder -> /Objects
+
+            m_scene = new SceneHelpers().SetupScene();
+
+            m_scene.InventoryService.CreateUserInventory(m_userID);
+
+            m_rootFolderID = m_scene.InventoryService.GetRootFolder(m_userID).ID;
+
+            InventoryFolderBase of = m_scene.InventoryService.GetFolderForType(m_userID, FolderType.Object);
+            m_objectsFolder = of.ID;
+
+            // Add an object
+            InventoryItemBase item = new InventoryItemBase(new UUID("b0000000-0000-0000-0000-00000000000b"), m_userID);
+            item.AssetID = UUID.Random();
+            item.AssetType = (int)AssetType.Object;
+            item.Folder = m_objectsFolder;
+            item.Name = "Some Object";
+            m_scene.InventoryService.AddItem(item);
+
+            InventoryFolderBase ncf = m_scene.InventoryService.GetFolderForType(m_userID, FolderType.Notecard);
+            m_notecardsFolder = ncf.ID;
+
+            // Add a notecard
+            item = new InventoryItemBase(new UUID("10000000-0000-0000-0000-000000000001"), m_userID);
+            item.AssetID = UUID.Random();
+            item.AssetType = (int)AssetType.Notecard;
+            item.Folder = m_notecardsFolder;
+            item.Name = "Test Notecard 1";
+            m_scene.InventoryService.AddItem(item);
+            // Add another notecard
+            item.ID = new UUID("20000000-0000-0000-0000-000000000002");
+            item.AssetID = new UUID("a0000000-0000-0000-0000-00000000000a");
+            item.Name = "Test Notecard 2";
+            m_scene.InventoryService.AddItem(item);
+
+            // Add a folder
+            InventoryFolderBase folder = new InventoryFolderBase(new UUID("f0000000-0000-0000-0000-00000000000f"), "Test Folder", m_userID, m_rootFolderID);
+            m_scene.InventoryService.AddFolder(folder);
+
+            // Add a link to notecard 2 in Test Folder
+            item.AssetID = item.ID; // use item ID of notecard 2
+            item.ID = new UUID("40000000-0000-0000-0000-000000000004");
+            item.AssetType = (int)AssetType.Link;
+            item.Folder = folder.ID;
+            item.Name = "Link to notecard";
+            m_scene.InventoryService.AddItem(item);
+
+            // Add a link to the Objects folder in Test Folder
+            item.AssetID = m_scene.InventoryService.GetFolderForType(m_userID, FolderType.Object).ID; // use item ID of Objects folder
+            item.ID = new UUID("50000000-0000-0000-0000-000000000005");
+            item.AssetType = (int)AssetType.LinkFolder;
+            item.Folder = folder.ID;
+            item.Name = "Link to Objects folder";
+            m_scene.InventoryService.AddItem(item);
+
+            InventoryCollection coll = m_scene.InventoryService.GetFolderContent(m_userID, m_rootFolderID);
+            m_rootDescendents = coll.Items.Count + coll.Folders.Count;
+            Console.WriteLine("Number of descendents: " + m_rootDescendents);
+        }
+
+        [Test]
+        public void Test_001_SimpleFolder()
+        {
+            TestHelpers.InMethod();
+
+            Init();
+
+            FetchInvDescHandler handler = new FetchInvDescHandler(m_scene.InventoryService, null, m_scene);
+            TestOSHttpRequest req = new TestOSHttpRequest();
+            TestOSHttpResponse resp = new TestOSHttpResponse();
+
+            string request = "<llsd><map><key>folders</key><array><map><key>fetch_folders</key><integer>1</integer><key>fetch_items</key><boolean>1</boolean><key>folder_id</key><uuid>";
+            request += m_rootFolderID;
+            request += "</uuid><key>owner_id</key><uuid>00000000-0000-0000-0000-000000000000</uuid><key>sort_order</key><integer>1</integer></map></array></map></llsd>";
+            
+            string llsdresponse = handler.FetchInventoryDescendentsRequest(request, "/FETCH", string.Empty, req, resp);
+
+            Assert.That(llsdresponse != null, Is.True, "Incorrect null response");
+            Assert.That(llsdresponse != string.Empty, Is.True, "Incorrect empty response");
+            Assert.That(llsdresponse.Contains("00000000-0000-0000-0000-000000000000"), Is.True, "Response should contain userID");
+
+            string descendents = "descendents</key><integer>" + m_rootDescendents + "</integer>";
+            Assert.That(llsdresponse.Contains(descendents), Is.True, "Incorrect number of descendents");
+            Console.WriteLine(llsdresponse);
+        }
+
+        [Test]
+        public void Test_002_MultipleFolders()
+        {
+            TestHelpers.InMethod();
+
+            FetchInvDescHandler handler = new FetchInvDescHandler(m_scene.InventoryService, null, m_scene);
+            TestOSHttpRequest req = new TestOSHttpRequest();
+            TestOSHttpResponse resp = new TestOSHttpResponse();
+
+            string request = "<llsd><map><key>folders</key><array>";
+            request += "<map><key>fetch_folders</key><integer>1</integer><key>fetch_items</key><boolean>1</boolean><key>folder_id</key><uuid>";
+            request += m_rootFolderID;
+            request += "</uuid><key>owner_id</key><uuid>00000000-0000-0000-0000-000000000000</uuid><key>sort_order</key><integer>1</integer></map>";
+            request += "<map><key>fetch_folders</key><integer>1</integer><key>fetch_items</key><boolean>1</boolean><key>folder_id</key><uuid>";
+            request += m_notecardsFolder;
+            request += "</uuid><key>owner_id</key><uuid>00000000-0000-0000-0000-000000000000</uuid><key>sort_order</key><integer>1</integer></map>";
+            request += "</array></map></llsd>";
+
+            string llsdresponse = handler.FetchInventoryDescendentsRequest(request, "/FETCH", string.Empty, req, resp);
+            Console.WriteLine(llsdresponse);
+
+            string descendents = "descendents</key><integer>" + m_rootDescendents + "</integer>";
+            Assert.That(llsdresponse.Contains(descendents), Is.True, "Incorrect number of descendents for root folder");
+            descendents = "descendents</key><integer>2</integer>";
+            Assert.That(llsdresponse.Contains(descendents), Is.True, "Incorrect number of descendents for Notecard folder");
+
+            Assert.That(llsdresponse.Contains("10000000-0000-0000-0000-000000000001"), Is.True, "Notecard 1 is missing from response");
+            Assert.That(llsdresponse.Contains("20000000-0000-0000-0000-000000000002"), Is.True, "Notecard 2 is missing from response");
+        }
+
+        [Test]
+        public void Test_003_Links()
+        {
+            TestHelpers.InMethod();
+
+            FetchInvDescHandler handler = new FetchInvDescHandler(m_scene.InventoryService, null, m_scene);
+            TestOSHttpRequest req = new TestOSHttpRequest();
+            TestOSHttpResponse resp = new TestOSHttpResponse();
+
+            string request = "<llsd><map><key>folders</key><array><map><key>fetch_folders</key><integer>1</integer><key>fetch_items</key><boolean>1</boolean><key>folder_id</key><uuid>";
+            request += "f0000000-0000-0000-0000-00000000000f";
+            request += "</uuid><key>owner_id</key><uuid>00000000-0000-0000-0000-000000000000</uuid><key>sort_order</key><integer>1</integer></map></array></map></llsd>";
+
+            string llsdresponse = handler.FetchInventoryDescendentsRequest(request, "/FETCH", string.Empty, req, resp);
+            Console.WriteLine(llsdresponse);
+
+            string descendents = "descendents</key><integer>2</integer>";
+            Assert.That(llsdresponse.Contains(descendents), Is.True, "Incorrect number of descendents for Test Folder");
+
+            // Make sure that the note card link is included
+            Assert.That(llsdresponse.Contains("Link to notecard"), Is.True, "Link to notecard is missing");
+            
+            //Make sure the notecard item itself is included
+            Assert.That(llsdresponse.Contains("Test Notecard 2"), Is.True, "Notecard 2 item (the source) is missing");
+
+            // Make sure that the source item is before the link item
+            int pos1 = llsdresponse.IndexOf("Test Notecard 2");
+            int pos2 = llsdresponse.IndexOf("Link to notecard");
+            Assert.Less(pos1, pos2, "Source of link is after link");
+
+            // Make sure the folder link is included
+            Assert.That(llsdresponse.Contains("Link to Objects folder"), Is.True, "Link to Objects folder is missing");
+
+            // Make sure the objects inside the Objects folder are included
+            // Note: I'm not entirely sure this is needed, but that's what I found in the implementation
+            Assert.That(llsdresponse.Contains("Some Object"), Is.True, "Some Object item (contents of the source) is missing");
+
+            // Make sure that the source item is before the link item
+            pos1 = llsdresponse.IndexOf("Some Object");
+            pos2 = llsdresponse.IndexOf("Link to Objects folder");
+            Assert.Less(pos1, pos2, "Contents of source of folder link is after folder link");
+        }
+
+        [Test]
+        public void Test_004_DuplicateFolders()
+        {
+            TestHelpers.InMethod();
+
+            FetchInvDescHandler handler = new FetchInvDescHandler(m_scene.InventoryService, null, m_scene);
+            TestOSHttpRequest req = new TestOSHttpRequest();
+            TestOSHttpResponse resp = new TestOSHttpResponse();
+
+            string request = "<llsd><map><key>folders</key><array>";
+            request += "<map><key>fetch_folders</key><integer>1</integer><key>fetch_items</key><boolean>1</boolean><key>folder_id</key><uuid>";
+            request += m_rootFolderID;
+            request += "</uuid><key>owner_id</key><uuid>00000000-0000-0000-0000-000000000000</uuid><key>sort_order</key><integer>1</integer></map>";
+            request += "<map><key>fetch_folders</key><integer>1</integer><key>fetch_items</key><boolean>1</boolean><key>folder_id</key><uuid>";
+            request += m_notecardsFolder;
+            request += "</uuid><key>owner_id</key><uuid>00000000-0000-0000-0000-000000000000</uuid><key>sort_order</key><integer>1</integer></map>";
+            request += "<map><key>fetch_folders</key><integer>1</integer><key>fetch_items</key><boolean>1</boolean><key>folder_id</key><uuid>";
+            request += m_rootFolderID;
+            request += "</uuid><key>owner_id</key><uuid>00000000-0000-0000-0000-000000000000</uuid><key>sort_order</key><integer>1</integer></map>";
+            request += "<map><key>fetch_folders</key><integer>1</integer><key>fetch_items</key><boolean>1</boolean><key>folder_id</key><uuid>";
+            request += m_notecardsFolder;
+            request += "</uuid><key>owner_id</key><uuid>00000000-0000-0000-0000-000000000000</uuid><key>sort_order</key><integer>1</integer></map>";
+            request += "</array></map></llsd>";
+
+            string llsdresponse = handler.FetchInventoryDescendentsRequest(request, "/FETCH", string.Empty, req, resp);
+            Console.WriteLine(llsdresponse);
+
+            string root_folder = "<key>folder_id</key><uuid>" + m_rootFolderID + "</uuid>";
+            string notecards_folder = "<key>folder_id</key><uuid>" + m_notecardsFolder + "</uuid>";
+
+            Assert.That(llsdresponse.Contains(root_folder), "Missing root folder");
+            Assert.That(llsdresponse.Contains(notecards_folder), "Missing notecards folder");
+            int count = Regex.Matches(llsdresponse, root_folder).Count;
+            Assert.AreEqual(1, count, "More than 1 root folder in response");
+            count = Regex.Matches(llsdresponse, notecards_folder).Count;
+            Assert.AreEqual(2, count, "More than 1 notecards folder in response"); // Notecards will also be under root, so 2
+        }
+
+        [Test]
+        public void Test_005_FolderZero()
+        {
+            TestHelpers.InMethod();
+
+            Init();
+
+            FetchInvDescHandler handler = new FetchInvDescHandler(m_scene.InventoryService, null, m_scene);
+            TestOSHttpRequest req = new TestOSHttpRequest();
+            TestOSHttpResponse resp = new TestOSHttpResponse();
+
+            string request = "<llsd><map><key>folders</key><array><map><key>fetch_folders</key><integer>1</integer><key>fetch_items</key><boolean>1</boolean><key>folder_id</key><uuid>";
+            request += UUID.Zero;
+            request += "</uuid><key>owner_id</key><uuid>00000000-0000-0000-0000-000000000000</uuid><key>sort_order</key><integer>1</integer></map></array></map></llsd>";
+
+            string llsdresponse = handler.FetchInventoryDescendentsRequest(request, "/FETCH", string.Empty, req, resp);
+
+            Assert.That(llsdresponse != null, Is.True, "Incorrect null response");
+            Assert.That(llsdresponse != string.Empty, Is.True, "Incorrect empty response");
+            Assert.That(llsdresponse.Contains("bad_folders</key><array><uuid>00000000-0000-0000-0000-000000000000"), Is.True, "Folder Zero should be a bad folder");
+
+            Console.WriteLine(llsdresponse);
+        }
+
+    }
+
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/Handlers/GetDisplayNames/GetDisplayNamesHandler.cs b/OpenSim/Capabilities/Handlers/GetDisplayNames/GetDisplayNamesHandler.cs
new file mode 100644
index 0000000..589602d
--- /dev/null
+++ b/OpenSim/Capabilities/Handlers/GetDisplayNames/GetDisplayNamesHandler.cs
@@ -0,0 +1,120 @@
+/*
+ * 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.Generic;
+using System.Collections.Specialized;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.Reflection;
+using System.IO;
+using System.Web;
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenMetaverse.Imaging;
+using OpenSim.Framework;
+using OpenSim.Framework.Capabilities;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+using OSDMap = OpenMetaverse.StructuredData.OSDMap;
+using OSDArray = OpenMetaverse.StructuredData.OSDArray;
+
+namespace OpenSim.Capabilities.Handlers
+{
+    public class GetDisplayNamesHandler : BaseStreamHandler
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private IUserManagement m_UserManagement;
+
+        public GetDisplayNamesHandler(string path, IUserManagement umService, string name, string description)
+            : base("GET", path, name, description)
+        {
+            m_UserManagement = umService;
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream request, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            m_log.DebugFormat("[GET_DISPLAY_NAMES]: called {0}", httpRequest.Url.Query);
+
+            NameValueCollection query = HttpUtility.ParseQueryString(httpRequest.Url.Query);
+            string[] ids = query.GetValues("ids");
+
+
+            if (m_UserManagement == null)
+            {
+                m_log.Error("[GET_DISPLAY_NAMES]: Cannot fetch display names without a user management component");
+                httpResponse.StatusCode = (int)System.Net.HttpStatusCode.InternalServerError;
+                return new byte[0];
+            }
+
+            OSDMap osdReply = new OSDMap();
+            OSDArray agents = new OSDArray();
+
+            osdReply["agents"] = agents;
+            foreach (string id in ids)
+            {
+                UUID uuid = UUID.Zero;
+                if (UUID.TryParse(id, out uuid))
+                {
+                    string name = m_UserManagement.GetUserName(uuid);
+                    if (!string.IsNullOrEmpty(name))
+                    {
+                        string[] parts = name.Split(new char[] {' '});
+                        OSDMap osdname = new OSDMap();
+                        osdname["display_name_next_update"] = OSD.FromDate(DateTime.MinValue);
+                        osdname["display_name_expires"] = OSD.FromDate(DateTime.Now.AddMonths(1));
+                        osdname["display_name"] = OSD.FromString(name);
+                        osdname["legacy_first_name"] = parts[0];
+                        osdname["legacy_last_name"] = parts[1];
+                        osdname["username"] = OSD.FromString(name);
+                        osdname["id"] = OSD.FromUUID(uuid);
+                        osdname["is_display_name_default"] = OSD.FromBoolean(true);
+
+                        agents.Add(osdname);
+                    }
+                }
+            }
+
+            // Full content request
+            httpResponse.StatusCode = (int)System.Net.HttpStatusCode.OK;
+            //httpResponse.ContentLength = ??;
+            httpResponse.ContentType = "application/llsd+xml";
+
+            string reply = OSDParser.SerializeLLSDXmlString(osdReply);
+            return System.Text.Encoding.UTF8.GetBytes(reply);
+
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/Handlers/GetDisplayNames/GetDisplayNamesServerConnector.cs b/OpenSim/Capabilities/Handlers/GetDisplayNames/GetDisplayNamesServerConnector.cs
new file mode 100644
index 0000000..d42de56
--- /dev/null
+++ b/OpenSim/Capabilities/Handlers/GetDisplayNames/GetDisplayNamesServerConnector.cs
@@ -0,0 +1,71 @@
+/*
+ * 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 Nini.Config;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+using OpenMetaverse;
+
+namespace OpenSim.Capabilities.Handlers
+{
+    public class GetDisplayNamesServerConnector : ServiceConnector
+    {
+        private IUserManagement m_UserManagement;
+        private string m_ConfigName = "CapsService";
+
+        public GetDisplayNamesServerConnector(IConfigSource config, IHttpServer server, string configName) :
+                base(config, server, configName)
+        {
+            if (configName != String.Empty)
+                m_ConfigName = configName;
+
+            IConfig serverConfig = config.Configs[m_ConfigName];
+            if (serverConfig == null)
+                throw new Exception(String.Format("No section '{0}' in config file", m_ConfigName));
+
+            string umService = serverConfig.GetString("AssetService", String.Empty);
+
+            if (umService == String.Empty)
+                throw new Exception("No AssetService in config file");
+
+            Object[] args = new Object[] { config };
+            m_UserManagement =
+                    ServerUtils.LoadPlugin<IUserManagement>(umService, args);
+
+            if (m_UserManagement == null)
+                throw new Exception(String.Format("Failed to load UserManagement from {0}; config is {1}", umService, m_ConfigName));
+
+            string rurl = serverConfig.GetString("GetTextureRedirectURL");
+            
+            server.AddStreamHandler(
+                new GetDisplayNamesHandler("/CAPS/agents/", m_UserManagement, "GetDisplayNames", null));
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/Handlers/GetMesh/GetMeshHandler.cs b/OpenSim/Capabilities/Handlers/GetMesh/GetMeshHandler.cs
new file mode 100644
index 0000000..6b67da1
--- /dev/null
+++ b/OpenSim/Capabilities/Handlers/GetMesh/GetMeshHandler.cs
@@ -0,0 +1,253 @@
+/*
+ * 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 log4net;
+using OpenMetaverse;
+using OpenMetaverse.Imaging;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Services.Interfaces;
+using System;
+using System.Collections.Specialized;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.IO;
+using System.Reflection;
+using System.Web;
+
+namespace OpenSim.Capabilities.Handlers
+{
+    public class GetMeshHandler : BaseStreamHandler
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private IAssetService m_assetService;
+
+        // TODO: Change this to a config option
+        private string m_RedirectURL = null;
+
+        public GetMeshHandler(string path, IAssetService assService, string name, string description, string redirectURL)
+            : base("GET", path, name, description)
+        {
+            m_assetService = assService;
+            m_RedirectURL = redirectURL;
+            if (m_RedirectURL != null && !m_RedirectURL.EndsWith("/"))
+                m_RedirectURL += "/";
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream request, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            // Try to parse the texture ID from the request URL
+            NameValueCollection query = HttpUtility.ParseQueryString(httpRequest.Url.Query);
+            string textureStr = query.GetOne("mesh_id");
+
+            if (m_assetService == null)
+            {
+                m_log.Error("[GETMESH]: Cannot fetch mesh " + textureStr + " without an asset service");
+                httpResponse.StatusCode = (int)System.Net.HttpStatusCode.NotFound;
+            }
+
+            UUID meshID;
+            if (!String.IsNullOrEmpty(textureStr) && UUID.TryParse(textureStr, out meshID))
+            {
+                // OK, we have an array with preferred formats, possibly with only one entry
+
+                httpResponse.StatusCode = (int)System.Net.HttpStatusCode.NotFound;
+                AssetBase mesh;
+
+                if (!String.IsNullOrEmpty(m_RedirectURL))
+                {
+                    // Only try to fetch locally cached meshes. Misses are redirected
+                    mesh = m_assetService.GetCached(meshID.ToString());
+
+                    if (mesh != null)
+                    {
+                        if (mesh.Type != (sbyte)AssetType.Mesh)
+                        {
+                            httpResponse.StatusCode = (int)System.Net.HttpStatusCode.NotFound;
+                        }
+                        WriteMeshData(httpRequest, httpResponse, mesh);
+                    }
+                    else
+                    {
+                        string textureUrl = m_RedirectURL + "?mesh_id="+ meshID.ToString();
+                        m_log.Debug("[GETMESH]: Redirecting mesh request to " + textureUrl);
+                        httpResponse.StatusCode = (int)OSHttpStatusCode.RedirectMovedPermanently;
+                        httpResponse.RedirectLocation = textureUrl;
+                        return null;
+                    }
+                }
+                else // no redirect
+                {
+                    // try the cache
+                    mesh = m_assetService.GetCached(meshID.ToString());
+
+                    if (mesh == null)
+                    {
+                        // Fetch locally or remotely. Misses return a 404
+                        mesh = m_assetService.Get(meshID.ToString());
+
+                        if (mesh != null)
+                        {
+                            if (mesh.Type != (sbyte)AssetType.Mesh)
+                            {
+                                httpResponse.StatusCode = (int)System.Net.HttpStatusCode.NotFound;
+                                return null;
+                            }
+                            WriteMeshData(httpRequest, httpResponse, mesh);
+                            return null;
+                        }
+                   }
+                   else // it was on the cache
+                   {
+                       if (mesh.Type != (sbyte)AssetType.Mesh)
+                       {
+                           httpResponse.StatusCode = (int)System.Net.HttpStatusCode.NotFound;
+                           return null;
+                       }
+                       WriteMeshData(httpRequest, httpResponse, mesh);
+                       return null;
+                   }
+                }
+
+                // not found
+                httpResponse.StatusCode = (int)System.Net.HttpStatusCode.NotFound;
+                return null;
+            }
+            else
+            {
+                m_log.Warn("[GETTEXTURE]: Failed to parse a mesh_id from GetMesh request: " + httpRequest.Url);
+            }
+
+            return null;
+        }
+
+        private void WriteMeshData(IOSHttpRequest request, IOSHttpResponse response, AssetBase texture)
+        {
+            string range = request.Headers.GetOne("Range");
+
+            if (!String.IsNullOrEmpty(range))
+            {
+                // Range request
+                int start, end;
+                if (TryParseRange(range, out start, out end))
+                {
+                    // Before clamping start make sure we can satisfy it in order to avoid
+                    // sending back the last byte instead of an error status
+                    if (start >= texture.Data.Length)
+                    {
+                        response.StatusCode = (int)System.Net.HttpStatusCode.PartialContent;
+                        response.ContentType = texture.Metadata.ContentType;
+                    }
+                    else
+                    {
+                        // Handle the case where no second range value was given.  This is equivalent to requesting
+                        // the rest of the entity.
+                        if (end == -1)
+                            end = int.MaxValue;
+
+                        end = Utils.Clamp(end, 0, texture.Data.Length - 1);
+                        start = Utils.Clamp(start, 0, end);
+                        int len = end - start + 1;
+
+                        if (0 == start && len == texture.Data.Length)
+                        {
+                            response.StatusCode = (int)System.Net.HttpStatusCode.OK;
+                        }
+                        else
+                        {
+                            response.StatusCode = (int)System.Net.HttpStatusCode.PartialContent;
+                            response.AddHeader("Content-Range", String.Format("bytes {0}-{1}/{2}", start, end, texture.Data.Length));
+                        }
+                        
+                        response.ContentLength = len;
+                        response.ContentType = "application/vnd.ll.mesh";
+    
+                        response.Body.Write(texture.Data, start, len);
+                    }
+                }
+                else
+                {
+                    m_log.Warn("[GETMESH]: Malformed Range header: " + range);
+                    response.StatusCode = (int)System.Net.HttpStatusCode.BadRequest;
+                }
+            }
+            else 
+            {
+                // Full content request
+                response.StatusCode = (int)System.Net.HttpStatusCode.OK;
+                response.ContentLength = texture.Data.Length;
+                response.ContentType = "application/vnd.ll.mesh";
+                response.Body.Write(texture.Data, 0, texture.Data.Length);
+            }
+        }
+
+        /// <summary>
+        /// Parse a range header.
+        /// </summary>
+        /// <remarks>
+        /// As per http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html,
+        /// this obeys range headers with two values (e.g. 533-4165) and no second value (e.g. 533-).
+        /// Where there is no value, -1 is returned.
+        /// FIXME: Need to cover the case where only a second value is specified (e.g. -4165), probably by returning -1
+        /// for start.</remarks>
+        /// <returns></returns>
+        /// <param name='header'></param>
+        /// <param name='start'>Start of the range.  Undefined if this was not a number.</param>
+        /// <param name='end'>End of the range.  Will be -1 if no end specified.  Undefined if there was a raw string but this was not a number.</param>
+        private bool TryParseRange(string header, out int start, out int end)
+        {
+            start = end = 0;
+
+            if (header.StartsWith("bytes="))
+            {
+                string[] rangeValues = header.Substring(6).Split('-');
+
+                if (rangeValues.Length == 2)
+                {
+                    if (!Int32.TryParse(rangeValues[0], out start))
+                        return false;
+
+                    string rawEnd = rangeValues[1];
+
+                    if (rawEnd == "")
+                    {
+                        end = -1;
+                        return true;
+                    }
+                    else if (Int32.TryParse(rawEnd, out end))
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            start = end = 0;
+            return false;
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/Handlers/GetMesh/GetMeshServerConnector.cs b/OpenSim/Capabilities/Handlers/GetMesh/GetMeshServerConnector.cs
new file mode 100644
index 0000000..19de3cf
--- /dev/null
+++ b/OpenSim/Capabilities/Handlers/GetMesh/GetMeshServerConnector.cs
@@ -0,0 +1,76 @@
+/*
+ * 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 Nini.Config;
+using OpenMetaverse;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Base;
+using OpenSim.Server.Handlers.Base;
+using OpenSim.Services.Interfaces;
+using System;
+
+namespace OpenSim.Capabilities.Handlers
+{
+    public class GetMeshServerConnector : ServiceConnector
+    {
+        private IAssetService m_AssetService;
+        private string m_ConfigName = "CapsService";
+
+        public GetMeshServerConnector(IConfigSource config, IHttpServer server, string configName) :
+                base(config, server, configName)
+        {
+            if (configName != String.Empty)
+                m_ConfigName = configName;
+
+            IConfig serverConfig = config.Configs[m_ConfigName];
+            if (serverConfig == null)
+                throw new Exception(String.Format("No section '{0}' in config file", m_ConfigName));
+
+            string assetService = serverConfig.GetString("AssetService", String.Empty);
+
+            if (assetService == String.Empty)
+                throw new Exception("No AssetService in config file");
+
+            Object[] args = new Object[] { config };
+            m_AssetService =
+                    ServerUtils.LoadPlugin<IAssetService>(assetService, args);
+
+            if (m_AssetService == null)
+                throw new Exception(String.Format("Failed to load AssetService from {0}; config is {1}", assetService, m_ConfigName));
+
+            string rurl = serverConfig.GetString("GetMeshRedirectURL");
+
+            server.AddStreamHandler(
+                new GetTextureHandler("/CAPS/GetMesh/" /*+ UUID.Random() */, m_AssetService, "GetMesh", null, rurl));
+
+            rurl = serverConfig.GetString("GetMesh2RedirectURL");
+
+            server.AddStreamHandler(
+                new GetTextureHandler("/CAPS/GetMesh2/" /*+ UUID.Random() */, m_AssetService, "GetMesh2", null, rurl));
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/Handlers/GetTexture/GetTextureHandler.cs b/OpenSim/Capabilities/Handlers/GetTexture/GetTextureHandler.cs
new file mode 100644
index 0000000..828e943
--- /dev/null
+++ b/OpenSim/Capabilities/Handlers/GetTexture/GetTextureHandler.cs
@@ -0,0 +1,431 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Specialized;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.Reflection;
+using System.IO;
+using System.Web;
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenMetaverse.Imaging;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+
+namespace OpenSim.Capabilities.Handlers
+{
+    public class GetTextureHandler : BaseStreamHandler
+    {
+        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
+        private string m_RedirectURL = null;
+
+        public GetTextureHandler(string path, IAssetService assService, string name, string description, string redirectURL)
+            : base("GET", path, name, description)
+        {
+            m_assetService = assService;
+            m_RedirectURL = redirectURL;
+            if (m_RedirectURL != null && !m_RedirectURL.EndsWith("/"))
+                m_RedirectURL += "/";
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream request, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            // 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");
+
+            //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;
+            if (!String.IsNullOrEmpty(textureStr) && UUID.TryParse(textureStr, out textureID))
+            {
+//                m_log.DebugFormat("[GETTEXTURE]: Received request for texture id {0}", textureID);
+                
+                string[] formats;
+                if (!string.IsNullOrEmpty(format))
+                {
+                    formats = new string[1] { format.ToLower() };
+                }
+                else
+                {
+                    formats = WebUtil.GetPreferredImageTypes(httpRequest.Headers.Get("Accept"));
+                    if (formats.Length == 0)
+                        formats = new string[1] { DefaultFormat }; // default
+
+                }
+                // OK, we have an array with preferred formats, possibly with only one entry
+
+                httpResponse.StatusCode = (int)System.Net.HttpStatusCode.NotFound;
+                foreach (string f in formats)
+                {
+                    if (FetchTexture(httpRequest, httpResponse, textureID, f))
+                        break;
+                }
+            }
+            else
+            {
+                m_log.Warn("[GETTEXTURE]: Failed to parse a texture_id from GetTexture request: " + httpRequest.Url);
+            }
+
+//            m_log.DebugFormat(
+//                "[GETTEXTURE]: For texture {0} sending back response {1}, data length {2}",
+//                textureID, httpResponse.StatusCode, httpResponse.ContentLength);
+
+            return null;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="httpRequest"></param>
+        /// <param name="httpResponse"></param>
+        /// <param name="textureID"></param>
+        /// <param name="format"></param>
+        /// <returns>False for "caller try another codec"; true otherwise</returns>
+        private bool FetchTexture(IOSHttpRequest httpRequest, IOSHttpResponse httpResponse, UUID textureID, string format)
+        {
+//            m_log.DebugFormat("[GETTEXTURE]: {0} with requested format {1}", textureID, format);
+            AssetBase texture;
+
+            string fullID = textureID.ToString();
+            if (format != DefaultFormat)
+                fullID = fullID + "-" + format;
+
+            if (!String.IsNullOrEmpty(m_RedirectURL))
+            {
+                // Only try to fetch locally cached textures. Misses are redirected
+                texture = m_assetService.GetCached(fullID);
+
+                if (texture != null)
+                {
+                    if (texture.Type != (sbyte)AssetType.Texture)
+                    {
+                        httpResponse.StatusCode = (int)System.Net.HttpStatusCode.NotFound;
+                        return true;
+                    }
+                    WriteTextureData(httpRequest, httpResponse, texture, format);
+                }
+                else
+                {
+                    string textureUrl = m_RedirectURL + "?texture_id="+ textureID.ToString();
+                    m_log.Debug("[GETTEXTURE]: Redirecting texture request to " + textureUrl);
+                    httpResponse.StatusCode = (int)OSHttpStatusCode.RedirectMovedPermanently;
+                    httpResponse.RedirectLocation = textureUrl;
+                    return true;
+                }
+            }
+            else // no redirect
+            {
+                // try the cache
+                texture = m_assetService.GetCached(fullID);
+
+                if (texture == null)
+                {
+//                    m_log.DebugFormat("[GETTEXTURE]: texture was not in the cache");
+
+                    // Fetch locally or remotely. Misses return a 404
+                    texture = m_assetService.Get(textureID.ToString());
+
+                    if (texture != null)
+                    {
+                        if (texture.Type != (sbyte)AssetType.Texture)
+                        {
+                            httpResponse.StatusCode = (int)System.Net.HttpStatusCode.NotFound;
+                            return true;
+                        }
+                        if (format == DefaultFormat)
+                        {
+                            WriteTextureData(httpRequest, httpResponse, texture, format);
+                            return true;
+                        }
+                        else
+                        {
+                            AssetBase newTexture = new AssetBase(texture.ID + "-" + format, texture.Name, (sbyte)AssetType.Texture, texture.Metadata.CreatorID);
+                            newTexture.Data = ConvertTextureData(texture, format);
+                            if (newTexture.Data.Length == 0)
+                                return false; // !!! Caller try another codec, please!
+
+                            newTexture.Flags = AssetFlags.Collectable;
+                            newTexture.Temporary = true;
+                            newTexture.Local = true;
+                            m_assetService.Store(newTexture);
+                            WriteTextureData(httpRequest, httpResponse, newTexture, format);
+                            return true;
+                        }
+                    }
+               }
+               else // it was on the cache
+               {
+//                   m_log.DebugFormat("[GETTEXTURE]: texture was in the cache");
+                   WriteTextureData(httpRequest, httpResponse, texture, format);
+                   return true;
+               }
+            }
+
+            // not found
+//            m_log.Warn("[GETTEXTURE]: Texture " + textureID + " not found");
+            httpResponse.StatusCode = (int)System.Net.HttpStatusCode.NotFound;
+            return true;
+        }
+
+        private void WriteTextureData(IOSHttpRequest request, IOSHttpResponse response, AssetBase texture, string format)
+        {
+            string range = request.Headers.GetOne("Range");
+
+            if (!String.IsNullOrEmpty(range)) // JP2's only
+            {
+                // Range request
+                int start, end;
+                if (TryParseRange(range, out start, out end))
+                {
+                    // Before clamping start make sure we can satisfy it in order to avoid
+                    // sending back the last byte instead of an error status
+                    if (start >= texture.Data.Length)
+                    {
+//                        m_log.DebugFormat(
+//                            "[GETTEXTURE]: Client requested range for texture {0} starting at {1} but texture has end of {2}",
+//                            texture.ID, start, texture.Data.Length);
+
+                        // Stricly speaking, as per http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html, we should be sending back
+                        // Requested Range Not Satisfiable (416) here.  However, it appears that at least recent implementations
+                        // of the Linden Lab viewer (3.2.1 and 3.3.4 and probably earlier), a viewer that has previously
+                        // received a very small texture  may attempt to fetch bytes from the server past the
+                        // range of data that it received originally.  Whether this happens appears to depend on whether
+                        // the viewer's estimation of how large a request it needs to make for certain discard levels
+                        // (http://wiki.secondlife.com/wiki/Image_System#Discard_Level_and_Mip_Mapping), chiefly discard
+                        // level 2.  If this estimate is greater than the total texture size, returning a RequestedRangeNotSatisfiable
+                        // here will cause the viewer to treat the texture as bad and never display the full resolution
+                        // 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;
+                    }
+                    else
+                    {
+                        // Handle the case where no second range value was given.  This is equivalent to requesting
+                        // the rest of the entity.
+                        if (end == -1)
+                            end = int.MaxValue;
+
+                        end = Utils.Clamp(end, 0, texture.Data.Length - 1);
+                        start = Utils.Clamp(start, 0, end);
+                        int len = end - start + 1;
+
+//                        m_log.Debug("Serving " + start + " to " + end + " of " + texture.Data.Length + " bytes for texture " + texture.ID);
+
+                        // 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);
+                    }
+                }
+                else
+                {
+                    m_log.Warn("[GETTEXTURE]: Malformed Range header: " + range);
+                    response.StatusCode = (int)System.Net.HttpStatusCode.BadRequest;
+                }
+            }
+            else // JP2's or other formats
+            {
+                // Full content request
+                response.StatusCode = (int)System.Net.HttpStatusCode.OK;
+                response.ContentLength = texture.Data.Length;
+                if (format == DefaultFormat)
+                    response.ContentType = texture.Metadata.ContentType;
+                else
+                    response.ContentType = "image/" + format;
+                response.Body.Write(texture.Data, 0, texture.Data.Length);
+            }
+
+//            if (response.StatusCode < 200 || response.StatusCode > 299)
+//                m_log.WarnFormat(
+//                    "[GETTEXTURE]: For texture {0} requested range {1} responded {2} with content length {3} (actual {4})",
+//                    texture.FullID, range, response.StatusCode, response.ContentLength, texture.Data.Length);
+//            else
+//                m_log.DebugFormat(
+//                    "[GETTEXTURE]: For texture {0} requested range {1} responded {2} with content length {3} (actual {4})",
+//                    texture.FullID, range, response.StatusCode, response.ContentLength, texture.Data.Length);
+        }
+
+        /// <summary>
+        /// Parse a range header.
+        /// </summary>
+        /// <remarks>
+        /// As per http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html,
+        /// this obeys range headers with two values (e.g. 533-4165) and no second value (e.g. 533-).
+        /// Where there is no value, -1 is returned.
+        /// FIXME: Need to cover the case where only a second value is specified (e.g. -4165), probably by returning -1
+        /// for start.</remarks>
+        /// <returns></returns>
+        /// <param name='header'></param>
+        /// <param name='start'>Start of the range.  Undefined if this was not a number.</param>
+        /// <param name='end'>End of the range.  Will be -1 if no end specified.  Undefined if there was a raw string but this was not a number.</param>
+        private bool TryParseRange(string header, out int start, out int end)
+        {
+            start = end = 0;
+
+            if (header.StartsWith("bytes="))
+            {
+                string[] rangeValues = header.Substring(6).Split('-');
+
+                if (rangeValues.Length == 2)
+                {
+                    if (!Int32.TryParse(rangeValues[0], out start))
+                        return false;
+
+                    string rawEnd = rangeValues[1];
+
+                    if (rawEnd == "")
+                    {
+                        end = -1;
+                        return true;
+                    }
+                    else if (Int32.TryParse(rawEnd, out end))
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            start = end = 0;
+            return false;
+        }
+
+        private byte[] ConvertTextureData(AssetBase texture, string format)
+        {
+            m_log.DebugFormat("[GETTEXTURE]: Converting texture {0} to {1}", texture.ID, format);
+            byte[] data = new byte[0];
+
+            MemoryStream imgstream = new MemoryStream();
+            Bitmap mTexture = new Bitmap(1, 1);
+            ManagedImage managedImage;
+            Image image = (Image)mTexture;
+
+            try
+            {
+                // Taking our jpeg2000 data, decoding it, then saving it to a byte array with regular data
+
+                imgstream = new MemoryStream();
+
+                // Decode image to System.Drawing.Image
+                if (OpenJPEG.DecodeToImage(texture.Data, out managedImage, out image))
+                {
+                    // Save to bitmap
+                    mTexture = new Bitmap(image);
+
+                    EncoderParameters myEncoderParameters = new EncoderParameters();
+                    myEncoderParameters.Param[0] = new EncoderParameter(Encoder.Quality, 95L);
+
+                    // Save bitmap to stream
+                    ImageCodecInfo codec = GetEncoderInfo("image/" + format);
+                    if (codec != null)
+                    {
+                        mTexture.Save(imgstream, codec, myEncoderParameters);
+                        // Write the stream to a byte array for output
+                        data = imgstream.ToArray();
+                    }
+                    else
+                        m_log.WarnFormat("[GETTEXTURE]: No such codec {0}", format);
+
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.WarnFormat("[GETTEXTURE]: Unable to convert texture {0} to {1}: {2}", texture.ID, format, e.Message);
+            }
+            finally
+            {
+                // Reclaim memory, these are unmanaged resources
+                // If we encountered an exception, one or more of these will be null
+                if (mTexture != null)
+                    mTexture.Dispose();
+
+                if (image != null)
+                    image.Dispose();
+
+                if (imgstream != null)
+                {
+                    imgstream.Close();
+                    imgstream.Dispose();
+                }
+            }
+
+            return data;
+        }
+
+        // From msdn
+        private static ImageCodecInfo GetEncoderInfo(String mimeType)
+        {
+            ImageCodecInfo[] encoders;
+            encoders = ImageCodecInfo.GetImageEncoders();
+            for (int j = 0; j < encoders.Length; ++j)
+            {
+                if (encoders[j].MimeType == mimeType)
+                    return encoders[j];
+            }
+            return null;
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/Handlers/GetTexture/GetTextureServerConnector.cs b/OpenSim/Capabilities/Handlers/GetTexture/GetTextureServerConnector.cs
new file mode 100644
index 0000000..fa0b228
--- /dev/null
+++ b/OpenSim/Capabilities/Handlers/GetTexture/GetTextureServerConnector.cs
@@ -0,0 +1,71 @@
+/*
+ * 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 Nini.Config;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+using OpenMetaverse;
+
+namespace OpenSim.Capabilities.Handlers
+{
+    public class GetTextureServerConnector : ServiceConnector
+    {
+        private IAssetService m_AssetService;
+        private string m_ConfigName = "CapsService";
+
+        public GetTextureServerConnector(IConfigSource config, IHttpServer server, string configName) :
+                base(config, server, configName)
+        {
+            if (configName != String.Empty)
+                m_ConfigName = configName;
+
+            IConfig serverConfig = config.Configs[m_ConfigName];
+            if (serverConfig == null)
+                throw new Exception(String.Format("No section '{0}' in config file", m_ConfigName));
+
+            string assetService = serverConfig.GetString("AssetService", String.Empty);
+
+            if (assetService == String.Empty)
+                throw new Exception("No AssetService in config file");
+
+            Object[] args = new Object[] { config };
+            m_AssetService =
+                    ServerUtils.LoadPlugin<IAssetService>(assetService, args);
+
+            if (m_AssetService == null)
+                throw new Exception(String.Format("Failed to load AssetService from {0}; config is {1}", assetService, m_ConfigName));
+
+            string rurl = serverConfig.GetString("GetTextureRedirectURL");
+            ;
+            server.AddStreamHandler(
+                new GetTextureHandler("/CAPS/GetTexture/" /*+ UUID.Random() */, m_AssetService, "GetTexture", null, rurl));
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/Handlers/GetTexture/Tests/GetTextureHandlerTests.cs b/OpenSim/Capabilities/Handlers/GetTexture/Tests/GetTextureHandlerTests.cs
new file mode 100644
index 0000000..e5d9618
--- /dev/null
+++ b/OpenSim/Capabilities/Handlers/GetTexture/Tests/GetTextureHandlerTests.cs
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Net;
+using log4net;
+using log4net.Config;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenSim.Capabilities.Handlers;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Tests.Common;
+
+namespace OpenSim.Capabilities.Handlers.GetTexture.Tests
+{
+    [TestFixture]
+    public class GetTextureHandlerTests : OpenSimTestCase
+    {
+        [Test]
+        public void TestTextureNotFound()
+        {
+            TestHelpers.InMethod();
+
+            // Overkill - we only really need the asset service, not a whole scene.
+            Scene scene = new SceneHelpers().SetupScene();
+
+            GetTextureHandler handler = new GetTextureHandler("/gettexture", scene.AssetService, "TestGetTexture", null, null);
+            TestOSHttpRequest req = new TestOSHttpRequest();
+            TestOSHttpResponse resp = new TestOSHttpResponse();
+            req.Url = new Uri("http://localhost/?texture_id=00000000-0000-1111-9999-000000000012");
+            handler.Handle(null, null, req, resp);
+            Assert.That(resp.StatusCode, Is.EqualTo((int)System.Net.HttpStatusCode.NotFound));
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/Handlers/Properties/AssemblyInfo.cs b/OpenSim/Capabilities/Handlers/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..3579649
--- /dev/null
+++ b/OpenSim/Capabilities/Handlers/Properties/AssemblyInfo.cs
@@ -0,0 +1,33 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("OpenSim.Capabilities.Handlers")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("http://opensimulator.org")]
+[assembly: AssemblyProduct("OpenSim")]
+[assembly: AssemblyCopyright("OpenSimulator developers")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("32350823-e1df-45e3-b7fa-0a58b4372433")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+[assembly: AssemblyVersion("0.8.2.*")]
+
diff --git a/OpenSim/Capabilities/Handlers/UploadBakedTexture/UploadBakedTextureHandler.cs b/OpenSim/Capabilities/Handlers/UploadBakedTexture/UploadBakedTextureHandler.cs
new file mode 100644
index 0000000..8849a59
--- /dev/null
+++ b/OpenSim/Capabilities/Handlers/UploadBakedTexture/UploadBakedTextureHandler.cs
@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections;
+using System.Collections.Specialized;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.Reflection;
+using System.IO;
+using System.Web;
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenMetaverse.Imaging;
+using OpenSim.Framework;
+using OpenSim.Framework.Capabilities;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+
+namespace OpenSim.Capabilities.Handlers
+{
+    public class UploadBakedTextureHandler
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private Caps m_HostCapsObj;
+        private IAssetService m_assetService;
+        private bool m_persistBakedTextures;
+
+        public UploadBakedTextureHandler(Caps caps, IAssetService assetService, bool persistBakedTextures)
+        {
+            m_HostCapsObj = caps;
+            m_assetService = assetService;
+            m_persistBakedTextures = persistBakedTextures;
+        }
+
+        /// <summary>
+        /// Handle a request from the client for a Uri to upload a baked texture.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <param name="httpRequest"></param>
+        /// <param name="httpResponse"></param>
+        /// <returns>The upload response if the request is successful, null otherwise.</returns>
+        public string UploadBakedTexture(
+            string request, string path, string param, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            try
+            {
+                string capsBase = "/CAPS/" + m_HostCapsObj.CapsObjectPath;
+                string uploaderPath = Util.RandomClass.Next(5000, 8000).ToString("0000");
+
+                BakedTextureUploader uploader =
+                    new BakedTextureUploader(capsBase + uploaderPath, m_HostCapsObj.HttpListener);
+                uploader.OnUpLoad += BakedTextureUploaded;
+
+                m_HostCapsObj.HttpListener.AddStreamHandler(
+                    new BinaryStreamHandler(
+                        "POST", capsBase + uploaderPath, uploader.uploaderCaps, "UploadBakedTexture", null));
+
+                string protocol = "http://";
+
+                if (m_HostCapsObj.SSLCaps)
+                    protocol = "https://";
+
+                string uploaderURL = protocol + m_HostCapsObj.HostName + ":" +
+                        m_HostCapsObj.Port.ToString() + capsBase + uploaderPath;
+
+                LLSDAssetUploadResponse uploadResponse = new LLSDAssetUploadResponse();
+                uploadResponse.uploader = uploaderURL;
+                uploadResponse.state = "upload";
+
+                return LLSDHelpers.SerialiseLLSDReply(uploadResponse);
+            }
+            catch (Exception e)
+            {
+                m_log.ErrorFormat("[UPLOAD BAKED TEXTURE HANDLER]: {0}{1}", e.Message, e.StackTrace);
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Called when a baked texture has been successfully uploaded by a client.
+        /// </summary>
+        /// <param name="assetID"></param>
+        /// <param name="data"></param>
+        private void BakedTextureUploaded(UUID assetID, byte[] data)
+        {
+//            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());
+            asset.Data = data;
+            asset.Temporary = true;
+            asset.Local = !m_persistBakedTextures; // Local assets aren't persisted, non-local are
+            m_assetService.Store(asset);
+        }
+    }
+
+    class BakedTextureUploader
+    {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        public event Action<UUID, byte[]> OnUpLoad;
+
+        private string uploaderPath = String.Empty;
+        private UUID newAssetID;
+        private IHttpServer httpListener;
+
+        public BakedTextureUploader(string path, IHttpServer httpServer)
+        {
+            newAssetID = UUID.Random();
+            uploaderPath = path;
+            httpListener = httpServer;
+            //                m_log.InfoFormat("[CAPS] baked texture upload starting for {0}",newAssetID);
+        }
+
+        /// <summary>
+        /// Handle raw uploaded baked texture data.
+        /// </summary>
+        /// <param name="data"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        public string uploaderCaps(byte[] data, string path, string param)
+        {
+            Action<UUID, byte[]> handlerUpLoad = OnUpLoad;
+
+            // Don't do this asynchronously, otherwise it's possible for the client to send set appearance information
+            // on another thread which might send out avatar updates before the asset has been put into the asset
+            // service.
+            if (handlerUpLoad != null)
+                handlerUpLoad(newAssetID, data);
+
+            string res = String.Empty;
+            LLSDAssetUploadComplete uploadComplete = new LLSDAssetUploadComplete();
+            uploadComplete.new_asset = newAssetID.ToString();
+            uploadComplete.new_inventory_item = UUID.Zero;
+            uploadComplete.state = "complete";
+
+            res = LLSDHelpers.SerialiseLLSDReply(uploadComplete);
+
+            httpListener.RemoveStreamHandler("POST", uploaderPath);
+
+//            m_log.DebugFormat("[BAKED TEXTURE UPLOADER]: baked texture upload completed for {0}", newAssetID);
+
+            return res;
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/Handlers/UploadBakedTexture/UploadBakedTextureServerConnector.cs b/OpenSim/Capabilities/Handlers/UploadBakedTexture/UploadBakedTextureServerConnector.cs
new file mode 100644
index 0000000..10ea8ee
--- /dev/null
+++ b/OpenSim/Capabilities/Handlers/UploadBakedTexture/UploadBakedTextureServerConnector.cs
@@ -0,0 +1,76 @@
+/*
+ * 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 Nini.Config;
+using OpenSim.Server.Base;
+using OpenSim.Services.Interfaces;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Server.Handlers.Base;
+using OpenMetaverse;
+
+namespace OpenSim.Capabilities.Handlers
+{
+    public class UploadBakedTextureServerConnector : ServiceConnector
+    {
+        private IAssetService m_AssetService;
+        private string m_ConfigName = "CapsService";
+
+        public UploadBakedTextureServerConnector(IConfigSource config, IHttpServer server, string configName) :
+                base(config, server, configName)
+        {
+            if (configName != String.Empty)
+                m_ConfigName = configName;
+
+            IConfig serverConfig = config.Configs[m_ConfigName];
+            if (serverConfig == null)
+                throw new Exception(String.Format("No section '{0}' in config file", m_ConfigName));
+
+            string assetService = serverConfig.GetString("AssetService", String.Empty);
+
+            if (assetService == String.Empty)
+                throw new Exception("No AssetService in config file");
+
+            Object[] args = new Object[] { config };
+            m_AssetService =
+                    ServerUtils.LoadPlugin<IAssetService>(assetService, args);
+
+            if (m_AssetService == null)
+                throw new Exception(String.Format("Failed to load AssetService from {0}; config is {1}", assetService, m_ConfigName));
+
+            // NEED TO FIX THIS
+            OpenSim.Framework.Capabilities.Caps caps = new OpenSim.Framework.Capabilities.Caps(server, "", server.Port, "", UUID.Zero, "");
+            server.AddStreamHandler(new RestStreamHandler(
+                        "POST",
+                        "/CAPS/UploadBakedTexture/",
+                        new UploadBakedTextureHandler(caps, m_AssetService, true).UploadBakedTexture,
+                        "UploadBakedTexture",
+                        "Upload Baked Texture Capability"));
+
+         }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/LLSD.cs b/OpenSim/Capabilities/LLSD.cs
new file mode 100644
index 0000000..c59cede
--- /dev/null
+++ b/OpenSim/Capabilities/LLSD.cs
@@ -0,0 +1,684 @@
+/*
+ * 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.Globalization;
+using System.IO;
+using System.Security.Cryptography;
+using System.Text;
+using System.Xml;
+using OpenMetaverse;
+
+namespace OpenSim.Framework.Capabilities
+{
+    /// <summary>
+    /// Borrowed from (a older version of) libsl for now, as their new llsd code doesn't work we our decoding code.
+    /// </summary>
+    public static class LLSD
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        public class LLSDParseException : Exception
+        {
+            public LLSDParseException(string message) : base(message)
+            {
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        public class LLSDSerializeException : Exception
+        {
+            public LLSDSerializeException(string message) : base(message)
+            {
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="b"></param>
+        /// <returns></returns>
+        public static object LLSDDeserialize(byte[] b)
+        {
+            using (MemoryStream ms = new MemoryStream(b, false))
+            {
+                return LLSDDeserialize(ms);
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="st"></param>
+        /// <returns></returns>
+        public static object LLSDDeserialize(Stream st)
+        {
+            using (XmlTextReader reader = new XmlTextReader(st))
+            {
+                reader.Read();
+                SkipWS(reader);
+
+                if (reader.NodeType != XmlNodeType.Element || reader.LocalName != "llsd")
+                    throw new LLSDParseException("Expected <llsd>");
+
+                reader.Read();
+                object ret = LLSDParseOne(reader);
+                SkipWS(reader);
+
+                if (reader.NodeType != XmlNodeType.EndElement || reader.LocalName != "llsd")
+                    throw new LLSDParseException("Expected </llsd>");
+
+                return ret;
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="obj"></param>
+        /// <returns></returns>
+        public static byte[] LLSDSerialize(object obj)
+        {
+            StringWriter sw = new StringWriter();
+            XmlTextWriter writer = new XmlTextWriter(sw);
+            writer.Formatting = Formatting.None;
+
+            writer.WriteStartElement(String.Empty, "llsd", String.Empty);
+            LLSDWriteOne(writer, obj);
+            writer.WriteEndElement();
+
+            writer.Close();
+
+            return Util.UTF8.GetBytes(sw.ToString());
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="obj"></param>
+        public static void LLSDWriteOne(XmlTextWriter writer, object obj)
+        {
+            if (obj == null)
+            {
+                writer.WriteStartElement(String.Empty, "undef", String.Empty);
+                writer.WriteEndElement();
+                return;
+            }
+
+            if (obj is string)
+            {
+                writer.WriteStartElement(String.Empty, "string", String.Empty);
+                writer.WriteString((string) obj);
+                writer.WriteEndElement();
+            }
+            else if (obj is int)
+            {
+                writer.WriteStartElement(String.Empty, "integer", String.Empty);
+                writer.WriteString(obj.ToString());
+                writer.WriteEndElement();
+            }
+            else if (obj is double)
+            {
+                writer.WriteStartElement(String.Empty, "real", String.Empty);
+                writer.WriteString(obj.ToString());
+                writer.WriteEndElement();
+            }
+            else if (obj is bool)
+            {
+                bool b = (bool) obj;
+                writer.WriteStartElement(String.Empty, "boolean", String.Empty);
+                writer.WriteString(b ? "1" : "0");
+                writer.WriteEndElement();
+            }
+            else if (obj is ulong)
+            {
+                throw new Exception("ulong in LLSD is currently not implemented, fix me!");
+            }
+            else if (obj is UUID)
+            {
+                UUID u = (UUID) obj;
+                writer.WriteStartElement(String.Empty, "uuid", String.Empty);
+                writer.WriteString(u.ToString());
+                writer.WriteEndElement();
+            }
+            else if (obj is Hashtable)
+            {
+                Hashtable h = obj as Hashtable;
+                writer.WriteStartElement(String.Empty, "map", String.Empty);
+                foreach (string key in h.Keys)
+                {
+                    writer.WriteStartElement(String.Empty, "key", String.Empty);
+                    writer.WriteString(key);
+                    writer.WriteEndElement();
+                    LLSDWriteOne(writer, h[key]);
+                }
+                writer.WriteEndElement();
+            }
+            else if (obj is ArrayList)
+            {
+                ArrayList a = obj as ArrayList;
+                writer.WriteStartElement(String.Empty, "array", String.Empty);
+                foreach (object item in a)
+                {
+                    LLSDWriteOne(writer, item);
+                }
+                writer.WriteEndElement();
+            }
+            else if (obj is byte[])
+            {
+                byte[] b = obj as byte[];
+                writer.WriteStartElement(String.Empty, "binary", String.Empty);
+
+                writer.WriteStartAttribute(String.Empty, "encoding", String.Empty);
+                writer.WriteString("base64");
+                writer.WriteEndAttribute();
+
+                //// Calculate the length of the base64 output
+                //long length = (long)(4.0d * b.Length / 3.0d);
+                //if (length % 4 != 0) length += 4 - (length % 4);
+
+                //// Create the char[] for base64 output and fill it
+                //char[] tmp = new char[length];
+                //int i = Convert.ToBase64CharArray(b, 0, b.Length, tmp, 0);
+
+                //writer.WriteString(new String(tmp));
+
+                writer.WriteString(Convert.ToBase64String(b));
+                writer.WriteEndElement();
+            }
+            else
+            {
+                throw new LLSDSerializeException("Unknown type " + obj.GetType().Name);
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <returns></returns>
+        public static object LLSDParseOne(XmlTextReader reader)
+        {
+            SkipWS(reader);
+            if (reader.NodeType != XmlNodeType.Element)
+                throw new LLSDParseException("Expected an element");
+
+            string dtype = reader.LocalName;
+            object ret = null;
+
+            switch (dtype)
+            {
+                case "undef":
+                    {
+                        if (reader.IsEmptyElement)
+                        {
+                            reader.Read();
+                            return null;
+                        }
+
+                        reader.Read();
+                        SkipWS(reader);
+                        ret = null;
+                        break;
+                    }
+                case "boolean":
+                    {
+                        if (reader.IsEmptyElement)
+                        {
+                            reader.Read();
+                            return false;
+                        }
+
+                        reader.Read();
+                        string s = reader.ReadString().Trim();
+
+                        if (s == String.Empty || s == "false" || s == "0")
+                            ret = false;
+                        else if (s == "true" || s == "1")
+                            ret = true;
+                        else
+                            throw new LLSDParseException("Bad boolean value " + s);
+
+                        break;
+                    }
+                case "integer":
+                    {
+                        if (reader.IsEmptyElement)
+                        {
+                            reader.Read();
+                            return 0;
+                        }
+
+                        reader.Read();
+                        ret = Convert.ToInt32(reader.ReadString().Trim());
+                        break;
+                    }
+                case "real":
+                    {
+                        if (reader.IsEmptyElement)
+                        {
+                            reader.Read();
+                            return 0.0f;
+                        }
+
+                        reader.Read();
+                        ret = Convert.ToDouble(reader.ReadString().Trim());
+                        break;
+                    }
+                case "uuid":
+                    {
+                        if (reader.IsEmptyElement)
+                        {
+                            reader.Read();
+                            return UUID.Zero;
+                        }
+
+                        reader.Read();
+                        ret = new UUID(reader.ReadString().Trim());
+                        break;
+                    }
+                case "string":
+                    {
+                        if (reader.IsEmptyElement)
+                        {
+                            reader.Read();
+                            return String.Empty;
+                        }
+
+                        reader.Read();
+                        ret = reader.ReadString();
+                        break;
+                    }
+                case "binary":
+                    {
+                        if (reader.IsEmptyElement)
+                        {
+                            reader.Read();
+                            return new byte[0];
+                        }
+
+                        if (reader.GetAttribute("encoding") != null &&
+                            reader.GetAttribute("encoding") != "base64")
+                        {
+                            throw new LLSDParseException("Unknown encoding: " + reader.GetAttribute("encoding"));
+                        }
+
+                        reader.Read();
+                        FromBase64Transform b64 = new FromBase64Transform(FromBase64TransformMode.IgnoreWhiteSpaces);
+                        byte[] inp = Util.UTF8.GetBytes(reader.ReadString());
+                        ret = b64.TransformFinalBlock(inp, 0, inp.Length);
+                        break;
+                    }
+                case "date":
+                    {
+                        reader.Read();
+                        throw new Exception("LLSD TODO: date");
+                    }
+                case "map":
+                    {
+                        return LLSDParseMap(reader);
+                    }
+                case "array":
+                    {
+                        return LLSDParseArray(reader);
+                    }
+                default:
+                    throw new LLSDParseException("Unknown element <" + dtype + ">");
+            }
+
+            if (reader.NodeType != XmlNodeType.EndElement || reader.LocalName != dtype)
+            {
+                throw new LLSDParseException("Expected </" + dtype + ">");
+            }
+
+            reader.Read();
+            return ret;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <returns></returns>
+        public static Hashtable LLSDParseMap(XmlTextReader reader)
+        {
+            Hashtable ret = new Hashtable();
+
+            if (reader.NodeType != XmlNodeType.Element || reader.LocalName != "map")
+                throw new LLSDParseException("Expected <map>");
+
+            if (reader.IsEmptyElement)
+            {
+                reader.Read();
+                return ret;
+            }
+
+            reader.Read();
+
+            while (true)
+            {
+                SkipWS(reader);
+                if (reader.NodeType == XmlNodeType.EndElement && reader.LocalName == "map")
+                {
+                    reader.Read();
+                    break;
+                }
+
+                if (reader.NodeType != XmlNodeType.Element || reader.LocalName != "key")
+                    throw new LLSDParseException("Expected <key>");
+
+                string key = reader.ReadString();
+
+                if (reader.NodeType != XmlNodeType.EndElement || reader.LocalName != "key")
+                    throw new LLSDParseException("Expected </key>");
+
+                reader.Read();
+                object val = LLSDParseOne(reader);
+                ret[key] = val;
+            }
+
+            return ret; // TODO
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <returns></returns>
+        public static ArrayList LLSDParseArray(XmlTextReader reader)
+        {
+            ArrayList ret = new ArrayList();
+
+            if (reader.NodeType != XmlNodeType.Element || reader.LocalName != "array")
+                throw new LLSDParseException("Expected <array>");
+
+            if (reader.IsEmptyElement)
+            {
+                reader.Read();
+                return ret;
+            }
+
+            reader.Read();
+
+            while (true)
+            {
+                SkipWS(reader);
+
+                if (reader.NodeType == XmlNodeType.EndElement && reader.LocalName == "array")
+                {
+                    reader.Read();
+                    break;
+                }
+
+                ret.Insert(ret.Count, LLSDParseOne(reader));
+            }
+
+            return ret; // TODO
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="count"></param>
+        /// <returns></returns>
+        private static string GetSpaces(int count)
+        {
+            StringBuilder b = new StringBuilder();
+            for (int i = 0; i < count; i++) b.Append(" ");
+            return b.ToString();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="obj"></param>
+        /// <param name="indent"></param>
+        /// <returns></returns>
+        public static String LLSDDump(object obj, int indent)
+        {
+            if (obj == null)
+            {
+                return GetSpaces(indent) + "- undef\n";
+            }
+            else if (obj is string)
+            {
+                return GetSpaces(indent) + "- string \"" + (string) obj + "\"\n";
+            }
+            else if (obj is int)
+            {
+                return GetSpaces(indent) + "- integer " + obj.ToString() + "\n";
+            }
+            else if (obj is double)
+            {
+                return GetSpaces(indent) + "- float " + obj.ToString() + "\n";
+            }
+            else if (obj is UUID)
+            {
+                return GetSpaces(indent) + "- uuid " + ((UUID) obj).ToString() + Environment.NewLine;
+            }
+            else if (obj is Hashtable)
+            {
+                StringBuilder ret = new StringBuilder();
+                ret.Append(GetSpaces(indent) + "- map" + Environment.NewLine);
+                Hashtable map = (Hashtable) obj;
+
+                foreach (string key in map.Keys)
+                {
+                    ret.Append(GetSpaces(indent + 2) + "- key \"" + key + "\"" + Environment.NewLine);
+                    ret.Append(LLSDDump(map[key], indent + 3));
+                }
+
+                return ret.ToString();
+            }
+            else if (obj is ArrayList)
+            {
+                StringBuilder ret = new StringBuilder();
+                ret.Append(GetSpaces(indent) + "- array\n");
+                ArrayList list = (ArrayList) obj;
+
+                foreach (object item in list)
+                {
+                    ret.Append(LLSDDump(item, indent + 2));
+                }
+
+                return ret.ToString();
+            }
+            else if (obj is byte[])
+            {
+                return GetSpaces(indent) + "- binary\n" + Utils.BytesToHexString((byte[]) obj, GetSpaces(indent)) +
+                       Environment.NewLine;
+            }
+            else
+            {
+                return GetSpaces(indent) + "- unknown type " + obj.GetType().Name + Environment.NewLine;
+            }
+        }
+
+        public static object ParseTerseLLSD(string llsd)
+        {
+            int notused;
+            return ParseTerseLLSD(llsd, out notused);
+        }
+
+        public static object ParseTerseLLSD(string llsd, out int endPos)
+        {
+            if (llsd.Length == 0)
+            {
+                endPos = 0;
+                return null;
+            }
+
+            // Identify what type of object this is
+            switch (llsd[0])
+            {
+                case '!':
+                    throw new LLSDParseException("Undefined value type encountered");
+                case '1':
+                    endPos = 1;
+                    return true;
+                case '0':
+                    endPos = 1;
+                    return false;
+                case 'i':
+                    {
+                        if (llsd.Length < 2) throw new LLSDParseException("Integer value type with no value");
+                        int value;
+                        endPos = FindEnd(llsd, 1);
+
+                        if (Int32.TryParse(llsd.Substring(1, endPos - 1), out value))
+                            return value;
+                        else
+                            throw new LLSDParseException("Failed to parse integer value type");
+                    }
+                case 'r':
+                    {
+                        if (llsd.Length < 2) throw new LLSDParseException("Real value type with no value");
+                        double value;
+                        endPos = FindEnd(llsd, 1);
+
+                        if (Double.TryParse(llsd.Substring(1, endPos - 1), NumberStyles.Float,
+                                            Utils.EnUsCulture.NumberFormat, out value))
+                            return value;
+                        else
+                            throw new LLSDParseException("Failed to parse double value type");
+                    }
+                case 'u':
+                    {
+                        if (llsd.Length < 17) throw new LLSDParseException("UUID value type with no value");
+                        UUID value;
+                        endPos = FindEnd(llsd, 1);
+
+                        if (UUID.TryParse(llsd.Substring(1, endPos - 1), out value))
+                            return value;
+                        else
+                            throw new LLSDParseException("Failed to parse UUID value type");
+                    }
+                case 'b':
+                    //byte[] value = new byte[llsd.Length - 1];
+                    // This isn't the actual binary LLSD format, just the terse format sent
+                    // at login so I don't even know if there is a binary type
+                    throw new LLSDParseException("Binary value type is unimplemented");
+                case 's':
+                case 'l':
+                    if (llsd.Length < 2) throw new LLSDParseException("String value type with no value");
+                    endPos = FindEnd(llsd, 1);
+                    return llsd.Substring(1, endPos - 1);
+                case 'd':
+                    // Never seen one before, don't know what the format is
+                    throw new LLSDParseException("Date value type is unimplemented");
+                case '[':
+                    {
+                        if (llsd.IndexOf(']') == -1) throw new LLSDParseException("Invalid array");
+
+                        int pos = 0;
+                        ArrayList array = new ArrayList();
+
+                        while (llsd[pos] != ']')
+                        {
+                            ++pos;
+
+                            // Advance past comma if need be
+                            if (llsd[pos] == ',') ++pos;
+
+                            // Allow a single whitespace character
+                            if (pos < llsd.Length && llsd[pos] == ' ') ++pos;
+
+                            int end;
+                            array.Add(ParseTerseLLSD(llsd.Substring(pos), out end));
+                            pos += end;
+                        }
+
+                        endPos = pos + 1;
+                        return array;
+                    }
+                case '{':
+                    {
+                        if (llsd.IndexOf('}') == -1) throw new LLSDParseException("Invalid map");
+
+                        int pos = 0;
+                        Hashtable hashtable = new Hashtable();
+
+                        while (llsd[pos] != '}')
+                        {
+                            ++pos;
+
+                            // Advance past comma if need be
+                            if (llsd[pos] == ',') ++pos;
+
+                            // Allow a single whitespace character
+                            if (pos < llsd.Length && llsd[pos] == ' ') ++pos;
+
+                            if (llsd[pos] != '\'') throw new LLSDParseException("Expected a map key");
+                            int endquote = llsd.IndexOf('\'', pos + 1);
+                            if (endquote == -1 || (endquote + 1) >= llsd.Length || llsd[endquote + 1] != ':')
+                                throw new LLSDParseException("Invalid map format");
+                            string key = llsd.Substring(pos, endquote - pos);
+                            key = key.Replace("'", String.Empty);
+                            pos += (endquote - pos) + 2;
+
+                            int end;
+                            hashtable.Add(key, ParseTerseLLSD(llsd.Substring(pos), out end));
+                            pos += end;
+                        }
+
+                        endPos = pos + 1;
+                        return hashtable;
+                    }
+                default:
+                    throw new Exception("Unknown value type");
+            }
+        }
+
+        private static int FindEnd(string llsd, int start)
+        {
+            int end = llsd.IndexOfAny(new char[] {',', ']', '}'});
+            if (end == -1) end = llsd.Length - 1;
+            return end;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="reader"></param>
+        private static void SkipWS(XmlTextReader reader)
+        {
+            while (
+                reader.NodeType == XmlNodeType.Comment ||
+                reader.NodeType == XmlNodeType.Whitespace ||
+                reader.NodeType == XmlNodeType.SignificantWhitespace ||
+                reader.NodeType == XmlNodeType.XmlDeclaration)
+            {
+                reader.Read();
+            }
+        }
+    }
+}
diff --git a/OpenSim/Capabilities/LLSDArray.cs b/OpenSim/Capabilities/LLSDArray.cs
new file mode 100644
index 0000000..3459e49
--- /dev/null
+++ b/OpenSim/Capabilities/LLSDArray.cs
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System.Collections;
+
+namespace OpenSim.Framework.Capabilities
+{
+    [LLSDType("ARRAY")]
+    public class OSDArray
+    {
+        public ArrayList Array = new ArrayList();
+
+        public OSDArray()
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/LLSDAssetUploadComplete.cs b/OpenSim/Capabilities/LLSDAssetUploadComplete.cs
new file mode 100644
index 0000000..ab6cee5
--- /dev/null
+++ b/OpenSim/Capabilities/LLSDAssetUploadComplete.cs
@@ -0,0 +1,45 @@
+/*
+ * 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 OpenMetaverse;
+
+namespace OpenSim.Framework.Capabilities
+{
+    [LLSDType("MAP")]
+    public class LLSDAssetUploadComplete
+    {
+        public string new_asset = String.Empty;
+        public UUID new_inventory_item = UUID.Zero;
+        public string state = String.Empty;
+        //public bool success = false;
+
+        public LLSDAssetUploadComplete()
+        {
+        }
+    }
+}
diff --git a/OpenSim/Capabilities/LLSDAssetUploadRequest.cs b/OpenSim/Capabilities/LLSDAssetUploadRequest.cs
new file mode 100644
index 0000000..6e66f0a
--- /dev/null
+++ b/OpenSim/Capabilities/LLSDAssetUploadRequest.cs
@@ -0,0 +1,46 @@
+/*
+ * 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 OpenMetaverse;
+
+namespace OpenSim.Framework.Capabilities
+{
+    [OSDMap]
+    public class LLSDAssetUploadRequest
+    {
+        public string asset_type = String.Empty;
+        public string description = String.Empty;
+        public UUID folder_id = UUID.Zero;
+        public string inventory_type = String.Empty;
+        public string name = String.Empty;
+
+        public LLSDAssetUploadRequest()
+        {
+        }
+    }
+}
diff --git a/OpenSim/Capabilities/LLSDAssetUploadResponse.cs b/OpenSim/Capabilities/LLSDAssetUploadResponse.cs
new file mode 100644
index 0000000..0d6f7f9
--- /dev/null
+++ b/OpenSim/Capabilities/LLSDAssetUploadResponse.cs
@@ -0,0 +1,56 @@
+/*
+ * 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;
+
+namespace OpenSim.Framework.Capabilities
+{
+    [OSDMap]
+    public class LLSDAssetUploadResponse
+    {
+        public string uploader = String.Empty;
+        public string state = String.Empty;
+
+        public LLSDAssetUploadResponse()
+        {
+        }
+    }
+
+    [OSDMap]
+    public class LLSDNewFileAngentInventoryVariablePriceReplyResponse
+    {
+        public int resource_cost;
+        public string state;
+        public int upload_price;
+        public string rsvp;
+        
+        public LLSDNewFileAngentInventoryVariablePriceReplyResponse()
+        {
+            state = "confirm_upload";
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/LLSDAvatarPicker.cs b/OpenSim/Capabilities/LLSDAvatarPicker.cs
new file mode 100644
index 0000000..d0b3f3a
--- /dev/null
+++ b/OpenSim/Capabilities/LLSDAvatarPicker.cs
@@ -0,0 +1,51 @@
+/*
+ * 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 OpenMetaverse;
+
+namespace OpenSim.Framework.Capabilities
+{
+    [OSDMap]
+    public class LLSDAvatarPicker
+    {
+        public string next_page_url;
+        // an array of LLSDPerson
+        public OSDArray agents = new OSDArray();
+    }
+
+    [OSDMap]
+    public class LLSDPerson
+    {
+        public string username;
+        public string display_name;
+        //'display_name_next_update':d"1970-01-01T00:00:00Z" 
+        public string legacy_first_name;
+        public string legacy_last_name;
+        public UUID id;
+        public bool is_display_name_default;
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/LLSDCapEvent.cs b/OpenSim/Capabilities/LLSDCapEvent.cs
new file mode 100644
index 0000000..63abd62
--- /dev/null
+++ b/OpenSim/Capabilities/LLSDCapEvent.cs
@@ -0,0 +1,40 @@
+/*
+ * 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.
+ */
+
+namespace OpenSim.Framework.Capabilities
+{
+    [LLSDType("MAP")]
+    public class LLSDCapEvent
+    {
+        public int id = 0;
+        public OSDArray events = new OSDArray();
+
+        public LLSDCapEvent()
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/LLSDEmpty.cs b/OpenSim/Capabilities/LLSDEmpty.cs
new file mode 100644
index 0000000..f94fcba
--- /dev/null
+++ b/OpenSim/Capabilities/LLSDEmpty.cs
@@ -0,0 +1,37 @@
+/*
+ * 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.
+ */
+
+namespace OpenSim.Framework.Capabilities
+{
+    [LLSDType("MAP")]
+    public class LLSDEmpty
+    {
+        public LLSDEmpty()
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/LLSDEnvironmentSettings.cs b/OpenSim/Capabilities/LLSDEnvironmentSettings.cs
new file mode 100644
index 0000000..39019af
--- /dev/null
+++ b/OpenSim/Capabilities/LLSDEnvironmentSettings.cs
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using OpenMetaverse;
+
+namespace OpenSim.Framework.Capabilities
+{
+    [OSDMap]
+    public class LLSDEnvironmentRequest
+    {
+        public UUID messageID;
+        public UUID regionID;
+    }
+
+    [OSDMap]
+    public class LLSDEnvironmentSetResponse
+    {
+        public UUID regionID;
+        public UUID messageID;
+        public Boolean success;
+        public String fail_reason;
+    }
+
+    public class EnvironmentSettings
+    {
+        /// <summary>
+        /// generates a empty llsd settings response for viewer
+        /// </summary>
+        /// <param name="messageID">the message UUID</param>
+        /// <param name="regionID">the region UUID</param>
+        public static string EmptySettings(UUID messageID, UUID regionID)
+        {
+            OSDArray arr = new OSDArray();
+            LLSDEnvironmentRequest msg = new LLSDEnvironmentRequest();
+            msg.messageID = messageID;
+            msg.regionID = regionID;
+            arr.Array.Add(msg);
+            return LLSDHelpers.SerialiseLLSDReply(arr);
+        }
+    }
+
+}
diff --git a/OpenSim/Capabilities/LLSDHelpers.cs b/OpenSim/Capabilities/LLSDHelpers.cs
new file mode 100644
index 0000000..8f1a40e
--- /dev/null
+++ b/OpenSim/Capabilities/LLSDHelpers.cs
@@ -0,0 +1,172 @@
+/*
+ * 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.IO;
+using System.Reflection;
+using System.Xml;
+
+namespace OpenSim.Framework.Capabilities
+{
+    public class LLSDHelpers
+    {
+//        private static readonly log4net.ILog m_log
+//            = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
+        public static string SerialiseLLSDReply(object obj)
+        {
+            StringWriter sw = new StringWriter();
+            XmlTextWriter writer = new XmlTextWriter(sw);
+            writer.Formatting = Formatting.None;
+            writer.WriteStartElement(String.Empty, "llsd", String.Empty);
+            SerializeOSDType(writer, obj);
+            writer.WriteEndElement();
+            writer.Close();
+
+            //m_log.DebugFormat("[LLSD Helpers]: Generated serialized LLSD reply {0}", sw.ToString());
+
+            return sw.ToString();
+        }
+
+        private static void SerializeOSDType(XmlTextWriter writer, object obj)
+        {
+            Type myType = obj.GetType();
+            LLSDType[] llsdattributes = (LLSDType[]) myType.GetCustomAttributes(typeof (LLSDType), false);
+            if (llsdattributes.Length > 0)
+            {
+                switch (llsdattributes[0].ObjectType)
+                {
+                    case "MAP":
+                        writer.WriteStartElement(String.Empty, "map", String.Empty);
+                        FieldInfo[] fields = myType.GetFields();
+                        for (int i = 0; i < fields.Length; i++)
+                        {
+                            if (fields[i] != null && fields[i].GetValue(obj) != null)
+                            {
+                                object fieldValue = fields[i].GetValue(obj);
+                                LLSDType[] fieldAttributes =
+                                    (LLSDType[]) fieldValue.GetType().GetCustomAttributes(typeof (LLSDType), false);
+                                if (fieldAttributes.Length > 0)
+                                {
+                                    writer.WriteStartElement(String.Empty, "key", String.Empty);
+                                    string fieldName = fields[i].Name;
+                                    fieldName = fieldName.Replace("___", "-");
+                                    writer.WriteString(fieldName);
+                                    writer.WriteEndElement();
+                                    SerializeOSDType(writer, fieldValue);
+                                }
+                                else
+                                {
+                                    writer.WriteStartElement(String.Empty, "key", String.Empty);
+                                    string fieldName = fields[i].Name;
+                                    fieldName = fieldName.Replace("___", "-");
+                                    writer.WriteString(fieldName);
+                                    writer.WriteEndElement();
+                                    LLSD.LLSDWriteOne(writer, fieldValue);
+                                    // OpenMetaverse.StructuredData.LLSDParser.SerializeXmlElement(
+                                    //    writer, OpenMetaverse.StructuredData.OSD.FromObject(fieldValue));
+                                }
+                            }
+                            else
+                            {
+                                // TODO from ADAM: There is a nullref being caused by fields[i] being null
+                                // on some computers. Unsure what is causing this, but would appreciate
+                                // if sdague could take a look at this.
+                            }
+                        }
+                        writer.WriteEndElement();
+                        break;
+                    case "ARRAY":
+                        // OSDArray arrayObject = obj as OSDArray;
+                        // ArrayList a = arrayObject.Array;
+                        ArrayList a = (ArrayList) obj.GetType().GetField("Array").GetValue(obj);
+                        if (a != null)
+                        {
+                            writer.WriteStartElement(String.Empty, "array", String.Empty);
+                            foreach (object item in a)
+                            {
+                                SerializeOSDType(writer, item);
+                            }
+                            writer.WriteEndElement();
+                        }
+                        break;
+                }
+            }
+            else
+            {
+                LLSD.LLSDWriteOne(writer, obj);
+                //OpenMetaverse.StructuredData.LLSDParser.SerializeXmlElement(
+                //    writer, OpenMetaverse.StructuredData.OSD.FromObject(obj));
+            }
+        }
+
+        public static object DeserialiseOSDMap(Hashtable llsd, object obj)
+        {
+            Type myType = obj.GetType();
+            LLSDType[] llsdattributes = (LLSDType[]) myType.GetCustomAttributes(typeof (LLSDType), false);
+            if (llsdattributes.Length > 0)
+            {
+                switch (llsdattributes[0].ObjectType)
+                {
+                    case "MAP":
+                        IDictionaryEnumerator enumerator = llsd.GetEnumerator();
+                        while (enumerator.MoveNext())
+                        {
+                            string keyName = (string)enumerator.Key;
+                            keyName = keyName.Replace("-","_");
+                            FieldInfo field = myType.GetField(keyName);
+                            if (field != null)
+                            {
+                                // if (enumerator.Value is OpenMetaverse.StructuredData.OSDMap)
+                                if (enumerator.Value is Hashtable)
+                                {
+                                    object fieldValue = field.GetValue(obj);
+                                    DeserialiseOSDMap((Hashtable) enumerator.Value, fieldValue);
+                                    //  DeserialiseOSDMap((OpenMetaverse.StructuredData.OSDMap) enumerator.Value, fieldValue);
+                                }
+                                else if (enumerator.Value is ArrayList)
+                                {
+                                    object fieldValue = field.GetValue(obj);
+                                    fieldValue.GetType().GetField("Array").SetValue(fieldValue, enumerator.Value);
+                                    //TODO
+                                    // the LLSD map/array types in the array need to be deserialised
+                                    // but first we need to know the right class to deserialise them into.
+                                }
+                                else
+                                {
+                                    field.SetValue(obj, enumerator.Value);
+                                }
+                            }
+                        }
+                        break;
+                }
+            }
+            return obj;
+        }
+    }
+}
diff --git a/OpenSim/Capabilities/LLSDInventoryFolder.cs b/OpenSim/Capabilities/LLSDInventoryFolder.cs
new file mode 100644
index 0000000..d085430
--- /dev/null
+++ b/OpenSim/Capabilities/LLSDInventoryFolder.cs
@@ -0,0 +1,41 @@
+/*
+ * 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 OpenMetaverse;
+
+namespace OpenSim.Framework.Capabilities
+{
+    [OSDMap]
+    public class LLSDInventoryFolder
+    {
+        public UUID folder_id;
+        public UUID parent_id;
+        public string name;
+        public int type;
+        public int preferred_type;
+    }
+}
diff --git a/OpenSim/Capabilities/LLSDInventoryItem.cs b/OpenSim/Capabilities/LLSDInventoryItem.cs
new file mode 100644
index 0000000..958e807
--- /dev/null
+++ b/OpenSim/Capabilities/LLSDInventoryItem.cs
@@ -0,0 +1,105 @@
+/*
+ * 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 OpenMetaverse;
+
+namespace OpenSim.Framework.Capabilities
+{
+    [OSDMap]
+    public class LLSDInventoryItem
+    {
+        public UUID parent_id;
+
+        public UUID asset_id;
+        public UUID item_id;
+        public LLSDPermissions permissions;
+        public int type;
+        public int inv_type;
+        public int flags;
+
+        public LLSDSaleInfo sale_info;
+        public string name;
+        public string desc;
+        public int created_at;
+    }
+
+    [OSDMap]
+    public class LLSDPermissions
+    {
+        public UUID creator_id;
+        public UUID owner_id;
+        public UUID group_id;
+        public int base_mask;
+        public int owner_mask;
+        public int group_mask;
+        public int everyone_mask;
+        public int next_owner_mask;
+        public bool is_owner_group;
+    }
+
+    [OSDMap]
+    public class LLSDSaleInfo
+    {
+        public int sale_price;
+        public int sale_type;
+    }
+
+    [OSDMap]
+    public class LLSDInventoryDescendents
+    {
+        public OSDArray folders = new OSDArray();
+    }
+
+    [OSDMap]
+    public class LLSDFetchInventoryDescendents
+    {
+        public UUID folder_id;
+        public UUID owner_id;
+        public int sort_order;
+        public bool fetch_folders;
+        public bool fetch_items;
+    }
+
+    [OSDMap]
+    public class LLSDInventoryFolderContents
+    {
+        public UUID agent_id; 
+        public int descendents;
+        public UUID folder_id; 
+        public OSDArray categories = new OSDArray();
+        public OSDArray items = new OSDArray();
+        public UUID owner_id; 
+        public int version;
+    }
+
+    [OSDMap]
+    public class LLSDFetchInventory
+    {
+        public UUID agent_id;
+        public OSDArray items = new OSDArray();
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/LLSDItemUpdate.cs b/OpenSim/Capabilities/LLSDItemUpdate.cs
new file mode 100644
index 0000000..96e2b61
--- /dev/null
+++ b/OpenSim/Capabilities/LLSDItemUpdate.cs
@@ -0,0 +1,41 @@
+/*
+ * 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 OpenMetaverse;
+
+namespace OpenSim.Framework.Capabilities
+{
+    [OSDMap]
+    public class LLSDItemUpdate
+    {
+        public UUID item_id;
+
+        public LLSDItemUpdate()
+        {
+        }
+    }
+}
diff --git a/OpenSim/Capabilities/LLSDMapLayer.cs b/OpenSim/Capabilities/LLSDMapLayer.cs
new file mode 100644
index 0000000..4aeb1ff
--- /dev/null
+++ b/OpenSim/Capabilities/LLSDMapLayer.cs
@@ -0,0 +1,45 @@
+/*
+ * 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 OpenMetaverse;
+
+namespace OpenSim.Framework.Capabilities
+{
+    [LLSDType("MAP")]
+    public class OSDMapLayer
+    {
+        public int Left = 0;
+        public int Right = 0;
+        public int Top = 0;
+        public int Bottom = 0;
+        public UUID ImageID = UUID.Zero;
+
+        public OSDMapLayer()
+        {
+        }
+    }
+}
diff --git a/OpenSim/Capabilities/LLSDMapLayerResponse.cs b/OpenSim/Capabilities/LLSDMapLayerResponse.cs
new file mode 100644
index 0000000..839e34c
--- /dev/null
+++ b/OpenSim/Capabilities/LLSDMapLayerResponse.cs
@@ -0,0 +1,40 @@
+/*
+ * 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.
+ */
+
+namespace OpenSim.Framework.Capabilities
+{
+    [LLSDType("MAP")]
+    public class LLSDMapLayerResponse
+    {
+        public LLSDMapRequest AgentData = new LLSDMapRequest();
+        public OSDArray LayerData = new OSDArray();
+
+        public LLSDMapLayerResponse()
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/LLSDMapRequest.cs b/OpenSim/Capabilities/LLSDMapRequest.cs
new file mode 100644
index 0000000..debf387
--- /dev/null
+++ b/OpenSim/Capabilities/LLSDMapRequest.cs
@@ -0,0 +1,39 @@
+/*
+ * 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.
+ */
+
+namespace OpenSim.Framework.Capabilities
+{
+    [LLSDType("MAP")]
+    public class LLSDMapRequest
+    {
+        public int Flags = 0;
+
+        public LLSDMapRequest()
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/LLSDMethod.cs b/OpenSim/Capabilities/LLSDMethod.cs
new file mode 100644
index 0000000..cd2574d
--- /dev/null
+++ b/OpenSim/Capabilities/LLSDMethod.cs
@@ -0,0 +1,31 @@
+/*
+ * 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.
+ */
+
+namespace OpenSim.Framework.Capabilities
+{
+    public delegate TResponse LLSDMethod<TRequest, TResponse>(TRequest request);
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/LLSDMethodString.cs b/OpenSim/Capabilities/LLSDMethodString.cs
new file mode 100644
index 0000000..38700d5
--- /dev/null
+++ b/OpenSim/Capabilities/LLSDMethodString.cs
@@ -0,0 +1,31 @@
+/*
+ * 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.
+ */
+
+namespace OpenSim.Framework.Capabilities
+{
+    public delegate TResponse LLSDMethodString<TRequest, TResponse>(TRequest request, string path);
+}
diff --git a/OpenSim/Capabilities/LLSDParcelVoiceInfoResponse.cs b/OpenSim/Capabilities/LLSDParcelVoiceInfoResponse.cs
new file mode 100644
index 0000000..b34a668
--- /dev/null
+++ b/OpenSim/Capabilities/LLSDParcelVoiceInfoResponse.cs
@@ -0,0 +1,51 @@
+/*
+* Copyright (c) Contributors, http://opensimulator.org/
+* See CONTRIBUTORS.TXT for a full list of copyright holders.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*     * Redistributions of source code must retain the above copyright
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above copyright
+*       notice, this list of conditions and the following disclaimer in the
+*       documentation and/or other materials provided with the distribution.
+*     * Neither the name of the OpenSimulator Project nor the
+*       names of its contributors may be used to endorse or promote products
+*       derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*
+*/
+
+using System.Collections;
+
+namespace OpenSim.Framework.Capabilities
+{
+    [OSDMap]
+    public class LLSDParcelVoiceInfoResponse
+    {
+        public int parcel_local_id;
+        public string region_name;
+        public Hashtable voice_credentials;
+
+        public LLSDParcelVoiceInfoResponse()
+        {
+        }
+
+        public LLSDParcelVoiceInfoResponse(string region, int localID, Hashtable creds)
+        {
+            region_name = region;
+            parcel_local_id = localID;
+            voice_credentials = creds;
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/LLSDRemoteParcelResponse.cs b/OpenSim/Capabilities/LLSDRemoteParcelResponse.cs
new file mode 100644
index 0000000..13d69d3
--- /dev/null
+++ b/OpenSim/Capabilities/LLSDRemoteParcelResponse.cs
@@ -0,0 +1,42 @@
+/*
+* 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 OpenMetaverse;
+
+namespace OpenSim.Framework.Capabilities
+{
+    [LLSDType("MAP")]
+    public class LLSDRemoteParcelResponse
+    {
+        public UUID parcel_id;
+
+        public LLSDRemoteParcelResponse()
+        {
+        }
+    }
+}
diff --git a/OpenSim/Capabilities/LLSDStreamHandler.cs b/OpenSim/Capabilities/LLSDStreamHandler.cs
new file mode 100644
index 0000000..4fa1153
--- /dev/null
+++ b/OpenSim/Capabilities/LLSDStreamHandler.cs
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System.Collections;
+using System.IO;
+using System.Text;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+
+namespace OpenSim.Framework.Capabilities
+{
+    public class LLSDStreamhandler<TRequest, TResponse> : BaseStreamHandler
+        where TRequest : new()
+    {
+        private LLSDMethod<TRequest, TResponse> m_method;
+
+        public LLSDStreamhandler(string httpMethod, string path, LLSDMethod<TRequest, TResponse> method)
+            : this(httpMethod, path, method, null, null) {}
+
+        public LLSDStreamhandler(
+            string httpMethod, string path, LLSDMethod<TRequest, TResponse> method, string name, string description)
+            : base(httpMethod, path, name, description)
+        {
+            m_method = method;
+        }
+
+        protected override byte[] ProcessRequest(string path, Stream request,
+                                      IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
+        {
+            //Encoding encoding = Util.UTF8;
+            //StreamReader streamReader = new StreamReader(request, false);
+
+            //string requestBody = streamReader.ReadToEnd();
+            //streamReader.Close();
+
+            // OpenMetaverse.StructuredData.OSDMap hash = (OpenMetaverse.StructuredData.OSDMap)
+            //    OpenMetaverse.StructuredData.LLSDParser.DeserializeXml(new XmlTextReader(request));
+
+            Hashtable hash = (Hashtable) LLSD.LLSDDeserialize(request);
+            TRequest llsdRequest = new TRequest();
+            LLSDHelpers.DeserialiseOSDMap(hash, llsdRequest);
+
+            TResponse response = m_method(llsdRequest);
+
+            return Util.UTF8NoBomEncoding.GetBytes(LLSDHelpers.SerialiseLLSDReply(response));
+        }
+    }
+}
diff --git a/OpenSim/Capabilities/LLSDTaskInventoryUploadComplete.cs b/OpenSim/Capabilities/LLSDTaskInventoryUploadComplete.cs
new file mode 100644
index 0000000..47fdaca
--- /dev/null
+++ b/OpenSim/Capabilities/LLSDTaskInventoryUploadComplete.cs
@@ -0,0 +1,50 @@
+/*
+ * 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 OpenMetaverse;
+
+namespace OpenSim.Framework.Capabilities
+{
+    [OSDMap]
+    public class LLSDTaskInventoryUploadComplete
+    {
+        /// <summary>
+        /// The task inventory item that was updated
+        /// </summary>
+        public UUID item_id;
+
+        /// <summary>
+        /// The task that was updated
+        /// </summary>
+        public UUID task_id;
+
+        /// <summary>
+        /// State of the upload.  So far have only even seen this set to "complete"
+        /// </summary>
+        public string state;
+    }
+}
diff --git a/OpenSim/Capabilities/LLSDTaskScriptUpdate.cs b/OpenSim/Capabilities/LLSDTaskScriptUpdate.cs
new file mode 100644
index 0000000..9d7c17f
--- /dev/null
+++ b/OpenSim/Capabilities/LLSDTaskScriptUpdate.cs
@@ -0,0 +1,50 @@
+/*
+ * 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 OpenMetaverse;
+
+namespace OpenSim.Framework.Capabilities
+{
+    [OSDMap]
+    public class LLSDTaskScriptUpdate
+    {
+        /// <summary>
+        /// The item containing the script to update
+        /// </summary>
+        public UUID item_id;
+
+        /// <summary>
+        /// The task containing the script
+        /// </summary>
+        public UUID task_id;
+
+        /// <summary>
+        /// Signals whether the script is currently active
+        /// </summary>
+        public int is_script_running;
+    }
+}
diff --git a/OpenSim/Capabilities/LLSDTaskScriptUploadComplete.cs b/OpenSim/Capabilities/LLSDTaskScriptUploadComplete.cs
new file mode 100644
index 0000000..d308831
--- /dev/null
+++ b/OpenSim/Capabilities/LLSDTaskScriptUploadComplete.cs
@@ -0,0 +1,54 @@
+/*
+ * 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 OpenMetaverse;
+using System;
+using System.Collections;
+
+namespace OpenSim.Framework.Capabilities
+{
+    [OSDMap]
+    public class LLSDTaskScriptUploadComplete
+    {
+        /// <summary>
+        /// The task inventory item that was updated
+        /// </summary>
+        public UUID new_asset;
+
+        /// <summary>
+        /// Was it compiled?
+        /// </summary>
+        public bool compiled;
+
+        /// <summary>
+        /// State of the upload.  So far have only even seen this set to "complete"
+        /// </summary>
+        public string state;
+
+        public OSDArray errors;
+    }
+}
diff --git a/OpenSim/Capabilities/LLSDTest.cs b/OpenSim/Capabilities/LLSDTest.cs
new file mode 100644
index 0000000..5f77c3d
--- /dev/null
+++ b/OpenSim/Capabilities/LLSDTest.cs
@@ -0,0 +1,40 @@
+/*
+ * 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.
+ */
+
+namespace OpenSim.Framework.Capabilities
+{
+    [LLSDType("MAP")]
+    public class LLSDTest
+    {
+        public int Test1 = 20;
+        public int Test2 = 10;
+
+        public LLSDTest()
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/LLSDType.cs b/OpenSim/Capabilities/LLSDType.cs
new file mode 100644
index 0000000..d5ca1ab
--- /dev/null
+++ b/OpenSim/Capabilities/LLSDType.cs
@@ -0,0 +1,55 @@
+/*
+ * 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;
+
+namespace OpenSim.Framework.Capabilities
+{
+    [AttributeUsage(AttributeTargets.Class)]
+    public class LLSDType : Attribute
+    {
+        protected string myType;
+
+        public LLSDType(string type)
+        {
+            myType = type;
+        }
+
+        public string ObjectType
+        {
+            get { return myType; }
+        }
+    }
+
+    [AttributeUsage(AttributeTargets.Class)]
+    public class OSDMap : LLSDType
+    {
+        public OSDMap() : base("MAP")
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/LLSDVoiceAccountResponse.cs b/OpenSim/Capabilities/LLSDVoiceAccountResponse.cs
new file mode 100644
index 0000000..53c11e7
--- /dev/null
+++ b/OpenSim/Capabilities/LLSDVoiceAccountResponse.cs
@@ -0,0 +1,57 @@
+/*
+* 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.
+*
+*/
+
+namespace OpenSim.Framework.Capabilities
+{
+    [OSDMap]
+    public class LLSDVoiceAccountResponse
+    {
+        public string username;
+        public string password;
+        public string voice_sip_uri_hostname;
+        public string voice_account_server_name;
+
+        public LLSDVoiceAccountResponse()
+        {
+        }
+
+        public LLSDVoiceAccountResponse(string user, string pass)
+        {
+            username = user;
+            password = pass;
+        }
+
+        public LLSDVoiceAccountResponse(string user, string pass, string sipUriHost, string accountServer)
+        {
+            username = user;
+            password = pass;
+            voice_sip_uri_hostname = sipUriHost;
+            voice_account_server_name = accountServer;
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Capabilities/Properties/AssemblyInfo.cs b/OpenSim/Capabilities/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..f8a9dae
--- /dev/null
+++ b/OpenSim/Capabilities/Properties/AssemblyInfo.cs
@@ -0,0 +1,33 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("OpenSim.Capabilities")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("http://opensimulator.org")]
+[assembly: AssemblyProduct("OpenSim")]
+[assembly: AssemblyCopyright("OpenSimulator developers")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("7d1a55b1-8fab-42ff-9c83-066a9cc34d76")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+[assembly: AssemblyVersion("0.7.6.*")]
+[assembly: AssemblyFileVersion("1.0.0.0")]