/// <summary> /// Set the display name for the given user /// </summary> /// <param name = "mDhttpMethod"></param> /// <param name = "agentID"></param> /// <returns></returns> private Hashtable ProcessSetDisplayName(Hashtable mDhttpMethod) { try { OSDMap rm = (OSDMap)OSDParser.DeserializeLLSDXml((string)mDhttpMethod["requestbody"]); OSDArray display_name = (OSDArray)rm["display_name"]; string oldDisplayName = display_name[0].AsString(); string newDisplayName = display_name[1].AsString(); UserAccount account = m_userService.GetUserAccount(UUID.Zero, m_service.AgentID); //Check to see if their name contains a banned character #if (!ISWIN) foreach (string bannedUserName in bannedNames) { string BannedUserName = bannedUserName.Replace(" ", ""); if (newDisplayName.ToLower().Contains(BannedUserName.ToLower())) { //Revert the name to the original and send them a warning newDisplayName = account.Name; //m_avatar.ControllingClient.SendAlertMessage ("You cannot update your display name to the name chosen, your name has been reverted. This request has been logged."); break; //No more checking } } #else if (bannedNames.Select(bannedUserName => bannedUserName.Replace(" ", "")).Any(BannedUserName => newDisplayName.ToLower().Contains(BannedUserName.ToLower()))) { newDisplayName = account.Name; } #endif IUserProfileInfo info = m_profileConnector.GetUserProfile(m_service.AgentID); if (info == null) { //m_avatar.ControllingClient.SendAlertMessage ("You cannot update your display name currently as your profile cannot be found."); } else { //Set the name info.DisplayName = newDisplayName; m_profileConnector.UpdateUserProfile(info); //One for us DisplayNameUpdate(newDisplayName, oldDisplayName, account, m_service.AgentID); #if (!ISWIN) foreach (IRegionClientCapsService avatar in m_service.RegionCaps.GetClients()) { if (avatar.AgentID != m_service.AgentID) { //Update all others DisplayNameUpdate(newDisplayName, oldDisplayName, account, avatar.AgentID); } } #else foreach (IRegionClientCapsService avatar in m_service.RegionCaps.GetClients().Where(avatar => avatar.AgentID != m_service.AgentID)) { //Update all others DisplayNameUpdate(newDisplayName, oldDisplayName, account, avatar.AgentID); } #endif //The reply SetDisplayNameReply(newDisplayName, oldDisplayName, account); } } catch { } //Send back data Hashtable responsedata = new Hashtable(); responsedata["int_response_code"] = 200; //501; //410; //404; responsedata["content_type"] = "text/plain"; responsedata["keepalive"] = false; responsedata["str_response_string"] = ""; return(responsedata); }
/// <summary> /// Add a new item to the user's inventory /// </summary> /// <param name="item"></param> /// <returns>true if the item was successfully added</returns> public bool AddItem(InventoryItemBase item) { // A folder of UUID.Zero means we need to find the most appropriate home for this item if (item.Folder == UUID.Zero) { InventoryFolderBase folder = GetFolderForType(item.Owner, (AssetType)item.AssetType); if (folder != null && folder.ID != UUID.Zero) { item.Folder = folder.ID; } else { item.Folder = item.Owner; // Root folder } } if ((AssetType)item.AssetType == AssetType.Gesture) { UpdateGesture(item.Owner, item.ID, item.Flags == 1); } if (item.BasePermissions == 0) { m_log.WarnFormat("[SIMIAN INVENTORY CONNECTOR]: Adding inventory item {0} ({1}) with no base permissions", item.Name, item.ID); } OSDMap permissions = new OSDMap { { "BaseMask", OSD.FromInteger(item.BasePermissions) }, { "EveryoneMask", OSD.FromInteger(item.EveryOnePermissions) }, { "GroupMask", OSD.FromInteger(item.GroupPermissions) }, { "NextOwnerMask", OSD.FromInteger(item.NextPermissions) }, { "OwnerMask", OSD.FromInteger(item.CurrentPermissions) } }; OSDMap extraData = new OSDMap() { { "Flags", OSD.FromInteger(item.Flags) }, { "GroupID", OSD.FromUUID(item.GroupID) }, { "GroupOwned", OSD.FromBoolean(item.GroupOwned) }, { "SalePrice", OSD.FromInteger(item.SalePrice) }, { "SaleType", OSD.FromInteger(item.SaleType) }, { "Permissions", permissions } }; // Add different asset type only if it differs from inventory type // (needed for links) string invContentType = SLUtil.SLInvTypeToContentType(item.InvType); string assetContentType = SLUtil.SLAssetTypeToContentType(item.AssetType); if (invContentType != assetContentType) { extraData["LinkedItemType"] = OSD.FromString(assetContentType); } NameValueCollection requestArgs = new NameValueCollection { { "RequestMethod", "AddInventoryItem" }, { "ItemID", item.ID.ToString() }, { "AssetID", item.AssetID.ToString() }, { "ParentID", item.Folder.ToString() }, { "OwnerID", item.Owner.ToString() }, { "Name", item.Name }, { "Description", item.Description }, { "CreatorID", item.CreatorId }, { "ContentType", invContentType }, { "ExtraData", OSDParser.SerializeJsonString(extraData) } }; OSDMap response = WebUtils.PostToService(m_serverUrl, requestArgs); bool success = response["Success"].AsBoolean(); if (!success) { m_log.Warn("[SIMIAN INVENTORY CONNECTOR]: Error creating item " + item.Name + " for " + item.Owner + ": " + response["Message"].AsString()); } return(success); }
public bool DoHelloNeighbourCall(GridRegion region, RegionInfo thisRegion) { string uri = region.ServerURI + "region/" + thisRegion.RegionID + "/"; // m_log.Debug(" >>> DoHelloNeighbourCall <<< " + uri); WebRequest helloNeighbourRequest; try { helloNeighbourRequest = WebRequest.Create(uri); } catch (Exception e) { m_log.Warn(string.Format( "[NEIGHBOUR SERVICES CONNECTOR]: Unable to parse uri {0} to send HelloNeighbour from {1} to {2}. Exception {3} ", uri, thisRegion.RegionName, region.RegionName, e.Message), e); return(false); } helloNeighbourRequest.Method = "POST"; helloNeighbourRequest.ContentType = "application/json"; helloNeighbourRequest.Timeout = 10000; // Fill it in OSDMap args = null; try { args = thisRegion.PackRegionInfoData(); } catch (Exception e) { m_log.Warn(string.Format( "[NEIGHBOUR SERVICES CONNECTOR]: PackRegionInfoData failed for HelloNeighbour from {0} to {1}. Exception {2} ", thisRegion.RegionName, region.RegionName, e.Message), e); return(false); } // Add the regionhandle of the destination region args["destination_handle"] = OSD.FromString(region.RegionHandle.ToString()); string strBuffer = ""; byte[] buffer = new byte[1]; try { strBuffer = OSDParser.SerializeJsonString(args); buffer = Util.UTF8NoBomEncoding.GetBytes(strBuffer); } catch (Exception e) { m_log.Warn(string.Format( "[NEIGHBOUR SERVICES CONNECTOR]: Exception thrown on serialization of HelloNeighbour from {0} to {1}. Exception {2} ", thisRegion.RegionName, region.RegionName, e.Message), e); return(false); } Stream os = null; try { // send the Post helloNeighbourRequest.ContentLength = buffer.Length; //Count bytes to send os = helloNeighbourRequest.GetRequestStream(); os.Write(buffer, 0, strBuffer.Length); //Send it //m_log.InfoFormat("[REST COMMS]: Posted HelloNeighbour request to remote sim {0}", uri); } catch (Exception e) { m_log.Warn(string.Format( "[NEIGHBOUR SERVICES CONNECTOR]: Unable to send HelloNeighbour from {0} to {1} (uri {2}). Exception {3} ", thisRegion.RegionName, region.RegionName, uri, e.Message), e); return(false); } finally { if (os != null) { os.Dispose(); } } // Let's wait for the response //m_log.Info("[REST COMMS]: Waiting for a reply after DoHelloNeighbourCall"); try { using (WebResponse webResponse = helloNeighbourRequest.GetResponse()) { if (webResponse == null) { m_log.DebugFormat( "[NEIGHBOUR SERVICES CONNECTOR]: Null reply on DoHelloNeighbourCall post from {0} to {1}", thisRegion.RegionName, region.RegionName); } using (Stream s = webResponse.GetResponseStream()) { using (StreamReader sr = new StreamReader(s)) { //reply = sr.ReadToEnd().Trim(); sr.ReadToEnd().Trim(); //m_log.InfoFormat("[REST COMMS]: DoHelloNeighbourCall reply was {0} ", reply); } } } } catch (Exception e) { m_log.Warn(string.Format( "[NEIGHBOUR SERVICES CONNECTOR]: Exception on reply of DoHelloNeighbourCall from {0} back to {1}. Exception {2} ", region.RegionName, thisRegion.RegionName, e.Message), e); return(false); } return(true); }
public string FetchInventoryRequest(string request, string path, string param, IOSHttpRequest httpRequest, IOSHttpResponse httpResponse) { //m_log.DebugFormat("[FETCH INVENTORY HANDLER]: Received FetchInventory capability request {0}", request); OSDMap requestmap = (OSDMap)OSDParser.DeserializeLLSDXml(Utils.StringToBytes(request)); OSDArray itemsRequested = (OSDArray)requestmap["items"]; UUID[] itemIDs = new UUID[itemsRequested.Count]; int i = 0; foreach (OSDMap osdItemId in itemsRequested) { itemIDs[i++] = osdItemId["item_id"].AsUUID(); } InventoryItemBase[] items = null; if (m_agentID != UUID.Zero) { items = m_inventoryService.GetMultipleItems(m_agentID, itemIDs); } else { items = new InventoryItemBase[itemsRequested.Count]; foreach (UUID id in itemIDs) { items[i++] = m_inventoryService.GetItem(UUID.Zero, id); } } osUTF8 lsl = LLSDxmlEncode2.Start(4096); LLSDxmlEncode2.AddMap(lsl); if (m_agentID == UUID.Zero && items.Length > 0) { LLSDxmlEncode2.AddElem("agent_id", items[0].Owner, lsl); } else { LLSDxmlEncode2.AddElem("agent_id", m_agentID, lsl); } if (items == null || items.Length == 0) { LLSDxmlEncode2.AddEmptyArray("items", lsl); } else { LLSDxmlEncode2.AddArray("items", lsl); foreach (InventoryItemBase item in items) { if (item != null) { item.ToLLSDxml(lsl, 0xff); } } LLSDxmlEncode2.AddEndArray(lsl); } LLSDxmlEncode2.AddEndMap(lsl); return(LLSDxmlEncode2.End(lsl)); }
private void RequestAvatarPropertiesHandler(IClientAPI client, UUID avatarID) { OSDMap user = FetchUserData(avatarID); ProfileFlags flags = ProfileFlags.AllowPublish | ProfileFlags.MaturePublish; if (user != null) { OSDMap about = null; if (user.ContainsKey("LLAbout")) { try { about = OSDParser.DeserializeJson(user["LLAbout"].AsString()) as OSDMap; } catch { } } if (about == null) { about = new OSDMap(0); } // Check if this user is a grid operator byte[] charterMember; if (user["AccessLevel"].AsInteger() >= 200) { charterMember = Utils.StringToBytes("Operator"); } else { charterMember = Utils.EmptyBytes; } // Check if the user is online if (client.Scene is Scene) { OpenSim.Services.Interfaces.PresenceInfo[] presences = ((Scene)client.Scene).PresenceService.GetAgents(new string[] { avatarID.ToString() }); if (presences != null && presences.Length > 0) { flags |= ProfileFlags.Online; } } // Check if the user is identified if (user["Identified"].AsBoolean()) { flags |= ProfileFlags.Identified; } client.SendAvatarProperties(avatarID, about["About"].AsString(), user["CreationDate"].AsDate().ToString("M/d/yyyy", System.Globalization.CultureInfo.InvariantCulture), charterMember, about["FLAbout"].AsString(), (uint)flags, about["FLImage"].AsUUID(), about["Image"].AsUUID(), about["URL"].AsString(), user["Partner"].AsUUID()); OSDMap interests = null; if (user.ContainsKey("LLInterests")) { try { interests = OSDParser.DeserializeJson(user["LLInterests"].AsString()) as OSDMap; client.SendAvatarInterestsReply(avatarID, interests["WantMask"].AsUInteger(), interests["WantText"].AsString(), interests["SkillsMask"].AsUInteger(), interests["SkillsText"].AsString(), interests["languages"].AsString()); } catch { } } if (about == null) { about = new OSDMap(0); } } else { m_log.Warn("[SIMIAN PROFILES]: Failed to fetch profile information for " + client.Name + ", returning default values"); client.SendAvatarProperties(avatarID, String.Empty, "1/1/1970", Utils.EmptyBytes, String.Empty, (uint)flags, UUID.Zero, UUID.Zero, String.Empty, UUID.Zero); } }
public void SaveModuleToArchive(TarArchiveWriter writer, IScene scene) { m_isArchiving = true; MainConsole.Instance.Info("[Archive]: Writing parcels to archive"); writer.WriteDir("parcels"); IParcelManagementModule module = scene.RequestModuleInterface <IParcelManagementModule> (); if (module != null) { List <ILandObject> landObject = module.AllParcels(); foreach (ILandObject parcel in landObject) { OSDMap parcelMap = parcel.LandData.ToOSD(); writer.WriteFile("parcels/" + parcel.LandData.GlobalID, OSDParser.SerializeLLSDBinary(parcelMap)); } } MainConsole.Instance.Info("[Archive]: Finished writing parcels to archive"); MainConsole.Instance.Info("[Archive]: Writing terrain to archive"); writer.WriteDir("newstyleterrain"); writer.WriteDir("newstylerevertterrain"); writer.WriteDir("newstylewater"); writer.WriteDir("newstylerevertwater"); ITerrainModule tModule = scene.RequestModuleInterface <ITerrainModule> (); if (tModule != null) { try { byte [] sdata = WriteTerrainToStream(tModule.TerrainMap); writer.WriteFile("newstyleterrain/" + scene.RegionInfo.RegionID + ".terrain", sdata); sdata = WriteTerrainToStream(tModule.TerrainRevertMap); writer.WriteFile("newstylerevertterrain/" + scene.RegionInfo.RegionID + ".terrain", sdata); sdata = null; if (tModule.TerrainWaterMap != null) { sdata = WriteTerrainToStream(tModule.TerrainWaterMap); writer.WriteFile("newstylewater/" + scene.RegionInfo.RegionID + ".terrain", sdata); sdata = WriteTerrainToStream(tModule.TerrainWaterRevertMap); writer.WriteFile( "newstylerevertwater/" + scene.RegionInfo.RegionID + ".terrain", sdata); sdata = null; } } catch (Exception ex) { MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex); } } MainConsole.Instance.Info("[Archive]: Finished writing terrain to archive"); MainConsole.Instance.Info("[Archive]: Writing entities to archive"); ISceneEntity [] entities = scene.Entities.GetEntities(); //Get all entities, then start writing them to the database writer.WriteDir("entities"); IDictionary <UUID, AssetType> assets = new Dictionary <UUID, AssetType> (); UuidGatherer assetGatherer = new UuidGatherer(m_scene.AssetService); IUniverseBackupArchiver archiver = m_scene.RequestModuleInterface <IUniverseBackupArchiver> (); bool saveAssets = false; if (archiver.AllowPrompting) { saveAssets = MainConsole.Instance.Prompt("Save assets? (Will not be able to load on other grids if not saved)", "false") .Equals("true", StringComparison.CurrentCultureIgnoreCase); } int count = 0; foreach (ISceneEntity entity in entities) { try { if (entity.IsAttachment || ((entity.RootChild.Flags & PrimFlags.Temporary) == PrimFlags.Temporary) || ((entity.RootChild.Flags & PrimFlags.TemporaryOnRez) == PrimFlags.TemporaryOnRez)) { continue; } //Write all entities byte [] xml = entity.ToBinaryXml2(); writer.WriteFile("entities/" + entity.UUID, xml); xml = null; count++; if (count % 3 == 0) { Thread.Sleep(5); } //Get all the assets too if (saveAssets) { assetGatherer.GatherAssetUuids(entity, assets); } } catch (Exception ex) { MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex); } } entities = null; MainConsole.Instance.Info("[Archive]: Finished writing entities to archive"); MainConsole.Instance.Info("[Archive]: Writing assets for entities to archive"); bool foundAllAssets = true; foreach (UUID assetID in new List <UUID> (assets.Keys)) { try { foundAllAssets = false; //Not all are cached m_scene.AssetService.Get(assetID.ToString(), writer, RetrievedAsset); m_missingAssets.Add(assetID); } catch (Exception ex) { MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex); } } if (foundAllAssets) { m_isArchiving = false; //We're done if all the assets were found } MainConsole.Instance.Info("[Archive]: Finished writing assets for entities to archive"); }
public Hashtable GetEvents(UUID requestID, UUID pAgentId) { if (DebugLevel >= 2) { m_log.WarnFormat("POLLED FOR EQ MESSAGES BY {0} in {1}", pAgentId, m_scene.Name); } Queue <OSD> queue = GetQueue(pAgentId); if (queue == null) { return(NoEvents(requestID, pAgentId)); } OSD element = null;; OSDArray array = new OSDArray(); int thisID = 0; bool negativeID = false; lock (queue) { if (queue.Count == 0) { return(NoEvents(requestID, pAgentId)); } lock (m_ids) thisID = m_ids[pAgentId]; if (thisID < 0) { negativeID = true; thisID = -thisID; } while (queue.Count > 0) { element = queue.Dequeue(); // add elements until a marker is found // so they get into a response if (element == null) { break; } if (DebugLevel > 0) { LogOutboundDebugMessage(element, pAgentId); } array.Add(element); } } lock (m_ids) { if (element == null && negativeID) { Random rnd = new Random(Environment.TickCount); m_ids[pAgentId] = rnd.Next(30000000); } else { m_ids[pAgentId] = thisID + 1; } } if (array.Count == 0) { return(NoEvents(requestID, pAgentId)); } OSDMap events = new OSDMap(); events.Add("events", array); events.Add("id", new OSDInteger(thisID)); Hashtable responsedata = new Hashtable(); responsedata["int_response_code"] = 200; responsedata["content_type"] = "application/xml"; //string tt = OSDParser.SerializeLLSDXmlString(events); responsedata["bin_response_data"] = Encoding.UTF8.GetBytes(OSDParser.SerializeLLSDXmlString(events)); //m_log.DebugFormat("[EVENTQUEUE]: sending response for {0} in region {1}: {2}", pAgentId, m_scene.RegionInfo.RegionName, responsedata["str_response_string"]); return(responsedata); }
public virtual bool Enqueue(OSD o, UUID agentID, UUID regionID) { return(Enqueue(OSDParser.SerializeLLSDXmlString(o), agentID, regionID)); }
public override void FinishedMigration(IDataConnector genericData) { if (!genericData.TableExists("estates")) { return; } DataReaderConnection dr = genericData.QueryData("WHERE `Key` = 'EstateID'", "estates", "`ID`, `Key`, `Value`"); if (dr != null) { try { while (dr.DataReader.Read()) { try { UUID ID = UUID.Parse(dr.DataReader["ID"].ToString()); string value = dr.DataReader["Value"].ToString(); QueryFilter filter = new QueryFilter(); filter.andFilters["`ID`"] = value; filter.andFilters["`Key`"] = "EstateSettings"; List <string> results = genericData.Query(new string[1] { "`Value`" }, "estates", filter, null, null, null); if ((results != null) && (results.Count >= 1)) { EstateSettings es = new EstateSettings(); es.FromOSD((OSDMap)OSDParser.DeserializeLLSDXml(results[0])); genericData.Insert("estateregions", new object[] { ID, value }); filter = new QueryFilter(); filter.andFilters["`EstateID`"] = value; List <string> exist = genericData.Query(new string[1] { "`EstateID`" }, "estatesettings", filter, null, null, null); if (exist == null || exist.Count == 0) { genericData.Insert("estatesettings", new object[] { value, es.EstateName, es.EstateOwner, es.ParentEstateID, es.ToOSD() }); } } } catch { } } } catch { } finally { dr.DataReader.Close(); genericData.CloseDatabase(dr); } } }
public static string ToXmlString(Packet packet) { return(OSDParser.SerializeLLSDXmlString(GetLLSD(packet))); }
public static byte[] ToBinary(Packet packet) { return(OSDParser.SerializeLLSDBinary(GetLLSD(packet))); }
/// <summary> /// Unpack agent circuit data map into an AgentCiruitData object /// </summary> /// <param name = "args"></param> public virtual void UnpackAgentCircuitData(OSDMap args) { if (args["agent_id"] != null) { AgentID = args["agent_id"].AsUUID(); } if (args["caps_path"] != null) { CapsPath = args["caps_path"].AsString(); } if (args["reallyischild"] != null) { reallyischild = args["reallyischild"].AsBoolean(); } if (args["child"] != null) { child = args["child"].AsBoolean(); } if (args["circuit_code"] != null) { UInt32.TryParse(args["circuit_code"].AsString(), out circuitcode); } if (args["secure_session_id"] != null) { SecureSessionID = args["secure_session_id"].AsUUID(); } if (args["session_id"] != null) { SessionID = args["session_id"].AsUUID(); } if (args["service_session_id"] != null) { ServiceSessionID = args["service_session_id"].AsString(); } if (args["client_ip"] != null) { IPAddress = args["client_ip"].AsString(); } if (args["first_name"] != null) { firstname = args["first_name"].AsString(); } if (args["last_name"] != null) { lastname = args["last_name"].AsString(); } if (args["start_pos"] != null) { Vector3.TryParse(args["start_pos"].AsString(), out startpos); } if (args["teleport_flags"] != null) { teleportFlags = args["teleport_flags"].AsUInteger(); } if (args["draw_distance"] != null) { DrawDistance = args["draw_distance"]; } // DEBUG ON //MainConsole.Instance.WarnFormat("[AGENTCIRCUITDATA] agentid={0}, child={1}, startpos={2}", AgentID, child, startpos.ToString()); // DEBUG OFF try { // Unpack various appearance elements Appearance = new AvatarAppearance(AgentID); // Eventually this code should be deprecated, use full appearance // packing in packed_appearance if (args["appearance_serial"] != null) { Appearance.Serial = args["appearance_serial"].AsInteger(); } if (args.ContainsKey("packed_appearance") && (args["packed_appearance"].Type == OSDType.Map)) { Appearance.Unpack((OSDMap)args["packed_appearance"]); // DEBUG ON //MainConsole.Instance.WarnFormat("[AGENTCIRCUITDATA] unpacked appearance"); // DEBUG OFF } // DEBUG ON else { MainConsole.Instance.Warn("[AGENTCIRCUITDATA] failed to find a valid packed_appearance, dne ? " + !args.ContainsKey("packed_appearance")); } // DEBUG OFF } catch (Exception e) { MainConsole.Instance.ErrorFormat("[AGENTCIRCUITDATA] failed to unpack appearance; {0}", e); } if (args.ContainsKey("otherInfo")) { OtherInformation = (OSDMap)OSDParser.DeserializeLLSDXml(args["otherInfo"].AsString()); } ServiceURLs = new Dictionary <string, object>(); // Try parse the new way, OSDMap if (args.ContainsKey("serviceurls") && args["serviceurls"] != null && (args["serviceurls"]).Type == OSDType.Map) { OSDMap urls = (OSDMap)(args["serviceurls"]); foreach (KeyValuePair <String, OSD> kvp in urls) { ServiceURLs[kvp.Key] = kvp.Value.AsString(); //System.Console.WriteLine("XXX " + kvp.Key + "=" + ServiceURLs[kvp.Key]); } } }
private bool AddToQueue(OSD ev, UUID avatarID, ulong regionHandle, bool runasync) { //MainConsole.Instance.DebugFormat("[EVENTQUEUE]: Enqueuing event for {0} in region {1}", avatarID, m_scene.RegionInfo.RegionName); if (ev == null) { return(false); } try { OSDMap request = new OSDMap { { "AgentID", avatarID }, { "RegionHandle", regionHandle } }; OSDArray events = new OSDArray { OSDParser.SerializeLLSDXmlString(ev) }; //Note: we HAVE to convert it to xml, otherwise things like byte[] arrays will not be passed through correctly! request.Add("Events", events); IConfigurationService configService = m_registry.RequestModuleInterface <IConfigurationService>(); List <string> serverURIs = configService.FindValueOf(avatarID.ToString(), regionHandle.ToString(), "EventQueueServiceURI"); foreach (string serverURI in serverURIs) { if (serverURI != "") { if (runasync) { /*AsynchronousRestObjectRequester.MakeRequest("POST", serverURI + "/CAPS/EQMPOSTER", * OSDParser.SerializeJsonString(request), * delegate(string resp) * { * return RequestHandler(resp, events, avatarID, regionHandle); * }); * * return true;*/ string resp = SynchronousRestFormsRequester.MakeRequest("POST", serverURI + "/CAPS/EQMPOSTER", OSDParser.SerializeJsonString(request)); return(RequestHandler(resp, events, avatarID, regionHandle)); } else { string resp = SynchronousRestFormsRequester.MakeRequest("POST", serverURI + "/CAPS/EQMPOSTER", OSDParser.SerializeJsonString(request)); return(RequestHandler(resp, events, avatarID, regionHandle)); } } } } catch (Exception e) { MainConsole.Instance.Error("[EVENTQUEUE] Caught exception: " + e); } return(false); }
/// <summary> /// Get the user's display name, currently not used? /// </summary> /// <param name = "mDhttpMethod"></param> /// <param name = "agentID"></param> /// <returns></returns> private byte[] ProcessGetDisplayName(string path, Stream request, OSHttpRequest httpRequest, OSHttpResponse httpResponse) { //I've never seen this come in, so for now... do nothing NameValueCollection query = HttpUtility.ParseQueryString(httpRequest.Url.Query); string[] ids = query.GetValues("ids"); string username = query.GetOne("username"); OSDMap map = new OSDMap(); OSDArray agents = new OSDArray(); OSDArray bad_ids = new OSDArray(); OSDArray bad_usernames = new OSDArray(); if (ids != null) { foreach (string id in ids) { UserAccount account = m_userService.GetUserAccount(UUID.Zero, UUID.Parse(id)); if (account != null) { IUserProfileInfo info = DataManager.RequestPlugin <IProfileConnector>().GetUserProfile(account.PrincipalID); if (info != null) { PackUserInfo(info, account, ref agents); } else { PackUserInfo(info, account, ref agents); } //else //Technically is right, but needs to be packed no matter what for OS based grids // bad_ids.Add (id); } } } else if (username != null) { UserAccount account = m_userService.GetUserAccount(UUID.Zero, username.Replace('.', ' ')); if (account != null) { IUserProfileInfo info = DataManager.RequestPlugin <IProfileConnector>().GetUserProfile(account.PrincipalID); if (info != null) { PackUserInfo(info, account, ref agents); } else { bad_usernames.Add(username); } } } map["agents"] = agents; map["bad_ids"] = bad_ids; map["bad_usernames"] = bad_usernames; byte[] m = OSDParser.SerializeLLSDXmlBytes(map); httpResponse.Body.Write(m, 0, m.Length); httpResponse.StatusCode = (int)HttpStatusCode.OK; httpResponse.Send(); return(null); }
private bool UpdateAgent(GridRegion destination, IAgentData cAgentData) { // Try local first if (cAgentData is AgentData) { if (m_localBackend.UpdateAgent(destination, (AgentData)cAgentData)) { return(true); } } else if (cAgentData is AgentPosition) { if (m_localBackend.UpdateAgent(destination, (AgentPosition)cAgentData)) { return(true); } } // else do the remote thing if (!m_localBackend.IsLocalRegion(destination.RegionHandle)) { // Eventually, we want to use a caps url instead of the agentID string uri = MakeUri(destination, true) + cAgentData.AgentID + "/"; if (m_blackListedRegions.ContainsKey(uri)) { //Check against time if (m_blackListedRegions[uri] > 3 && Util.EnvironmentTickCountSubtract(m_blackListedRegions[uri]) > 0) { MainConsole.Instance.Warn("[SimServiceConnector]: Blacklisted region " + destination.RegionName + " requested"); //Still blacklisted return(false); } } try { OSDMap args = cAgentData.Pack(); args["destination_x"] = OSD.FromString(destination.RegionLocX.ToString()); args["destination_y"] = OSD.FromString(destination.RegionLocY.ToString()); args["destination_name"] = OSD.FromString(destination.RegionName); args["destination_uuid"] = OSD.FromString(destination.RegionID.ToString()); string result = WebUtils.PutToService(uri, args); if (result == "") { if (m_blackListedRegions.ContainsKey(uri)) { if (m_blackListedRegions[uri] == 3) { //add it to the blacklist as the request completely failed 3 times m_blackListedRegions[uri] = Util.EnvironmentTickCount() + 60 * 1000; //60 seconds } else if (m_blackListedRegions[uri] == 0) { m_blackListedRegions[uri]++; } } else { m_blackListedRegions[uri] = 0; } return(false); } //Clear out the blacklist if it went through m_blackListedRegions.Remove(uri); OSDMap innerResult = (OSDMap)OSDParser.DeserializeJson(result); return(innerResult["Updated"].AsBoolean()); } catch (Exception e) { MainConsole.Instance.Warn("[REMOTE SIMULATION CONNECTOR]: UpdateAgent failed with exception: " + e); } return(false); } return(false); }
public void DeserializeUndef() { OSD llsdUndef = OSDParser.DeserializeLLSDBinary(binaryUndef); Assert.AreEqual(OSDType.Unknown, llsdUndef.Type); }
private UserSession ParseViewerStats(string request, UUID agentID) { UserSession uid = new UserSession(); UserSessionData usd; OSD message = OSDParser.DeserializeLLSDXml(request); OSDMap mmap; lock (m_sessions) { if (agentID != UUID.Zero) { if (!m_sessions.ContainsKey(agentID)) { m_log.WarnFormat("[WEB STATS MODULE]: no session for stat disclosure for agent {0}", agentID); return(new UserSession()); } uid = m_sessions[agentID]; // m_log.DebugFormat("[WEB STATS MODULE]: Got session {0} for {1}", uid.session_id, agentID); } else { // parse through the beginning to locate the session if (message.Type != OSDType.Map) { return(new UserSession()); } mmap = (OSDMap)message; { UUID sessionID = mmap["session_id"].AsUUID(); if (sessionID == UUID.Zero) { return(new UserSession()); } // search through each session looking for the owner foreach (UUID usersessionid in m_sessions.Keys) { // got it! if (m_sessions[usersessionid].session_id == sessionID) { agentID = usersessionid; uid = m_sessions[usersessionid]; break; } } // can't find a session if (agentID == UUID.Zero) { return(new UserSession()); } } } } usd = uid.session_data; if (message.Type != OSDType.Map) { return(new UserSession()); } mmap = (OSDMap)message; { if (mmap["agent"].Type != OSDType.Map) { return(new UserSession()); } OSDMap agent_map = (OSDMap)mmap["agent"]; usd.agent_id = agentID; usd.name_f = uid.name_f; usd.name_l = uid.name_l; usd.region_id = uid.region_id; usd.a_language = agent_map["language"].AsString(); usd.mem_use = (float)agent_map["mem_use"].AsReal(); usd.meters_traveled = (float)agent_map["meters_traveled"].AsReal(); usd.regions_visited = agent_map["regions_visited"].AsInteger(); usd.run_time = (float)agent_map["run_time"].AsReal(); usd.start_time = (float)agent_map["start_time"].AsReal(); usd.client_version = agent_map["version"].AsString(); UserSessionUtil.UpdateMultiItems(ref usd, agent_map["agents_in_view"].AsInteger(), (float)agent_map["ping"].AsReal(), (float)agent_map["sim_fps"].AsReal(), (float)agent_map["fps"].AsReal()); if (mmap["downloads"].Type != OSDType.Map) { return(new UserSession()); } OSDMap downloads_map = (OSDMap)mmap["downloads"]; usd.d_object_kb = (float)downloads_map["object_kbytes"].AsReal(); usd.d_texture_kb = (float)downloads_map["texture_kbytes"].AsReal(); usd.d_world_kb = (float)downloads_map["workd_kbytes"].AsReal(); // m_log.DebugFormat("[WEB STATS MODULE]: mmap[\"session_id\"] = [{0}]", mmap["session_id"].AsUUID()); usd.session_id = mmap["session_id"].AsUUID(); if (mmap["system"].Type != OSDType.Map) { return(new UserSession()); } OSDMap system_map = (OSDMap)mmap["system"]; usd.s_cpu = system_map["cpu"].AsString(); usd.s_gpu = system_map["gpu"].AsString(); usd.s_os = system_map["os"].AsString(); usd.s_ram = system_map["ram"].AsInteger(); if (mmap["stats"].Type != OSDType.Map) { return(new UserSession()); } OSDMap stats_map = (OSDMap)mmap["stats"]; { if (stats_map["failures"].Type != OSDType.Map) { return(new UserSession()); } OSDMap stats_failures = (OSDMap)stats_map["failures"]; usd.f_dropped = stats_failures["dropped"].AsInteger(); usd.f_failed_resends = stats_failures["failed_resends"].AsInteger(); usd.f_invalid = stats_failures["invalid"].AsInteger(); usd.f_resent = stats_failures["resent"].AsInteger(); usd.f_send_packet = stats_failures["send_packet"].AsInteger(); if (stats_map["net"].Type != OSDType.Map) { return(new UserSession()); } OSDMap stats_net = (OSDMap)stats_map["net"]; { if (stats_net["in"].Type != OSDType.Map) { return(new UserSession()); } OSDMap net_in = (OSDMap)stats_net["in"]; usd.n_in_kb = (float)net_in["kbytes"].AsReal(); usd.n_in_pk = net_in["packets"].AsInteger(); if (stats_net["out"].Type != OSDType.Map) { return(new UserSession()); } OSDMap net_out = (OSDMap)stats_net["out"]; usd.n_out_kb = (float)net_out["kbytes"].AsReal(); usd.n_out_pk = net_out["packets"].AsInteger(); } } } uid.session_data = usd; m_sessions[agentID] = uid; // m_log.DebugFormat( // "[WEB STATS MODULE]: Parse data for {0} {1}, session {2}", uid.name_f, uid.name_l, uid.session_id); return(uid); }
protected virtual void DoAgentPost(Hashtable request, Hashtable responsedata, UUID id) { if (m_safemode) { // Authentication string authority = string.Empty; string authToken = string.Empty; if (!GetAuthentication(request, out authority, out authToken)) { m_log.InfoFormat("[REST COMMS]: Authentication failed for agent message {0}", request["uri"]); responsedata["int_response_code"] = 403; responsedata["str_response_string"] = "Forbidden"; return; } if (!VerifyKey(id, authority, authToken)) { m_log.InfoFormat("[REST COMMS]: Authentication failed for agent message {0}", request["uri"]); responsedata["int_response_code"] = 403; responsedata["str_response_string"] = "Forbidden"; return; } m_log.DebugFormat("[REST COMMS]: Authentication succeeded for {0}", id); } OSDMap args = RegionClient.GetOSDMap((string)request["body"]); if (args == null) { responsedata["int_response_code"] = 400; responsedata["str_response_string"] = "false"; return; } // retrieve the regionhandle ulong regionhandle = 0; if (args["destination_handle"] != null) { UInt64.TryParse(args["destination_handle"].AsString(), out regionhandle); } AgentCircuitData aCircuit = new AgentCircuitData(); try { aCircuit.UnpackAgentCircuitData(args); } catch (Exception ex) { m_log.InfoFormat("[REST COMMS]: exception on unpacking ChildCreate message {0}", ex.Message); return; } OSDMap resp = new OSDMap(2); string reason = String.Empty; // This is the meaning of POST agent m_regionClient.AdjustUserInformation(aCircuit); bool result = m_localBackend.SendCreateChildAgent(regionhandle, aCircuit, out reason); resp["reason"] = OSD.FromString(reason); resp["success"] = OSD.FromBoolean(result); // TODO: add reason if not String.Empty? responsedata["int_response_code"] = 200; responsedata["str_response_string"] = OSDParser.SerializeJsonString(resp); }
public void LoadModuleFromArchive(byte [] data, string filePath, TarArchiveReader.TarEntryType type, IScene scene) { if (filePath.StartsWith("parcels/", StringComparison.Ordinal)) { if (!m_merge) { //Only use if we are not merging LandData parcel = new LandData(); OSD parcelData = OSDParser.DeserializeLLSDBinary(data); parcel.FromOSD((OSDMap)parcelData); m_parcels.Add(parcel); } } #region New Style Terrain Loading else if (filePath.StartsWith("newstyleterrain/", StringComparison.Ordinal)) { ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule> (); terrainModule.TerrainMap = ReadTerrain(data, scene); } else if (filePath.StartsWith("newstylerevertterrain/", StringComparison.Ordinal)) { ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule> (); terrainModule.TerrainRevertMap = ReadTerrain(data, scene); } else if (filePath.StartsWith("newstylewater/", StringComparison.Ordinal)) { ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule> (); terrainModule.TerrainWaterMap = ReadTerrain(data, scene); } else if (filePath.StartsWith("newstylerevertwater/", StringComparison.Ordinal)) { ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule> (); terrainModule.TerrainWaterRevertMap = ReadTerrain(data, scene); } #endregion #region Old Style Terrain Loading else if (filePath.StartsWith("terrain/", StringComparison.Ordinal)) { ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule> (); MemoryStream ms = new MemoryStream(data); terrainModule.LoadFromStream(filePath, ms, 0, 0); ms.Close(); } else if (filePath.StartsWith("revertterrain/", StringComparison.Ordinal)) { ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule> (); MemoryStream ms = new MemoryStream(data); terrainModule.LoadRevertMapFromStream(filePath, ms, 0, 0); ms.Close(); } else if (filePath.StartsWith("water/", StringComparison.Ordinal)) { ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule> (); MemoryStream ms = new MemoryStream(data); terrainModule.LoadWaterFromStream(filePath, ms, 0, 0); ms.Close(); } else if (filePath.StartsWith("revertwater/", StringComparison.Ordinal)) { ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule> (); MemoryStream ms = new MemoryStream(data); terrainModule.LoadWaterRevertMapFromStream(filePath, ms, 0, 0); ms.Close(); } #endregion else if (filePath.StartsWith("entities/", StringComparison.Ordinal)) { MemoryStream ms = new MemoryStream(data); ISceneEntity sceneObject = SceneEntitySerializer.SceneObjectSerializer.FromXml2Format(ref ms, scene); ms.Close(); m_groups.Add(sceneObject); } else if (filePath.StartsWith("assets/", StringComparison.Ordinal)) { if (m_loadAssets) { AssetBase asset = new AssetBase(); asset.Unpack(OSDParser.DeserializeJson(Encoding.UTF8.GetString(data))); scene.AssetService.Store(asset); } } }
protected virtual void DoQueryAccess(Hashtable request, Hashtable responsedata, UUID agentID, UUID regionID) { EntityTransferContext ctx = new EntityTransferContext(); if (m_SimulationService == null) { m_log.Debug("[AGENT HANDLER]: Agent QUERY called. Harmless but useless."); responsedata["content_type"] = "application/json"; responsedata["int_response_code"] = HttpStatusCode.NotImplemented; responsedata["str_response_string"] = string.Empty; return; } // m_log.DebugFormat("[AGENT HANDLER]: Received QUERYACCESS with {0}", (string)request["body"]); OSDMap args = Utils.GetOSDMap((string)request["body"]); bool viaTeleport = true; if (args.ContainsKey("viaTeleport")) { viaTeleport = args["viaTeleport"].AsBoolean(); } Vector3 position = Vector3.Zero; if (args.ContainsKey("position")) { position = Vector3.Parse(args["position"].AsString()); } string agentHomeURI = null; if (args.ContainsKey("agent_home_uri")) { agentHomeURI = args["agent_home_uri"].AsString(); } // Decode the legacy (string) version and extract the number float theirVersion = 0f; if (args.ContainsKey("my_version")) { string theirVersionStr = args["my_version"].AsString(); string[] parts = theirVersionStr.Split(new char[] { '/' }); if (parts.Length > 1) { theirVersion = float.Parse(parts[1]); } } if (args.ContainsKey("context")) { ctx.Unpack((OSDMap)args["context"]); } // Decode the new versioning data float minVersionRequired = 0f; float maxVersionRequired = 0f; float minVersionProvided = 0f; float maxVersionProvided = 0f; if (args.ContainsKey("simulation_service_supported_min")) { minVersionProvided = (float)args["simulation_service_supported_min"].AsReal(); } if (args.ContainsKey("simulation_service_supported_max")) { maxVersionProvided = (float)args["simulation_service_supported_max"].AsReal(); } if (args.ContainsKey("simulation_service_accepted_min")) { minVersionRequired = (float)args["simulation_service_accepted_min"].AsReal(); } if (args.ContainsKey("simulation_service_accepted_max")) { maxVersionRequired = (float)args["simulation_service_accepted_max"].AsReal(); } responsedata["int_response_code"] = HttpStatusCode.OK; OSDMap resp = new OSDMap(3); float version = 0f; float outboundVersion = 0f; float inboundVersion = 0f; if (minVersionProvided == 0f) // string version or older { // If there is no version in the packet at all we're looking at 0.6 or // even more ancient. Refuse it. if (theirVersion == 0f) { resp["success"] = OSD.FromBoolean(false); resp["reason"] = OSD.FromString("Your region is running a old version of opensim no longer supported. Consider updating it"); responsedata["str_response_string"] = OSDParser.SerializeJsonString(resp, true); return; } version = theirVersion; if (version < VersionInfo.SimulationServiceVersionAcceptedMin || version > VersionInfo.SimulationServiceVersionAcceptedMax) { resp["success"] = OSD.FromBoolean(false); resp["reason"] = OSD.FromString(String.Format("Your region protocol version is {0} and we accept only {1} - {2}. No version overlap.", theirVersion, VersionInfo.SimulationServiceVersionAcceptedMin, VersionInfo.SimulationServiceVersionAcceptedMax)); responsedata["str_response_string"] = OSDParser.SerializeJsonString(resp, true); return; } } else { // Test for no overlap if (minVersionProvided > VersionInfo.SimulationServiceVersionAcceptedMax || maxVersionProvided < VersionInfo.SimulationServiceVersionAcceptedMin) { resp["success"] = OSD.FromBoolean(false); resp["reason"] = OSD.FromString(String.Format("Your region provide protocol versions {0} - {1} and we accept only {2} - {3}. No version overlap.", minVersionProvided, maxVersionProvided, VersionInfo.SimulationServiceVersionAcceptedMin, VersionInfo.SimulationServiceVersionAcceptedMax)); responsedata["str_response_string"] = OSDParser.SerializeJsonString(resp, true); return; } if (minVersionRequired > VersionInfo.SimulationServiceVersionSupportedMax || maxVersionRequired < VersionInfo.SimulationServiceVersionSupportedMin) { resp["success"] = OSD.FromBoolean(false); resp["reason"] = OSD.FromString(String.Format("You require region protocol versions {0} - {1} and we provide only {2} - {3}. No version overlap.", minVersionRequired, maxVersionRequired, VersionInfo.SimulationServiceVersionSupportedMin, VersionInfo.SimulationServiceVersionSupportedMax)); responsedata["str_response_string"] = OSDParser.SerializeJsonString(resp, true); return; } // Determine versions to use // This is intentionally inverted. Inbound and Outbound refer to the direction of the transfer. // Therefore outbound means from the sender to the receier and inbound means from the receiver to the sender. // So outbound is what we will accept and inbound is what we will send. Confused yet? outboundVersion = Math.Min(maxVersionProvided, VersionInfo.SimulationServiceVersionAcceptedMax); inboundVersion = Math.Min(maxVersionRequired, VersionInfo.SimulationServiceVersionSupportedMax); } List <UUID> features = new List <UUID>(); if (args.ContainsKey("features")) { OSDArray array = (OSDArray)args["features"]; foreach (OSD o in array) { features.Add(new UUID(o.AsString())); } } GridRegion destination = new GridRegion(); destination.RegionID = regionID; string reason; // We're sending the version numbers down to the local connector to do the varregion check. ctx.InboundVersion = inboundVersion; ctx.OutboundVersion = outboundVersion; if (minVersionProvided == 0f) { ctx.InboundVersion = version; ctx.OutboundVersion = version; } bool result = m_SimulationService.QueryAccess(destination, agentID, agentHomeURI, viaTeleport, position, features, ctx, out reason); resp["success"] = OSD.FromBoolean(result); resp["reason"] = OSD.FromString(reason); string legacyVersion = String.Format("SIMULATION/{0}", version); resp["version"] = OSD.FromString(legacyVersion); resp["negotiated_inbound_version"] = OSD.FromReal(inboundVersion); resp["negotiated_outbound_version"] = OSD.FromReal(outboundVersion); OSDArray featuresWanted = new OSDArray(); foreach (UUID feature in features) { featuresWanted.Add(OSD.FromString(feature.ToString())); } resp["features"] = featuresWanted; // We must preserve defaults here, otherwise a false "success" will not be put into the JSON map! responsedata["str_response_string"] = OSDParser.SerializeJsonString(resp, true); // Console.WriteLine("str_response_string [{0}]", responsedata["str_response_string"]); }
void RequestCompletedHandler(HttpWebRequest request, HttpWebResponse response, byte[] responseData, Exception error) { // We don't care about this request now that it has completed _Request = null; OSDArray events = null; int ack = 0; if (responseData != null) { _errorCount = 0; // Got a response if (OSDParser.DeserializeLLSDXml(responseData) is OSDMap result) { events = result["events"] as OSDArray; ack = result["id"].AsInteger(); } else { Logger.Log("Got an unparseable response from the event queue: \"" + System.Text.Encoding.UTF8.GetString(responseData) + "\"", Helpers.LogLevel.Warning); } } else if (error != null) { #region Error handling HttpStatusCode code = HttpStatusCode.OK; if (error is WebException webException) { // Filter out some of the status requests to skip handling switch (webException.Status) { case WebExceptionStatus.RequestCanceled: case WebExceptionStatus.KeepAliveFailure: goto HandlingDone; } if (webException.Response != null) { code = ((HttpWebResponse)webException.Response).StatusCode; } } switch (code) { case HttpStatusCode.NotFound: case HttpStatusCode.Gone: Logger.Log($"Closing event queue at {_Address} due to missing caps URI", Helpers.LogLevel.Info); _Running = false; _Dead = true; break; case (HttpStatusCode)499: // weird error returned occasionally, ignore for now case HttpStatusCode.BadGateway: // This is not good (server) protocol design, but it's normal. // The EventQueue server is a proxy that connects to a Squid // cache which will time out periodically. The EventQueue server // interprets this as a generic error and returns a 502 to us // that we ignore break; default: ++_errorCount; // Try to log a meaningful error message if (code != HttpStatusCode.OK) { Logger.Log($"Unrecognized caps connection problem from {_Address}: {code}", Helpers.LogLevel.Warning); } else if (error.InnerException != null) { Logger.Log( $"Unrecognized internal caps exception from {_Address}: {error.InnerException.Message}", Helpers.LogLevel.Warning); } else { Logger.Log($"Unrecognized caps exception from {_Address}: {error.Message}", Helpers.LogLevel.Warning); } break; } #endregion Error handling } else { ++_errorCount; Logger.Log("No response from the event queue but no reported error either", Helpers.LogLevel.Warning); } HandlingDone: #region Resume the connection if (_Running) { OSDMap osdRequest = new OSDMap(); if (ack != 0) { osdRequest["ack"] = OSD.FromInteger(ack); } else { osdRequest["ack"] = new OSD(); } osdRequest["done"] = OSD.FromBoolean(_Dead); byte[] postData = OSDParser.SerializeLLSDXmlBytes(osdRequest); if (_errorCount > 0) // Exponentially back off, so we don't hammer the CPU { Thread.Sleep(Math.Min(REQUEST_BACKOFF_SECONDS + _errorCount * REQUEST_BACKOFF_SECONDS_INC, REQUEST_BACKOFF_SECONDS_MAX)); } // Resume the connection. The event handler for the connection opening // just sets class _Request variable to the current HttpWebRequest CapsBase.UploadDataAsync(_Address, null, REQUEST_CONTENT_TYPE, postData, REQUEST_TIMEOUT, delegate(HttpWebRequest newRequest) { _Request = newRequest; }, null, RequestCompletedHandler); // If the event queue is dead at this point, turn it off since // that was the last thing we want to do if (_Dead) { _Running = false; Logger.DebugLog("Sent event queue shutdown message"); } } #endregion Resume the connection #region Handle incoming events if (OnEvent == null || events == null || events.Count <= 0) { return; } // Fire callbacks for each event received foreach (var osd in events) { var evt = (OSDMap)osd; string msg = evt["message"].AsString(); OSDMap body = (OSDMap)evt["body"]; try { OnEvent(msg, body); } catch (Exception ex) { Logger.Log(ex.Message, Helpers.LogLevel.Error, ex); } } #endregion Handle incoming events }
protected void DoAgentPost(Hashtable request, Hashtable responsedata, UUID id) { EntityTransferContext ctx = new EntityTransferContext(); OSDMap args = Utils.GetOSDMap((string)request["body"]); if (args == null) { responsedata["int_response_code"] = HttpStatusCode.BadRequest; responsedata["str_response_string"] = "Bad request"; return; } if (args.ContainsKey("context")) { ctx.Unpack((OSDMap)args["context"]); } AgentDestinationData data = CreateAgentDestinationData(); UnpackData(args, data, request); GridRegion destination = new GridRegion(); destination.RegionID = data.uuid; destination.RegionLocX = data.x; destination.RegionLocY = data.y; destination.RegionName = data.name; GridRegion gatekeeper = ExtractGatekeeper(data); AgentCircuitData aCircuit = new AgentCircuitData(); try { aCircuit.UnpackAgentCircuitData(args); } catch (Exception ex) { m_log.InfoFormat("[AGENT HANDLER]: exception on unpacking ChildCreate message {0}", ex.Message); responsedata["int_response_code"] = HttpStatusCode.BadRequest; responsedata["str_response_string"] = "Bad request"; return; } GridRegion source = null; if (args.ContainsKey("source_uuid")) { source = new GridRegion(); source.RegionLocX = Int32.Parse(args["source_x"].AsString()); source.RegionLocY = Int32.Parse(args["source_y"].AsString()); source.RegionName = args["source_name"].AsString(); source.RegionID = UUID.Parse(args["source_uuid"].AsString()); if (args.ContainsKey("source_server_uri")) { source.RawServerURI = args["source_server_uri"].AsString(); } else { source.RawServerURI = null; } } OSDMap resp = new OSDMap(2); string reason = String.Empty; // This is the meaning of POST agent //m_regionClient.AdjustUserInformation(aCircuit); //bool result = m_SimulationService.CreateAgent(destination, aCircuit, teleportFlags, out reason); bool result = CreateAgent(source, gatekeeper, destination, aCircuit, data.flags, data.fromLogin, ctx, out reason); resp["reason"] = OSD.FromString(reason); resp["success"] = OSD.FromBoolean(result); // Let's also send out the IP address of the caller back to the caller (HG 1.5) resp["your_ip"] = OSD.FromString(GetCallerIP(request)); // TODO: add reason if not String.Empty? responsedata["int_response_code"] = HttpStatusCode.OK; responsedata["str_response_string"] = OSDParser.SerializeJsonString(resp); }
public void ExportToFile(string filename, uint localID) { Primitive exportPrim; uint localid; ExportDirectory = Path.Combine(Path.GetDirectoryName(filename), Path.GetFileNameWithoutExtension(filename)); Directory.CreateDirectory(ExportDirectory); exportPrim = Client.Network.CurrentSim.ObjectsPrimitives.Find( delegate(Primitive prim) { return(prim.LocalID == localID); } ); if (exportPrim != null) { if (exportPrim.ParentID != 0) { localid = exportPrim.ParentID; } else { localid = exportPrim.LocalID; } uLocalID = localid; // Check for export permission first Client.Objects.RequestObjectPropertiesFamily(Client.Network.CurrentSim, exportPrim.ID); GotPermissionsEvent.WaitOne(1000 * 10, false); if (!GotPermissions) { throw new Exception("Couldn't fetch permissions for the requested object, try again"); } else { GotPermissions = false; // Must be Owner and Creator of the item to export, per Linden Lab's TOS if (!(Properties.CreatorID == Client.Self.AgentID && Properties.OwnerID == Client.Self.AgentID)) { string msg = "That object is owned by {0}, Created by {1} we don't have permission to export it. Your UUID: {2}"; throw new Exception(String.Format(msg, Properties.OwnerID, Properties.CreatorID, Client.Self.AgentID)); } List <Primitive> prims = Client.Network.CurrentSim.ObjectsPrimitives.FindAll( delegate(Primitive prim) { return(prim.LocalID == localid || prim.ParentID == localid); } ); bool complete = RequestObjectProperties(prims, 250); string output = OSDParser.SerializeLLSDXmlString(Helpers.PrimListToOSD(prims)); File.WriteAllText(filename, output); List <ImageRequest> textureRequests = new List <ImageRequest>(); lock (Textures) { for (int i = 0; i < prims.Count; i++) { Primitive prim = prims[i]; UUID texture; if (prim.Textures.DefaultTexture.TextureID != Primitive.TextureEntry.WHITE_TEXTURE && !Textures.Contains(prim.Textures.DefaultTexture.TextureID)) { texture = new UUID(prim.Textures.DefaultTexture.TextureID); Textures.Add(texture); } for (int j = 0; j < prim.Textures.FaceTextures.Length; j++) { if (prim.Textures.FaceTextures[j] != null && prim.Textures.FaceTextures[j].TextureID != Primitive.TextureEntry.WHITE_TEXTURE && !Textures.Contains(prim.Textures.FaceTextures[j].TextureID)) { texture = new UUID(prim.Textures.FaceTextures[j].TextureID); Textures.Add(texture); } } if (prim.Sculpt != null && prim.Sculpt.SculptTexture != UUID.Zero && !Textures.Contains(prim.Sculpt.SculptTexture)) { texture = new UUID(prim.Sculpt.SculptTexture); Textures.Add(texture); } } FindImagesInInventory(); for (int i = 0; i < Textures.Count; i++) { textureRequests.Add(new ImageRequest(Textures[i], ImageType.Normal, 1013000.0f, 0)); } foreach (ImageRequest request in textureRequests) { Client.Assets.RequestImage(request.ImageID, request.Type, Assets_OnImageReceived); } } } } else { throw new Exception("Couldn't find id " + localID.ToString() + " in the " + Client.Network.CurrentSim.ObjectsPrimitives.Count + " objects currently indexed in the current simulator."); } }
/// <summary> /// Save a backup of the sim /// </summary> /// <param name = "appendedFilePath">The file path where the backup will be saved</param> protected virtual void SaveBackup(string appendedFilePath, bool saveAssets) { if (appendedFilePath == "/") { appendedFilePath = ""; } if (m_scene.RegionInfo.HasBeenDeleted) { return; } IBackupModule backupModule = m_scene.RequestModuleInterface <IBackupModule>(); if (backupModule != null && backupModule.LoadingPrims) //Something is changing lots of prims { MainConsole.Instance.Info("[Backup]: Not saving backup because the backup module is loading prims"); return; } //Save any script state saves that might be around IScriptModule[] engines = m_scene.RequestModuleInterfaces <IScriptModule>(); try { if (engines != null) { #if (!ISWIN) foreach (IScriptModule engine in engines) { if (engine != null) { engine.SaveStateSaves(); } } #else foreach (IScriptModule engine in engines.Where(engine => engine != null)) { engine.SaveStateSaves(); } #endif } } catch (Exception ex) { MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex); } MainConsole.Instance.Info("[FileBasedSimulationData]: Saving backup for region " + m_scene.RegionInfo.RegionName); string fileName = appendedFilePath + m_scene.RegionInfo.RegionName + m_saveAppendedFileName + ".abackup"; if (File.Exists(fileName)) { //Do new style saving here! GZipStream m_saveStream = new GZipStream(new FileStream(fileName + ".tmp", FileMode.Create), CompressionMode.Compress); TarArchiveWriter writer = new TarArchiveWriter(m_saveStream); GZipStream m_loadStream = new GZipStream(new FileStream(fileName, FileMode.Open), CompressionMode.Decompress); TarArchiveReader reader = new TarArchiveReader(m_loadStream); writer.WriteDir("parcels"); IParcelManagementModule module = m_scene.RequestModuleInterface <IParcelManagementModule>(); if (module != null) { List <ILandObject> landObject = module.AllParcels(); foreach (ILandObject parcel in landObject) { OSDMap parcelMap = parcel.LandData.ToOSD(); var binary = OSDParser.SerializeLLSDBinary(parcelMap); writer.WriteFile("parcels/" + parcel.LandData.GlobalID.ToString(), binary); binary = null; parcelMap = null; } } writer.WriteDir("newstyleterrain"); writer.WriteDir("newstylerevertterrain"); writer.WriteDir("newstylewater"); writer.WriteDir("newstylerevertwater"); ITerrainModule tModule = m_scene.RequestModuleInterface <ITerrainModule>(); if (tModule != null) { try { byte[] sdata = WriteTerrainToStream(tModule.TerrainMap); writer.WriteFile("newstyleterrain/" + m_scene.RegionInfo.RegionID.ToString() + ".terrain", sdata); sdata = null; sdata = WriteTerrainToStream(tModule.TerrainRevertMap); writer.WriteFile( "newstylerevertterrain/" + m_scene.RegionInfo.RegionID.ToString() + ".terrain", sdata); sdata = null; if (tModule.TerrainWaterMap != null) { sdata = WriteTerrainToStream(tModule.TerrainWaterMap); writer.WriteFile("newstylewater/" + m_scene.RegionInfo.RegionID.ToString() + ".terrain", sdata); sdata = null; sdata = WriteTerrainToStream(tModule.TerrainWaterRevertMap); writer.WriteFile( "newstylerevertwater/" + m_scene.RegionInfo.RegionID.ToString() + ".terrain", sdata); sdata = null; } } catch (Exception ex) { MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex); } } IDictionary <UUID, AssetType> assets = new Dictionary <UUID, AssetType>(); UuidGatherer assetGatherer = new UuidGatherer(m_scene.AssetService); ISceneEntity[] saveentities = m_scene.Entities.GetEntities(); List <UUID> entitiesToSave = new List <UUID>(); foreach (ISceneEntity entity in saveentities) { try { if (entity.IsAttachment || ((entity.RootChild.Flags & PrimFlags.Temporary) == PrimFlags.Temporary) || ((entity.RootChild.Flags & PrimFlags.TemporaryOnRez) == PrimFlags.TemporaryOnRez)) { continue; } if (entity.HasGroupChanged) { entity.HasGroupChanged = false; //Write all entities byte[] xml = ((ISceneObject)entity).ToBinaryXml2(); writer.WriteFile("entities/" + entity.UUID.ToString(), xml); xml = null; } else { entitiesToSave.Add(entity.UUID); } if (saveAssets) { assetGatherer.GatherAssetUuids(entity, assets, m_scene); } } catch (Exception ex) { MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex); entitiesToSave.Add(entity.UUID); } } byte[] data; string filePath; TarArchiveReader.TarEntryType entryType; //Load the archive data that we need try { while ((data = reader.ReadEntry(out filePath, out entryType)) != null) { if (TarArchiveReader.TarEntryType.TYPE_DIRECTORY == entryType) { continue; } if (filePath.StartsWith("entities/")) { UUID entityID = UUID.Parse(filePath.Remove(0, 9)); if (entitiesToSave.Contains(entityID)) { writer.WriteFile(filePath, data); entitiesToSave.Remove(entityID); } } data = null; } } catch (Exception ex) { MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex); } if (entitiesToSave.Count > 0) { MainConsole.Instance.Fatal(entitiesToSave.Count + " PRIMS WERE NOT GOING TO BE SAVED! FORCE SAVING NOW! "); foreach (ISceneEntity entity in saveentities) { if (entitiesToSave.Contains(entity.UUID)) { if (entity.IsAttachment || ((entity.RootChild.Flags & PrimFlags.Temporary) == PrimFlags.Temporary) || ((entity.RootChild.Flags & PrimFlags.TemporaryOnRez) == PrimFlags.TemporaryOnRez)) { continue; } //Write all entities byte[] xml = ((ISceneObject)entity).ToBinaryXml2(); writer.WriteFile("entities/" + entity.UUID.ToString(), xml); xml = null; } } } if (saveAssets) { foreach (UUID assetID in new List <UUID>(assets.Keys)) { try { WriteAsset(assetID.ToString(), m_scene.AssetService.Get(assetID.ToString()), writer); } catch (Exception ex) { MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex); } } } reader.Close(); writer.Close(); m_loadStream.Close(); m_saveStream.Close(); GC.Collect(); if (m_keepOldSave && !m_oldSaveHasBeenSaved) { //Havn't moved it yet, so make sure the directory exists, then move it m_oldSaveHasBeenSaved = true; if (!Directory.Exists(m_oldSaveDirectory)) { Directory.CreateDirectory(m_oldSaveDirectory); } File.Copy(fileName + ".tmp", Path.Combine(m_oldSaveDirectory, m_scene.RegionInfo.RegionName + SerializeDateTime() + m_saveAppendedFileName + ".abackup")); } //Just remove the file File.Delete(fileName); } else { //Add the .temp since we might need to make a backup and so that if something goes wrong, we don't corrupt the main backup GZipStream m_saveStream = new GZipStream(new FileStream(fileName + ".tmp", FileMode.Create), CompressionMode.Compress); TarArchiveWriter writer = new TarArchiveWriter(m_saveStream); IAuroraBackupArchiver archiver = m_scene.RequestModuleInterface <IAuroraBackupArchiver>(); //Turn off prompting so that we don't ask the user questions every time we need to save the backup archiver.AllowPrompting = false; archiver.SaveRegionBackup(writer, m_scene); archiver.AllowPrompting = true; m_saveStream.Close(); writer.Close(); GC.Collect(); } File.Move(fileName + ".tmp", fileName); ISceneEntity[] entities = m_scene.Entities.GetEntities(); try { #if (!ISWIN) foreach (ISceneEntity entity in entities) { if (entity.HasGroupChanged) { entity.HasGroupChanged = false; } } #else foreach (ISceneEntity entity in entities.Where(entity => entity.HasGroupChanged)) { entity.HasGroupChanged = false; } #endif } catch (Exception ex) { MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex); } //Now make it the full file again MapTileNeedsGenerated = true; MainConsole.Instance.Info("[FileBasedSimulationData]: Saved Backup for region " + m_scene.RegionInfo.RegionName); }
public void TestRegionPing() { RegionInfo info = new RegionInfo { ExternalHostName = "localhost", InternalEndPoint = new System.Net.IPEndPoint(new System.Net.IPAddress(2130706433), 9001), HttpPort = 9000, OutsideIP = "127.0.0.1", RegionID = UUID.Random(), RegionLocX = 1100, RegionLocY = 1000, }; WebRequest req = HttpWebRequest.Create("http://127.0.0.1:9000/region2/regionup"); req.Headers["authorization"] = Util.GenerateHttpAuthorization("key"); req.Timeout = 10000; req.Method = "POST"; byte[] serRegInfo = OSDParser.SerializeLLSDBinary(info.PackRegionInfoData()); var rs = req.GetRequestStream(); rs.Write(serRegInfo, 0, serRegInfo.Length); rs.Flush(); var response = req.GetResponse(); StreamReader sr = new StreamReader(response.GetResponseStream()); response.Dispose(); var neighbors = srm.GetNeighborsSnapshot(); var firstPing = neighbors[0].LastPingReceivedOn; Thread.Sleep(1000); req = HttpWebRequest.Create("http://127.0.0.1:9000/region2/heartbeat"); req.Headers["authorization"] = Util.GenerateHttpAuthorization("key"); req.Timeout = 10000; req.Method = "POST"; serRegInfo = OSDParser.SerializeLLSDBinary(info.PackRegionInfoData()); rs = req.GetRequestStream(); rs.Write(serRegInfo, 0, serRegInfo.Length); rs.Flush(); response = req.GetResponse(); Assert.AreEqual(2, response.ContentLength); sr = new StreamReader(response.GetResponseStream()); Assert.AreEqual("OK", sr.ReadToEnd()); neighbors = srm.GetNeighborsSnapshot(); Assert.AreEqual(1, neighbors.Count); Assert.Greater(neighbors[0].LastPingReceivedOn, firstPing); response.Dispose(); Assert.AreEqual(1, stateChangeCounts[NeighborStateChangeType.NeighborPing]); stateChangeCounts.Clear(); }
protected virtual void ReadBackup(IScene scene) { MainConsole.Instance.Debug("[FileBasedSimulationData]: Reading file for " + scene.RegionInfo.RegionName); List <uint> foundLocalIDs = new List <uint>(); var stream = ArchiveHelpers.GetStream((m_loadDirectory == "" || m_loadDirectory == "/") ? m_fileName : Path.Combine(m_loadDirectory, m_fileName)); if (stream == null) { return; } GZipStream m_loadStream = new GZipStream(stream, CompressionMode.Decompress); TarArchiveReader reader = new TarArchiveReader(m_loadStream); byte[] data; string filePath; TarArchiveReader.TarEntryType entryType; System.Collections.Concurrent.ConcurrentQueue <byte[]> groups = new System.Collections.Concurrent.ConcurrentQueue <byte[]>(); //Load the archive data that we need while ((data = reader.ReadEntry(out filePath, out entryType)) != null) { if (TarArchiveReader.TarEntryType.TYPE_DIRECTORY == entryType) { continue; } if (filePath.StartsWith("parcels/")) { //Only use if we are not merging LandData parcel = new LandData(); OSD parcelData = OSDParser.DeserializeLLSDBinary(data); parcel.FromOSD((OSDMap)parcelData); m_parcels.Add(parcel); } else if (filePath.StartsWith("terrain/")) { m_oldstyleterrain = data; } else if (filePath.StartsWith("revertterrain/")) { m_oldstylerevertTerrain = data; } else if (filePath.StartsWith("newstyleterrain/")) { m_terrain = data; } else if (filePath.StartsWith("newstylerevertterrain/")) { m_revertTerrain = data; } else if (filePath.StartsWith("newstylewater/")) { m_water = data; } else if (filePath.StartsWith("newstylerevertwater/")) { m_revertWater = data; } else if (filePath.StartsWith("entities/")) { groups.Enqueue(data); } data = null; } m_loadStream.Close(); m_loadStream = null; int threadCount = groups.Count > 16 ? 16 : groups.Count; System.Threading.Thread[] threads = new System.Threading.Thread[threadCount]; for (int i = 0; i < threadCount; i++) { threads[i] = new System.Threading.Thread(() => { byte[] groupData; while (groups.TryDequeue(out groupData)) { MemoryStream ms = new MemoryStream(groupData); SceneObjectGroup sceneObject = SceneObjectSerializer.FromXml2Format(ref ms, scene); ms.Close(); ms = null; data = null; if (sceneObject != null) { foreach (ISceneChildEntity part in sceneObject.ChildrenEntities()) { lock (foundLocalIDs) { if (!foundLocalIDs.Contains(part.LocalId)) { foundLocalIDs.Add(part.LocalId); } else { part.LocalId = 0; //Reset it! Only use it once! } } } m_groups.Add(sceneObject); } } }); threads[i].Start(); } for (int i = 0; i < threadCount; i++) { threads[i].Join(); } foundLocalIDs.Clear(); GC.Collect(); }
///<summary> /// ///</summary> private void UploadMapTile(IScene scene) { m_log.DebugFormat("[SIMIAN MAPTILE]: upload maptile for {0}", scene.RegionInfo.RegionName); // Create a PNG map tile and upload it to the AddMapTile API byte[] pngData = Utils.EmptyBytes; IMapImageGenerator tileGenerator = scene.RequestModuleInterface <IMapImageGenerator>(); if (tileGenerator == null) { m_log.Warn("[SIMIAN MAPTILE]: Cannot upload PNG map tile without an ImageGenerator"); return; } using (Image mapTile = tileGenerator.CreateMapTile()) { using (MemoryStream stream = new MemoryStream()) { mapTile.Save(stream, ImageFormat.Png); pngData = stream.ToArray(); } } List <MultipartForm.Element> postParameters = new List <MultipartForm.Element>() { new MultipartForm.Parameter("X", scene.RegionInfo.RegionLocX.ToString()), new MultipartForm.Parameter("Y", scene.RegionInfo.RegionLocY.ToString()), new MultipartForm.File("Tile", "tile.png", "image/png", pngData) }; string errorMessage = null; int tickstart = Util.EnvironmentTickCount(); // Make the remote storage request try { HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(m_serverUrl); request.Timeout = 20000; request.ReadWriteTimeout = 5000; using (HttpWebResponse response = MultipartForm.Post(request, postParameters)) { using (Stream responseStream = response.GetResponseStream()) { string responseStr = responseStream.GetStreamString(); OSD responseOSD = OSDParser.Deserialize(responseStr); if (responseOSD.Type == OSDType.Map) { OSDMap responseMap = (OSDMap)responseOSD; if (responseMap["Success"].AsBoolean()) { return; } errorMessage = "Upload failed: " + responseMap["Message"].AsString(); } else { errorMessage = "Response format was invalid:\n" + responseStr; } } } } catch (WebException we) { errorMessage = we.Message; if (we.Status == WebExceptionStatus.ProtocolError) { HttpWebResponse webResponse = (HttpWebResponse)we.Response; errorMessage = String.Format("[{0}] {1}", webResponse.StatusCode, webResponse.StatusDescription); } } catch (Exception ex) { errorMessage = ex.Message; } finally { // This just dumps a warning for any operation that takes more than 100 ms int tickdiff = Util.EnvironmentTickCountSubtract(tickstart); m_log.DebugFormat("[SIMIAN MAPTILE]: map tile uploaded in {0}ms", tickdiff); } m_log.WarnFormat("[SIMIAN MAPTILE]: Failed to store {0} byte tile for {1}: {2}", pngData.Length, scene.RegionInfo.RegionName, errorMessage); }
public virtual bool CreateAgent(GridRegion destination, AgentCircuitData aCircuit, uint teleportFlags, AgentData data, out int requestedUDPPort, out string reason) { reason = String.Empty; // Try local first if (m_localBackend.CreateAgent(destination, aCircuit, teleportFlags, data, out requestedUDPPort, out reason)) { return(true); } requestedUDPPort = destination.ExternalEndPoint.Port; //Just make sure.. reason = String.Empty; string uri = MakeUri(destination, true) + aCircuit.AgentID + "/"; try { OSDMap args = aCircuit.PackAgentCircuitData(); args["destination_x"] = OSD.FromString(destination.RegionLocX.ToString()); args["destination_y"] = OSD.FromString(destination.RegionLocY.ToString()); args["destination_name"] = OSD.FromString(destination.RegionName); args["destination_uuid"] = OSD.FromString(destination.RegionID.ToString()); args["teleport_flags"] = OSD.FromString(teleportFlags.ToString()); if (data != null) { args["agent_data"] = data.Pack(); } string resultStr = WebUtils.PostToService(uri, args); //Pull out the result and set it as the reason if (resultStr == "") { return(false); } OSDMap result = OSDParser.DeserializeJson(resultStr) as OSDMap; reason = result["reason"] != null ? result["reason"].AsString() : ""; if (result["success"].AsBoolean()) { //Not right... don't return true except for opensim combatibility :/ if (reason == "" || reason == "authorized") { return(true); } //We were able to contact the region try { //We send the CapsURLs through, so we need these OSDMap responseMap = (OSDMap)OSDParser.DeserializeJson(reason); if (responseMap.ContainsKey("Reason")) { reason = responseMap["Reason"].AsString(); } if (responseMap.ContainsKey("requestedUDPPort")) { requestedUDPPort = responseMap["requestedUDPPort"]; } return(result["success"].AsBoolean()); } catch { //Something went wrong return(false); } } reason = result.ContainsKey("Message") ? result["Message"].AsString() : "Could not contact the region"; return(false); } catch (Exception e) { MainConsole.Instance.Warn("[REMOTE SIMULATION CONNECTOR]: CreateAgent failed with exception: " + e); reason = e.Message; } return(false); }
public string RenderMaterialsPostCap(string request, UUID agentID) { OSDMap req = (OSDMap)OSDParser.DeserializeLLSDXml(request); OSDMap resp = new OSDMap(); OSDArray respArr = new OSDArray(); if (req.ContainsKey("Zipped")) { OSD osd = null; byte[] inBytes = req["Zipped"].AsBinary(); try { osd = ZDecompressBytesToOsd(inBytes); if (osd != null && osd is OSDArray) { foreach (OSD elem in (OSDArray)osd) { try { UUID id = new UUID(elem.AsBinary(), 0); lock (m_Materials) { if (m_Materials.ContainsKey(id)) { OSDMap matMap = new OSDMap(); matMap["ID"] = OSD.FromBinary(id.GetBytes()); matMap["Material"] = m_Materials[id]; respArr.Add(matMap); } else { m_log.Warn("[Materials]: request for unknown material ID: " + id.ToString()); // Theoretically we could try to load the material from the assets service, // but that shouldn't be necessary because the viewer should only request // materials that exist in a prim on the region, and all of these materials // are already stored in m_regionMaterials. } } } catch (Exception e) { m_log.Error("Error getting materials in response to viewer request", e); continue; } } } } catch (Exception e) { m_log.Warn("[Materials]: exception decoding zipped CAP payload ", e); //return ""; } } resp["Zipped"] = ZCompressOSD(respArr, false); string response = OSDParser.SerializeLLSDXmlString(resp); //m_log.Debug("[Materials]: cap request: " + request); //m_log.Debug("[Materials]: cap request (zipped portion): " + ZippedOsdBytesToString(req["Zipped"].AsBinary())); //m_log.Debug("[Materials]: cap response: " + response); return(response); }
/// <summary> /// Does the actual remote mapitem request /// This should be called from an asynchronous thread /// Request failures get blacklisted until region restart so we don't /// continue to spend resources trying to contact regions that are down. /// </summary> /// <param name="httpserver">blank string, we discover this in the process</param> /// <param name="id">Agent ID that we are making this request on behalf</param> /// <param name="flags">passed in from packet</param> /// <param name="EstateID">passed in from packet</param> /// <param name="godlike">passed in from packet</param> /// <param name="itemtype">passed in from packet</param> /// <param name="regionhandle">Region we're looking up</param> /// <returns></returns> private OSDMap RequestMapItemsAsync(string httpserver, UUID id, uint flags, uint EstateID, bool godlike, uint itemtype, ulong regionhandle) { bool blacklisted = false; lock (m_blacklistedregions) { if (m_blacklistedregions.ContainsKey(regionhandle)) { blacklisted = true; } } if (blacklisted) { return(new OSDMap()); } UUID requestID = UUID.Random(); lock (m_cachedRegionMapItemsAddress) { if (m_cachedRegionMapItemsAddress.ContainsKey(regionhandle)) { httpserver = m_cachedRegionMapItemsAddress[regionhandle]; } } if (String.IsNullOrEmpty(httpserver)) { RegionInfo mreg = m_scene.SceneGridService.RequestNeighbouringRegionInfo(regionhandle); if (mreg != null) { httpserver = "http://" + mreg.ExternalHostName + ":" + mreg.HttpPort + "/MAP/MapItems/" + regionhandle.ToString(); lock (m_cachedRegionMapItemsAddress) { if (!m_cachedRegionMapItemsAddress.ContainsKey(regionhandle)) { m_cachedRegionMapItemsAddress.Add(regionhandle, httpserver); } } } else { lock (m_blacklistedregions) { if (!m_blacklistedregions.ContainsKey(regionhandle)) { m_blacklistedregions.Add(regionhandle, Environment.TickCount); } } m_log.InfoFormat("[WORLD MAP]: Blacklisted region {0}", regionhandle.ToString()); } } blacklisted = false; lock (m_blacklistedurls) { if (m_blacklistedurls.ContainsKey(httpserver)) { blacklisted = true; } } // Can't find the http server if (String.IsNullOrEmpty(httpserver) || blacklisted) { return(new OSDMap()); } MapRequestState mrs = new MapRequestState(); mrs.agentID = id; mrs.EstateID = EstateID; mrs.flags = flags; mrs.godlike = godlike; mrs.itemtype = itemtype; mrs.regionhandle = regionhandle; lock (m_openRequests) m_openRequests.Add(requestID, mrs); WebRequest mapitemsrequest = WebRequest.Create(httpserver); mapitemsrequest.Method = "POST"; mapitemsrequest.ContentType = "application/xml+llsd"; OSDMap RAMap = new OSDMap(); // string RAMapString = RAMap.ToString(); OSD LLSDofRAMap = RAMap; // RENAME if this works byte[] buffer = OSDParser.SerializeLLSDXmlBytes(LLSDofRAMap); OSDMap responseMap = new OSDMap(); responseMap["requestID"] = OSD.FromUUID(requestID); Stream os = null; try { // send the Post mapitemsrequest.ContentLength = buffer.Length; //Count bytes to send os = mapitemsrequest.GetRequestStream(); os.Write(buffer, 0, buffer.Length); //Send it os.Close(); //m_log.DebugFormat("[WORLD MAP]: Getting MapItems from Sim {0}", httpserver); } catch (WebException ex) { m_log.WarnFormat("[WORLD MAP]: Bad send on GetMapItems {0}", ex.Message); responseMap["connect"] = OSD.FromBoolean(false); lock (m_blacklistedurls) { if (!m_blacklistedurls.ContainsKey(httpserver)) { m_blacklistedurls.Add(httpserver, Environment.TickCount); } } m_log.WarnFormat("[WORLD MAP]: Blacklisted {0}", httpserver); return(responseMap); } string response_mapItems_reply = null; { // get the response try { WebResponse webResponse = mapitemsrequest.GetResponse(); if (webResponse != null) { StreamReader sr = new StreamReader(webResponse.GetResponseStream()); response_mapItems_reply = sr.ReadToEnd().Trim(); } else { return(new OSDMap()); } } catch (WebException) { responseMap["connect"] = OSD.FromBoolean(false); lock (m_blacklistedurls) { if (!m_blacklistedurls.ContainsKey(httpserver)) { m_blacklistedurls.Add(httpserver, Environment.TickCount); } } m_log.WarnFormat("[WORLD MAP]: Blacklisted {0}", httpserver); return(responseMap); } OSD rezResponse = null; try { rezResponse = OSDParser.DeserializeLLSDXml(response_mapItems_reply); responseMap = (OSDMap)rezResponse; responseMap["requestID"] = OSD.FromUUID(requestID); } catch (Exception) { //m_log.InfoFormat("[OGP]: exception on parse of rez reply {0}", ex.Message); responseMap["connect"] = OSD.FromBoolean(false); return(responseMap); } } return(responseMap); }