4 files changed, 580 insertions, 172 deletions

diff --git a/OpenSim/Server/Handlers/Simulation/AgentHandlers.cs b/OpenSim/Server/Handlers/Simulation/AgentHandlers.cs
index 3da72c7..b648e12 100644
--- a/OpenSim/Server/Handlers/Simulation/AgentHandlers.cs
+++ b/OpenSim/Server/Handlers/Simulation/AgentHandlers.cs
@@ -26,6 +26,7 @@
  */
 
 using System;
+using System.Collections;
 using System.IO;
 using System.Reflection;
 using System.Net;
@@ -34,6 +35,7 @@ using System.Text;
 using OpenSim.Server.Base;
 using OpenSim.Server.Handlers.Base;
 using OpenSim.Services.Interfaces;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
 using OpenSim.Framework;
 using OpenSim.Framework.Servers.HttpServer;
 
@@ -45,93 +47,118 @@ using log4net;
 
 namespace OpenSim.Server.Handlers.Simulation
 {
-    public class AgentGetHandler : BaseStreamHandler
+    public class AgentHandler
     {
-        // TODO: unused: private ISimulationService m_SimulationService;
-        // TODO: unused: private IAuthenticationService m_AuthenticationService;
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private ISimulationService m_SimulationService;
+
+        public AgentHandler() { }
 
-        public AgentGetHandler(ISimulationService service, IAuthenticationService authentication) :
-                base("GET", "/agent")
+        public AgentHandler(ISimulationService sim)
         {
-            // TODO: unused: m_SimulationService = service;
-            // TODO: unused: m_AuthenticationService = authentication;
+            m_SimulationService = sim;
         }
 
-        public override byte[] Handle(string path, Stream request,
-                OSHttpRequest httpRequest, OSHttpResponse httpResponse)
+        public Hashtable Handler(Hashtable request)
         {
-            // Not implemented yet
-            httpResponse.StatusCode = (int)HttpStatusCode.NotImplemented;
-            return new byte[] { };
-        }
-    }
+            m_log.Debug("[CONNECTION DEBUGGING]: AgentHandler Called");
 
-    public class AgentPostHandler : BaseStreamHandler
-    {
-        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-        private ISimulationService m_SimulationService;
-        private IAuthenticationService m_AuthenticationService;
-        // TODO: unused: private bool m_AllowForeignGuests;
+            m_log.Debug("---------------------------");
+            m_log.Debug(" >> uri=" + request["uri"]);
+            m_log.Debug(" >> content-type=" + request["content-type"]);
+            m_log.Debug(" >> http-method=" + request["http-method"]);
+            m_log.Debug("---------------------------\n");
 
-        public AgentPostHandler(ISimulationService service, IAuthenticationService authentication, bool foreignGuests) :
-            base("POST", "/agent")
-        {
-            m_SimulationService = service;
-            m_AuthenticationService = authentication;
-            // TODO: unused: m_AllowForeignGuests = foreignGuests;
-        }
+            Hashtable responsedata = new Hashtable();
+            responsedata["content_type"] = "text/html";
+            responsedata["keepalive"] = false;
 
-        public override byte[] Handle(string path, Stream request,
-                OSHttpRequest httpRequest, OSHttpResponse httpResponse)
-        {
-            byte[] result = new byte[0];
 
             UUID agentID;
+            UUID regionID;
             string action;
-            ulong regionHandle;
-            if (!RestHandlerUtils.GetParams(path, out agentID, out regionHandle, out action))
+            if (!Utils.GetParams((string)request["uri"], out agentID, out regionID, out action))
             {
-                m_log.InfoFormat("[AgentPostHandler]: Invalid parameters for agent message {0}", path);
-                httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
-                httpResponse.StatusDescription = "Invalid parameters for agent message " + path;
+                m_log.InfoFormat("[AGENT HANDLER]: Invalid parameters for agent message {0}", request["uri"]);
+                responsedata["int_response_code"] = 404;
+                responsedata["str_response_string"] = "false";
 
-                return result;
+                return responsedata;
             }
 
-            if (m_AuthenticationService != null)
+            // Next, let's parse the verb
+            string method = (string)request["http-method"];
+            if (method.Equals("PUT"))
             {
-                // Authentication
-                string authority = string.Empty;
-                string authToken = string.Empty;
-                if (!RestHandlerUtils.GetAuthentication(httpRequest, out authority, out authToken))
-                {
-                    m_log.InfoFormat("[AgentPostHandler]: Authentication failed for agent message {0}", path);
-                    httpResponse.StatusCode = (int)HttpStatusCode.Unauthorized;
-                    return result;
-                }
-                // TODO: Rethink this
-                //if (!m_AuthenticationService.VerifyKey(agentID, authToken))
-                //{
-                //    m_log.InfoFormat("[AgentPostHandler]: Authentication failed for agent message {0}", path);
-                //    httpResponse.StatusCode = (int)HttpStatusCode.Forbidden;
-                //    return result;
-                //}
-                m_log.DebugFormat("[AgentPostHandler]: Authentication succeeded for {0}", agentID);
+                DoAgentPut(request, responsedata);
+                return responsedata;
+            }
+            else if (method.Equals("POST"))
+            {
+                DoAgentPost(request, responsedata, agentID);
+                return responsedata;
+            }
+            else if (method.Equals("GET"))
+            {
+                DoAgentGet(request, responsedata, agentID, regionID);
+                return responsedata;
+            }
+            else if (method.Equals("DELETE"))
+            {
+                DoAgentDelete(request, responsedata, agentID, action, regionID);
+                return responsedata;
+            }
+            else if (method.Equals("DELETECHILD"))
+            {
+                DoChildAgentDelete(request, responsedata, agentID, action, regionID);
+                return responsedata;
             }
+            else
+            {
+                m_log.InfoFormat("[AGENT HANDLER]: method {0} not supported in agent message", method);
+                responsedata["int_response_code"] = HttpStatusCode.MethodNotAllowed;
+                responsedata["str_response_string"] = "Method not allowed";
+
+                return responsedata;
+            }
+
+        }
 
-            OSDMap args = Util.GetOSDMap(request, (int)httpRequest.ContentLength);
+        protected void DoAgentPost(Hashtable request, Hashtable responsedata, UUID id)
+        {
+            OSDMap args = Utils.GetOSDMap((string)request["body"]);
             if (args == null)
             {
-                httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
-                httpResponse.StatusDescription = "Unable to retrieve data";
-                m_log.DebugFormat("[AgentPostHandler]: Unable to retrieve data for post {0}", path);
-                return result;
+                responsedata["int_response_code"] = HttpStatusCode.BadRequest;
+                responsedata["str_response_string"] = "Bad request";
+                return;
             }
 
-            // retrieve the regionhandle
-            ulong regionhandle = 0;
-            if (args["destination_handle"] != null)
-                UInt64.TryParse(args["destination_handle"].AsString(), out regionhandle);
+            // retrieve the input arguments
+            int x = 0, y = 0;
+            UUID uuid = UUID.Zero;
+            string regionname = string.Empty;
+            uint teleportFlags = 0;
+            if (args.ContainsKey("destination_x") && args["destination_x"] != null)
+                Int32.TryParse(args["destination_x"].AsString(), out x);
+            else
+                m_log.WarnFormat("  -- request didn't have destination_x");
+            if (args.ContainsKey("destination_y") && args["destination_y"] != null)
+                Int32.TryParse(args["destination_y"].AsString(), out y);
+            else
+                m_log.WarnFormat("  -- request didn't have destination_y");
+            if (args.ContainsKey("destination_uuid") && args["destination_uuid"] != null)
+                UUID.TryParse(args["destination_uuid"].AsString(), out uuid);
+            if (args.ContainsKey("destination_name") && args["destination_name"] != null)
+                regionname = args["destination_name"].ToString();
+            if (args.ContainsKey("teleport_flags") && args["teleport_flags"] != null)
+                teleportFlags = args["teleport_flags"].AsUInteger();
+
+            GridRegion destination = new GridRegion();
+            destination.RegionID = uuid;
+            destination.RegionLocX = x;
+            destination.RegionLocY = y;
+            destination.RegionName = regionname;
 
             AgentCircuitData aCircuit = new AgentCircuitData();
             try
@@ -140,70 +167,204 @@ namespace OpenSim.Server.Handlers.Simulation
             }
             catch (Exception ex)
             {
-                m_log.InfoFormat("[AgentPostHandler]: exception on unpacking CreateAgent message {0}", ex.Message);
-                httpResponse.StatusCode = (int)HttpStatusCode.BadRequest;
-                httpResponse.StatusDescription = "Problems with data deserialization";
-                return result;
+                m_log.InfoFormat("[AGENT HANDLER]: exception on unpacking ChildCreate message {0}", ex.Message);
+                responsedata["int_response_code"] = HttpStatusCode.BadRequest;
+                responsedata["str_response_string"] = "Bad request";
+                return;
             }
 
-            string reason = string.Empty;
+            OSDMap resp = new OSDMap(2);
+            string reason = String.Empty;
 
-            // We need to clean up a few things in the user service before I can do this
-            //if (m_AllowForeignGuests)
-            //    m_regionClient.AdjustUserInformation(aCircuit);
+            // This is the meaning of POST agent
+            //m_regionClient.AdjustUserInformation(aCircuit);
+            //bool result = m_SimulationService.CreateAgent(destination, aCircuit, teleportFlags, out reason);
+            bool result = CreateAgent(destination, aCircuit, teleportFlags, out reason);
 
-            // Finally!
-            bool success = m_SimulationService.CreateAgent(regionhandle, aCircuit, out reason);
+            resp["reason"] = OSD.FromString(reason);
+            resp["success"] = OSD.FromBoolean(result);
 
-            OSDMap resp = new OSDMap(1);
+            // TODO: add reason if not String.Empty?
+            responsedata["int_response_code"] = HttpStatusCode.OK;
+            responsedata["str_response_string"] = OSDParser.SerializeJsonString(resp);
+        }
+
+        // subclasses can override this
+        protected virtual bool CreateAgent(GridRegion destination, AgentCircuitData aCircuit, uint teleportFlags, out string reason)
+        {
+            return m_SimulationService.CreateAgent(destination, aCircuit, teleportFlags, out reason);
+        }
 
-            resp["success"] = OSD.FromBoolean(success);
+        protected void DoAgentPut(Hashtable request, Hashtable responsedata)
+        {
+            OSDMap args = Utils.GetOSDMap((string)request["body"]);
+            if (args == null)
+            {
+                responsedata["int_response_code"] = HttpStatusCode.BadRequest;
+                responsedata["str_response_string"] = "Bad request";
+                return;
+            }
 
-            httpResponse.StatusCode = (int)HttpStatusCode.OK;
+            // retrieve the input arguments
+            int x = 0, y = 0;
+            UUID uuid = UUID.Zero;
+            string regionname = string.Empty;
+            if (args.ContainsKey("destination_x") && args["destination_x"] != null)
+                Int32.TryParse(args["destination_x"].AsString(), out x);
+            if (args.ContainsKey("destination_y") && args["destination_y"] != null)
+                Int32.TryParse(args["destination_y"].AsString(), out y);
+            if (args.ContainsKey("destination_uuid") && args["destination_uuid"] != null)
+                UUID.TryParse(args["destination_uuid"].AsString(), out uuid);
+            if (args.ContainsKey("destination_name") && args["destination_name"] != null)
+                regionname = args["destination_name"].ToString();
 
-            return Util.UTF8.GetBytes(OSDParser.SerializeJsonString(resp));
-        }
-    }
+            GridRegion destination = new GridRegion();
+            destination.RegionID = uuid;
+            destination.RegionLocX = x;
+            destination.RegionLocY = y;
+            destination.RegionName = regionname;
 
-    public class AgentPutHandler : BaseStreamHandler
-    {
-        // TODO: unused: private ISimulationService m_SimulationService;
-        // TODO: unused: private IAuthenticationService m_AuthenticationService;
+            string messageType;
+            if (args["message_type"] != null)
+                messageType = args["message_type"].AsString();
+            else
+            {
+                m_log.Warn("[AGENT HANDLER]: Agent Put Message Type not found. ");
+                messageType = "AgentData";
+            }
 
-        public AgentPutHandler(ISimulationService service, IAuthenticationService authentication) :
-            base("PUT", "/agent")
+            bool result = true;
+            if ("AgentData".Equals(messageType))
+            {
+                AgentData agent = new AgentData();
+                try
+                {
+                    agent.Unpack(args);
+                }
+                catch (Exception ex)
+                {
+                    m_log.InfoFormat("[AGENT HANDLER]: exception on unpacking ChildAgentUpdate message {0}", ex.Message);
+                    responsedata["int_response_code"] = HttpStatusCode.BadRequest;
+                    responsedata["str_response_string"] = "Bad request";
+                    return;
+                }
+
+                //agent.Dump();
+                // This is one of the meanings of PUT agent
+                result = UpdateAgent(destination, agent);
+
+            }
+            else if ("AgentPosition".Equals(messageType))
+            {
+                AgentPosition agent = new AgentPosition();
+                try
+                {
+                    agent.Unpack(args);
+                }
+                catch (Exception ex)
+                {
+                    m_log.InfoFormat("[AGENT HANDLER]: exception on unpacking ChildAgentUpdate message {0}", ex.Message);
+                    return;
+                }
+                //agent.Dump();
+                // This is one of the meanings of PUT agent
+                result = m_SimulationService.UpdateAgent(destination, agent);
+
+            }
+
+            responsedata["int_response_code"] = HttpStatusCode.OK;
+            responsedata["str_response_string"] = result.ToString();
+            //responsedata["str_response_string"] = OSDParser.SerializeJsonString(resp); ??? instead
+        }
+
+        // subclasses cab override this
+        protected virtual bool UpdateAgent(GridRegion destination, AgentData agent)
         {
-            // TODO: unused: m_SimulationService = service;
-            // TODO: unused: m_AuthenticationService = authentication;
+            return m_SimulationService.UpdateAgent(destination, agent);
         }
 
-        public override byte[] Handle(string path, Stream request,
-                OSHttpRequest httpRequest, OSHttpResponse httpResponse)
+        protected virtual void DoAgentGet(Hashtable request, Hashtable responsedata, UUID id, UUID regionID)
         {
-            // Not implemented yet
-            httpResponse.StatusCode = (int)HttpStatusCode.NotImplemented;
-            return new byte[] { };
+            GridRegion destination = new GridRegion();
+            destination.RegionID = regionID;
+
+            IAgentData agent = null;
+            bool result = m_SimulationService.RetrieveAgent(destination, id, out agent);
+            OSDMap map = null;
+            if (result)
+            {
+                if (agent != null) // just to make sure
+                {
+                    map = agent.Pack();
+                    string strBuffer = "";
+                    try
+                    {
+                        strBuffer = OSDParser.SerializeJsonString(map);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.WarnFormat("[AGENT HANDLER]: Exception thrown on serialization of DoAgentGet: {0}", e.Message);
+                        responsedata["int_response_code"] = HttpStatusCode.InternalServerError;
+                        // ignore. buffer will be empty, caller should check.
+                    }
+
+                    responsedata["content_type"] = "application/json";
+                    responsedata["int_response_code"] = HttpStatusCode.OK;
+                    responsedata["str_response_string"] = strBuffer;
+                }
+                else
+                {
+                    responsedata["int_response_code"] = HttpStatusCode.InternalServerError;
+                    responsedata["str_response_string"] = "Internal error";
+                }
+            }
+            else
+            {
+                responsedata["int_response_code"] = HttpStatusCode.NotFound;
+                responsedata["str_response_string"] = "Not Found";
+            }
         }
-    }
 
-    public class AgentDeleteHandler : BaseStreamHandler
-    {
-        // TODO: unused: private ISimulationService m_SimulationService;
-        // TODO: unused: private IAuthenticationService m_AuthenticationService;
+        protected void DoChildAgentDelete(Hashtable request, Hashtable responsedata, UUID id, string action, UUID regionID)
+        {
+            m_log.Debug(" >>> DoChildAgentDelete action:" + action + "; RegionID:" + regionID);
 
-        public AgentDeleteHandler(ISimulationService service, IAuthenticationService authentication) :
-            base("DELETE", "/agent")
+            GridRegion destination = new GridRegion();
+            destination.RegionID = regionID;
+
+            if (action.Equals("release"))
+                ReleaseAgent(regionID, id);
+            else
+                m_SimulationService.CloseChildAgent(destination, id);
+
+            responsedata["int_response_code"] = HttpStatusCode.OK;
+            responsedata["str_response_string"] = "OpenSim agent " + id.ToString();
+
+            m_log.Debug("[AGENT HANDLER]: Child Agent Released/Deleted.");
+        }
+
+        protected void DoAgentDelete(Hashtable request, Hashtable responsedata, UUID id, string action, UUID regionID)
         {
-            // TODO: unused: m_SimulationService = service;
-            // TODO: unused: m_AuthenticationService = authentication;
+            m_log.Debug(" >>> DoDelete action:" + action + "; RegionID:" + regionID);
+
+            GridRegion destination = new GridRegion();
+            destination.RegionID = regionID;
+
+            if (action.Equals("release"))
+                ReleaseAgent(regionID, id);
+            else
+                m_SimulationService.CloseAgent(destination, id);
+
+            responsedata["int_response_code"] = HttpStatusCode.OK;
+            responsedata["str_response_string"] = "OpenSim agent " + id.ToString();
+
+            m_log.Debug("[AGENT HANDLER]: Agent Released/Deleted.");
         }
 
-        public override byte[] Handle(string path, Stream request,
-                OSHttpRequest httpRequest, OSHttpResponse httpResponse)
+        protected virtual void ReleaseAgent(UUID regionID, UUID id)
         {
-            // Not implemented yet
-            httpResponse.StatusCode = (int)HttpStatusCode.NotImplemented;
-            return new byte[] { };
+            m_SimulationService.ReleaseAgent(regionID, id, "");
         }
     }
+
 }
diff --git a/OpenSim/Server/Handlers/Simulation/ObjectHandlers.cs b/OpenSim/Server/Handlers/Simulation/ObjectHandlers.cs
new file mode 100644
index 0000000..33e5aa6
--- /dev/null
+++ b/OpenSim/Server/Handlers/Simulation/ObjectHandlers.cs
@@ -0,0 +1,246 @@
+/*
+ * 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.Net;
+using System.Text;
+
+using OpenSim.Server.Base;
+using OpenSim.Server.Handlers.Base;
+using OpenSim.Services.Interfaces;
+using GridRegion = OpenSim.Services.Interfaces.GridRegion;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers.HttpServer;
+
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using Nini.Config;
+using log4net;
+
+
+namespace OpenSim.Server.Handlers.Simulation
+{
+    public class ObjectHandler
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private ISimulationService m_SimulationService;
+
+        public ObjectHandler() { }
+
+        public ObjectHandler(ISimulationService sim)
+        {
+            m_SimulationService = sim;
+        }
+
+        public Hashtable Handler(Hashtable request)
+        {
+            //m_log.Debug("[CONNECTION DEBUGGING]: ObjectHandler Called");
+
+            //m_log.Debug("---------------------------");
+            //m_log.Debug(" >> uri=" + request["uri"]);
+            //m_log.Debug(" >> content-type=" + request["content-type"]);
+            //m_log.Debug(" >> http-method=" + request["http-method"]);
+            //m_log.Debug("---------------------------\n");
+
+            Hashtable responsedata = new Hashtable();
+            responsedata["content_type"] = "text/html";
+
+            UUID objectID;
+            UUID regionID;
+            string action;
+            if (!Utils.GetParams((string)request["uri"], out objectID, out regionID, out action))
+            {
+                m_log.InfoFormat("[OBJECT HANDLER]: Invalid parameters for object message {0}", request["uri"]);
+                responsedata["int_response_code"] = 404;
+                responsedata["str_response_string"] = "false";
+
+                return responsedata;
+            }
+
+            // Next, let's parse the verb
+            string method = (string)request["http-method"];
+            if (method.Equals("POST"))
+            {
+                DoObjectPost(request, responsedata, regionID);
+                return responsedata;
+            }
+            else if (method.Equals("PUT"))
+            {
+                DoObjectPut(request, responsedata, regionID);
+                return responsedata;
+            }
+            //else if (method.Equals("DELETE"))
+            //{
+            //    DoObjectDelete(request, responsedata, agentID, action, regionHandle);
+            //    return responsedata;
+            //}
+            else
+            {
+                m_log.InfoFormat("[OBJECT HANDLER]: method {0} not supported in object message", method);
+                responsedata["int_response_code"] = HttpStatusCode.MethodNotAllowed;
+                responsedata["str_response_string"] = "Mthod not allowed";
+
+                return responsedata;
+            }
+
+        }
+
+        protected void DoObjectPost(Hashtable request, Hashtable responsedata, UUID regionID)
+        {
+            OSDMap args = Utils.GetOSDMap((string)request["body"]);
+            if (args == null)
+            {
+                responsedata["int_response_code"] = 400;
+                responsedata["str_response_string"] = "false";
+                return;
+            }
+            // retrieve the input arguments
+            int x = 0, y = 0;
+            UUID uuid = UUID.Zero;
+            string regionname = string.Empty;
+            if (args.ContainsKey("destination_x") && args["destination_x"] != null)
+                Int32.TryParse(args["destination_x"].AsString(), out x);
+            if (args.ContainsKey("destination_y") && args["destination_y"] != null)
+                Int32.TryParse(args["destination_y"].AsString(), out y);
+            if (args.ContainsKey("destination_uuid") && args["destination_uuid"] != null)
+                UUID.TryParse(args["destination_uuid"].AsString(), out uuid);
+            if (args.ContainsKey("destination_name") && args["destination_name"] != null)
+                regionname = args["destination_name"].ToString();
+
+            GridRegion destination = new GridRegion();
+            destination.RegionID = uuid;
+            destination.RegionLocX = x;
+            destination.RegionLocY = y;
+            destination.RegionName = regionname;
+
+            string sogXmlStr = "", extraStr = "", stateXmlStr = "";
+            if (args.ContainsKey("sog") && args["sog"] != null)
+                sogXmlStr = args["sog"].AsString();
+            if (args.ContainsKey("extra") && args["extra"] != null)
+                extraStr = args["extra"].AsString();
+
+            IScene s = m_SimulationService.GetScene(destination.RegionHandle);
+            ISceneObject sog = null;
+            try
+            {
+                //m_log.DebugFormat("[OBJECT HANDLER]: received {0}", sogXmlStr);
+                sog = s.DeserializeObject(sogXmlStr);
+                sog.ExtraFromXmlString(extraStr);
+            }
+            catch (Exception ex)
+            {
+                m_log.InfoFormat("[OBJECT HANDLER]: exception on deserializing scene object {0}", ex.Message);
+                responsedata["int_response_code"] = HttpStatusCode.BadRequest;
+                responsedata["str_response_string"] = "Bad request";
+                return;
+            }
+
+            if ((args["state"] != null) && s.AllowScriptCrossings)
+            {
+                stateXmlStr = args["state"].AsString();
+                if (stateXmlStr != "")
+                {
+                    try
+                    {
+                        sog.SetState(stateXmlStr, s);
+                    }
+                    catch (Exception ex)
+                    {
+                        m_log.InfoFormat("[OBJECT HANDLER]: exception on setting state for scene object {0}", ex.Message);
+                        // ignore and continue
+                    }
+                }
+            }
+
+            bool result = false;
+            try
+            {
+                // This is the meaning of POST object
+                result = CreateObject(destination, sog);
+            }
+            catch (Exception e)
+            {
+                m_log.DebugFormat("[OBJECT HANDLER]: Exception in CreateObject: {0}", e.StackTrace);
+            }
+
+            responsedata["int_response_code"] = HttpStatusCode.OK;
+            responsedata["str_response_string"] = result.ToString();
+        }
+
+        // subclasses can override this
+        protected virtual bool CreateObject(GridRegion destination, ISceneObject sog)
+        {
+            return m_SimulationService.CreateObject(destination, sog, false);
+        }
+
+        protected virtual void DoObjectPut(Hashtable request, Hashtable responsedata, UUID regionID)
+        {
+            OSDMap args = Utils.GetOSDMap((string)request["body"]);
+            if (args == null)
+            {
+                responsedata["int_response_code"] = 400;
+                responsedata["str_response_string"] = "false";
+                return;
+            }
+
+            // retrieve the input arguments
+            int x = 0, y = 0;
+            UUID uuid = UUID.Zero;
+            string regionname = string.Empty;
+            if (args.ContainsKey("destination_x") && args["destination_x"] != null)
+                Int32.TryParse(args["destination_x"].AsString(), out x);
+            if (args.ContainsKey("destination_y") && args["destination_y"] != null)
+                Int32.TryParse(args["destination_y"].AsString(), out y);
+            if (args.ContainsKey("destination_uuid") && args["destination_uuid"] != null)
+                UUID.TryParse(args["destination_uuid"].AsString(), out uuid);
+            if (args.ContainsKey("destination_name") && args["destination_name"] != null)
+                regionname = args["destination_name"].ToString();
+
+            GridRegion destination = new GridRegion();
+            destination.RegionID = uuid;
+            destination.RegionLocX = x;
+            destination.RegionLocY = y;
+            destination.RegionName = regionname;
+
+            UUID userID = UUID.Zero, itemID = UUID.Zero;
+            if (args.ContainsKey("userid") && args["userid"] != null)
+                userID = args["userid"].AsUUID();
+            if (args.ContainsKey("itemid") && args["itemid"] != null)
+                itemID = args["itemid"].AsUUID();
+
+            // This is the meaning of PUT object
+            bool result = m_SimulationService.CreateObject(destination, userID, itemID);
+
+            responsedata["int_response_code"] = 200;
+            responsedata["str_response_string"] = result.ToString();
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Server/Handlers/Simulation/SimulationServiceInConnector.cs b/OpenSim/Server/Handlers/Simulation/SimulationServiceInConnector.cs
index fe93fa5..50d6fb2 100644
--- a/OpenSim/Server/Handlers/Simulation/SimulationServiceInConnector.cs
+++ b/OpenSim/Server/Handlers/Simulation/SimulationServiceInConnector.cs
@@ -37,22 +37,15 @@ namespace OpenSim.Server.Handlers.Simulation
 {
     public class SimulationServiceInConnector : ServiceConnector
     {
-        private ISimulationService m_SimulationService;
+        private ISimulationService m_LocalSimulationService;
         private IAuthenticationService m_AuthenticationService;
 
         public SimulationServiceInConnector(IConfigSource config, IHttpServer server, IScene scene) :
                 base(config, server, String.Empty)
         {
-            IConfig serverConfig = config.Configs["SimulationService"];
-            if (serverConfig == null)
-                throw new Exception("No section 'SimulationService' in config file");
-
-            bool authentication = serverConfig.GetBoolean("RequireAuthentication", false);
-
-            if (authentication)
-                m_AuthenticationService = scene.RequestModuleInterface<IAuthenticationService>();
-
-            bool foreignGuests = serverConfig.GetBoolean("AllowForeignGuests", false);
+            //IConfig serverConfig = config.Configs["SimulationService"];
+            //if (serverConfig == null)
+            //    throw new Exception("No section 'SimulationService' in config file");
 
             //string simService = serverConfig.GetString("LocalServiceModule",
             //        String.Empty);
@@ -61,20 +54,19 @@ namespace OpenSim.Server.Handlers.Simulation
             //    throw new Exception("No SimulationService in config file");
 
             //Object[] args = new Object[] { config };
-            m_SimulationService = scene.RequestModuleInterface<ISimulationService>();
+            m_LocalSimulationService = scene.RequestModuleInterface<ISimulationService>();
+            m_LocalSimulationService = m_LocalSimulationService.GetInnerService();
                     //ServerUtils.LoadPlugin<ISimulationService>(simService, args);
-            if (m_SimulationService == null)
-                throw new Exception("No Local ISimulationService Module");
-
-
 
             //System.Console.WriteLine("XXXXXXXXXXXXXXXXXXX m_AssetSetvice == null? " + ((m_AssetService == null) ? "yes" : "no"));
-            server.AddStreamHandler(new AgentGetHandler(m_SimulationService, m_AuthenticationService));
-            server.AddStreamHandler(new AgentPostHandler(m_SimulationService, m_AuthenticationService, foreignGuests));
-            server.AddStreamHandler(new AgentPutHandler(m_SimulationService, m_AuthenticationService));
-            server.AddStreamHandler(new AgentDeleteHandler(m_SimulationService, m_AuthenticationService));
+            //server.AddStreamHandler(new AgentGetHandler(m_SimulationService, m_AuthenticationService));
+            //server.AddStreamHandler(new AgentPostHandler(m_SimulationService, m_AuthenticationService));
+            //server.AddStreamHandler(new AgentPutHandler(m_SimulationService, m_AuthenticationService));
+            //server.AddStreamHandler(new AgentDeleteHandler(m_SimulationService, m_AuthenticationService));
+            server.AddHTTPHandler("/agent/", new AgentHandler(m_LocalSimulationService).Handler);
+            server.AddHTTPHandler("/object/", new ObjectHandler(m_LocalSimulationService).Handler);
+
             //server.AddStreamHandler(new ObjectPostHandler(m_SimulationService, authentication));
-            //server.AddStreamHandler(new NeighborPostHandler(m_SimulationService, authentication));
         }
     }
 }
diff --git a/OpenSim/Data/MySQL/Tests/MySQLGridTest.cs b/OpenSim/Server/Handlers/Simulation/Utils.cs
index 8272316..ed379da 100644
--- a/OpenSim/Data/MySQL/Tests/MySQLGridTest.cs
+++ b/OpenSim/Server/Handlers/Simulation/Utils.cs
@@ -1,4 +1,4 @@
-/*
+/*
  * Copyright (c) Contributors, http://opensimulator.org/
  * See CONTRIBUTORS.TXT for a full list of copyright holders.
  *
@@ -26,69 +26,78 @@
  */
 
 using System;
-using NUnit.Framework;
-using OpenSim.Data.Tests;
-using log4net;
+using System.Collections.Generic;
 using System.Reflection;
-using OpenSim.Tests.Common;
-using MySql.Data.MySqlClient;
 
-namespace OpenSim.Data.MySQL.Tests
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+
+using log4net;
+
+namespace OpenSim.Server.Handlers.Simulation
 {
-    [TestFixture, DatabaseTest]
-    public class MySQLGridTest : BasicGridTest
+    public class Utils
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
-        public string file;
-        public MySQLManager database;
-        public string connect = "Server=localhost;Port=3306;Database=opensim-nunit;User ID=opensim-nunit;Password=opensim-nunit;Pooling=false;";
-
-        [TestFixtureSetUp]
-        public void Init()
+        /// <summary>
+        /// Extract the param from an uri.
+        /// </summary>
+        /// <param name="uri">Something like this: /agent/uuid/ or /agent/uuid/handle/release</param>
+        /// <param name="uri">uuid on uuid field</param>
+        /// <param name="action">optional action</param>
+        public static bool GetParams(string uri, out UUID uuid, out UUID regionID, out string action)
         {
-            SuperInit();
-            // If we manage to connect to the database with the user
-            // and password above it is our test database, and run
-            // these tests.  If anything goes wrong, ignore these
-            // tests.
-            try
+            uuid = UUID.Zero;
+            regionID = UUID.Zero;
+            action = "";
+
+            uri = uri.Trim(new char[] { '/' });
+            string[] parts = uri.Split('/');
+            if (parts.Length <= 1)
             {
-                database = new MySQLManager(connect);
-                db = new MySQLGridData();
-                db.Initialise(connect);
+                return false;
             }
-            catch (Exception e)
+            else
             {
-                m_log.Error("Exception {0}", e);
-                Assert.Ignore();
-            }
+                if (!UUID.TryParse(parts[1], out uuid))
+                    return false;
 
-            // This actually does the roll forward assembly stuff
-            Assembly assem = GetType().Assembly;
+                if (parts.Length >= 3)
+                    UUID.TryParse(parts[2], out regionID);
+                if (parts.Length >= 4)
+                    action = parts[3];
 
-            using (MySqlConnection dbcon = new MySqlConnection(connect))
-            {
-                dbcon.Open();
-                Migration m = new Migration(dbcon, assem, "AssetStore");
-                m.Update();
+                return true;
             }
         }
 
-        [TestFixtureTearDown]
-        public void Cleanup()
+        public static OSDMap GetOSDMap(string data)
         {
-            m_log.Warn("Cleaning up.");
-            if (db != null)
+            OSDMap args = null;
+            try
             {
-                db.Dispose();
+                OSD buffer;
+                // We should pay attention to the content-type, but let's assume we know it's Json
+                buffer = OSDParser.DeserializeJson(data);
+                if (buffer.Type == OSDType.Map)
+                {
+                    args = (OSDMap)buffer;
+                    return args;
+                }
+                else
+                {
+                    // uh?
+                    m_log.Debug(("[REST COMMS]: Got OSD of unexpected type " + buffer.Type.ToString()));
+                    return null;
+                }
             }
-            // if a new table is added, it has to be dropped here
-            if (database != null)
+            catch (Exception ex)
             {
-                database.ExecuteSql("drop table migrations");
-                database.ExecuteSql("drop table regions");
+                m_log.Debug("[REST COMMS]: exception on parse of REST message " + ex.Message);
+                return null;
             }
         }
+
     }
 }