Merge branch 'moap'

13 files changed, 1213 insertions, 12 deletions

diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
index 0aec01a..c59eedf 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
@@ -4288,8 +4288,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         public void SendLandObjectOwners(LandData land, List<UUID> groups, Dictionary<UUID, int> ownersAndCount)
         {
-
-
             int notifyCount = ownersAndCount.Count;
             ParcelObjectOwnersReplyPacket pack = (ParcelObjectOwnersReplyPacket)PacketPool.Instance.GetPacket(PacketType.ParcelObjectOwnersReply);
 
@@ -4561,6 +4559,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             update.TextureEntry = data.Shape.TextureEntry ?? Utils.EmptyBytes;
             update.Scale = data.Shape.Scale;
             update.Text = Util.StringToBytes256(data.Text);
+            update.MediaURL = Util.StringToBytes256(data.MediaUrl);
 
             #region PrimFlags
 
diff --git a/OpenSim/Region/CoreModules/World/Media/Moap/MoapModule.cs b/OpenSim/Region/CoreModules/World/Media/Moap/MoapModule.cs
new file mode 100644
index 0000000..82ad109
--- /dev/null
+++ b/OpenSim/Region/CoreModules/World/Media/Moap/MoapModule.cs
@@ -0,0 +1,596 @@
+/*
+ * 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.Reflection;
+using System.IO;
+using System.Web;
+using System.Xml;
+using log4net;
+using Mono.Addins;
+using Nini.Config;
+using OpenMetaverse;
+using OpenMetaverse.Messages.Linden;
+using OpenMetaverse.StructuredData;
+using OpenSim.Framework;
+using OpenSim.Framework.Capabilities;
+using OpenSim.Framework.Servers;
+using OpenSim.Framework.Servers.HttpServer;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Services.Interfaces;
+using Caps = OpenSim.Framework.Capabilities.Caps;
+using OSDArray = OpenMetaverse.StructuredData.OSDArray;
+using OSDMap = OpenMetaverse.StructuredData.OSDMap;
+
+namespace OpenSim.Region.CoreModules.Media.Moap
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "MoapModule")]
+    public class MoapModule : INonSharedRegionModule, IMoapModule
+    {    
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        
+        public string Name { get { return "MoapModule"; } }                
+        public Type ReplaceableInterface { get { return null; } }        
+
+        /// <summary>
+        /// Is this module enabled?
+        /// </summary>
+        protected bool m_isEnabled = true;
+        
+        /// <summary>
+        /// The scene to which this module is attached
+        /// </summary>
+        protected Scene m_scene;
+        
+        /// <summary>
+        /// Track the ObjectMedia capabilities given to users keyed by path
+        /// </summary>
+        protected Dictionary<string, UUID> m_omCapUsers = new Dictionary<string, UUID>();
+        
+        /// <summary>
+        /// Track the ObjectMedia capabilities given to users keyed by agent.  Lock m_omCapUsers to manipulate.
+        /// </summary>
+        protected Dictionary<UUID, string> m_omCapUrls = new Dictionary<UUID, string>();        
+        
+        /// <summary>
+        /// Track the ObjectMediaUpdate capabilities given to users keyed by path
+        /// </summary>        
+        protected Dictionary<string, UUID> m_omuCapUsers = new Dictionary<string, UUID>();
+        
+        /// <summary>
+        /// Track the ObjectMediaUpdate capabilities given to users keyed by agent.  Lock m_omuCapUsers to manipulate
+        /// </summary>        
+        protected Dictionary<UUID, string> m_omuCapUrls = new Dictionary<UUID, string>();      
+        
+        public void Initialise(IConfigSource configSource) 
+        {
+            IConfig config = configSource.Configs["MediaOnAPrim"];
+
+            if (config != null && !config.GetBoolean("Enabled", false))
+                m_isEnabled = false;
+//            else
+//                m_log.Debug("[MOAP]: Initialised module.")l
+        }
+
+        public void AddRegion(Scene scene) 
+        { 
+            if (!m_isEnabled)
+                return;
+            
+            m_scene = scene;
+            m_scene.RegisterModuleInterface<IMoapModule>(this);
+        }
+
+        public void RemoveRegion(Scene scene) {}
+
+        public void RegionLoaded(Scene scene) 
+        {
+            if (!m_isEnabled)
+                return;
+            
+            m_scene.EventManager.OnRegisterCaps += OnRegisterCaps;
+            m_scene.EventManager.OnDeregisterCaps += OnDeregisterCaps;
+            m_scene.EventManager.OnSceneObjectPartCopy += OnSceneObjectPartCopy;
+        }
+        
+        public void Close() 
+        {
+            if (!m_isEnabled)
+                return;
+            
+            m_scene.EventManager.OnRegisterCaps -= OnRegisterCaps;
+            m_scene.EventManager.OnDeregisterCaps -= OnDeregisterCaps;
+            m_scene.EventManager.OnSceneObjectPartCopy -= OnSceneObjectPartCopy;
+        }        
+        
+        public void OnRegisterCaps(UUID agentID, Caps caps)
+        {
+//            m_log.DebugFormat(
+//                "[MOAP]: Registering ObjectMedia and ObjectMediaNavigate capabilities for agent {0}", agentID);
+            
+            string omCapUrl = "/CAPS/" + UUID.Random();
+            
+            lock (m_omCapUsers)
+            {
+                m_omCapUsers[omCapUrl] = agentID;
+                m_omCapUrls[agentID] = omCapUrl;
+                
+                // Even though we're registering for POST we're going to get GETS and UPDATES too
+                caps.RegisterHandler(
+                    "ObjectMedia", new RestStreamHandler("POST", omCapUrl, HandleObjectMediaMessage));
+            }
+            
+            string omuCapUrl = "/CAPS/" + UUID.Random();
+            
+            lock (m_omuCapUsers)
+            {
+                m_omuCapUsers[omuCapUrl] = agentID;
+                m_omuCapUrls[agentID] = omuCapUrl;
+                
+                // Even though we're registering for POST we're going to get GETS and UPDATES too
+                caps.RegisterHandler(
+                    "ObjectMediaNavigate", new RestStreamHandler("POST", omuCapUrl, HandleObjectMediaNavigateMessage));
+            }
+        }  
+        
+        public void OnDeregisterCaps(UUID agentID, Caps caps)
+        {
+            lock (m_omCapUsers)
+            {
+                string path = m_omCapUrls[agentID];
+                m_omCapUrls.Remove(agentID);
+                m_omCapUsers.Remove(path);
+            }
+            
+            lock (m_omuCapUsers)
+            {
+                string path = m_omuCapUrls[agentID];
+                m_omuCapUrls.Remove(agentID);
+                m_omuCapUsers.Remove(path);
+            }
+        }
+        
+        protected void OnSceneObjectPartCopy(SceneObjectPart copy, SceneObjectPart original, bool userExposed)
+        {            
+            if (original.Shape.Media != null)
+            {
+                PrimitiveBaseShape.MediaList dupeMedia = new PrimitiveBaseShape.MediaList();
+                lock (original.Shape.Media)
+                {
+                    foreach (MediaEntry me in original.Shape.Media)
+                    {
+                        if (me != null)
+                            dupeMedia.Add(MediaEntry.FromOSD(me.GetOSD()));
+                        else
+                            dupeMedia.Add(null);
+                    }
+                }
+                
+                copy.Shape.Media = dupeMedia;
+            }            
+        }
+            
+        public MediaEntry GetMediaEntry(SceneObjectPart part, int face)
+        {
+            MediaEntry me = null;
+            
+            CheckFaceParam(part, face);
+            
+            List<MediaEntry> media = part.Shape.Media;
+            
+            if (null == media)
+            {
+                me = null;
+            }
+            else
+            {     
+                lock (media)
+                    me = media[face];                
+                
+                // TODO: Really need a proper copy constructor down in libopenmetaverse
+                if (me != null)
+                    me = MediaEntry.FromOSD(me.GetOSD());
+            }
+            
+//            m_log.DebugFormat("[MOAP]: GetMediaEntry for {0} face {1} found {2}", part.Name, face, me);
+            
+            return me;
+        }
+        
+        public void SetMediaEntry(SceneObjectPart part, int face, MediaEntry me)
+        {
+            CheckFaceParam(part, face);          
+            
+            if (null == part.Shape.Media)
+                part.Shape.Media = new PrimitiveBaseShape.MediaList(new MediaEntry[part.GetNumberOfSides()]);
+                
+            lock (part.Shape.Media)                
+                part.Shape.Media[face] = me;
+            
+            UpdateMediaUrl(part, UUID.Zero);                      
+            part.ScheduleFullUpdate();
+            part.TriggerScriptChangedEvent(Changed.MEDIA);                
+        }
+        
+        public void ClearMediaEntry(SceneObjectPart part, int face)
+        {
+            SetMediaEntry(part, face, null);
+        }
+        
+        /// <summary>
+        /// Sets or gets per face media textures.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <param name="httpRequest"></param>
+        /// <param name="httpResponse"></param>
+        /// <returns></returns>
+        protected string HandleObjectMediaMessage(
+            string request, string path, string param, OSHttpRequest httpRequest, OSHttpResponse httpResponse)
+        {            
+//            m_log.DebugFormat("[MOAP]: Got ObjectMedia path [{0}], raw request [{1}]", path, request);
+         
+            OSDMap osd = (OSDMap)OSDParser.DeserializeLLSDXml(request);
+            ObjectMediaMessage omm = new ObjectMediaMessage();
+            omm.Deserialize(osd);
+            
+            if (omm.Request is ObjectMediaRequest)
+                return HandleObjectMediaRequest(omm.Request as ObjectMediaRequest);
+            else if (omm.Request is ObjectMediaUpdate)
+                return HandleObjectMediaUpdate(path, omm.Request as ObjectMediaUpdate);               
+
+            throw new Exception(
+                string.Format(
+                    "[MOAP]: ObjectMediaMessage has unrecognized ObjectMediaBlock of {0}", 
+                    omm.Request.GetType()));         
+        }
+        
+        /// <summary>
+        /// Handle a fetch request for media textures
+        /// </summary>
+        /// <param name="omr"></param>
+        /// <returns></returns>
+        protected string HandleObjectMediaRequest(ObjectMediaRequest omr)       
+        {
+            UUID primId = omr.PrimID;
+            
+            SceneObjectPart part = m_scene.GetSceneObjectPart(primId);
+            
+            if (null == part)
+            {
+                m_log.WarnFormat(
+                    "[MOAP]: Received a GET ObjectMediaRequest for prim {0} but this doesn't exist in region {1}", 
+                    primId, m_scene.RegionInfo.RegionName);
+                return string.Empty;
+            }
+            
+            if (null == part.Shape.Media)
+                return string.Empty;
+            
+            ObjectMediaResponse resp = new ObjectMediaResponse();
+            
+            resp.PrimID = primId;
+            
+            lock (part.Shape.Media)
+                resp.FaceMedia = part.Shape.Media.ToArray();
+            
+            resp.Version = part.MediaUrl;
+           
+            string rawResp = OSDParser.SerializeLLSDXmlString(resp.Serialize());
+            
+//            m_log.DebugFormat("[MOAP]: Got HandleObjectMediaRequestGet raw response is [{0}]", rawResp);
+            
+            return rawResp;
+        }
+        
+        /// <summary>
+        /// Handle an update of media textures.
+        /// </summary>
+        /// <param name="path">Path on which this request was made</param>
+        /// <param name="omu">/param>
+        /// <returns></returns>
+        protected string HandleObjectMediaUpdate(string path, ObjectMediaUpdate omu)      
+        {
+            UUID primId = omu.PrimID;
+            
+            SceneObjectPart part = m_scene.GetSceneObjectPart(primId);
+            
+            if (null == part)
+            {
+                m_log.WarnFormat(
+                    "[MOAP]: Received an UPDATE ObjectMediaRequest for prim {0} but this doesn't exist in region {1}", 
+                    primId, m_scene.RegionInfo.RegionName);
+                return string.Empty;
+            }                                    
+            
+//            m_log.DebugFormat("[MOAP]: Received {0} media entries for prim {1}", omu.FaceMedia.Length, primId);                        
+                       
+//            for (int i = 0; i < omu.FaceMedia.Length; i++)
+//            {
+//                MediaEntry me = omu.FaceMedia[i];
+//                string v = (null == me ? "null": OSDParser.SerializeLLSDXmlString(me.GetOSD()));
+//                m_log.DebugFormat("[MOAP]: Face {0} [{1}]", i, v);
+//            }
+            
+            if (omu.FaceMedia.Length > part.GetNumberOfSides())
+            {
+                m_log.WarnFormat(
+                    "[MOAP]: Received {0} media entries from client for prim {1} {2} but this prim has only {3} faces.  Dropping request.", 
+                    omu.FaceMedia.Length, part.Name, part.UUID, part.GetNumberOfSides());
+                return string.Empty;
+            }
+            
+            UUID agentId = default(UUID);
+            
+            lock (m_omCapUsers)
+                agentId = m_omCapUsers[path]; 
+            
+            List<MediaEntry> media = part.Shape.Media;
+            
+            if (null == media)
+            {
+//                m_log.DebugFormat("[MOAP]: Setting all new media list for {0}", part.Name);
+                part.Shape.Media = new PrimitiveBaseShape.MediaList(omu.FaceMedia);
+                
+                for (int i = 0; i < omu.FaceMedia.Length; i++)
+                {
+                    if (omu.FaceMedia[i] != null)
+                    {
+                        // FIXME: Race condition here since some other texture entry manipulator may overwrite/get
+                        // overwritten.  Unfortunately, PrimitiveBaseShape does not allow us to change texture entry
+                        // directly.
+                        Primitive.TextureEntry te = part.Shape.Textures;
+                        Primitive.TextureEntryFace face = te.CreateFace((uint)i);
+                        face.MediaFlags = true;
+                        part.Shape.Textures = te;
+//                        m_log.DebugFormat(
+//                            "[MOAP]: Media flags for face {0} is {1}", 
+//                            i, part.Shape.Textures.FaceTextures[i].MediaFlags);                        
+                    }
+                }
+            }
+            else
+            {                
+                // We need to go through the media textures one at a time to make sure that we have permission 
+                // to change them                                                  
+                
+                // FIXME: Race condition here since some other texture entry manipulator may overwrite/get
+                // overwritten.  Unfortunately, PrimitiveBaseShape does not allow us to change texture entry
+                // directly.
+                Primitive.TextureEntry te = part.Shape.Textures;
+                
+                lock (media)
+                {
+                    for (int i = 0; i < media.Count; i++)
+                    {                                    
+                        if (m_scene.Permissions.CanControlPrimMedia(agentId, part.UUID, i))
+                        {            
+                            media[i] = omu.FaceMedia[i];
+                            
+                            // When a face is cleared this is done by setting the MediaFlags in the TextureEntry via a normal
+                            // texture update, so we don't need to worry about clearing MediaFlags here.
+                            if (null == media[i])
+                                continue;                            
+                            
+                            Primitive.TextureEntryFace face = te.CreateFace((uint)i);
+                            face.MediaFlags = true;                     
+    
+    //                        m_log.DebugFormat(
+    //                            "[MOAP]: Media flags for face {0} is {1}", 
+    //                            i, face.MediaFlags);
+    //                        m_log.DebugFormat("[MOAP]: Set media entry for face {0} on {1}", i, part.Name);
+                        }
+                    }
+                }
+                
+                part.Shape.Textures = te;
+                        
+//                for (int i2 = 0; i2 < part.Shape.Textures.FaceTextures.Length; i2++)                    
+//                    m_log.DebugFormat("[MOAP]: FaceTexture[{0}] is {1}", i2, part.Shape.Textures.FaceTextures[i2]);                  
+            }
+            
+            UpdateMediaUrl(part, agentId);                        
+            
+            // Arguably, we could avoid sending a full update to the avatar that just changed the texture.
+            part.ScheduleFullUpdate();
+            
+            part.TriggerScriptChangedEvent(Changed.MEDIA);
+            
+            return string.Empty;
+        }
+        
+        /// <summary>
+        /// Received from the viewer if a user has changed the url of a media texture.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="path"></param>
+        /// <param name="param"></param>
+        /// <param name="httpRequest">/param>
+        /// <param name="httpResponse">/param>
+        /// <returns></returns>
+        protected string HandleObjectMediaNavigateMessage(
+            string request, string path, string param, OSHttpRequest httpRequest, OSHttpResponse httpResponse)
+        {            
+//            m_log.DebugFormat("[MOAP]: Got ObjectMediaNavigate request [{0}]", request);
+            
+            OSDMap osd = (OSDMap)OSDParser.DeserializeLLSDXml(request);
+            ObjectMediaNavigateMessage omn = new ObjectMediaNavigateMessage();
+            omn.Deserialize(osd);           
+            
+            UUID primId = omn.PrimID;
+            
+            SceneObjectPart part = m_scene.GetSceneObjectPart(primId);            
+            
+            if (null == part)
+            {
+                m_log.WarnFormat(
+                    "[MOAP]: Received an ObjectMediaNavigateMessage for prim {0} but this doesn't exist in region {1}", 
+                    primId, m_scene.RegionInfo.RegionName);
+                return string.Empty;
+            }  
+            
+            UUID agentId = default(UUID);
+            
+            lock (m_omuCapUsers)
+                agentId = m_omuCapUsers[path];         
+            
+            if (!m_scene.Permissions.CanInteractWithPrimMedia(agentId, part.UUID, omn.Face))
+                return string.Empty;
+            
+//            m_log.DebugFormat(
+//                "[MOAP]: Received request to update media entry for face {0} on prim {1} {2} to {3}", 
+//                omn.Face, part.Name, part.UUID, omn.URL);
+            
+            // If media has never been set for this prim, then just return.
+            if (null == part.Shape.Media)
+                return string.Empty;
+            
+            MediaEntry me = null;
+                
+            lock (part.Shape.Media)
+                me = part.Shape.Media[omn.Face];
+            
+            // Do the same if media has not been set up for a specific face
+            if (null == me)
+                return string.Empty;
+            
+            if (me.EnableWhiteList)
+            {                
+                if (!CheckUrlAgainstWhitelist(omn.URL, me.WhiteList))
+                {
+//                    m_log.DebugFormat(
+//                        "[MOAP]: Blocking change of face {0} on prim {1} {2} to {3} since it's not on the enabled whitelist", 
+//                        omn.Face, part.Name, part.UUID, omn.URL);
+                    
+                    return string.Empty;
+                }
+            }            
+            
+            me.CurrentURL = omn.URL;
+            
+            UpdateMediaUrl(part, agentId);
+            
+            part.ScheduleFullUpdate();      
+            
+            part.TriggerScriptChangedEvent(Changed.MEDIA);
+            
+            return OSDParser.SerializeLLSDXmlString(new OSD());
+        }      
+        
+        /// <summary>
+        /// Check that the face number is valid for the given prim.
+        /// </summary>
+        /// <param name="part"></param>
+        /// <param name="face"></param>
+        protected void CheckFaceParam(SceneObjectPart part, int face)
+        {
+            if (face < 0)
+                throw new ArgumentException("Face cannot be less than zero");
+                               
+            int maxFaces = part.GetNumberOfSides() - 1;
+            if (face > maxFaces)
+                throw new ArgumentException(
+                    string.Format("Face argument was {0} but max is {1}", face, maxFaces));             
+        }
+        
+        /// <summary>
+        /// Update the media url of the given part
+        /// </summary>
+        /// <param name="part"></param>
+        /// <param name="updateId">
+        /// The id to attach to this update.  Normally, this is the user that changed the
+        /// texture
+        /// </param>
+        protected void UpdateMediaUrl(SceneObjectPart part, UUID updateId)
+        {
+            if (null == part.MediaUrl)
+            {
+                // TODO: We can't set the last changer until we start tracking which cap we give to which agent id
+                part.MediaUrl = "x-mv:0000000000/" + updateId;
+            }
+            else
+            {
+                string rawVersion = part.MediaUrl.Substring(5, 10);
+                int version = int.Parse(rawVersion);
+                part.MediaUrl = string.Format("x-mv:{0:D10}/{1}", ++version, updateId);
+            }   
+            
+//            m_log.DebugFormat("[MOAP]: Storing media url [{0}] in prim {1} {2}", part.MediaUrl, part.Name, part.UUID);            
+        }
+        
+        /// <summary>
+        /// Check the given url against the given whitelist.
+        /// </summary>
+        /// <param name="rawUrl"></param>
+        /// <param name="whitelist"></param>
+        /// <returns>true if the url matches an entry on the whitelist, false otherwise</returns>
+        protected bool CheckUrlAgainstWhitelist(string rawUrl, string[] whitelist)
+        {            
+            Uri url = new Uri(rawUrl);
+            
+            foreach (string origWlUrl in whitelist)
+            {
+                string wlUrl = origWlUrl;
+                
+                // Deal with a line-ending wildcard
+                if (wlUrl.EndsWith("*"))
+                    wlUrl = wlUrl.Remove(wlUrl.Length - 1);
+                
+//                m_log.DebugFormat("[MOAP]: Checking whitelist URL pattern {0}", origWlUrl);
+                
+                // Handle a line starting wildcard slightly differently since this can only match the domain, not the path
+                if (wlUrl.StartsWith("*"))
+                {
+                    wlUrl = wlUrl.Substring(1);
+                    
+                    if (url.Host.Contains(wlUrl))
+                    {
+//                        m_log.DebugFormat("[MOAP]: Whitelist URL {0} matches {1}", origWlUrl, rawUrl);
+                        return true;                        
+                    }
+                }
+                else
+                {
+                    string urlToMatch = url.Authority + url.AbsolutePath;
+    
+                    if (urlToMatch.StartsWith(wlUrl))
+                    {
+//                        m_log.DebugFormat("[MOAP]: Whitelist URL {0} matches {1}", origWlUrl, rawUrl);
+                        return true;
+                    }
+                }
+            }        
+            
+            return false;
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/CoreModules/World/Permissions/PermissionsModule.cs b/OpenSim/Region/CoreModules/World/Permissions/PermissionsModule.cs
index 1d70546..bc54997 100644
--- a/OpenSim/Region/CoreModules/World/Permissions/PermissionsModule.cs
+++ b/OpenSim/Region/CoreModules/World/Permissions/PermissionsModule.cs
@@ -164,6 +164,7 @@ namespace OpenSim.Region.CoreModules.World.Permissions
         private Dictionary<string, bool> GrantYP = new Dictionary<string, bool>();
         private IFriendsModule m_friendsModule;
         private IGroupsModule m_groupsModule;
+        private IMoapModule m_moapModule;
 
         #endregion
 
@@ -177,7 +178,7 @@ namespace OpenSim.Region.CoreModules.World.Permissions
 
             string permissionModules = myConfig.GetString("permissionmodules", "DefaultPermissionsModule");
 
-            List<string> modules=new List<string>(permissionModules.Split(','));
+            List<string> modules = new List<string>(permissionModules.Split(','));
 
             if (!modules.Contains("DefaultPermissionsModule"))
                 return;
@@ -249,6 +250,9 @@ namespace OpenSim.Region.CoreModules.World.Permissions
             m_scene.Permissions.OnDeleteUserInventory += CanDeleteUserInventory; //NOT YET IMPLEMENTED
             
             m_scene.Permissions.OnTeleport += CanTeleport; //NOT YET IMPLEMENTED
+            
+            m_scene.Permissions.OnControlPrimMedia += CanControlPrimMedia;
+            m_scene.Permissions.OnInteractWithPrimMedia += CanInteractWithPrimMedia;
 
             m_scene.AddCommand(this, "bypass permissions",
                     "bypass permissions <true / false>",
@@ -394,6 +398,12 @@ namespace OpenSim.Region.CoreModules.World.Permissions
 
             if (m_groupsModule == null)
                 m_log.Warn("[PERMISSIONS]: Groups module not found, group permissions will not work");        
+            
+            m_moapModule = m_scene.RequestModuleInterface<IMoapModule>();
+            
+            // This log line will be commented out when no longer required for debugging
+//            if (m_moapModule == null)
+//                m_log.Warn("[PERMISSIONS]: Media on a prim module not found, media on a prim permissions will not work");                    
         }
 
         public void Close()
@@ -1894,5 +1904,80 @@ namespace OpenSim.Region.CoreModules.World.Permissions
             }
             return(false);
         }
+        
+        private bool CanControlPrimMedia(UUID agentID, UUID primID, int face)
+        {            
+//            m_log.DebugFormat(
+//                "[PERMISSONS]: Performing CanControlPrimMedia check with agentID {0}, primID {1}, face {2}",
+//                agentID, primID, face);
+            
+            if (null == m_moapModule)
+                return false;
+            
+            SceneObjectPart part = m_scene.GetSceneObjectPart(primID);
+            if (null == part)
+                return false;
+            
+            MediaEntry me = m_moapModule.GetMediaEntry(part, face);                                  
+            
+            // If there is no existing media entry then it can be controlled (in this context, created).
+            if (null == me)
+                return true;
+            
+//            m_log.DebugFormat(
+//                "[PERMISSIONS]: Checking CanControlPrimMedia for {0} on {1} face {2} with control permissions {3}", 
+//                agentID, primID, face, me.ControlPermissions);
+            
+            return GenericPrimMediaPermission(part, agentID, me.ControlPermissions);
+        }  
+        
+        private bool CanInteractWithPrimMedia(UUID agentID, UUID primID, int face)
+        {
+//            m_log.DebugFormat(
+//                "[PERMISSONS]: Performing CanInteractWithPrimMedia check with agentID {0}, primID {1}, face {2}",
+//                agentID, primID, face);
+            
+            if (null == m_moapModule)
+                return false;
+            
+            SceneObjectPart part = m_scene.GetSceneObjectPart(primID);
+            if (null == part)
+                return false;
+            
+            MediaEntry me = m_moapModule.GetMediaEntry(part, face);
+            
+            // If there is no existing media entry then it can be controlled (in this context, created).
+            if (null == me)
+                return true;
+            
+//            m_log.DebugFormat(
+//                "[PERMISSIONS]: Checking CanInteractWithPrimMedia for {0} on {1} face {2} with interact permissions {3}", 
+//                agentID, primID, face, me.InteractPermissions);            
+            
+            return GenericPrimMediaPermission(part, agentID, me.InteractPermissions);
+        }          
+        
+        private bool GenericPrimMediaPermission(SceneObjectPart part, UUID agentID, MediaPermission perms)
+        {
+//            if (IsAdministrator(agentID))
+//                return true;            
+            
+            if ((perms & MediaPermission.Anyone) == MediaPermission.Anyone)
+                return true;
+
+            if ((perms & MediaPermission.Owner) == MediaPermission.Owner)
+            {
+                if (agentID == part.OwnerID)
+                    return true;
+            }           
+            
+            if ((perms & MediaPermission.Group) == MediaPermission.Group)
+            {
+                if (IsGroupMember(part.GroupID, agentID, 0))
+                    return true;
+            }                 
+            
+            return false;            
+        }
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Interfaces/IMoapModule.cs b/OpenSim/Region/Framework/Interfaces/IMoapModule.cs
new file mode 100644
index 0000000..24b6860
--- /dev/null
+++ b/OpenSim/Region/Framework/Interfaces/IMoapModule.cs
@@ -0,0 +1,67 @@
+/*
+ * 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;
+using OpenSim.Region.Framework.Scenes;
+
+namespace OpenSim.Region.Framework.Interfaces
+{
+    /// <summary>
+    /// Provides methods from manipulating media-on-a-prim
+    /// </summary>
+    public interface IMoapModule
+    {
+        /// <summary>
+        /// Get the media entry for a given prim face.
+        /// </summary>
+        /// A copy of the media entry is returned rather than the original, so this can be altered at will without
+        /// affecting the original settings.
+        /// <param name="part"></param>
+        /// <param name="face"></param>
+        /// <returns></returns>
+        MediaEntry GetMediaEntry(SceneObjectPart part, int face);
+        
+        /// <summary>
+        /// Set the media entry for a given prim face.
+        /// </summary>
+        /// <param name="SceneObjectPart"></param>
+        /// <param name="face"></param>
+        /// <param name="me"></param>
+        void SetMediaEntry(SceneObjectPart part, int face, MediaEntry me);
+        
+        /// <summary>
+        /// Clear the media entry for a given prim face.
+        /// </summary>
+        /// 
+        /// This is the equivalent of setting a media entry of null
+        /// 
+        /// <param name="part"></param>
+        /// <param name="face">/param>
+        void ClearMediaEntry(SceneObjectPart part, int face);
+    }        
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Scenes/EventManager.cs b/OpenSim/Region/Framework/Scenes/EventManager.cs
index 9db2e41..0ae3146 100644
--- a/OpenSim/Region/Framework/Scenes/EventManager.cs
+++ b/OpenSim/Region/Framework/Scenes/EventManager.cs
@@ -330,10 +330,38 @@ namespace OpenSim.Region.Framework.Scenes
         /// If the object is being attached, then the avatarID will be present.  If the object is being detached then
         /// the avatarID is UUID.Zero (I know, this doesn't make much sense but now it's historical).
         public delegate void Attach(uint localID, UUID itemID, UUID avatarID);
-        public event Attach OnAttach;
+        public event Attach OnAttach;                
+        
+        /// <summary>
+        /// Called immediately after an object is loaded from storage.
+        /// </summary>
+        public event SceneObjectDelegate OnSceneObjectLoaded;
+        public delegate void SceneObjectDelegate(SceneObjectGroup so);
+        
+        /// <summary>
+        /// Called immediately before an object is saved to storage.
+        /// </summary>
+        /// <param name="persistingSo">
+        /// The scene object being persisted.  
+        /// This is actually a copy of the original scene object so changes made here will be saved to storage but will not be kept in memory.
+        /// </param>
+        /// <param name="originalSo">
+        /// The original scene object being persisted.  Changes here will stay in memory but will not be saved to storage on this save.
+        /// </param>
+        public event SceneObjectPreSaveDelegate OnSceneObjectPreSave;
+        public delegate void SceneObjectPreSaveDelegate(SceneObjectGroup persistingSo, SceneObjectGroup originalSo);
+        
+        /// <summary>
+        /// Called when a scene object part is cloned within the region.
+        /// </summary>
+        /// <param name="copy"></param>
+        /// <param name="original"></param>
+        /// <param name="userExposed">True if the duplicate will immediately be in the scene, false otherwise</param>
+        public event SceneObjectPartCopyDelegate OnSceneObjectPartCopy;
+        public delegate void SceneObjectPartCopyDelegate(SceneObjectPart copy, SceneObjectPart original, bool userExposed);
 
         public delegate void RegionUp(GridRegion region);
-        public event RegionUp OnRegionUp;
+        public event RegionUp OnRegionUp;       
 
         public class MoneyTransferArgs : EventArgs
         {
@@ -2013,5 +2041,68 @@ namespace OpenSim.Region.Framework.Scenes
                 }
             }
         }
+        
+        public void TriggerOnSceneObjectLoaded(SceneObjectGroup so)
+        {
+            SceneObjectDelegate handler = OnSceneObjectLoaded;
+            if (handler != null)
+            {
+                foreach (SceneObjectDelegate d in handler.GetInvocationList())
+                {
+                    try
+                    {
+                        d(so);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerOnSceneObjectLoaded failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }
+        }  
+        
+        public void TriggerOnSceneObjectPreSave(SceneObjectGroup persistingSo, SceneObjectGroup originalSo)
+        {
+            SceneObjectPreSaveDelegate handler = OnSceneObjectPreSave;
+            if (handler != null)
+            {
+                foreach (SceneObjectPreSaveDelegate d in handler.GetInvocationList())
+                {
+                    try
+                    {
+                        d(persistingSo, originalSo);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerOnSceneObjectPreSave failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }
+        } 
+        
+        public void TriggerOnSceneObjectPartCopy(SceneObjectPart copy, SceneObjectPart original, bool userExposed)
+        {
+            SceneObjectPartCopyDelegate handler = OnSceneObjectPartCopy;
+            if (handler != null)
+            {
+                foreach (SceneObjectPartCopyDelegate d in handler.GetInvocationList())
+                {
+                    try
+                    {
+                        d(copy, original, userExposed);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(
+                            "[EVENT MANAGER]: Delegate for TriggerOnSceneObjectPartCopy failed - continuing.  {0} {1}", 
+                            e.Message, e.StackTrace);
+                    }
+                }
+            }
+        }   
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Scenes/Scene.Permissions.cs b/OpenSim/Region/Framework/Scenes/Scene.Permissions.cs
index a523351..4e80bf2 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.Permissions.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.Permissions.cs
@@ -1,4 +1,4 @@
-/*
+/*
  * Copyright (c) Contributors, http://opensimulator.org/
  * See CONTRIBUTORS.TXT for a full list of copyright holders.
  *
@@ -82,6 +82,8 @@ namespace OpenSim.Region.Framework.Scenes
     public delegate bool CopyUserInventoryHandler(UUID itemID, UUID userID);
     public delegate bool DeleteUserInventoryHandler(UUID itemID, UUID userID);
     public delegate bool TeleportHandler(UUID userID, Scene scene);
+    public delegate bool ControlPrimMediaHandler(UUID userID, UUID primID, int face);
+    public delegate bool InteractWithPrimMediaHandler(UUID userID, UUID primID, int face);
     #endregion
 
     public class ScenePermissions
@@ -141,6 +143,8 @@ namespace OpenSim.Region.Framework.Scenes
         public event CopyUserInventoryHandler OnCopyUserInventory;
         public event DeleteUserInventoryHandler OnDeleteUserInventory;
         public event TeleportHandler OnTeleport;
+        public event ControlPrimMediaHandler OnControlPrimMedia;
+        public event InteractWithPrimMediaHandler OnInteractWithPrimMedia;
         #endregion
 
         #region Object Permission Checks
@@ -964,5 +968,35 @@ namespace OpenSim.Region.Framework.Scenes
             }
             return true;
         }
+        
+        public bool CanControlPrimMedia(UUID userID, UUID primID, int face)
+        {
+            ControlPrimMediaHandler handler = OnControlPrimMedia;
+            if (handler != null)
+            {
+                Delegate[] list = handler.GetInvocationList();
+                foreach (ControlPrimMediaHandler h in list)
+                {
+                    if (h(userID, primID, face) == false)
+                        return false;
+                }
+            }
+            return true;
+        } 
+        
+        public bool CanInteractWithPrimMedia(UUID userID, UUID primID, int face)
+        {
+            InteractWithPrimMediaHandler handler = OnInteractWithPrimMedia;
+            if (handler != null)
+            {
+                Delegate[] list = handler.GetInvocationList();
+                foreach (InteractWithPrimMediaHandler h in list)
+                {
+                    if (h(userID, primID, face) == false)
+                        return false;
+                }
+            }
+            return true;
+        }    
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Scenes/Scene.cs b/OpenSim/Region/Framework/Scenes/Scene.cs
index 93f684c..dcd7f3d 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.cs
@@ -1887,9 +1887,11 @@ namespace OpenSim.Region.Framework.Scenes
 
             foreach (SceneObjectGroup group in PrimsFromDB)
             {
+                EventManager.TriggerOnSceneObjectLoaded(group);
+                
                 if (group.RootPart == null)
                 {
-                    m_log.ErrorFormat("[SCENE] Found a SceneObjectGroup with m_rootPart == null and {0} children",
+                    m_log.ErrorFormat("[SCENE]: Found a SceneObjectGroup with m_rootPart == null and {0} children",
                                       group.Children == null ? 0 : group.Children.Count);
                 }
 
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
index 17275d0..e26e4ae 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
@@ -1479,6 +1479,7 @@ namespace OpenSim.Region.Framework.Scenes
                         backup_group.RootPart.ParticleSystem = RootPart.ParticleSystem;
                         HasGroupChanged = false;
 
+                        m_scene.EventManager.TriggerOnSceneObjectPreSave(backup_group, this);
                         datastore.StoreObject(backup_group, m_scene.RegionInfo.RegionID);
 
                         backup_group.ForEachPart(delegate(SceneObjectPart part) 
@@ -1527,6 +1528,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// <summary>
         /// Duplicates this object, including operations such as physics set up and attaching to the backup event.
         /// </summary>
+        /// <param name="userExposed">True if the duplicate will immediately be in the scene, false otherwise</param>
         /// <returns></returns>
         public SceneObjectGroup Copy(bool userExposed)
         {
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
index 69f9627..3dac0ad 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
@@ -59,6 +59,7 @@ namespace OpenSim.Region.Framework.Scenes
         REGION = 256,
         TELEPORT = 512,
         REGION_RESTART = 1024,
+        MEDIA = 2048,
         ANIMATION = 16384
     }
 
@@ -321,6 +322,11 @@ namespace OpenSim.Region.Framework.Scenes
         protected Vector3 m_lastAcceleration;
         protected Vector3 m_lastAngularVelocity;
         protected int m_lastTerseSent;
+        
+        /// <summary>
+        /// Stores media texture data
+        /// </summary>
+        protected string m_mediaUrl;
 
         // TODO: Those have to be changed into persistent properties at some later point,
         // or sit-camera on vehicles will break on sim-crossing.
@@ -965,18 +971,39 @@ namespace OpenSim.Region.Framework.Scenes
                 TriggerScriptChangedEvent(Changed.SCALE);
             }
         }
+        
         public byte UpdateFlag
         {
             get { return m_updateFlag; }
             set { m_updateFlag = value; }
         }
+        
+        /// <summary>
+        /// Used for media on a prim.
+        /// </summary>
+        /// Do not change this value directly - always do it through an IMoapModule.
+        public string MediaUrl 
+        { 
+            get
+            {
+                return m_mediaUrl; 
+            }
+            
+            set               
+            {   
+                m_mediaUrl = value;
+                
+                if (ParentGroup != null)
+                    ParentGroup.HasGroupChanged = true;        
+            }
+        }
 
         [XmlIgnore]
         public bool CreateSelected
         {
             get { return m_createSelected; }
             set { m_createSelected = value; }
-        }
+        }                
 
         #endregion
 
@@ -1527,6 +1554,11 @@ namespace OpenSim.Region.Framework.Scenes
         /// <summary>
         /// Duplicates this part.
         /// </summary>
+        /// <param name="localID"></param>
+        /// <param name="AgentID"></param>
+        /// <param name="GroupID"></param>
+        /// <param name="linkNum"></param>
+        /// <param name="userExposed">True if the duplicate will immediately be in the scene, false otherwise</param>
         /// <returns></returns>
         public SceneObjectPart Copy(uint localID, UUID AgentID, UUID GroupID, int linkNum, bool userExposed)
         {
@@ -1590,7 +1622,11 @@ namespace OpenSim.Region.Framework.Scenes
                 dupe.DoPhysicsPropertyUpdate(UsePhysics, true);
             }
             
-            return dupe;
+            ParentGroup.Scene.EventManager.TriggerOnSceneObjectPartCopy(dupe, this, userExposed);
+
+//            m_log.DebugFormat("[SCENE OBJECT PART]: Clone of {0} {1} finished", Name, UUID);
+                          
+            return dupe;            
         }
 
         protected void AssetReceived(string id, Object sender, AssetBase asset)
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
index f26fc2e..139b4f1 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
@@ -7842,6 +7842,241 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             return res;
         }
 
+        public LSL_List llGetPrimMediaParams(int face, LSL_List rules)
+        {
+            m_host.AddScriptLPS(1);
+            ScriptSleep(1000);
+
+            // LSL Spec http://wiki.secondlife.com/wiki/LlGetPrimMediaParams says to fail silently if face is invalid
+            // TODO: Need to correctly handle case where a face has no media (which gives back an empty list).
+            // Assuming silently fail means give back an empty list.  Ideally, need to check this.
+            if (face < 0 || face > m_host.GetNumberOfSides() - 1)
+                return new LSL_List();
+            
+            return GetPrimMediaParams(face, rules);
+        }
+        
+        private LSL_List GetPrimMediaParams(int face, LSL_List rules)
+        {
+            IMoapModule module = m_ScriptEngine.World.RequestModuleInterface<IMoapModule>();
+            if (null == module)
+                throw new Exception("Media on a prim functions not available");
+            
+            MediaEntry me = module.GetMediaEntry(m_host, face);
+            
+            // As per http://wiki.secondlife.com/wiki/LlGetPrimMediaParams
+            if (null == me)
+                return new LSL_List();
+            
+            LSL_List res = new LSL_List();
+
+            for (int i = 0; i < rules.Length; i++)
+            {
+                int code = (int)rules.GetLSLIntegerItem(i);
+                
+                switch (code)
+                {
+                    case ScriptBaseClass.PRIM_MEDIA_ALT_IMAGE_ENABLE:
+                        // Not implemented
+                        res.Add(new LSL_Integer(0));
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_CONTROLS:
+                        if (me.Controls == MediaControls.Standard)
+                            res.Add(new LSL_Integer(ScriptBaseClass.PRIM_MEDIA_CONTROLS_STANDARD));
+                        else
+                            res.Add(new LSL_Integer(ScriptBaseClass.PRIM_MEDIA_CONTROLS_MINI));
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_CURRENT_URL:
+                        res.Add(new LSL_String(me.CurrentURL));
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_HOME_URL:
+                        res.Add(new LSL_String(me.HomeURL));
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_AUTO_LOOP:
+                        res.Add(me.AutoLoop ? ScriptBaseClass.TRUE : ScriptBaseClass.FALSE);
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_AUTO_PLAY:
+                        res.Add(me.AutoPlay ? ScriptBaseClass.TRUE : ScriptBaseClass.FALSE);
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_AUTO_SCALE:
+                        res.Add(me.AutoScale ? ScriptBaseClass.TRUE : ScriptBaseClass.FALSE);
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_AUTO_ZOOM:
+                        res.Add(me.AutoZoom ? ScriptBaseClass.TRUE : ScriptBaseClass.FALSE);
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_FIRST_CLICK_INTERACT:
+                        res.Add(me.InteractOnFirstClick ? ScriptBaseClass.TRUE : ScriptBaseClass.FALSE);
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_WIDTH_PIXELS:
+                        res.Add(new LSL_Integer(me.Width));
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_HEIGHT_PIXELS:
+                        res.Add(new LSL_Integer(me.Height));
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_WHITELIST_ENABLE:
+                        res.Add(me.EnableWhiteList ? ScriptBaseClass.TRUE : ScriptBaseClass.FALSE);
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_WHITELIST:
+                        string[] urls = (string[])me.WhiteList.Clone();
+                    
+                        for (int j = 0; j < urls.Length; j++)
+                            urls[j] = Uri.EscapeDataString(urls[j]);
+                    
+                        res.Add(new LSL_String(string.Join(", ", urls)));
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_PERMS_INTERACT:
+                        res.Add(new LSL_Integer((int)me.InteractPermissions));
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_PERMS_CONTROL:
+                        res.Add(new LSL_Integer((int)me.ControlPermissions));
+                        break;
+                }
+            }            
+            
+            return res;
+        }
+        
+        public LSL_Integer llSetPrimMediaParams(int face, LSL_List rules)
+        {
+            m_host.AddScriptLPS(1);
+            ScriptSleep(1000);
+
+            // LSL Spec http://wiki.secondlife.com/wiki/LlSetPrimMediaParams says to fail silently if face is invalid
+            // Assuming silently fail means sending back LSL_STATUS_OK.  Ideally, need to check this.
+            // Don't perform the media check directly
+            if (face < 0 || face > m_host.GetNumberOfSides() - 1)
+                return ScriptBaseClass.LSL_STATUS_OK;
+            
+            return SetPrimMediaParams(face, rules);            
+        }
+        
+        private LSL_Integer SetPrimMediaParams(int face, LSL_List rules)
+        {
+            IMoapModule module = m_ScriptEngine.World.RequestModuleInterface<IMoapModule>();
+            if (null == module)
+                throw new Exception("Media on a prim functions not available");
+            
+            MediaEntry me = module.GetMediaEntry(m_host, face);
+            if (null == me)
+                me = new MediaEntry();
+            
+            int i = 0;
+            
+            while (i < rules.Length - 1)
+            {
+                int code = rules.GetLSLIntegerItem(i++);
+                
+                switch (code)
+                {
+                    case ScriptBaseClass.PRIM_MEDIA_ALT_IMAGE_ENABLE:
+                        me.EnableAlterntiveImage = (rules.GetLSLIntegerItem(i++) != 0 ? true : false);
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_CONTROLS:
+                        int v = rules.GetLSLIntegerItem(i++);
+                        if (ScriptBaseClass.PRIM_MEDIA_CONTROLS_STANDARD == v)
+                            me.Controls = MediaControls.Standard;
+                        else
+                            me.Controls = MediaControls.Mini;
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_CURRENT_URL:
+                        me.CurrentURL = rules.GetLSLStringItem(i++);
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_HOME_URL:
+                        me.HomeURL = rules.GetLSLStringItem(i++);
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_AUTO_LOOP:
+                        me.AutoLoop = (ScriptBaseClass.TRUE == rules.GetLSLIntegerItem(i++) ? true : false);
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_AUTO_PLAY:
+                        me.AutoPlay = (ScriptBaseClass.TRUE == rules.GetLSLIntegerItem(i++) ? true : false);
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_AUTO_SCALE:
+                        me.AutoScale = (ScriptBaseClass.TRUE == rules.GetLSLIntegerItem(i++) ? true : false);
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_AUTO_ZOOM:
+                        me.AutoZoom = (ScriptBaseClass.TRUE == rules.GetLSLIntegerItem(i++) ? true : false);
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_FIRST_CLICK_INTERACT:
+                        me.InteractOnFirstClick = (ScriptBaseClass.TRUE == rules.GetLSLIntegerItem(i++) ? true : false);
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_WIDTH_PIXELS:
+                        me.Width = (int)rules.GetLSLIntegerItem(i++);
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_HEIGHT_PIXELS:
+                        me.Height = (int)rules.GetLSLIntegerItem(i++);
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_WHITELIST_ENABLE:
+                        me.EnableWhiteList = (ScriptBaseClass.TRUE == rules.GetLSLIntegerItem(i++) ? true : false);
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_WHITELIST:
+                        string[] rawWhiteListUrls = rules.GetLSLStringItem(i++).ToString().Split(new char[] { ',' });
+                        List<string> whiteListUrls = new List<string>();
+                        Array.ForEach(
+                            rawWhiteListUrls, delegate(string rawUrl) { whiteListUrls.Add(rawUrl.Trim()); });
+                        me.WhiteList = whiteListUrls.ToArray();
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_PERMS_INTERACT:
+                        me.InteractPermissions = (MediaPermission)(byte)(int)rules.GetLSLIntegerItem(i++);
+                        break;
+                        
+                    case ScriptBaseClass.PRIM_MEDIA_PERMS_CONTROL:
+                        me.ControlPermissions = (MediaPermission)(byte)(int)rules.GetLSLIntegerItem(i++);
+                        break;
+                }
+            }       
+                        
+            module.SetMediaEntry(m_host, face, me);
+            
+            return ScriptBaseClass.LSL_STATUS_OK;
+        }
+        
+        public LSL_Integer llClearPrimMedia(LSL_Integer face)
+        {
+            m_host.AddScriptLPS(1);
+            ScriptSleep(1000);
+
+            // LSL Spec http://wiki.secondlife.com/wiki/LlClearPrimMedia says to fail silently if face is invalid
+            // Assuming silently fail means sending back LSL_STATUS_OK.  Ideally, need to check this.
+            // FIXME: Don't perform the media check directly
+            if (face < 0 || face > m_host.GetNumberOfSides() - 1)
+                return ScriptBaseClass.LSL_STATUS_OK;
+            
+            IMoapModule module = m_ScriptEngine.World.RequestModuleInterface<IMoapModule>();
+            if (null == module)
+                throw new Exception("Media on a prim functions not available");            
+            
+            module.ClearMediaEntry(m_host, face);
+            
+            return ScriptBaseClass.LSL_STATUS_OK;
+        }
+        
         //  <remarks>
         //  <para>
         //  The .NET definition of base 64 is:
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Interface/ILSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Interface/ILSL_Api.cs
index cba46a3..561e3b3 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Interface/ILSL_Api.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Interface/ILSL_Api.cs
@@ -62,6 +62,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api.Interfaces
               void llBreakLink(int linknum);
        LSL_Integer llCeil(double f);
               void llClearCameraParams();
+       LSL_Integer llClearPrimMedia(LSL_Integer face);
               void llCloseRemoteDataChannel(string channel);
          LSL_Float llCloud(LSL_Vector offset);
               void llCollisionFilter(string name, string id, int accept);
@@ -162,6 +163,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api.Interfaces
           LSL_List llGetParcelPrimOwners(LSL_Vector pos);
        LSL_Integer llGetPermissions();
            LSL_Key llGetPermissionsKey();
+          LSL_List llGetPrimMediaParams(int face, LSL_List rules);
         LSL_Vector llGetPos();
           LSL_List llGetPrimitiveParams(LSL_List rules);
        LSL_Integer llGetRegionAgentCount();
@@ -332,6 +334,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api.Interfaces
               void llSetParcelMusicURL(string url);
               void llSetPayPrice(int price, LSL_List quick_pay_buttons);
               void llSetPos(LSL_Vector pos);
+       LSL_Integer llSetPrimMediaParams(int face, LSL_List rules);
               void llSetPrimitiveParams(LSL_List rules);
               void llSetLinkPrimitiveParamsFast(int linknum, LSL_List rules);
               void llSetPrimURL(string url);
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Constants.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Constants.cs
index 69f48c9..5da6bb9 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Constants.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Constants.cs
@@ -277,6 +277,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase
         public const int CHANGED_TELEPORT = 512;
         public const int CHANGED_REGION_RESTART = 1024;
         public const int CHANGED_REGION_START = 1024; //LL Changed the constant from CHANGED_REGION_RESTART
+        public const int CHANGED_MEDIA = 2048;
         public const int CHANGED_ANIMATION = 16384;
         public const int TYPE_INVALID = 0;
         public const int TYPE_INTEGER = 1;
@@ -518,6 +519,41 @@ namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase
         public const int TOUCH_INVALID_FACE = -1;
         public static readonly vector TOUCH_INVALID_TEXCOORD = new vector(-1.0, -1.0, 0.0);
         public static readonly vector TOUCH_INVALID_VECTOR = ZERO_VECTOR;
+        
+        // constants for llGetPrimMediaParams/llSetPrimMediaParams
+        public const int PRIM_MEDIA_ALT_IMAGE_ENABLE = 0;
+        public const int PRIM_MEDIA_CONTROLS = 1;
+        public const int PRIM_MEDIA_CURRENT_URL = 2;
+        public const int PRIM_MEDIA_HOME_URL = 3;
+        public const int PRIM_MEDIA_AUTO_LOOP = 4;
+        public const int PRIM_MEDIA_AUTO_PLAY = 5;
+        public const int PRIM_MEDIA_AUTO_SCALE = 6;
+        public const int PRIM_MEDIA_AUTO_ZOOM = 7;
+        public const int PRIM_MEDIA_FIRST_CLICK_INTERACT = 8;
+        public const int PRIM_MEDIA_WIDTH_PIXELS = 9;
+        public const int PRIM_MEDIA_HEIGHT_PIXELS = 10;
+        public const int PRIM_MEDIA_WHITELIST_ENABLE = 11;
+        public const int PRIM_MEDIA_WHITELIST = 12;
+        public const int PRIM_MEDIA_PERMS_INTERACT = 13;
+        public const int PRIM_MEDIA_PERMS_CONTROL = 14;
+        
+        public const int PRIM_MEDIA_CONTROLS_STANDARD = 0;
+        public const int PRIM_MEDIA_CONTROLS_MINI = 1;
+        
+        public const int PRIM_MEDIA_PERM_NONE = 0;
+        public const int PRIM_MEDIA_PERM_OWNER = 1;
+        public const int PRIM_MEDIA_PERM_GROUP = 2;
+        public const int PRIM_MEDIA_PERM_ANYONE = 4;
+        
+        // extra constants for llSetPrimMediaParams
+        public static readonly LSLInteger LSL_STATUS_OK = new LSLInteger(0);
+        public static readonly LSLInteger LSL_STATUS_MALFORMED_PARAMS = new LSLInteger(1000);
+        public static readonly LSLInteger LSL_STATUS_TYPE_MISMATCH = new LSLInteger(1001);
+        public static readonly LSLInteger LSL_STATUS_BOUNDS_ERROR = new LSLInteger(1002);
+        public static readonly LSLInteger LSL_STATUS_NOT_FOUND = new LSLInteger(1003);
+        public static readonly LSLInteger LSL_STATUS_NOT_SUPPORTED = new LSLInteger(1004);
+        public static readonly LSLInteger LSL_STATUS_INTERNAL_ERROR = new LSLInteger(1999);
+        public static readonly LSLInteger LSL_STATUS_WHITELIST_FAILED = new LSLInteger(2001);
 
         // Constants for default textures
         public const string TEXTURE_BLANK = "5748decc-f629-461c-9a36-a35a221fe21f";
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Stub.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Stub.cs
index 3339995..451163f 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Stub.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/LSL_Stub.cs
@@ -1832,5 +1832,20 @@ namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase
         {
             return m_LSL_Functions.llXorBase64StringsCorrect(str1, str2);
         }
+        
+        public LSL_List llGetPrimMediaParams(int face, LSL_List rules)
+        {
+            return m_LSL_Functions.llGetPrimMediaParams(face, rules);
+        }
+        
+        public LSL_Integer llSetPrimMediaParams(int face, LSL_List rules)
+        {
+            return m_LSL_Functions.llSetPrimMediaParams(face, rules);
+        }
+        
+        public LSL_Integer llClearPrimMedia(LSL_Integer face)
+        {
+            return m_LSL_Functions.llClearPrimMedia(face);
+        }
     }
 }