Nope, that didn't feel right. Moving all those modules to Linden space.

1 files changed, 370 insertions, 0 deletions

diff --git a/OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/ObjectAdd.cs b/OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/ObjectAdd.cs
new file mode 100644
index 0000000..15139a3
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/ObjectAdd.cs
@@ -0,0 +1,370 @@
+/*
+ * 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.Reflection;
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using Caps=OpenSim.Framework.Capabilities.Caps;
+
+namespace OpenSim.Region.ClientStack.Linden
+{
+    public class ObjectAdd : IRegionModule
+    {
+//        private static readonly ILog m_log =
+//            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        
+        private Scene m_scene;
+        #region IRegionModule Members
+
+        public void Initialise(Scene pScene, IConfigSource pSource)
+        {
+            m_scene = pScene;
+            m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+        }
+
+        public void PostInitialise()
+        {
+            
+        }
+
+        public void RegisterCaps(UUID agentID, Caps caps)
+        {
+            UUID capuuid = UUID.Random();
+            
+//            m_log.InfoFormat("[OBJECTADD]: {0}", "/CAPS/OA/" + capuuid + "/");
+
+            caps.RegisterHandler("ObjectAdd",
+                                 new RestHTTPHandler("POST", "/CAPS/OA/" + capuuid + "/",
+                                                       delegate(Hashtable m_dhttpMethod)
+                                                       {
+                                                           return ProcessAdd(m_dhttpMethod, agentID, caps);
+                                                       }));
+        }
+
+        public Hashtable ProcessAdd(Hashtable request, UUID AgentId, Caps cap)
+        {
+            Hashtable responsedata = new Hashtable();
+            responsedata["int_response_code"] = 400; //501; //410; //404;
+            responsedata["content_type"] = "text/plain";
+            responsedata["keepalive"] = false;
+            responsedata["str_response_string"] = "Request wasn't what was expected";
+            ScenePresence avatar;
+            
+            if (!m_scene.TryGetScenePresence(AgentId, out avatar))
+                return responsedata;
+
+
+            OSD r = OSDParser.DeserializeLLSDXml((string)request["requestbody"]);
+            //UUID session_id = UUID.Zero;
+            bool bypass_raycast = false;
+            uint everyone_mask = 0;
+            uint group_mask = 0;
+            uint next_owner_mask = 0;
+            uint flags = 0;
+            UUID group_id = UUID.Zero;
+            int hollow = 0;
+            int material = 0;
+            int p_code = 0;
+            int path_begin = 0;
+            int path_curve = 0;
+            int path_end = 0;
+            int path_radius_offset = 0;
+            int path_revolutions = 0;
+            int path_scale_x = 0;
+            int path_scale_y = 0;
+            int path_shear_x = 0;
+            int path_shear_y = 0;
+            int path_skew = 0;
+            int path_taper_x = 0;
+            int path_taper_y = 0;
+            int path_twist = 0;
+            int path_twist_begin = 0;
+            int profile_begin = 0;
+            int profile_curve = 0;
+            int profile_end = 0;
+            Vector3 ray_end = Vector3.Zero;
+            bool ray_end_is_intersection = false;
+            Vector3 ray_start = Vector3.Zero;
+            UUID ray_target_id = UUID.Zero;
+            Quaternion rotation = Quaternion.Identity;
+            Vector3 scale = Vector3.Zero;
+            int state = 0;
+
+            if (r.Type != OSDType.Map) // not a proper req
+                return responsedata;
+            
+            OSDMap rm = (OSDMap)r;
+
+            if (rm.ContainsKey("ObjectData")) //v2
+            {
+                if (rm["ObjectData"].Type != OSDType.Map)
+                {
+                    responsedata["str_response_string"] = "Has ObjectData key, but data not in expected format";
+                    return responsedata;
+                }
+
+                OSDMap ObjMap = (OSDMap) rm["ObjectData"];
+
+                bypass_raycast = ObjMap["BypassRaycast"].AsBoolean();
+                everyone_mask = readuintval(ObjMap["EveryoneMask"]);
+                flags = readuintval(ObjMap["Flags"]);
+                group_mask = readuintval(ObjMap["GroupMask"]);
+                material = ObjMap["Material"].AsInteger();
+                next_owner_mask = readuintval(ObjMap["NextOwnerMask"]);
+                p_code = ObjMap["PCode"].AsInteger();
+
+                if (ObjMap.ContainsKey("Path"))
+                {
+                    if (ObjMap["Path"].Type != OSDType.Map)
+                    {
+                        responsedata["str_response_string"] = "Has Path key, but data not in expected format";
+                        return responsedata;
+                    }
+
+                    OSDMap PathMap = (OSDMap)ObjMap["Path"];
+                    path_begin = PathMap["Begin"].AsInteger();
+                    path_curve = PathMap["Curve"].AsInteger();
+                    path_end = PathMap["End"].AsInteger();
+                    path_radius_offset = PathMap["RadiusOffset"].AsInteger();
+                    path_revolutions = PathMap["Revolutions"].AsInteger();
+                    path_scale_x = PathMap["ScaleX"].AsInteger();
+                    path_scale_y = PathMap["ScaleY"].AsInteger();
+                    path_shear_x = PathMap["ShearX"].AsInteger();
+                    path_shear_y = PathMap["ShearY"].AsInteger();
+                    path_skew = PathMap["Skew"].AsInteger();
+                    path_taper_x = PathMap["TaperX"].AsInteger();
+                    path_taper_y = PathMap["TaperY"].AsInteger();
+                    path_twist = PathMap["Twist"].AsInteger();
+                    path_twist_begin = PathMap["TwistBegin"].AsInteger();
+
+                }
+
+                if (ObjMap.ContainsKey("Profile"))
+                {
+                    if (ObjMap["Profile"].Type != OSDType.Map)
+                    {
+                        responsedata["str_response_string"] = "Has Profile key, but data not in expected format";
+                        return responsedata;
+                    }
+                        
+                    OSDMap ProfileMap = (OSDMap)ObjMap["Profile"];
+
+                    profile_begin = ProfileMap["Begin"].AsInteger();
+                    profile_curve = ProfileMap["Curve"].AsInteger();
+                    profile_end = ProfileMap["End"].AsInteger();
+                    hollow = ProfileMap["Hollow"].AsInteger();
+                }
+                ray_end_is_intersection = ObjMap["RayEndIsIntersection"].AsBoolean();
+                
+                ray_target_id = ObjMap["RayTargetId"].AsUUID();
+                state = ObjMap["State"].AsInteger();
+                try
+                {
+                    ray_end = ((OSDArray) ObjMap["RayEnd"]).AsVector3();
+                    ray_start = ((OSDArray) ObjMap["RayStart"]).AsVector3();
+                    scale = ((OSDArray) ObjMap["Scale"]).AsVector3();
+                    rotation = ((OSDArray)ObjMap["Rotation"]).AsQuaternion();
+                }
+                catch (Exception)
+                {
+                    responsedata["str_response_string"] = "RayEnd, RayStart, Scale or Rotation wasn't in the expected format";
+                    return responsedata;
+                }
+
+                if (rm.ContainsKey("AgentData"))
+                {
+                    if (rm["AgentData"].Type != OSDType.Map)
+                    {
+                        responsedata["str_response_string"] = "Has AgentData key, but data not in expected format";
+                        return responsedata;
+                    }
+
+                    OSDMap AgentDataMap = (OSDMap) rm["AgentData"];
+
+                    //session_id = AgentDataMap["SessionId"].AsUUID();
+                    group_id = AgentDataMap["GroupId"].AsUUID();
+                }
+
+            }
+            else
+            { //v1
+                bypass_raycast = rm["bypass_raycast"].AsBoolean();
+
+                everyone_mask = readuintval(rm["everyone_mask"]);
+                flags = readuintval(rm["flags"]);
+                group_id = rm["group_id"].AsUUID();
+                group_mask = readuintval(rm["group_mask"]);
+                hollow = rm["hollow"].AsInteger();
+                material = rm["material"].AsInteger();
+                next_owner_mask = readuintval(rm["next_owner_mask"]);
+                hollow = rm["hollow"].AsInteger();
+                p_code = rm["p_code"].AsInteger();
+                path_begin = rm["path_begin"].AsInteger();
+                path_curve = rm["path_curve"].AsInteger();
+                path_end = rm["path_end"].AsInteger();
+                path_radius_offset = rm["path_radius_offset"].AsInteger();
+                path_revolutions = rm["path_revolutions"].AsInteger();
+                path_scale_x = rm["path_scale_x"].AsInteger();
+                path_scale_y = rm["path_scale_y"].AsInteger();
+                path_shear_x = rm["path_shear_x"].AsInteger();
+                path_shear_y = rm["path_shear_y"].AsInteger();
+                path_skew = rm["path_skew"].AsInteger();
+                path_taper_x = rm["path_taper_x"].AsInteger();
+                path_taper_y = rm["path_taper_y"].AsInteger();
+                path_twist = rm["path_twist"].AsInteger();
+                path_twist_begin = rm["path_twist_begin"].AsInteger();
+                profile_begin = rm["profile_begin"].AsInteger();
+                profile_curve = rm["profile_curve"].AsInteger();
+                profile_end = rm["profile_end"].AsInteger();
+                
+                ray_end_is_intersection = rm["ray_end_is_intersection"].AsBoolean();
+                
+                ray_target_id = rm["ray_target_id"].AsUUID();
+                
+                
+                //session_id = rm["session_id"].AsUUID();
+                state = rm["state"].AsInteger();
+                try 
+                {
+                    ray_end = ((OSDArray)rm["ray_end"]).AsVector3();
+                    ray_start = ((OSDArray)rm["ray_start"]).AsVector3();
+                    rotation = ((OSDArray)rm["rotation"]).AsQuaternion();
+                    scale = ((OSDArray)rm["scale"]).AsVector3();
+                } 
+                catch (Exception)
+                {
+                    responsedata["str_response_string"] = "RayEnd, RayStart, Scale or Rotation wasn't in the expected format";
+                    return responsedata;
+                }
+            }
+
+           
+
+            Vector3 pos = m_scene.GetNewRezLocation(ray_start, ray_end, ray_target_id, rotation, (bypass_raycast) ? (byte)1 : (byte)0,  (ray_end_is_intersection) ? (byte)1 : (byte)0, true, scale, false);
+
+            PrimitiveBaseShape pbs = PrimitiveBaseShape.CreateBox();
+
+            pbs.PathBegin = (ushort)path_begin;
+            pbs.PathCurve = (byte)path_curve;
+            pbs.PathEnd = (ushort)path_end;
+            pbs.PathRadiusOffset = (sbyte)path_radius_offset;
+            pbs.PathRevolutions = (byte)path_revolutions;
+            pbs.PathScaleX = (byte)path_scale_x;
+            pbs.PathScaleY = (byte)path_scale_y;
+            pbs.PathShearX = (byte) path_shear_x;
+            pbs.PathShearY = (byte)path_shear_y;
+            pbs.PathSkew = (sbyte)path_skew;
+            pbs.PathTaperX = (sbyte)path_taper_x;
+            pbs.PathTaperY = (sbyte)path_taper_y;
+            pbs.PathTwist = (sbyte)path_twist;
+            pbs.PathTwistBegin = (sbyte)path_twist_begin;
+            pbs.HollowShape = (HollowShape) hollow;
+            pbs.PCode = (byte)p_code;
+            pbs.ProfileBegin = (ushort) profile_begin;
+            pbs.ProfileCurve = (byte) profile_curve;
+            pbs.ProfileEnd = (ushort)profile_end;
+            pbs.Scale = scale;
+            pbs.State = (byte)state;
+
+            SceneObjectGroup obj = null; ;
+
+            if (m_scene.Permissions.CanRezObject(1, avatar.UUID, pos))
+            {
+                // rez ON the ground, not IN the ground
+               // pos.Z += 0.25F;
+
+                obj = m_scene.AddNewPrim(avatar.UUID, group_id, pos, rotation, pbs);
+            }
+
+
+            if (obj == null)
+                return responsedata;
+
+            SceneObjectPart rootpart = obj.RootPart;
+            rootpart.Shape = pbs;
+            rootpart.Flags |= (PrimFlags)flags;
+            rootpart.EveryoneMask = everyone_mask;
+            rootpart.GroupID = group_id;
+            rootpart.GroupMask = group_mask;
+            rootpart.NextOwnerMask = next_owner_mask;
+            rootpart.Material = (byte)material;
+            
+            
+            
+            m_scene.PhysicsScene.AddPhysicsActorTaint(rootpart.PhysActor);
+            
+            responsedata["int_response_code"] = 200; //501; //410; //404;
+            responsedata["content_type"] = "text/plain";
+            responsedata["keepalive"] = false;
+            responsedata["str_response_string"] = String.Format("<llsd><map><key>local_id</key>{0}</map></llsd>",ConvertUintToBytes(obj.LocalId));
+
+            return responsedata;
+        }
+
+        private uint readuintval(OSD obj)
+        {
+            byte[] tmp = obj.AsBinary();
+            if (BitConverter.IsLittleEndian)
+                Array.Reverse(tmp);
+            return Utils.BytesToUInt(tmp);
+
+        }
+        private string ConvertUintToBytes(uint val)
+        {
+            byte[] resultbytes = Utils.UIntToBytes(val);
+            if (BitConverter.IsLittleEndian)
+                Array.Reverse(resultbytes);
+            return String.Format("<binary encoding=\"base64\">{0}</binary>",Convert.ToBase64String(resultbytes));
+        }
+
+        public void Close()
+        {
+            
+        }
+
+        public string Name
+        {
+            get { return "ObjectAddModule"; }
+        }
+
+        public bool IsSharedModule
+        {
+            get { return false; }
+        }
+
+        #endregion
+    }
+}