Merge branch 'master' of brain.opensimulator.org:/var/git/opensim

OpenSim/Region/ClientStack/Linden/Caps/EstateChangeInfo.cs

@@ -0,0 +1,228 @@
+/*
+ * 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.Text;
+using System.Reflection;
+
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using Mono.Addins;
+
+using OpenSim.Framework;
+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
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "EstateChangeInfoCapModule")]
+    public class EstateChangeInfoCapModule : INonSharedRegionModule
+    {
+        private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private Scene m_scene;
+        private bool m_Enabled = false;
+        private string m_capUrl;
+        IEstateModule m_EstateModule;
+
+        #region INonSharedRegionModule Members
+
+        public void Initialise(IConfigSource pSource)
+        {
+            IConfig config = pSource.Configs["ClientStack.LindenCaps"];
+            if (config == null)
+                return;
+
+            m_capUrl = config.GetString("Cap_EstateChangeInfo", string.Empty);
+            if (!String.IsNullOrEmpty(m_capUrl) && m_capUrl.Equals("localhost"))
+                m_Enabled = true;
+        }
+
+        public void AddRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            m_scene = scene;
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            if (m_scene == scene)
+            {
+                m_scene.EventManager.OnRegisterCaps -= RegisterCaps;
+                m_scene = null;
+            }
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            if (scene.RegionInfo == null || scene.RegionInfo.EstateSettings == null)
+            {
+                m_Enabled = false;
+                return;
+            }
+
+            m_EstateModule = scene.RequestModuleInterface<IEstateModule>();
+            if(m_EstateModule == null)
+            {
+                m_Enabled = false;
+                return;
+            }
+
+            scene.EventManager.OnRegisterCaps += RegisterCaps;
+        }
+
+        public void Close()
+        {
+        }
+
+        public string Name
+        {
+            get { return "EstateChangeInfoCapModule"; }
+        }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        #endregion
+
+        public void RegisterCaps(UUID agentID, Caps caps)
+        {
+            string capUrl = "/CAPS/" + UUID.Random() + "/";
+
+            caps.RegisterHandler(
+                "EstateChangeInfo",
+                new RestHTTPHandler(
+                    "POST",
+                    capUrl,
+                    httpMethod => ProcessRequest(httpMethod, agentID, caps),
+                    "EstateChangeInfo",
+                    agentID.ToString())); ;
+        }
+
+        public Hashtable ProcessRequest(Hashtable request, UUID AgentId, Caps cap)
+        {
+            Hashtable responsedata = new Hashtable();
+
+            ScenePresence avatar;
+            if (!m_scene.TryGetScenePresence(AgentId, out avatar) || !m_scene.Permissions.CanIssueEstateCommand(AgentId, false))
+            {
+                responsedata["int_response_code"] = 401;
+                responsedata["str_response_string"] = LLSDxmlEncode.LLSDEmpty;
+                responsedata["keepalive"] = false;
+                return responsedata;
+            }
+
+            if (m_scene.RegionInfo == null 
+                || m_scene.RegionInfo.EstateSettings == null)
+            {
+                responsedata["int_response_code"] = 501;
+                responsedata["str_response_string"] = LLSDxmlEncode.LLSDEmpty;
+                responsedata["keepalive"] = false;
+                return responsedata;
+            }
+
+            OSDMap r;
+
+            try
+            {
+                r = (OSDMap)OSDParser.Deserialize((string)request["requestbody"]);
+            }
+            catch (Exception ex)
+            {
+                m_log.Error("[UPLOAD OBJECT ASSET MODULE]: Error deserializing message " + ex.ToString());
+                r = null;
+            }
+
+            if (r == null)
+            {
+                responsedata["int_response_code"] = 400; //501; //410; //404;
+                responsedata["content_type"] = "text/plain";
+                responsedata["keepalive"] = false;
+                responsedata["str_response_string"] = LLSDxmlEncode.LLSDEmpty;
+                return responsedata;
+            }
+
+            bool ok = true;
+            try
+            {
+                string estateName = r["estate_name"].AsString();
+                UUID invoice = r["invoice"].AsUUID();
+                int sunHour = r["sun_hour"].AsInteger();
+                bool sunFixed = r["is_sun_fixed"].AsBoolean();
+                bool externallyVisible = r["is_externally_visible"].AsBoolean();
+                bool allowDirectTeleport = r["allow_direct_teleport"].AsBoolean();
+                bool denyAnonymous = r["deny_anonymous"].AsBoolean();
+                bool denyAgeUnverified = r["deny_age_unverified"].AsBoolean();
+                bool alloVoiceChat = r["allow_voice_chat"].AsBoolean();
+                // taxfree is now AllowAccessOverride
+                bool overridePublicAccess = m_scene.RegionInfo.EstateSettings.TaxFree;
+                if (r.ContainsKey("override_public_access"))
+                    overridePublicAccess = r["override_public_access"].AsBoolean();
+
+                ok = m_EstateModule.handleEstateChangeInfoCap(estateName, invoice, sunHour, sunFixed,
+                        externallyVisible, allowDirectTeleport, denyAnonymous, denyAgeUnverified,
+                        alloVoiceChat, overridePublicAccess);
+            }
+            catch
+            {
+                ok = false;
+            }
+
+            if(ok)
+            {
+                responsedata["int_response_code"] = 200;
+                responsedata["content_type"] = "text/plain";
+                responsedata["str_response_string"] = LLSDxmlEncode.LLSDEmpty;
+            }
+            else
+            {
+                responsedata["int_response_code"] = 400; //501; //410; //404;
+                responsedata["content_type"] = "text/plain";
+                responsedata["keepalive"] = false;
+                responsedata["str_response_string"] = LLSDxmlEncode.LLSDEmpty;
+            }
+            return responsedata;
+        }
+    }
+}

OpenSim/Region/ClientStack/Linden/Caps/ObjectCaps/ObjectAdd.cs

@@ -161,34 +161,34 @@ namespace OpenSim.Region.ClientStack.Linden
             int lastattach = 0;
 
             OSDMap rm = (OSDMap)r;
-
-            if (rm.ContainsKey("ObjectData")) //v2
+            OSD tmpOSD;
+            if (rm.TryGetValue("ObjectData", out tmpOSD)) //v2
             {
-                if (rm["ObjectData"].Type != OSDType.Map)
+                if (tmpOSD.Type != OSDType.Map)
                 {
                     responsedata["str_response_string"] = "Has ObjectData key, but data not in expected format";
                     return responsedata;
                 }
 
-                OSDMap ObjMap = (OSDMap)rm["ObjectData"];
+                OSDMap ObjMap = (OSDMap)tmpOSD;
 
                 bypass_raycast = ObjMap["BypassRaycast"].AsBoolean();
-                everyone_mask = readuintval(ObjMap["EveryoneMask"]);
-                flags = readuintval(ObjMap["Flags"]);
-                group_mask = readuintval(ObjMap["GroupMask"]);
+                everyone_mask = ReadUIntVal(ObjMap["EveryoneMask"]);
+                flags = ReadUIntVal(ObjMap["Flags"]);
+                group_mask = ReadUIntVal(ObjMap["GroupMask"]);
                 material = ObjMap["Material"].AsInteger();
-                next_owner_mask = readuintval(ObjMap["NextOwnerMask"]);
+                next_owner_mask = ReadUIntVal(ObjMap["NextOwnerMask"]);
                 p_code = ObjMap["PCode"].AsInteger();
 
-                if (ObjMap.ContainsKey("Path"))
+                if (ObjMap.TryGetValue("Path", out tmpOSD))
                 {
-                    if (ObjMap["Path"].Type != OSDType.Map)
+                    if (tmpOSD.Type != OSDType.Map)
                     {
                         responsedata["str_response_string"] = "Has Path key, but data not in expected format";
                         return responsedata;
                     }
 
-                    OSDMap PathMap = (OSDMap)ObjMap["Path"];
+                    OSDMap PathMap = (OSDMap)tmpOSD;
                     path_begin = PathMap["Begin"].AsInteger();
                     path_curve = PathMap["Curve"].AsInteger();
                     path_end = PathMap["End"].AsInteger();
@@ -203,18 +203,17 @@ namespace OpenSim.Region.ClientStack.Linden
                     path_taper_y = PathMap["TaperY"].AsInteger();
                     path_twist = PathMap["Twist"].AsInteger();
                     path_twist_begin = PathMap["TwistBegin"].AsInteger();
-
                 }
 
-                if (ObjMap.ContainsKey("Profile"))
+                if (ObjMap.TryGetValue("Profile", out tmpOSD))
                 {
-                    if (ObjMap["Profile"].Type != OSDType.Map)
+                    if (tmpOSD.Type != OSDType.Map)
                     {
                         responsedata["str_response_string"] = "Has Profile key, but data not in expected format";
                         return responsedata;
                     }
 
-                    OSDMap ProfileMap = (OSDMap)ObjMap["Profile"];
+                    OSDMap ProfileMap = (OSDMap)tmpOSD;
 
                     profile_begin = ProfileMap["Begin"].AsInteger();
                     profile_curve = ProfileMap["Curve"].AsInteger();
@@ -239,15 +238,15 @@ namespace OpenSim.Region.ClientStack.Linden
                     return responsedata;
                 }
 
-                if (rm.ContainsKey("AgentData"))
+                if (rm.TryGetValue("AgentData", out tmpOSD))
                 {
-                    if (rm["AgentData"].Type != OSDType.Map)
+                    if (tmpOSD.Type != OSDType.Map)
                     {
                         responsedata["str_response_string"] = "Has AgentData key, but data not in expected format";
                         return responsedata;
                     }
 
-                    OSDMap AgentDataMap = (OSDMap)rm["AgentData"];
+                    OSDMap AgentDataMap = (OSDMap)tmpOSD;
 
                     //session_id = AgentDataMap["SessionId"].AsUUID();
                     group_id = AgentDataMap["GroupId"].AsUUID();
@@ -258,13 +257,13 @@ namespace OpenSim.Region.ClientStack.Linden
             { //v1
                 bypass_raycast = rm["bypass_raycast"].AsBoolean();
 
-                everyone_mask = readuintval(rm["everyone_mask"]);
-                flags = readuintval(rm["flags"]);
+                everyone_mask = ReadUIntVal(rm["everyone_mask"]);
+                flags = ReadUIntVal(rm["flags"]);
                 group_id = rm["group_id"].AsUUID();
-                group_mask = readuintval(rm["group_mask"]);
+                group_mask = ReadUIntVal(rm["group_mask"]);
                 hollow = rm["hollow"].AsInteger();
                 material = rm["material"].AsInteger();
-                next_owner_mask = readuintval(rm["next_owner_mask"]);
+                next_owner_mask = ReadUIntVal(rm["next_owner_mask"]);
                 hollow = rm["hollow"].AsInteger();
                 p_code = rm["p_code"].AsInteger();
                 path_begin = rm["path_begin"].AsInteger();
@@ -344,7 +343,6 @@ namespace OpenSim.Region.ClientStack.Linden
                 obj = m_scene.AddNewPrim(avatar.UUID, group_id, pos, rotation, pbs);
             }
 
-
             if (obj == null)
                 return responsedata;
 
@@ -369,7 +367,7 @@ namespace OpenSim.Region.ClientStack.Linden
             return responsedata;
         }
 
-        private uint readuintval(OSD obj)
+        private uint ReadUIntVal(OSD obj)
         {
             byte[] tmp = obj.AsBinary();
             if (BitConverter.IsLittleEndian)