public void HandleParcelPropertiesUpdate(AgentCircuit circuit, SceneInterface scene, Message m)
        {
            var req = (ParcelPropertiesUpdate)m;

            if (req.AgentID != req.CircuitAgentID ||
                req.SessionID != req.CircuitSessionID)
            {
                return;
            }

            IAgent agent = circuit.Agent;

            ParcelInfo pInfo;

            if (scene.Parcels.TryGetValue(req.LocalID, out pInfo) &&
                scene.CanEditParcelDetails(agent.Owner, pInfo))
            {
                pInfo.Flags       = req.ParcelFlags;
                pInfo.SalePrice   = req.SalePrice;
                pInfo.Name        = req.Name;
                pInfo.Description = req.Description;
                pInfo.MusicURI    = (req.MusicURL.Length != 0) && Uri.IsWellFormedUriString(req.MusicURL, UriKind.Absolute) ?
                                    new URI(req.MusicURL) : null;

                pInfo.MediaURI = (req.MediaURL.Length != 0) && Uri.IsWellFormedUriString(req.MediaURL, UriKind.Absolute) ?
                                 new URI(req.MediaURL) : null;
                pInfo.MediaAutoScale = req.MediaAutoScale;
                UGI ugi;
                if (req.GroupID == UUID.Zero)
                {
                    ugi = UGI.Unknown;
                }
                else if (scene.GroupsNameService.TryGetValue(req.GroupID, out ugi))
                {
                    pInfo.Group = ugi;
                }
                else
                {
                    pInfo.Group = UGI.Unknown;
                }

                pInfo.PassPrice = req.PassPrice;
                pInfo.PassHours = req.PassHours;
                pInfo.Category  = req.Category;
                if (req.AuthBuyerID == UUID.Zero ||
                    !scene.AvatarNameService.TryGetValue(req.AuthBuyerID, out pInfo.AuthBuyer))
                {
                    pInfo.AuthBuyer = UGUI.Unknown;
                }

                pInfo.SnapshotID      = req.SnapshotID;
                pInfo.LandingPosition = req.UserLocation;
                pInfo.LandingLookAt   = req.UserLookAt;
                pInfo.LandingType     = req.LandingType;
                scene.TriggerParcelUpdate(pInfo);
            }
        }
        public void HandleParcelSetOtherCleanTime(AgentCircuit circuit, SceneInterface scene, Message m)
        {
            var req = (ParcelSetOtherCleanTime)m;

            if (req.AgentID != req.CircuitAgentID ||
                req.SessionID != req.CircuitSessionID)
            {
                return;
            }

            IAgent     agent = circuit.Agent;
            ParcelInfo pInfo;

            if (scene.Parcels.TryGetValue(req.LocalID, out pInfo) &&
                scene.CanEditParcelDetails(agent.Owner, pInfo))
            {
                pInfo.OtherCleanTime = req.OtherCleanTime;
                scene.TriggerParcelUpdate(pInfo);
            }
        }
        public void HttpRequestHandler(HttpRequest httpreq)
        {
            if (httpreq.CallerIP != m_RemoteIP)
            {
                httpreq.ErrorResponse(HttpStatusCode.Forbidden, "Forbidden");
                return;
            }
            if (httpreq.Method != "POST")
            {
                httpreq.ErrorResponse(HttpStatusCode.MethodNotAllowed, "Method not allowed");
                return;
            }

            Map reqmap;

            try
            {
                reqmap = LlsdXml.Deserialize(httpreq.Body) as Map;
            }
            catch (Exception e)
            {
                m_Log.ErrorFormat("Exception {0}: {1}\n{2}", e.GetType().FullName, e.Message, e.StackTrace);
                httpreq.ErrorResponse(HttpStatusCode.UnsupportedMediaType, "Unsupported Media Type");
                return;
            }
            if (reqmap == null)
            {
                httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Misformatted LLSD-XML");
                return;
            }

            ParcelInfo pInfo;

            if (!m_Scene.Parcels.TryGetValue(reqmap["local_id"].AsInt, out pInfo))
            {
                httpreq.ErrorResponse(HttpStatusCode.Forbidden, "Forbidden");
                return;
            }

            if (!m_Scene.CanEditParcelDetails(m_Agent.Owner, pInfo))
            {
                httpreq.ErrorResponse(HttpStatusCode.Forbidden, "Forbidden");
                return;
            }

            byte[] parcelFlagsBinary = (BinaryData)reqmap["parcel_flags"];
            if (BitConverter.IsLittleEndian)
            {
                Array.Reverse(parcelFlagsBinary);
            }
            uint parcelFlags = BitConverter.ToUInt32(parcelFlagsBinary, 0);

            pInfo.Flags       = (ParcelFlags)parcelFlags;
            pInfo.Name        = reqmap["name"].ToString();
            pInfo.SalePrice   = reqmap["sale_price"].AsInt;
            pInfo.Description = reqmap["description"].ToString();
            var music_uri = reqmap["music_url"].ToString();

            pInfo.MusicURI = music_uri != string.Empty && Uri.IsWellFormedUriString(music_uri, UriKind.Absolute) ? new URI(music_uri) : null;
            var media_uri = reqmap["media_url"].ToString();

            pInfo.MediaURI         = media_uri != string.Empty && Uri.IsWellFormedUriString(media_uri, UriKind.Absolute) ? new URI(media_uri) : null;
            pInfo.MediaDescription = reqmap["media_desc"].ToString();
            pInfo.MediaType        = reqmap["media_type"].ToString();
            pInfo.MediaWidth       = reqmap["media_width"].AsInt;
            pInfo.MediaHeight      = reqmap["media_height"].AsInt;
            pInfo.MediaAutoScale   = reqmap["auto_scale"].AsBoolean;
            pInfo.MediaLoop        = reqmap["media_loop"].AsBoolean;
            pInfo.ObscureMedia     = reqmap["obscure_media"].AsBoolean;
            pInfo.ObscureMusic     = reqmap["obscure_music"].AsBoolean;
            pInfo.MediaID          = reqmap["media_id"].AsUUID;
            pInfo.Group            = new UGI(reqmap["group_id"].AsUUID);
            pInfo.PassPrice        = reqmap["pass_price"].AsInt;
            pInfo.PassHours        = reqmap["pass_hours"].AsReal;
            pInfo.Category         = (ParcelCategory)reqmap["category"].AsInt;
            pInfo.AuthBuyer        = new UGUIWithName(reqmap["auth_buyer_id"].AsUUID);
            pInfo.SnapshotID       = reqmap["snapshot_id"].AsUUID;
            pInfo.LandingPosition  = reqmap["user_location"].AsVector3;
            pInfo.LandingLookAt    = reqmap["user_look_at"].AsVector3;
            pInfo.LandingType      = (TeleportLandingType)reqmap["landing_type"].AsInt;
            if (reqmap.ContainsKey("see_avs"))
            {
                pInfo.SeeAvatars = reqmap["see_avs"].AsBoolean;
            }
            if (reqmap.ContainsKey("group_av_sounds"))
            {
                pInfo.GroupAvatarSounds = reqmap["group_av_sounds"].AsBoolean;
            }
            if (reqmap.ContainsKey("any_av_sounds"))
            {
                pInfo.AnyAvatarSounds = reqmap["any_av_sounds"].AsBoolean;
            }
            if (reqmap.ContainsKey("obscure_media"))
            {
                pInfo.ObscureMedia = reqmap["obscure_media"].AsBoolean;
            }
            if (reqmap.ContainsKey("obscure_music"))
            {
                pInfo.ObscureMusic = reqmap["obscure_music"].AsBoolean;
            }

            //media_prevent_camera_zoom
            //media_url_timeout
            //media_allow_navigate
            //media_current_url

            m_Scene.TriggerParcelUpdate(pInfo);

            using (var httpres = httpreq.BeginResponse())
            {
                httpres.ContentType = "application/llsd+xml";
                using (var outStream = httpres.GetOutputStream())
                {
                    LlsdXml.Serialize(new Map(), outStream);
                }
            }
        }
        public void HttpRequestHandler(HttpRequest httpreq)
        {
            if (httpreq.CallerIP != m_RemoteIP)
            {
                httpreq.ErrorResponse(HttpStatusCode.Forbidden, "Forbidden");
                return;
            }
            if (httpreq.Method != "POST")
            {
                httpreq.ErrorResponse(HttpStatusCode.MethodNotAllowed, "Method not allowed");
                return;
            }

            Map reqmap;

            try
            {
                reqmap = LlsdXml.Deserialize(httpreq.Body) as Map;
            }
            catch
            {
                httpreq.ErrorResponse(HttpStatusCode.UnsupportedMediaType, "Unsupported Media Type");
                return;
            }
            if (reqmap == null)
            {
                httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Misformatted LLSD-XML");
                return;
            }

            if (reqmap["agent-id"].AsUUID != m_Agent.ID)
            {
                httpreq.ErrorResponse(HttpStatusCode.BadRequest, "Misformatted LLSD-XML");
                return;
            }

            var localID = reqmap["local-id"].AsInt; /* this is parcel local id */
            var url     = reqmap["url"].ToString();

            ParcelInfo parcelInfo;

            if (m_Scene.Parcels.TryGetValue(localID, out parcelInfo))
            {
                if (!m_Scene.CanEditParcelDetails(m_Agent, parcelInfo))
                {
                    return;
                }
                parcelInfo.MediaURI = new URI(url);
                var pmu = new ParcelMediaUpdate
                {
                    MediaAutoScale = parcelInfo.MediaAutoScale,
                    MediaDesc      = parcelInfo.MediaDescription,
                    MediaHeight    = parcelInfo.MediaHeight,
                    MediaID        = parcelInfo.MediaID,
                    MediaLoop      = parcelInfo.MediaLoop,
                    MediaType      = parcelInfo.MediaType,
                    MediaURL       = url,
                    MediaWidth     = parcelInfo.MediaWidth
                };
                parcelInfo.MediaAutoScale   = pmu.MediaAutoScale;
                parcelInfo.MediaDescription = pmu.MediaDesc;
                parcelInfo.MediaHeight      = pmu.MediaHeight;
                parcelInfo.MediaID          = pmu.MediaID;
                parcelInfo.MediaType        = pmu.MediaType;
                parcelInfo.MediaLoop        = pmu.MediaLoop;
                parcelInfo.MediaURI         = new URI(pmu.MediaURL);
                parcelInfo.MediaWidth       = pmu.MediaWidth;
                m_Scene.Parcels.Store(parcelInfo.ID);

                foreach (var rootAgent in m_Scene.RootAgents)
                {
                    rootAgent.SendMessageIfRootAgent(pmu, m_Scene.ID);
                }
            }

            var m = new Map();

            using (var resp = httpreq.BeginResponse(HttpStatusCode.OK, "OK"))
            {
                resp.ContentType = "application/llsd+xml";
                using (var s = resp.GetOutputStream())
                {
                    LlsdXml.Serialize(m, s);
                }
            }
        }