public void IncomingCapsRequest(UUID agentID, Aurora.Framework.Services.GridRegion region, ISimulationBase simbase, ref OSDMap capURLs) { m_agentID = agentID; m_moneyModule = simbase.ApplicationRegistry.RequestModuleInterface <IMoneyModule>(); m_assetService = simbase.ApplicationRegistry.RequestModuleInterface <IAssetService>(); m_inventoryService = simbase.ApplicationRegistry.RequestModuleInterface <IInventoryService>(); m_libraryService = simbase.ApplicationRegistry.RequestModuleInterface <ILibraryService>(); m_inventoryData = Framework.Utilities.DataManager.RequestPlugin <IInventoryData>(); HttpServerHandle method = delegate(string path, Stream request, OSHttpRequest httpRequest, OSHttpResponse httpResponse) { return(HandleWebFetchInventoryDescendents(request, m_agentID)); }; string uri = "/CAPS/FetchInventoryDescendents/" + UUID.Random() + "/"; capURLs["WebFetchInventoryDescendents"] = MainServer.Instance.ServerURI + uri; capURLs["FetchInventoryDescendents"] = MainServer.Instance.ServerURI + uri; capURLs["FetchInventoryDescendents2"] = MainServer.Instance.ServerURI + uri; m_uris.Add(uri); MainServer.Instance.AddStreamHandler(new GenericStreamHandler("POST", uri, method)); method = delegate(string path, Stream request, OSHttpRequest httpRequest, OSHttpResponse httpResponse) { return(HandleFetchLibDescendents(request, m_agentID)); }; uri = "/CAPS/FetchLibDescendents/" + UUID.Random() + "/"; capURLs["FetchLibDescendents"] = MainServer.Instance.ServerURI + uri; capURLs["FetchLibDescendents2"] = MainServer.Instance.ServerURI + uri; m_uris.Add(uri); MainServer.Instance.AddStreamHandler(new GenericStreamHandler("POST", uri, method)); method = delegate(string path, Stream request, OSHttpRequest httpRequest, OSHttpResponse httpResponse) { return(HandleFetchInventory(request, m_agentID)); }; uri = "/CAPS/FetchInventory/" + UUID.Random() + "/"; capURLs["FetchInventory"] = MainServer.Instance.ServerURI + uri; capURLs["FetchInventory2"] = MainServer.Instance.ServerURI + uri; m_uris.Add(uri); MainServer.Instance.AddStreamHandler(new GenericStreamHandler("POST", uri, method)); method = delegate(string path, Stream request, OSHttpRequest httpRequest, OSHttpResponse httpResponse) { return(HandleFetchLib(request, m_agentID)); }; uri = "/CAPS/FetchLib/" + UUID.Random() + "/"; capURLs["FetchLib"] = MainServer.Instance.ServerURI + uri; capURLs["FetchLib2"] = MainServer.Instance.ServerURI + uri; m_uris.Add(uri); MainServer.Instance.AddStreamHandler(new GenericStreamHandler("POST", uri, method)); uri = "/CAPS/NewFileAgentInventory/" + UUID.Random() + "/"; capURLs["NewFileAgentInventory"] = MainServer.Instance.ServerURI + uri; m_uris.Add(uri); MainServer.Instance.AddStreamHandler(new GenericStreamHandler("POST", uri, NewAgentInventoryRequest)); uri = "/CAPS/NewFileAgentInventoryVariablePrice/" + UUID.Random() + "/"; capURLs["NewFileAgentInventoryVariablePrice"] = MainServer.Instance.ServerURI + uri; m_uris.Add(uri); MainServer.Instance.AddStreamHandler(new GenericStreamHandler("POST", uri, NewAgentInventoryRequestVariablePrice)); uri = "/CAPS/CreateInventoryCategory/" + UUID.Random() + "/"; capURLs["CreateInventoryCategory"] = MainServer.Instance.ServerURI + uri; m_uris.Add(uri); MainServer.Instance.AddStreamHandler(new GenericStreamHandler("POST", uri, CreateInventoryCategory)); }
/// <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(UUID id, uint flags, uint EstateID, bool godlike, uint itemtype, ulong regionhandle) { string httpserver = ""; 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 (httpserver.Length == 0) { uint x = 0, y = 0; Utils.LongToUInts(regionhandle, out x, out y); GridRegion mreg = m_scene.GridService.GetRegionByPosition(m_scene.RegionInfo.ScopeID, (int)x, (int)y); if (mreg != null) { httpserver = mreg.ServerURI + "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 (httpserver.Length == 0 || 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 = null; try { mapitemsrequest = WebRequest.Create(httpserver); } catch (Exception e) { m_log.DebugFormat("[WORLD MAP]: Access to {0} failed with {1}", httpserver, e); return(new OSDMap()); } 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 {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); } catch { m_log.DebugFormat("[WORLD MAP]: RequestMapItems failed for {0}", httpserver); responseMap["connect"] = OSD.FromBoolean(false); return(responseMap); } string response_mapItems_reply = null; { // get the response StreamReader sr = null; try { WebResponse webResponse = mapitemsrequest.GetResponse(); if (webResponse != null) { 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); } catch { m_log.DebugFormat("[WORLD MAP]: RequestMapItems failed for {0}", httpserver); responseMap["connect"] = OSD.FromBoolean(false); lock (m_blacklistedregions) { if (!m_blacklistedregions.ContainsKey(regionhandle)) { m_blacklistedregions.Add(regionhandle, Environment.TickCount); } } return(responseMap); } finally { if (sr != null) { sr.Close(); } } OSD rezResponse = null; try { rezResponse = OSDParser.DeserializeLLSDXml(response_mapItems_reply); responseMap = (OSDMap)rezResponse; responseMap["requestID"] = OSD.FromUUID(requestID); } catch (Exception ex) { m_log.InfoFormat("[WORLD MAP]: exception on parse of RequestMapItems reply from {0}: {1}", httpserver, ex.Message); responseMap["connect"] = OSD.FromBoolean(false); lock (m_blacklistedregions) { if (!m_blacklistedregions.ContainsKey(regionhandle)) { m_blacklistedregions.Add(regionhandle, Environment.TickCount); } } return(responseMap); } } if (!responseMap.ContainsKey(itemtype.ToString())) // remote sim doesnt have the stated region handle { m_log.DebugFormat("[WORLD MAP]: Remote sim does not have the stated region. Blacklisting."); lock (m_blacklistedregions) { if (!m_blacklistedregions.ContainsKey(regionhandle)) { m_blacklistedregions.Add(regionhandle, Environment.TickCount); } } } return(responseMap); }
public UUID StartHttpRequest( uint localID, UUID itemID, string url, List <string> parameters, Dictionary <string, string> headers, string body, out HttpInitialRequestStatus status) { if (!CheckAllowed(new Uri(url))) { status = HttpInitialRequestStatus.DISALLOWED_BY_FILTER; return(UUID.Zero); } UUID reqID = UUID.Random(); HttpRequestClass htc = new HttpRequestClass(); // Partial implementation: support for parameter flags needed // see http://wiki.secondlife.com/wiki/LlHTTPRequest // // Parameters are expected in {key, value, ... , key, value} if (parameters != null) { string[] parms = parameters.ToArray(); for (int i = 0; i < parms.Length; i += 2) { switch (Int32.Parse(parms[i])) { case (int)HttpRequestConstants.HTTP_METHOD: htc.HttpMethod = parms[i + 1]; break; case (int)HttpRequestConstants.HTTP_MIMETYPE: htc.HttpMIMEType = parms[i + 1]; break; case (int)HttpRequestConstants.HTTP_BODY_MAXLENGTH: int len; if (int.TryParse(parms[i + 1], out len)) { if (len > HttpRequestClass.HttpBodyMaxLenMAX) { len = HttpRequestClass.HttpBodyMaxLenMAX; } else if (len < 64) //??? { len = 64; } htc.HttpBodyMaxLen = len; } break; case (int)HttpRequestConstants.HTTP_VERIFY_CERT: htc.HttpVerifyCert = (int.Parse(parms[i + 1]) != 0); break; case (int)HttpRequestConstants.HTTP_VERBOSE_THROTTLE: // TODO implement me break; case (int)HttpRequestConstants.HTTP_CUSTOM_HEADER: //Parameters are in pairs and custom header takes //arguments in pairs so adjust for header marker. ++i; //Maximum of 8 headers are allowed based on the //Second Life documentation for llHTTPRequest. for (int count = 1; count <= 8; ++count) { //Not enough parameters remaining for a header? if (parms.Length - i < 2) { break; } if (htc.HttpCustomHeaders == null) { htc.HttpCustomHeaders = new List <string>(); } htc.HttpCustomHeaders.Add(parms[i]); htc.HttpCustomHeaders.Add(parms[i + 1]); int nexti = i + 2; if (nexti >= parms.Length || Char.IsDigit(parms[nexti][0])) { break; } i = nexti; } break; case (int)HttpRequestConstants.HTTP_PRAGMA_NO_CACHE: htc.HttpPragmaNoCache = (int.Parse(parms[i + 1]) != 0); break; } } } htc.RequestModule = this; htc.LocalID = localID; htc.ItemID = itemID; htc.Url = url; htc.ReqID = reqID; htc.HttpTimeout = m_httpTimeout; htc.OutboundBody = body; htc.ResponseHeaders = headers; htc.proxyurl = m_proxyurl; htc.proxyexcepts = m_proxyexcepts; // Same number as default HttpWebRequest.MaximumAutomaticRedirections htc.MaxRedirects = 50; lock (m_httpListLock) m_pendingRequests.Add(reqID, htc); htc.Process(); status = HttpInitialRequestStatus.OK; return(reqID); }
public UUID CreateAvatar(string firstName, string lastName, IScene scene, AvatarAppearance avatarApp, UUID creatorID, Vector3 startPos) { //Add the circuit data so they can login AgentCircuitData m_aCircuitData = new AgentCircuitData { IsChildAgent = false, CircuitCode = (uint)Util.RandomClass.Next() }; //Create the new bot data BotClientAPI m_character = new BotClientAPI(scene, m_aCircuitData); m_character.Name = firstName + " " + lastName; m_aCircuitData.AgentID = m_character.AgentId; //Set up appearance var origOwner = avatarApp.Owner; avatarApp.Owner = m_character.AgentId; List <AvatarAttachment> attachments = avatarApp.GetAttachments(); avatarApp.ClearAttachments(); // get original attachments foreach (AvatarAttachment t in attachments) { InventoryItemBase item = scene.InventoryService.GetItem(origOwner, t.ItemID); if (item != null) { item.ID = UUID.Random(); item.Owner = m_character.AgentId; item.Folder = UUID.Zero; scene.InventoryService.AddCacheItemAsync(item); //Now fix the ItemID avatarApp.SetAttachment(t.AttachPoint, item.ID, t.AssetID); } } scene.AuthenticateHandler.AgentCircuits.Add(m_character.CircuitCode, m_aCircuitData); //This adds them to the scene and sets them in world AddAndWaitUntilAgentIsAdded(scene, m_character); IScenePresence SP = scene.GetScenePresence(m_character.AgentId); if (SP == null) { return(UUID.Zero); //Failed! } IAvatarAppearanceModule appearance = SP.RequestModuleInterface <IAvatarAppearanceModule>(); appearance.Appearance = avatarApp; appearance.InitialHasWearablesBeenSent = true; Bot bot = new Bot(); bot.Initialize(SP, creatorID); try { SP.MakeRootAgent(startPos, false, true); } catch { MainConsole.Instance.ErrorFormat("[BotManager]: Error creating bot {0} as root agent!", m_character.AgentId); } //Move them SP.Teleport(startPos); foreach (var presence in scene.GetScenePresences()) { presence.SceneViewer.QueuePresenceForUpdate(SP, PrimUpdateFlags.ForcedFullUpdate); } IAttachmentsModule attModule = SP.Scene.RequestModuleInterface <IAttachmentsModule>(); if (attModule != null) { foreach (AvatarAttachment att in attachments) { attModule.RezSingleAttachmentFromInventory(SP.ControllingClient, att.ItemID, att.AssetID, 0, true); } } //Save them in the bots list m_bots.Add(m_character.AgentId, bot); AddTagToBot(m_character.AgentId, "AllBots", bot.AvatarCreatorID); MainConsole.Instance.InfoFormat("[BotManager]: Added bot {0} to region {1}", m_character.Name, scene.RegionInfo.RegionName); //Return their UUID return(m_character.AgentId); }
public void ProcessMessages() { if (m_transmitter.PendingSessionCount > 0) { Session tmp = m_transmitter.AcceptPendingSession(); m_sessions.Add(tmp); m_sessionsToClient.Add(tmp); } List <Session> tmpRemove = new List <Session>(); foreach (Session session in m_sessionsToClient) { while (session.AvailableMessages > 0) { Message message = session.Receive(); if (message.GetType() == typeof(JoinRequestMessage)) { JoinRequestMessage joinRequestMessage = (JoinRequestMessage)message; m_log.Info("[MXP ClientStack]: Session join request: " + session.SessionId + " (" + (session.IsIncoming ? "from" : "to") + " " + session.RemoteEndPoint.Address + ":" + session.RemoteEndPoint.Port + ")"); try { if (joinRequestMessage.BubbleId == Guid.Empty) { foreach (Scene scene in m_scenes.Values) { if (scene.RegionInfo.RegionName == joinRequestMessage.BubbleName) { m_log.Info("[MXP ClientStack]: Resolved region by name: " + joinRequestMessage.BubbleName + " (" + scene.RegionInfo.RegionID + ")"); joinRequestMessage.BubbleId = scene.RegionInfo.RegionID.Guid; } } } if (joinRequestMessage.BubbleId == Guid.Empty) { m_log.Warn("[MXP ClientStack]: Failed to resolve region by name: " + joinRequestMessage.BubbleName); } UUID sceneId = new UUID(joinRequestMessage.BubbleId); bool regionExists = true; if (!m_scenes.ContainsKey(sceneId)) { m_log.Info("[MXP ClientStack]: No such region: " + sceneId); regionExists = false; } UUID userId = UUID.Zero; UserAccount account = null; bool authorized = regionExists ? AuthoriseUser(joinRequestMessage.ParticipantName, joinRequestMessage.ParticipantPassphrase, new UUID(joinRequestMessage.BubbleId), out account) : false; if (authorized) { Scene scene = m_scenes[sceneId]; UUID mxpSessionID = UUID.Random(); string reason; m_log.Debug("[MXP ClientStack]: Session join request success: " + session.SessionId + " (" + (session.IsIncoming ? "from" : "to") + " " + session.RemoteEndPoint.Address + ":" + session.RemoteEndPoint.Port + ")"); m_log.Debug("[MXP ClientStack]: Attaching UserAgent to UserProfile..."); UUID secureSession = UUID.Zero; AttachUserAgentToUserProfile(account, session, mxpSessionID, sceneId, out secureSession); m_log.Debug("[MXP ClientStack]: Attached UserAgent to UserProfile."); m_log.Debug("[MXP ClientStack]: Preparing Scene to Connection..."); if (!PrepareSceneForConnection(mxpSessionID, secureSession, sceneId, account, out reason)) { m_log.DebugFormat("[MXP ClientStack]: Scene refused connection: {0}", reason); DeclineConnection(session, joinRequestMessage); tmpRemove.Add(session); continue; } m_log.Debug("[MXP ClientStack]: Prepared Scene to Connection."); m_log.Debug("[MXP ClientStack]: Accepting connection..."); AcceptConnection(session, joinRequestMessage, mxpSessionID, userId); m_log.Info("[MXP ClientStack]: Accepted connection."); m_log.Debug("[MXP ClientStack]: Creating ClientView...."); MXPClientView client = new MXPClientView(session, mxpSessionID, userId, scene, account.FirstName, account.LastName); m_clients.Add(client); m_log.Debug("[MXP ClientStack]: Created ClientView."); client.MXPSendSynchronizationBegin(m_scenes[new UUID(joinRequestMessage.BubbleId)].SceneContents.GetTotalObjectsCount()); m_log.Debug("[MXP ClientStack]: Starting ClientView..."); try { client.Start(); m_log.Debug("[MXP ClientStack]: Started ClientView."); } catch (Exception e) { m_log.Error(e); } m_log.Debug("[MXP ClientStack]: Connected"); } else { m_log.Info("[MXP ClientStack]: Session join request failure: " + session.SessionId + " (" + (session.IsIncoming ? "from" : "to") + " " + session.RemoteEndPoint.Address + ":" + session.RemoteEndPoint.Port + ")"); DeclineConnection(session, joinRequestMessage); } } catch (Exception e) { m_log.Error("[MXP ClientStack]: Session join request failure: " + session.SessionId + " (" + (session.IsIncoming ? "from" : "to") + " " + session.RemoteEndPoint.Address + ":" + session.RemoteEndPoint.Port + "): " + e.ToString() + " :" + e.StackTrace.ToString()); } tmpRemove.Add(session); } } } foreach (Session session in tmpRemove) { m_sessionsToClient.Remove(session); } foreach (MXPClientView clientView in m_clients) { int messagesProcessedCount = 0; Session session = clientView.Session; while (session.AvailableMessages > 0) { Message message = session.Receive(); if (message.GetType() == typeof(LeaveRequestMessage)) { LeaveResponseMessage leaveResponseMessage = (LeaveResponseMessage)MessageFactory.Current.ReserveMessage( typeof(LeaveResponseMessage)); m_log.Debug("[MXP ClientStack]: Session leave request: " + session.SessionId + " (" + (session.IsIncoming ? "from" : "to") + " " + session.RemoteEndPoint.Address + ":" + session.RemoteEndPoint.Port + ")"); leaveResponseMessage.RequestMessageId = message.MessageId; leaveResponseMessage.FailureCode = 0; session.Send(leaveResponseMessage); if (session.SessionState != SessionState.Disconnected) { session.SetStateDisconnected(); } m_log.Debug("[MXP ClientStack]: Removing Client from Scene"); //clientView.Scene.RemoveClient(clientView.AgentId); } if (message.GetType() == typeof(LeaveResponseMessage)) { LeaveResponseMessage leaveResponseMessage = (LeaveResponseMessage)message; m_log.Debug("[MXP ClientStack]: Session leave response: " + session.SessionId + " (" + (session.IsIncoming ? "from" : "to") + " " + session.RemoteEndPoint.Address + ":" + session.RemoteEndPoint.Port + ")"); if (leaveResponseMessage.FailureCode == 0) { session.SetStateDisconnected(); } m_log.Debug("[MXP ClientStack]: Removing Client from Scene"); //clientView.Scene.RemoveClient(clientView.AgentId); } else { clientView.MXPPRocessMessage(message); } MessageFactory.Current.ReleaseMessage(message); messagesProcessedCount++; if (messagesProcessedCount > 1000) { break; } } } }
private byte[] HandleHttpStartSession(string path, Stream request, OSHttpRequest httpRequest, OSHttpResponse httpResponse) { DoExpire(); Hashtable post = DecodePostString(request.ReadUntilEnd()); httpResponse.StatusCode = 401; httpResponse.ContentType = "text/plain"; if (m_UserName == String.Empty) { return(MainServer.BlankResponse); } if (post["USER"] == null || post["PASS"] == null) { return(MainServer.BlankResponse); } if (m_UserName != post["USER"].ToString() || m_Password != post["PASS"].ToString()) { return(MainServer.BlankResponse); } ConsoleConnection c = new ConsoleConnection { last = Environment.TickCount, lastLineSeen = 0 }; UUID sessionID = UUID.Random(); lock (m_Connections) { m_Connections[sessionID] = c; } string uri = "/ReadResponses/" + sessionID.ToString() + "/"; m_Server.AddPollServiceHTTPHandler(uri, new PollServiceEventArgs(null, HasEvents, GetEvents, NoEvents, sessionID)); XmlDocument xmldoc = new XmlDocument(); XmlNode xmlnode = xmldoc.CreateNode(XmlNodeType.XmlDeclaration, "", ""); xmldoc.AppendChild(xmlnode); XmlElement rootElement = xmldoc.CreateElement("", "ConsoleSession", ""); xmldoc.AppendChild(rootElement); XmlElement id = xmldoc.CreateElement("", "SessionID", ""); id.AppendChild(xmldoc.CreateTextNode(sessionID.ToString())); rootElement.AppendChild(id); XmlElement prompt = xmldoc.CreateElement("", "Prompt", ""); prompt.AppendChild(xmldoc.CreateTextNode(DefaultPrompt)); rootElement.AppendChild(prompt); httpResponse.StatusCode = 200; httpResponse.ContentType = "text/xml"; return(Encoding.UTF8.GetBytes(xmldoc.InnerXml)); }
/// <summary> /// Try to set up the estate owner for the given scene. /// </summary> /// <remarks> /// The involves asking the user for information about the user on the console. If the user does not already /// exist then it is created. /// </remarks> /// <param name="scene"></param> private void SetUpEstateOwner(Scene scene) { RegionInfo regionInfo = scene.RegionInfo; string estateOwnerFirstName = null; string estateOwnerLastName = null; string estateOwnerEMail = null; string estateOwnerPassword = null; string rawEstateOwnerUuid = null; if (Config.Configs[ESTATE_SECTION_NAME] != null) { string defaultEstateOwnerName = Config.Configs[ESTATE_SECTION_NAME].GetString("DefaultEstateOwnerName", "").Trim(); string[] ownerNames = defaultEstateOwnerName.Split(' '); if (ownerNames.Length >= 2) { estateOwnerFirstName = ownerNames[0]; estateOwnerLastName = ownerNames[1]; } // Info to be used only on Standalone Mode rawEstateOwnerUuid = Config.Configs[ESTATE_SECTION_NAME].GetString("DefaultEstateOwnerUUID", null); estateOwnerEMail = Config.Configs[ESTATE_SECTION_NAME].GetString("DefaultEstateOwnerEMail", null); estateOwnerPassword = Config.Configs[ESTATE_SECTION_NAME].GetString("DefaultEstateOwnerPassword", null); } MainConsole.Instance.Output("Estate {0} has no owner set.", regionInfo.EstateSettings.EstateName); List <char> excluded = new List <char>(new char[1] { ' ' }); if (estateOwnerFirstName == null || estateOwnerLastName == null) { estateOwnerFirstName = MainConsole.Instance.Prompt("Estate owner first name", "Test", excluded); estateOwnerLastName = MainConsole.Instance.Prompt("Estate owner last name", "User", excluded); } UserAccount account = scene.UserAccountService.GetUserAccount(regionInfo.ScopeID, estateOwnerFirstName, estateOwnerLastName); if (account == null) { // XXX: The LocalUserAccountServicesConnector is currently registering its inner service rather than // itself! // if (scene.UserAccountService is LocalUserAccountServicesConnector) // { // IUserAccountService innerUas // = ((LocalUserAccountServicesConnector)scene.UserAccountService).UserAccountService; // // m_log.DebugFormat("B {0}", innerUas.GetType()); // // if (innerUas is UserAccountService) // { if (scene.UserAccountService is UserAccountService) { if (estateOwnerPassword == null) { estateOwnerPassword = MainConsole.Instance.Prompt("Password", null, null, false); } if (estateOwnerEMail == null) { estateOwnerEMail = MainConsole.Instance.Prompt("Email"); } if (rawEstateOwnerUuid == null) { rawEstateOwnerUuid = MainConsole.Instance.Prompt("User ID", UUID.Random().ToString()); } UUID estateOwnerUuid = UUID.Zero; if (!UUID.TryParse(rawEstateOwnerUuid, out estateOwnerUuid)) { m_log.ErrorFormat("[OPENSIM]: ID {0} is not a valid UUID", rawEstateOwnerUuid); return; } // If we've been given a zero uuid then this signals that we should use a random user id if (estateOwnerUuid == UUID.Zero) { estateOwnerUuid = UUID.Random(); } account = ((UserAccountService)scene.UserAccountService).CreateUser( regionInfo.ScopeID, estateOwnerUuid, estateOwnerFirstName, estateOwnerLastName, estateOwnerPassword, estateOwnerEMail); } } if (account == null) { m_log.ErrorFormat( "[OPENSIM]: Unable to store account. If this simulator is connected to a grid, you must create the estate owner account first at the grid level."); } else { regionInfo.EstateSettings.EstateOwner = account.PrincipalID; m_estateDataService.StoreEstateSettings(regionInfo.EstateSettings); } }
public void AgentPositionTest01() { UUID AgentId1 = UUID.Random(); UUID SessionId1 = UUID.Random(); uint CircuitCode1 = uint.MinValue; Vector3 Size1 = Vector3.UnitZ; Vector3 Position1 = Vector3.UnitX; Vector3 LeftAxis1 = Vector3.UnitY; Vector3 UpAxis1 = Vector3.UnitZ; Vector3 AtAxis1 = Vector3.UnitX; ulong RegionHandle1 = ulong.MinValue; byte[] Throttles1 = new byte[] { 0, 1, 0 }; Vector3 Velocity1 = Vector3.Zero; float Far1 = 256; bool ChangedGrid1 = false; Vector3 Center1 = Vector3.Zero; AgentPosition position1 = new AgentPosition(); position1.AgentID = AgentId1; position1.SessionID = SessionId1; position1.CircuitCode = CircuitCode1; position1.Size = Size1; position1.Position = Position1; position1.LeftAxis = LeftAxis1; position1.UpAxis = UpAxis1; position1.AtAxis = AtAxis1; position1.RegionHandle = RegionHandle1; position1.Throttles = Throttles1; position1.Velocity = Velocity1; position1.Far = Far1; position1.ChangedGrid = ChangedGrid1; position1.Center = Center1; ChildAgentDataUpdate cadu = new ChildAgentDataUpdate(); cadu.AgentID = AgentId1.Guid; cadu.ActiveGroupID = UUID.Zero.Guid; cadu.throttles = Throttles1; cadu.drawdistance = Far1; cadu.Position = Position1; cadu.Velocity = Velocity1; cadu.regionHandle = RegionHandle1; cadu.cameraPosition = Center1; cadu.AVHeight = Size1.Z; AgentPosition position2 = new AgentPosition(); position2.CopyFrom(cadu, position1.SessionID); Assert.IsTrue( position2.AgentID == position1.AgentID && position2.Size == position1.Size && position2.Position == position1.Position && position2.Velocity == position1.Velocity && position2.Center == position1.Center && position2.RegionHandle == position1.RegionHandle && position2.Far == position1.Far , "Copy From ChildAgentDataUpdate failed"); position2 = new AgentPosition(); Assert.IsFalse(position2.AgentID == position1.AgentID, "Test Error, position2 should be a blank uninitialized AgentPosition"); EntityTransferContext ctx = new EntityTransferContext(); position2.Unpack(position1.Pack(ctx), null, ctx); Assert.IsTrue(position2.AgentID == position1.AgentID, "Agent ID didn't unpack the same way it packed"); Assert.IsTrue(position2.Position == position1.Position, "Position didn't unpack the same way it packed"); Assert.IsTrue(position2.Velocity == position1.Velocity, "Velocity didn't unpack the same way it packed"); Assert.IsTrue(position2.SessionID == position1.SessionID, "SessionID didn't unpack the same way it packed"); Assert.IsTrue(position2.CircuitCode == position1.CircuitCode, "CircuitCode didn't unpack the same way it packed"); Assert.IsTrue(position2.LeftAxis == position1.LeftAxis, "LeftAxis didn't unpack the same way it packed"); Assert.IsTrue(position2.UpAxis == position1.UpAxis, "UpAxis didn't unpack the same way it packed"); Assert.IsTrue(position2.AtAxis == position1.AtAxis, "AtAxis didn't unpack the same way it packed"); Assert.IsTrue(position2.RegionHandle == position1.RegionHandle, "RegionHandle didn't unpack the same way it packed"); Assert.IsTrue(position2.ChangedGrid == position1.ChangedGrid, "ChangedGrid didn't unpack the same way it packed"); Assert.IsTrue(position2.Center == position1.Center, "Center didn't unpack the same way it packed"); Assert.IsTrue(position2.Size == position1.Size, "Size didn't unpack the same way it packed"); }
protected void ConstructDefaultIarBytesForTestLoad() { // log4net.Config.XmlConfigurator.Configure(); InventoryArchiverModule archiverModule = new InventoryArchiverModule(); Scene scene = SceneHelpers.SetupScene(); SceneHelpers.SetupSceneModules(scene, archiverModule); UserAccountHelpers.CreateUserWithInventory(scene, m_uaLL1, "hampshire"); MemoryStream archiveWriteStream = new MemoryStream(); // Create scene object asset UUID ownerId = UUID.Parse("00000000-0000-0000-0000-000000000040"); SceneObjectGroup object1 = SceneHelpers.CreateSceneObject(1, ownerId, "Ray Gun Object", 0x50); UUID asset1Id = UUID.Parse("00000000-0000-0000-0000-000000000060"); AssetBase asset1 = AssetHelpers.CreateAsset(asset1Id, object1); scene.AssetService.Store(asset1); // Create scene object item InventoryItemBase item1 = new InventoryItemBase(); item1.Name = m_item1Name; item1.ID = UUID.Parse("00000000-0000-0000-0000-000000000020"); item1.AssetID = asset1.FullID; item1.GroupID = UUID.Random(); item1.CreatorIdAsUuid = m_uaLL1.PrincipalID; item1.Owner = m_uaLL1.PrincipalID; item1.Folder = scene.InventoryService.GetRootFolder(m_uaLL1.PrincipalID).ID; scene.AddInventoryItem(item1); // Create coalesced objects asset SceneObjectGroup cobj1 = SceneHelpers.CreateSceneObject(1, m_uaLL1.PrincipalID, "Object1", 0x120); cobj1.AbsolutePosition = new Vector3(15, 30, 45); SceneObjectGroup cobj2 = SceneHelpers.CreateSceneObject(1, m_uaLL1.PrincipalID, "Object2", 0x140); cobj2.AbsolutePosition = new Vector3(25, 50, 75); CoalescedSceneObjects coa = new CoalescedSceneObjects(m_uaLL1.PrincipalID, cobj1, cobj2); AssetBase coaAsset = AssetHelpers.CreateAsset(0x160, coa); scene.AssetService.Store(coaAsset); // Create coalesced objects inventory item InventoryItemBase coaItem = new InventoryItemBase(); coaItem.Name = m_coaItemName; coaItem.ID = UUID.Parse("00000000-0000-0000-0000-000000000180"); coaItem.AssetID = coaAsset.FullID; coaItem.GroupID = UUID.Random(); coaItem.CreatorIdAsUuid = m_uaLL1.PrincipalID; coaItem.Owner = m_uaLL1.PrincipalID; coaItem.Folder = scene.InventoryService.GetRootFolder(m_uaLL1.PrincipalID).ID; scene.AddInventoryItem(coaItem); archiverModule.ArchiveInventory( Guid.NewGuid(), m_uaLL1.FirstName, m_uaLL1.LastName, "/*", "hampshire", archiveWriteStream); m_iarStreamBytes = archiveWriteStream.ToArray(); }
private void ProcessMoneyTransferRequest(UUID fromID, UUID toID, int amount, int type, string description) { if (toID != UUID.Zero) { ISceneManager manager = m_registry.RequestModuleInterface <ISceneManager>(); if (manager != null) { bool paid = false; foreach (IScene scene in manager.Scenes) { ISceneChildEntity ent = scene.GetSceneObjectPart(toID); if (ent != null) { bool success = m_connector.UserCurrencyTransfer(ent.OwnerID, fromID, ent.UUID, ent.Name, UUID.Zero, "", (uint)amount, description, (TransactionType)type, UUID.Random()); if (success) { FireObjectPaid(toID, fromID, amount); } paid = true; break; } } if (!paid) { m_connector.UserCurrencyTransfer(toID, fromID, (uint)amount, description, (TransactionType)type, UUID.Random()); } } } }
private bool ValidateLandBuy(EventManager.LandBuyArgs e) { return(m_connector.UserCurrencyTransfer(e.parcelOwnerID, e.agentId, (uint)e.parcelPrice, "Land Purchase", TransactionType.LandSale, UUID.Random())); }
/// <summary> /// The default override for TestClient commands /// </summary> /// <param name="args"></param> /// <param name="fromAgentId"></param> /// <returns></returns> public override string Execute(string[] args, UUID fromAgentId) { if (args.Length < 1) { return("Usage: uploadscript filename.lsl"); } var file = args.Aggregate(string.Empty, (current, t) => $"{current}{t} "); file = file.TrimEnd(); if (!File.Exists(file)) { return($"Filename '{file}' does not exist"); } try { using (var reader = new StreamReader(file)) { var body = reader.ReadToEnd(); var desc = $"{file} created by OpenMetaverse TestClient {DateTime.Now}"; // create the asset Client.Inventory.RequestCreateItem(Client.Inventory.FindFolderForType(AssetType.LSLText), file, desc, AssetType.LSLText, UUID.Random(), InventoryType.LSL, PermissionMask.All, (success, item) => { if (success) { // upload the asset Client.Inventory.RequestUpdateScriptAgentInventory( System.Text.Encoding.UTF8.GetBytes(body), item.UUID, true, (uploadSuccess, uploadStatus, compileSuccess, compileMessages, itemId, assetId) => { var log = $"Filename: {file}"; if (uploadSuccess) { log += $" Script successfully uploaded, ItemID {itemId} AssetID {assetId}"; } else { log += $" Script failed to upload, ItemID {itemId}"; } if (compileSuccess) { log += " compilation successful"; } else { log += " compilation failed"; } Logger.Log(log, Helpers.LogLevel.Info, Client); }); } }); } return($"Filename: {file} is being uploaded."); } catch (Exception e) { Logger.Log(e.ToString(), Helpers.LogLevel.Error, Client); return($"Error creating script for {file}"); } }
private void btnDecline_Click(object sender, EventArgs e) { client.Self.TeleportLureRespond(targetUUID, UUID.Random(), false); CloseTab(); }
/// <summary> /// Parses ad request /// </summary> /// <param name="request"></param> /// <param name="response"></param> /// <param name="AgentId"></param> /// <returns></returns> public byte[] ProcessAdd(Stream request, OSHttpResponse response, UUID AgentId) { IScenePresence avatar; if (!m_scene.TryGetScenePresence(AgentId, out avatar)) { return(MainServer.BlankResponse); } OSDMap r = (OSDMap)OSDParser.Deserialize(HttpServerHandlerHelpers.ReadFully(request)); UploadObjectAssetMessage message = new UploadObjectAssetMessage(); try { message.Deserialize(r); } catch (Exception ex) { MainConsole.Instance.Error("[UploadObjectAssetModule]: Error de-serializing message " + ex); message = null; } if (message == null) { response.StatusCode = 400; //501; //410; //404; return (Encoding.UTF8.GetBytes( "<llsd><map><key>error</key><string>Error parsing Object</string></map></llsd>")); } Vector3 pos = avatar.AbsolutePosition + (Vector3.UnitX * avatar.Rotation); Quaternion rot = Quaternion.Identity; Vector3 rootpos = Vector3.Zero; SceneObjectGroup rootGroup = null; SceneObjectGroup[] allparts = new SceneObjectGroup[message.Objects.Length]; for (int i = 0; i < message.Objects.Length; i++) { UploadObjectAssetMessage.Object obj = message.Objects[i]; PrimitiveBaseShape pbs = PrimitiveBaseShape.CreateBox(); if (i == 0) { rootpos = obj.Position; } // Combine the extraparams data into it's ugly blob again.... //int bytelength = 0; //for (int extparams = 0; extparams < obj.ExtraParams.Length; extparams++) //{ // bytelength += obj.ExtraParams[extparams].ExtraParamData.Length; //} //byte[] extraparams = new byte[bytelength]; //int position = 0; //for (int extparams = 0; extparams < obj.ExtraParams.Length; extparams++) //{ // Buffer.BlockCopy(obj.ExtraParams[extparams].ExtraParamData, 0, extraparams, position, // obj.ExtraParams[extparams].ExtraParamData.Length); // // position += obj.ExtraParams[extparams].ExtraParamData.Length; // } //pbs.ExtraParams = extraparams; foreach (UploadObjectAssetMessage.Object.ExtraParam extraParam in obj.ExtraParams) { switch ((ushort)extraParam.Type) { case (ushort)ExtraParamType.Sculpt: Primitive.SculptData sculpt = new Primitive.SculptData(extraParam.ExtraParamData, 0); pbs.SculptEntry = true; pbs.SculptTexture = obj.SculptID; pbs.SculptType = (byte)sculpt.Type; break; case (ushort)ExtraParamType.Flexible: Primitive.FlexibleData flex = new Primitive.FlexibleData(extraParam.ExtraParamData, 0); pbs.FlexiEntry = true; pbs.FlexiDrag = flex.Drag; pbs.FlexiForceX = flex.Force.X; pbs.FlexiForceY = flex.Force.Y; pbs.FlexiForceZ = flex.Force.Z; pbs.FlexiGravity = flex.Gravity; pbs.FlexiSoftness = flex.Softness; pbs.FlexiTension = flex.Tension; pbs.FlexiWind = flex.Wind; break; case (ushort)ExtraParamType.Light: Primitive.LightData light = new Primitive.LightData(extraParam.ExtraParamData, 0); pbs.LightColorA = light.Color.A; pbs.LightColorB = light.Color.B; pbs.LightColorG = light.Color.G; pbs.LightColorR = light.Color.R; pbs.LightCutoff = light.Cutoff; pbs.LightEntry = true; pbs.LightFalloff = light.Falloff; pbs.LightIntensity = light.Intensity; pbs.LightRadius = light.Radius; break; case 0x40: pbs.ReadProjectionData(extraParam.ExtraParamData, 0); break; } } pbs.PathBegin = (ushort)obj.PathBegin; pbs.PathCurve = (byte)obj.PathCurve; pbs.PathEnd = (ushort)obj.PathEnd; pbs.PathRadiusOffset = (sbyte)obj.RadiusOffset; pbs.PathRevolutions = (byte)obj.Revolutions; pbs.PathScaleX = (byte)obj.ScaleX; pbs.PathScaleY = (byte)obj.ScaleY; pbs.PathShearX = (byte)obj.ShearX; pbs.PathShearY = (byte)obj.ShearY; pbs.PathSkew = (sbyte)obj.Skew; pbs.PathTaperX = (sbyte)obj.TaperX; pbs.PathTaperY = (sbyte)obj.TaperY; pbs.PathTwist = (sbyte)obj.Twist; pbs.PathTwistBegin = (sbyte)obj.TwistBegin; pbs.HollowShape = (HollowShape)obj.ProfileHollow; pbs.PCode = (byte)PCode.Prim; pbs.ProfileBegin = (ushort)obj.ProfileBegin; pbs.ProfileCurve = (byte)obj.ProfileCurve; pbs.ProfileEnd = (ushort)obj.ProfileEnd; pbs.Scale = obj.Scale; pbs.State = 0; SceneObjectPart prim = new SceneObjectPart(AgentId, pbs, obj.Position, obj.Rotation, Vector3.Zero, obj.Name) { UUID = UUID.Random(), CreatorID = AgentId, OwnerID = AgentId, GroupID = obj.GroupID }; prim.LastOwnerID = prim.OwnerID; prim.CreationDate = Util.UnixTimeSinceEpoch(); prim.Name = obj.Name; prim.Description = ""; prim.PayPrice[0] = -2; prim.PayPrice[1] = -2; prim.PayPrice[2] = -2; prim.PayPrice[3] = -2; prim.PayPrice[4] = -2; Primitive.TextureEntry tmp = new Primitive.TextureEntry(UUID.Parse("89556747-24cb-43ed-920b-47caed15465f")); for (int j = 0; j < obj.Faces.Length; j++) { UploadObjectAssetMessage.Object.Face face = obj.Faces[j]; Primitive.TextureEntryFace primFace = tmp.CreateFace((uint)j); primFace.Bump = face.Bump; primFace.RGBA = face.Color; primFace.Fullbright = face.Fullbright; primFace.Glow = face.Glow; primFace.TextureID = face.ImageID; primFace.Rotation = face.ImageRot; primFace.MediaFlags = ((face.MediaFlags & 1) != 0); primFace.OffsetU = face.OffsetS; primFace.OffsetV = face.OffsetT; primFace.RepeatU = face.ScaleS; primFace.RepeatV = face.ScaleT; primFace.TexMapType = (MappingType)(face.MediaFlags & 6); } pbs.TextureEntry = tmp.GetBytes(); prim.Shape = pbs; prim.Scale = obj.Scale; SceneObjectGroup grp = new SceneObjectGroup(prim, m_scene); prim.ParentID = 0; if (i == 0) { rootGroup = grp; } grp.AbsolutePosition = obj.Position; prim.SetRotationOffset(true, obj.Rotation, true); grp.RootPart.IsAttachment = false; string reason; if (m_scene.Permissions.CanRezObject(1, avatar.UUID, pos, out reason)) { m_scene.SceneGraph.AddPrimToScene(grp); grp.AbsolutePosition = obj.Position; } else { //Stop now then avatar.ControllingClient.SendAlertMessage("You do not have permission to rez objects here: " + reason); return(MainServer.BlankResponse); } allparts[i] = grp; } if (rootGroup != null) { for (int j = 1; j < allparts.Length; j++) { rootGroup.LinkToGroup(allparts [j]); } rootGroup.ScheduleGroupUpdate(PrimUpdateFlags.ForcedFullUpdate); pos = m_scene.SceneGraph.GetNewRezLocation(Vector3.Zero, rootpos, UUID.Zero, rot, 1, 1, true, allparts [0].GroupScale(), false); } else { MainConsole.Instance.Error("[UploadObjectAssetModule]: Unable to locate root group!"); } OSDMap map = new OSDMap(); map["local_id"] = allparts[0].LocalId; return(OSDParser.SerializeLLSDXmlBytes(map)); }
/// <summary> /// Set up a test scene /// </summary> /// <remarks> /// Automatically starts services, as would the normal runtime. /// </remarks> /// <returns></returns> public TestScene SetupScene() { return(SetupScene("Unit test region", UUID.Random(), 1000, 1000)); }
/// <summary> /// Set up a scene. /// </summary> /// <param name="name">Name of the region</param> /// <param name="id">ID of the region</param> /// <param name="x">X co-ordinate of the region</param> /// <param name="y">Y co-ordinate of the region</param> /// <param name="sizeX">X size of scene</param> /// <param name="sizeY">Y size of scene</param> /// <param name="configSource"></param> /// <returns></returns> public TestScene SetupScene( string name, UUID id, uint x, uint y, uint sizeX, uint sizeY, IConfigSource configSource) { Console.WriteLine("Setting up test scene {0}", name); // We must set up a console otherwise setup of some modules may fail MainConsole.Instance = new MockConsole(); RegionInfo regInfo = new RegionInfo(x, y, new IPEndPoint(IPAddress.Loopback, 9000), "127.0.0.1"); regInfo.RegionName = name; regInfo.RegionID = id; regInfo.RegionSizeX = sizeX; regInfo.RegionSizeY = sizeY; TestScene testScene = new TestScene( regInfo, m_acm, SimDataService, m_estateDataService, configSource, null); INonSharedRegionModule godsModule = new GodsModule(); godsModule.Initialise(new IniConfigSource()); godsModule.AddRegion(testScene); // Add scene to physics ((INonSharedRegionModule)m_physicsScene).AddRegion(testScene); ((INonSharedRegionModule)m_physicsScene).RegionLoaded(testScene); // Add scene to services m_assetService.AddRegion(testScene); if (m_cache != null) { m_cache.AddRegion(testScene); m_cache.RegionLoaded(testScene); testScene.AddRegionModule(m_cache.Name, m_cache); } m_assetService.RegionLoaded(testScene); testScene.AddRegionModule(m_assetService.Name, m_assetService); m_authenticationService.AddRegion(testScene); m_authenticationService.RegionLoaded(testScene); testScene.AddRegionModule(m_authenticationService.Name, m_authenticationService); m_inventoryService.AddRegion(testScene); m_inventoryService.RegionLoaded(testScene); testScene.AddRegionModule(m_inventoryService.Name, m_inventoryService); m_gridService.AddRegion(testScene); m_gridService.RegionLoaded(testScene); testScene.AddRegionModule(m_gridService.Name, m_gridService); m_userAccountService.AddRegion(testScene); m_userAccountService.RegionLoaded(testScene); testScene.AddRegionModule(m_userAccountService.Name, m_userAccountService); m_presenceService.AddRegion(testScene); m_presenceService.RegionLoaded(testScene); testScene.AddRegionModule(m_presenceService.Name, m_presenceService); testScene.RegionInfo.EstateSettings.EstateOwner = UUID.Random(); testScene.SetModuleInterfaces(); testScene.LandChannel = new TestLandChannel(testScene); testScene.LoadWorldMap(); testScene.RegionInfo.EstateSettings = new EstateSettings(); testScene.LoginsEnabled = true; testScene.RegisterRegionWithGrid(); SceneManager.Add(testScene); return(testScene); }
/// <summary> /// Set up a scene. /// </summary> /// <param name="name">Name of the region</param> /// <param name="id">ID of the region</param> /// <param name="x">X co-ordinate of the region</param> /// <param name="y">Y co-ordinate of the region</param> /// <param name="sizeX">X size of scene</param> /// <param name="sizeY">Y size of scene</param> /// <param name="configSource"></param> /// <returns></returns> public TestScene SetupScene( string name, UUID id, uint x, uint y, uint sizeX, uint sizeY, IConfigSource configSource) { Console.WriteLine("Setting up test scene {0}", name); // We must set up a console otherwise setup of some modules may fail MainConsole.Instance = new MockConsole(); RegionInfo regInfo = new RegionInfo(x, y, new IPEndPoint(IPAddress.Loopback, 9000), "127.0.0.1"); regInfo.RegionName = name; regInfo.RegionID = id; regInfo.RegionSizeX = sizeX; regInfo.RegionSizeY = sizeY; SceneCommunicationService scs = new SceneCommunicationService(); PhysicsPluginManager physicsPluginManager = new PhysicsPluginManager(); physicsPluginManager.LoadPluginsFromAssembly("Physics/OpenSim.Region.Physics.BasicPhysicsPlugin.dll"); Vector3 regionExtent = new Vector3(regInfo.RegionSizeX, regInfo.RegionSizeY, regInfo.RegionSizeZ); PhysicsScene physicsScene = physicsPluginManager.GetPhysicsScene( "basicphysics", "ZeroMesher", new IniConfigSource(), "test", regionExtent); TestScene testScene = new TestScene( regInfo, m_acm, physicsScene, scs, SimDataService, m_estateDataService, configSource, null); INonSharedRegionModule godsModule = new GodsModule(); godsModule.Initialise(new IniConfigSource()); godsModule.AddRegion(testScene); // Add scene to services m_assetService.AddRegion(testScene); if (m_cache != null) { m_cache.AddRegion(testScene); m_cache.RegionLoaded(testScene); testScene.AddRegionModule(m_cache.Name, m_cache); } m_assetService.RegionLoaded(testScene); testScene.AddRegionModule(m_assetService.Name, m_assetService); m_authenticationService.AddRegion(testScene); m_authenticationService.RegionLoaded(testScene); testScene.AddRegionModule(m_authenticationService.Name, m_authenticationService); m_inventoryService.AddRegion(testScene); m_inventoryService.RegionLoaded(testScene); testScene.AddRegionModule(m_inventoryService.Name, m_inventoryService); m_gridService.AddRegion(testScene); m_gridService.RegionLoaded(testScene); testScene.AddRegionModule(m_gridService.Name, m_gridService); m_userAccountService.AddRegion(testScene); m_userAccountService.RegionLoaded(testScene); testScene.AddRegionModule(m_userAccountService.Name, m_userAccountService); m_presenceService.AddRegion(testScene); m_presenceService.RegionLoaded(testScene); testScene.AddRegionModule(m_presenceService.Name, m_presenceService); testScene.RegionInfo.EstateSettings.EstateOwner = UUID.Random(); testScene.SetModuleInterfaces(); testScene.LandChannel = new TestLandChannel(testScene); testScene.LoadWorldMap(); testScene.RegionInfo.EstateSettings = new EstateSettings(); testScene.LoginsEnabled = true; testScene.RegisterRegionWithGrid(); SceneManager.Add(testScene); return(testScene); }
/// <summary> /// Add a test object /// </summary> /// <param name="scene"></param> /// <returns></returns> public static SceneObjectGroup AddSceneObject(Scene scene) { return(AddSceneObject(scene, "Test Object", UUID.Random())); }
private void ReadNiniConfig(IConfigSource source, string name) { // bool creatingNew = false; if (source.Configs.Count == 0) { MainConsole.Instance.Output("=====================================\n"); MainConsole.Instance.Output("We are now going to ask a couple of questions about your region.\n"); MainConsole.Instance.Output("You can press 'enter' without typing anything to use the default\n"); MainConsole.Instance.Output("the default is displayed between [ ] brackets.\n"); MainConsole.Instance.Output("=====================================\n"); if (name == String.Empty) { while (name.Trim() == string.Empty) { name = MainConsole.Instance.CmdPrompt("New region name", name); if (name.Trim() == string.Empty) { MainConsole.Instance.Output("Cannot interactively create region with no name"); } } } source.AddConfig(name); // creatingNew = true; } if (name == String.Empty) { name = source.Configs[0].Name; } if (source.Configs[name] == null) { source.AddConfig(name); } RegionName = name; IConfig config = source.Configs[name]; // Track all of the keys in this config and remove as they are processed // The remaining keys will be added to generic key-value storage for // whoever might need it HashSet <String> allKeys = new HashSet <String>(); foreach (string s in config.GetKeys()) { allKeys.Add(s); } // RegionUUID // allKeys.Remove("RegionUUID"); string regionUUID = config.GetString("RegionUUID", string.Empty); if (!UUID.TryParse(regionUUID.Trim(), out RegionID)) { UUID newID = UUID.Random(); while (RegionID == UUID.Zero) { regionUUID = MainConsole.Instance.CmdPrompt("RegionUUID", newID.ToString()); if (!UUID.TryParse(regionUUID.Trim(), out RegionID)) { MainConsole.Instance.Output("RegionUUID must be a valid UUID"); } } config.Set("RegionUUID", regionUUID); } originRegionID = RegionID; // What IS this?! (Needed for RegionCombinerModule?) // Location // allKeys.Remove("Location"); string location = config.GetString("Location", String.Empty); if (location == String.Empty) { location = MainConsole.Instance.CmdPrompt("Region Location", "1000,1000"); config.Set("Location", location); } string[] locationElements = location.Split(new char[] { ',' }); m_regionLocX = Convert.ToUInt32(locationElements[0]); m_regionLocY = Convert.ToUInt32(locationElements[1]); // InternalAddress // IPAddress address; allKeys.Remove("InternalAddress"); if (config.Contains("InternalAddress")) { address = IPAddress.Parse(config.GetString("InternalAddress", String.Empty)); } else { address = IPAddress.Parse(MainConsole.Instance.CmdPrompt("Internal IP address", "0.0.0.0")); config.Set("InternalAddress", address.ToString()); } // InternalPort // int port; allKeys.Remove("InternalPort"); if (config.Contains("InternalPort")) { port = config.GetInt("InternalPort", 9000); } else { port = Convert.ToInt32(MainConsole.Instance.CmdPrompt("Internal port", "9000")); config.Set("InternalPort", port); } m_internalEndPoint = new IPEndPoint(address, port); // AllowAlternatePorts // allKeys.Remove("AllowAlternatePorts"); if (config.Contains("AllowAlternatePorts")) { m_allow_alternate_ports = config.GetBoolean("AllowAlternatePorts", true); } else { m_allow_alternate_ports = Convert.ToBoolean(MainConsole.Instance.CmdPrompt("Allow alternate ports", "False")); config.Set("AllowAlternatePorts", m_allow_alternate_ports.ToString()); } // ExternalHostName // allKeys.Remove("ExternalHostName"); string externalName; if (config.Contains("ExternalHostName")) { externalName = config.GetString("ExternalHostName", "SYSTEMIP"); } else { externalName = MainConsole.Instance.CmdPrompt("External host name", "SYSTEMIP"); config.Set("ExternalHostName", externalName); } if (externalName == "SYSTEMIP") { m_externalHostName = Util.GetLocalHost().ToString(); m_log.InfoFormat( "[REGIONINFO]: Resolving SYSTEMIP to {0} for external hostname of region {1}", m_externalHostName, name); } else { m_externalHostName = externalName; } // RegionType m_regionType = config.GetString("RegionType", String.Empty); allKeys.Remove("RegionType"); #region Prim and map stuff m_nonphysPrimMin = config.GetFloat("NonPhysicalPrimMin", 0); allKeys.Remove("NonPhysicalPrimMin"); m_nonphysPrimMax = config.GetInt("NonPhysicalPrimMax", 0); allKeys.Remove("NonPhysicalPrimMax"); m_physPrimMin = config.GetFloat("PhysicalPrimMin", 0); allKeys.Remove("PhysicalPrimMin"); m_physPrimMax = config.GetInt("PhysicalPrimMax", 0); allKeys.Remove("PhysicalPrimMax"); m_clampPrimSize = config.GetBoolean("ClampPrimSize", false); allKeys.Remove("ClampPrimSize"); m_objectCapacity = config.GetInt("MaxPrims", 15000); allKeys.Remove("MaxPrims"); m_linksetCapacity = config.GetInt("LinksetPrims", 0); allKeys.Remove("LinksetPrims"); allKeys.Remove("MaptileStaticUUID"); string mapTileStaticUUID = config.GetString("MaptileStaticUUID", UUID.Zero.ToString()); if (UUID.TryParse(mapTileStaticUUID.Trim(), out m_maptileStaticUUID)) { config.Set("MaptileStaticUUID", m_maptileStaticUUID.ToString()); } #endregion m_agentCapacity = config.GetInt("MaxAgents", 100); allKeys.Remove("MaxAgents"); // Multi-tenancy // ScopeID = new UUID(config.GetString("ScopeID", UUID.Zero.ToString())); allKeys.Remove("ScopeID"); foreach (String s in allKeys) { SetOtherSetting(s, config.GetString(s)); } }
public UUID StartHttpRequest(uint localID, UUID itemID, string url, List <string> parameters, Dictionary <string, string> headers, string body) { UUID reqID = UUID.Random(); HttpRequestClass htc = new HttpRequestClass(); // Partial implementation: support for parameter flags needed // see http://wiki.secondlife.com/wiki/LlHTTPRequest // // Parameters are expected in {key, value, ... , key, value} if (parameters != null) { string[] parms = parameters.ToArray(); for (int i = 0; i < parms.Length; i += 2) { switch (Int32.Parse(parms[i])) { case (int)HttpRequestConstants.HTTP_METHOD: htc.HttpMethod = parms[i + 1]; break; case (int)HttpRequestConstants.HTTP_MIMETYPE: htc.HttpMIMEType = parms[i + 1]; break; case (int)HttpRequestConstants.HTTP_BODY_MAXLENGTH: // TODO implement me break; case (int)HttpRequestConstants.HTTP_VERIFY_CERT: htc.HttpVerifyCert = (int.Parse(parms[i + 1]) != 0); break; case (int)HttpRequestConstants.HTTP_VERBOSE_THROTTLE: // TODO implement me break; case (int)HttpRequestConstants.HTTP_CUSTOM_HEADER: //Parameters are in pairs and custom header takes //arguments in pairs so adjust for header marker. ++i; //Maximum of 8 headers are allowed based on the //Second Life documentation for llHTTPRequest. for (int count = 1; count <= 8; ++count) { //Not enough parameters remaining for a header? if (parms.Length - i < 2) { break; } //Have we reached the end of the list of headers? //End is marked by a string with a single digit. //We already know we have at least one parameter //so it is safe to do this check at top of loop. if (Char.IsDigit(parms[i][0])) { break; } if (htc.HttpCustomHeaders == null) { htc.HttpCustomHeaders = new List <string>(); } htc.HttpCustomHeaders.Add(parms[i]); htc.HttpCustomHeaders.Add(parms[i + 1]); i += 2; } break; case (int)HttpRequestConstants.HTTP_PRAGMA_NO_CACHE: htc.HttpPragmaNoCache = (int.Parse(parms[i + 1]) != 0); break; } } } htc.LocalID = localID; htc.ItemID = itemID; htc.Url = url; htc.ReqID = reqID; htc.HttpTimeout = httpTimeout; htc.OutboundBody = body; htc.ResponseHeaders = headers; htc.proxyurl = m_proxyurl; htc.proxyexcepts = m_proxyexcepts; m_pendingRequests.Add(reqID, htc); htc.Process(); return(reqID); }
public virtual string RegisterRegion(GridRegion regionInfos, UUID oldSessionID, out UUID SessionID, out List <GridRegion> neighbors) { SessionID = UUID.Zero; neighbors = new List <GridRegion>(); if (m_DisableRegistrations) { return("Registrations are disabled."); } UUID NeedToDeletePreviousRegion = UUID.Zero; IConfig gridConfig = m_config.Configs["GridService"]; //Get the range of this so that we get the full count and make sure that we are not overlapping smaller regions List <GridRegion> regions = m_Database.Get(regionInfos.RegionLocX, regionInfos.RegionLocY, regionInfos.RegionLocX + regionInfos.RegionSizeX - 1, regionInfos.RegionLocY + regionInfos.RegionSizeY - 1, regionInfos.ScopeID); if (regions.Count > 1) { //More than one region is here... it is overlapping stuff MainConsole.Instance.WarnFormat( "[GRID SERVICE]: Region {0} tried to register in coordinates {1}, {2} which are already in use in scope {3}.", regionInfos.RegionID, regionInfos.RegionLocX, regionInfos.RegionLocY, regionInfos.ScopeID); return("Region overlaps another region"); } GridRegion region = regions.Count > 0 ? regions[0] : null; if (!m_AllowNewRegistrations && region == null) { MainConsole.Instance.WarnFormat("[GRID SERVICE]: Region {0} tried to register but registrations are disabled.", regionInfos.RegionName); return("Registrations are disabled."); } if (m_maxRegionSize != 0 && (regionInfos.RegionSizeX > m_maxRegionSize || regionInfos.RegionSizeY > m_maxRegionSize)) { //Too big... kick it out MainConsole.Instance.WarnFormat("[GRID SERVICE]: Region {0} tried to register with too large of a size {1},{2}.", regionInfos.RegionName, regionInfos.RegionSizeX, regionInfos.RegionSizeY); return("Region overlaps another region"); } if ((region != null) && (region.RegionID != regionInfos.RegionID)) { MainConsole.Instance.WarnFormat( "[GRID SERVICE]: Region {0} tried to register in coordinates {1}, {2} which are already in use in scope {3}.", regionInfos.RegionName, regionInfos.RegionLocX, regionInfos.RegionLocY, regionInfos.ScopeID); return("Region overlaps another region"); } if ((region != null) && (region.RegionID == regionInfos.RegionID) && ((region.RegionLocX != regionInfos.RegionLocX) || (region.RegionLocY != regionInfos.RegionLocY))) { if ((region.Flags & (int)RegionFlags.NoMove) != 0) { return("Can't move this region," + region.RegionLocX + "," + region.RegionLocY); } // Region reregistering in other coordinates. Delete the old entry MainConsole.Instance.DebugFormat( "[GRID SERVICE]: Region {0} ({1}) was previously registered at {2}-{3}. Deleting old entry.", regionInfos.RegionName, regionInfos.RegionID, regionInfos.RegionLocX, regionInfos.RegionLocY); NeedToDeletePreviousRegion = regionInfos.RegionID; } if (region != null) { // There is a preexisting record // // Get it's flags // RegionFlags rflags = (RegionFlags)region.Flags; // Is this a reservation? // if ((rflags & RegionFlags.Reservation) != 0) { // Regions reserved for the null key cannot be taken. if (region.SessionID == UUID.Zero) { return("Region location is reserved"); } // Treat it as an auth request // // NOTE: Fudging the flags value here, so these flags // should not be used elsewhere. Don't optimize // this with the later retrieval of the same flags! rflags |= RegionFlags.Authenticate; } if ((rflags & RegionFlags.Authenticate) != 0) { // Can we authenticate at all? // if (m_AuthenticationService == null) { return("No authentication possible"); } //Make sure the key exists if (!m_AuthenticationService.CheckExists(regionInfos.SessionID, "SessionID")) { return("Bad authentication"); } //Now verify the key if (!m_AuthenticationService.Verify(regionInfos.SessionID, "SessionID", regionInfos.AuthToken, 30)) { return("Bad authentication"); } } } if (!m_AllowDuplicateNames) { List <GridRegion> dupe = m_Database.Get(regionInfos.RegionName, regionInfos.ScopeID); if (dupe != null && dupe.Count > 0) { #if (!ISWIN) foreach (GridRegion d in dupe) { if (d.RegionID != regionInfos.RegionID) { MainConsole.Instance.WarnFormat("[GRID SERVICE]: Region {0} tried to register duplicate name with ID {1}.", regionInfos.RegionName, regionInfos.RegionID); return("Duplicate region name"); } } #else if (dupe.Any(d => d.RegionID != regionInfos.RegionID)) { MainConsole.Instance.WarnFormat("[GRID SERVICE]: Region {0} tried to register duplicate name with ID {1}.", regionInfos.RegionName, regionInfos.RegionID); return("Duplicate region name"); } #endif } } if (region != null) { //If we are locked out, we can't come in if ((region.Flags & (int)RegionFlags.LockedOut) != 0) { return("Region locked out"); } //Remove the reservation if we are there now region.Flags &= ~(int)RegionFlags.Reservation; regionInfos.Flags = region.Flags; // Preserve flags } else { //Regions do not get to set flags, so wipe them regionInfos.Flags = 0; //See if we are in the configs anywhere and have flags set if ((gridConfig != null) && regionInfos.RegionName != string.Empty) { int newFlags = 0; string regionName = regionInfos.RegionName.Trim().Replace(' ', '_'); newFlags = ParseFlags(newFlags, gridConfig.GetString("DefaultRegionFlags", String.Empty)); newFlags = ParseFlags(newFlags, gridConfig.GetString("Region_" + regionName, String.Empty)); newFlags = ParseFlags(newFlags, gridConfig.GetString("Region_" + regionInfos.RegionID.ToString(), String.Empty)); regionInfos.Flags = newFlags; } } //Set these so that we can make sure the region is online later regionInfos.Flags |= (int)RegionFlags.RegionOnline; regionInfos.Flags |= (int)RegionFlags.Safe; regionInfos.LastSeen = Util.UnixTimeSinceEpoch(); if (region != null) { //If we already have a session, we need to check it if (!VerifyRegionSessionID(region, oldSessionID)) { MainConsole.Instance.WarnFormat( "[GRID SERVICE]: Region {0} called register, but the sessionID they provided is wrong!", region.RegionName); return("Wrong Session ID"); } } //Update the sessionID, use the old so that we don't generate a bunch of these SessionID = oldSessionID == UUID.Zero ? UUID.Random() : oldSessionID; regionInfos.SessionID = SessionID; // Everything is ok, let's register try { if (NeedToDeletePreviousRegion != UUID.Zero) { m_Database.Delete(NeedToDeletePreviousRegion); } if (m_Database.Store(regionInfos)) { //Fire the event so that other modules notice m_simulationBase.EventManager.FireGenericEventHandler("RegionRegistered", regionInfos); //Get the neighbors for them neighbors = GetNeighbors(regionInfos); FixNeighbors(regionInfos, neighbors, false); MainConsole.Instance.DebugFormat("[GRID SERVICE]: Region {0} registered successfully at {1}-{2}", regionInfos.RegionName, regionInfos.RegionLocX, regionInfos.RegionLocY); return(String.Empty); } } catch (Exception e) { MainConsole.Instance.WarnFormat("[GRID SERVICE]: Database exception: {0}", e); } return("Failed to save region into the database."); }
/// <summary> /// Create an item using details for the given scene object. /// </summary> /// <param name="action"></param> /// <param name="remoteClient"></param> /// <param name="so"></param> /// <param name="folderID"></param> /// <returns></returns> protected InventoryItemBase CreateItemForObject( DeRezAction action, IClientAPI remoteClient, SceneObjectGroup so, UUID folderID) { // Get the user info of the item destination // UUID userID = UUID.Zero; if (action == DeRezAction.Take || action == DeRezAction.TakeCopy || action == DeRezAction.SaveToExistingUserInventoryItem) { // Take or take copy require a taker // Saving changes requires a local user // if (remoteClient == null) { return(null); } userID = remoteClient.AgentId; // m_log.DebugFormat( // "[INVENTORY ACCESS MODULE]: Target of {0} in CreateItemForObject() is {1} {2}", // action, remoteClient.Name, userID); } else if (so.RootPart.OwnerID == so.RootPart.GroupID) { // Group owned objects go to the last owner before the object was transferred. userID = so.RootPart.LastOwnerID; } else { // Other returns / deletes go to the object owner // userID = so.RootPart.OwnerID; // m_log.DebugFormat( // "[INVENTORY ACCESS MODULE]: Target of {0} in CreateItemForObject() is object owner {1}", // action, userID); } if (userID == UUID.Zero) // Can't proceed { return(null); } // If we're returning someone's item, it goes back to the // owner's Lost And Found folder. // Delete is treated like return in this case // Deleting your own items makes them go to trash // InventoryFolderBase folder = null; InventoryItemBase item = null; if (DeRezAction.SaveToExistingUserInventoryItem == action) { item = new InventoryItemBase(so.RootPart.FromUserInventoryItemID, userID); item = m_Scene.InventoryService.GetItem(item); //item = userInfo.RootFolder.FindItem( // objectGroup.RootPart.FromUserInventoryItemID); if (null == item) { m_log.DebugFormat( "[INVENTORY ACCESS MODULE]: Object {0} {1} scheduled for save to inventory has already been deleted.", so.Name, so.UUID); return(null); } } else { // Folder magic // if (action == DeRezAction.Delete) { // Deleting someone else's item // if (remoteClient == null || so.OwnerID != remoteClient.AgentId) { folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.LostAndFoundFolder); } else { folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.TrashFolder); } } else if (action == DeRezAction.Return) { // Dump to lost + found unconditionally // folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.LostAndFoundFolder); } if (folderID == UUID.Zero && folder == null) { if (action == DeRezAction.Delete) { // Deletes go to trash by default // folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.TrashFolder); } else { if (remoteClient == null || so.OwnerID != remoteClient.AgentId) { // Taking copy of another person's item. Take to // Objects folder. folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.Object); } else { // Catch all. Use lost & found // folder = m_Scene.InventoryService.GetFolderForType(userID, AssetType.LostAndFoundFolder); } } } // Override and put into where it came from, if it came // from anywhere in inventory and the owner is taking it back. // if (action == DeRezAction.Take || action == DeRezAction.TakeCopy) { if (so.FromFolderID != UUID.Zero && userID == remoteClient.AgentId) { InventoryFolderBase f = new InventoryFolderBase(so.FromFolderID, userID); folder = m_Scene.InventoryService.GetFolder(f); } } if (folder == null) // None of the above { folder = new InventoryFolderBase(folderID); if (folder == null) // Nowhere to put it { return(null); } } item = new InventoryItemBase(); item.ID = UUID.Random(); item.InvType = (int)InventoryType.Object; item.Folder = folder.ID; item.Owner = userID; } return(item); }
// End #region constructor public LandData() { _globalID = UUID.Random(); }
public virtual void HandleMapItemRequest(IClientAPI remoteClient, uint flags, uint EstateID, bool godlike, uint itemtype, ulong regionhandle) { //All the parts are in for this, except for popular places and those are not in as they are not reqested anymore. List <mapItemReply> mapitems = new List <mapItemReply>(); mapItemReply mapitem = new mapItemReply(); uint xstart = 0; uint ystart = 0; OpenMetaverse.Utils.LongToUInts(remoteClient.Scene.RegionInfo.RegionHandle, out xstart, out ystart); OpenSim.Services.Interfaces.GridRegion GR = m_Scenes[0].GridService.GetRegionByPosition(UUID.Zero, (int)xstart, (int)ystart); #region Telehub if (itemtype == (uint)OpenMetaverse.GridItemType.Telehub) { IRegionConnector GF = DataManager.DataManager.RequestPlugin <IRegionConnector>(); if (GF == null) { return; } int tc = Environment.TickCount; //Find the telehub Telehub telehub = GF.FindTelehub(GR.RegionID, GR.RegionHandle); if (telehub != null) { mapitem = new mapItemReply(); //The position is in GLOBAL coordinates (in meters) mapitem.x = (uint)(GR.RegionLocX + telehub.TelehubLocX); mapitem.y = (uint)(GR.RegionLocY + telehub.TelehubLocY); mapitem.id = GR.RegionID; //This is how the name is sent, go figure mapitem.name = Util.Md5Hash(GR.RegionName + tc.ToString()); //Not sure, but this is what gets sent mapitem.Extra = 1; mapitem.Extra2 = 0; mapitems.Add(mapitem); remoteClient.SendMapItemReply(mapitems.ToArray(), itemtype, flags); mapitems.Clear(); } } #endregion #region Land for sale //PG land that is for sale if (itemtype == (uint)OpenMetaverse.GridItemType.LandForSale) { if (directoryService == null) { return; } //Find all the land, use "0" for the flags so we get all land for sale, no price or area checking DirLandReplyData[] Landdata = directoryService.FindLandForSale("0", int.MaxValue.ToString(), "0", 0, 0); int locX = 0; int locY = 0; foreach (DirLandReplyData landDir in Landdata) { LandData landdata = directoryService.GetParcelInfo(landDir.parcelID); if (landdata.Maturity != 0) { continue; //Not a PG land } foreach (Scene scene in m_Scenes) { if (scene.RegionInfo.RegionID == landdata.RegionID) { //Global coords, so add the meters locX = scene.RegionInfo.RegionLocX; locY = scene.RegionInfo.RegionLocY; } } if (locY == 0 && locX == 0) { //Ask the grid service for the coordinates if the region is not local OpenSim.Services.Interfaces.GridRegion r = m_Scenes[0].GridService.GetRegionByUUID(UUID.Zero, landdata.RegionID); if (r != null) { locX = r.RegionLocX; locY = r.RegionLocY; } } if (locY == 0 && locX == 0) //Couldn't find the region, don't send { continue; } mapitem = new mapItemReply(); //Global coords, so make sure its in meters mapitem.x = (uint)(locX + landdata.UserLocation.X); mapitem.y = (uint)(locY + landdata.UserLocation.Y); mapitem.id = landDir.parcelID; mapitem.name = landDir.name; mapitem.Extra = landDir.actualArea; mapitem.Extra2 = landDir.salePrice; mapitems.Add(mapitem); } //Send all the map items if (mapitems.Count != 0) { remoteClient.SendMapItemReply(mapitems.ToArray(), itemtype, flags); mapitems.Clear(); } } //Adult or mature land that is for sale if (itemtype == (uint)OpenMetaverse.GridItemType.AdultLandForSale) { if (directoryService == null) { return; } //Find all the land, use "0" for the flags so we get all land for sale, no price or area checking DirLandReplyData[] Landdata = directoryService.FindLandForSale("0", int.MaxValue.ToString(), "0", 0, 0); int locX = 0; int locY = 0; foreach (DirLandReplyData landDir in Landdata) { LandData landdata = directoryService.GetParcelInfo(landDir.parcelID); if (landdata.Maturity == 0) { continue; //Its PG } foreach (Scene scene in m_Scenes) { if (scene.RegionInfo.RegionID == landdata.RegionID) { locX = scene.RegionInfo.RegionLocX; locY = scene.RegionInfo.RegionLocY; } } if (locY == 0 && locX == 0) { //Ask the grid service for the coordinates if the region is not local OpenSim.Services.Interfaces.GridRegion r = m_Scenes[0].GridService.GetRegionByUUID(UUID.Zero, landdata.RegionID); if (r != null) { locX = r.RegionLocX; locY = r.RegionLocY; } } if (locY == 0 && locX == 0) //Couldn't find the region, don't send { continue; } mapitem = new mapItemReply(); //Global coords, so make sure its in meters mapitem.x = (uint)(locX + landdata.UserLocation.X); mapitem.y = (uint)(locY + landdata.UserLocation.Y); mapitem.id = landDir.parcelID; mapitem.name = landDir.name; mapitem.Extra = landDir.actualArea; mapitem.Extra2 = landDir.salePrice; mapitems.Add(mapitem); } //Send the results if we have any if (mapitems.Count != 0) { remoteClient.SendMapItemReply(mapitems.ToArray(), itemtype, flags); mapitems.Clear(); } } #endregion #region Events if (itemtype == (uint)OpenMetaverse.GridItemType.PgEvent || itemtype == (uint)OpenMetaverse.GridItemType.MatureEvent || itemtype == (uint)OpenMetaverse.GridItemType.AdultEvent) { if (directoryService == null) { return; } //Find the maturity level int maturity = itemtype == (uint)OpenMetaverse.GridItemType.PgEvent ? (int)DirectoryManager.EventFlags.PG : (itemtype == (uint)GridItemType.MatureEvent) ? (int)DirectoryManager.EventFlags.Mature : (int)DirectoryManager.EventFlags.Adult; //Gets all the events occuring in the given region by maturity level DirEventsReplyData[] Eventdata = directoryService.FindAllEventsInRegion(GR.RegionName, maturity); foreach (DirEventsReplyData eventData in Eventdata) { //Get more info on the event EventData eventdata = directoryService.GetEventInfo(eventData.eventID.ToString()); Vector3 globalPos = eventdata.globalPos; mapitem = new mapItemReply(); //Use global position plus half the region so that it doesn't always appear in the bottom corner mapitem.x = (uint)(globalPos.X + (remoteClient.Scene.RegionInfo.RegionSizeX / 2)); mapitem.y = (uint)(globalPos.Y + (remoteClient.Scene.RegionInfo.RegionSizeY / 2)); mapitem.id = UUID.Random(); mapitem.name = eventData.name; mapitem.Extra = (int)eventdata.dateUTC; mapitem.Extra2 = (int)eventdata.eventID; mapitems.Add(mapitem); } //Send if we have any if (mapitems.Count != 0) { remoteClient.SendMapItemReply(mapitems.ToArray(), itemtype, flags); mapitems.Clear(); } } #endregion #region Classified if (itemtype == (uint)OpenMetaverse.GridItemType.Classified) { if (directoryService == null) { return; } //Get all the classifieds in this region Classified[] Classifieds = directoryService.GetClassifiedsInRegion(GR.RegionName); foreach (Classified classified in Classifieds) { //Get the region so we have its position OpenSim.Services.Interfaces.GridRegion region = m_Scenes[0].GridService.GetRegionByName(UUID.Zero, classified.SimName); mapitem = new mapItemReply(); //Use global position plus half the sim so that all classifieds are not in the bottom corner mapitem.x = (uint)(region.RegionLocX + classified.GlobalPos.X + (remoteClient.Scene.RegionInfo.RegionSizeX / 2)); mapitem.y = (uint)(region.RegionLocY + classified.GlobalPos.Y + (remoteClient.Scene.RegionInfo.RegionSizeY / 2)); mapitem.id = classified.CreatorUUID; mapitem.name = classified.Name; mapitem.Extra = 0; mapitem.Extra2 = 0; mapitems.Add(mapitem); } //Send the events, if we have any if (mapitems.Count != 0) { remoteClient.SendMapItemReply(mapitems.ToArray(), itemtype, flags); mapitems.Clear(); } } #endregion }
public static InventoryItemBase GetEmbeddedItem(byte[] data, UUID itemID) { if (data == null || data.Length < 300) { return(null); } string note = Util.UTF8.GetString(data); if (String.IsNullOrWhiteSpace(note)) { return(null); } // waste some time checking rigid versions string version = note.Substring(0, 21); if (!version.Equals("Linden text version 2")) { return(null); } version = note.Substring(24, 25); if (!version.Equals("LLEmbeddedItems version 1")) { return(null); } int indx = note.IndexOf(itemID.ToString(), 100); if (indx < 0) { return(null); } indx = note.IndexOf("permissions", indx, 100); // skip parentID if (indx < 0) { return(null); } string valuestr; indx = getField(note, indx, "base_mask", false, out valuestr); if (indx < 0) { return(null); } if (!uint.TryParse(valuestr, NumberStyles.HexNumber, Culture.NumberFormatInfo, out uint basemask)) { return(null); } indx = getField(note, indx, "owner_mask", false, out valuestr); if (indx < 0) { return(null); } if (!uint.TryParse(valuestr, NumberStyles.HexNumber, Culture.NumberFormatInfo, out uint ownermask)) { return(null); } indx = getField(note, indx, "group_mask", false, out valuestr); if (indx < 0) { return(null); } if (!uint.TryParse(valuestr, NumberStyles.HexNumber, Culture.NumberFormatInfo, out uint groupmask)) { return(null); } indx = getField(note, indx, "everyone_mask", false, out valuestr); if (indx < 0) { return(null); } if (!uint.TryParse(valuestr, NumberStyles.HexNumber, Culture.NumberFormatInfo, out uint everyonemask)) { return(null); } indx = getField(note, indx, "next_owner_mask", false, out valuestr); if (indx < 0) { return(null); } if (!uint.TryParse(valuestr, NumberStyles.HexNumber, Culture.NumberFormatInfo, out uint nextownermask)) { return(null); } indx = getField(note, indx, "creator_id", false, out valuestr); if (indx < 0) { return(null); } if (!UUID.TryParse(valuestr, out UUID creatorID)) { return(null); } indx = getField(note, indx, "owner_id", false, out valuestr); if (indx < 0) { return(null); } if (!UUID.TryParse(valuestr, out UUID ownerID)) { return(null); } int limit = note.Length - indx; if (limit > 120) { limit = 120; } indx = note.IndexOf('}', indx, limit); // last owner if (indx < 0) { return(null); } int curindx = indx; UUID assetID = UUID.Zero; indx = getField(note, indx, "asset_id", false, out valuestr); if (indx < 0) { indx = getField(note, curindx, "shadow_id", false, out valuestr); if (indx < 0) { return(null); } if (!UUID.TryParse(valuestr, out assetID)) { return(null); } assetID = deMoronize(assetID); } else { if (!UUID.TryParse(valuestr, out assetID)) { return(null); } } indx = getField(note, indx, "type", false, out valuestr); if (indx < 0) { return(null); } AssetType assetType = SLAssetName2Type(valuestr); indx = getField(note, indx, "inv_type", false, out valuestr); if (indx < 0) { return(null); } FolderType invType = SLInvName2Type(valuestr); indx = getField(note, indx, "flags", false, out valuestr); if (indx < 0) { return(null); } if (!uint.TryParse(valuestr, NumberStyles.HexNumber, Culture.NumberFormatInfo, out uint flags)) { return(null); } limit = note.Length - indx; if (limit > 120) { limit = 120; } indx = note.IndexOf('}', indx, limit); // skip sale if (indx < 0) { return(null); } indx = getField(note, indx, "name", true, out valuestr); if (indx < 0) { return(null); } string name = valuestr; indx = getField(note, indx, "desc", true, out valuestr); if (indx < 0) { return(null); } string desc = valuestr; InventoryItemBase item = new InventoryItemBase(); item.AssetID = assetID; item.AssetType = (sbyte)assetType; item.BasePermissions = basemask; item.CreationDate = Util.UnixTimeSinceEpoch(); item.CreatorData = ""; item.CreatorId = creatorID.ToString(); item.CurrentPermissions = ownermask; item.Description = desc; item.Flags = flags; item.Folder = UUID.Zero; item.GroupID = UUID.Zero; item.GroupOwned = false; item.GroupPermissions = groupmask; item.InvType = (sbyte)invType; item.Name = name; item.NextPermissions = nextownermask; item.Owner = ownerID; item.SalePrice = 0; item.SaleType = (byte)SaleType.Not; item.ID = UUID.Random(); return(item); }
public void OnFileRequested(HttpRequest request, IDirectory directory) { //request.Response.SetHeader("Content-Type", "text/plain; charset=utf-8"); request.Response.ResponseContent = new MemoryStream(); StreamWriter textwriter = new StreamWriter(request.Response.ResponseContent); GridClient client; AvatarTracker avatars; Events events; StreamReader reader = new StreamReader(request.PostData); string qstring = reader.ReadToEnd(); reader.Dispose(); Dictionary <string, string> POST = AjaxLife.PostDecode(qstring); // Pull out the session. if (!POST.ContainsKey("sid")) { textwriter.WriteLine("Need an SID."); textwriter.Flush(); return; } Guid guid = new Guid(POST["sid"]); User user = new User(); lock (this.users) { if (!this.users.ContainsKey(guid)) { textwriter.WriteLine("Error: invalid SID"); textwriter.Flush(); return; } user = this.users[guid]; client = user.Client; avatars = user.Avatars; events = user.Events; user.LastRequest = DateTime.Now; } // Get the message type. string messagetype = POST["MessageType"]; // Check that the message is signed if it should be. if (Array.IndexOf(REQUIRED_SIGNATURES, messagetype) > -1) { if (!VerifySignature(user, qstring)) { textwriter.WriteLine("Error: Received hash and expected hash do not match."); textwriter.Flush(); return; } } // Right. This file is fun. It takes information in POST paramaters and sends them to // the server in the appropriate format. Some will return data immediately, some will return // keys to data that will arrive in the message queue, some return nothing but you get // something in the message queue later, and some return nother ever. // // The joys of dealing with multiple bizarre message types. switch (messagetype) { case "SpatialChat": client.Self.Chat(POST["Message"], int.Parse(POST["Channel"]), (ChatType)((byte)int.Parse(POST["Type"]))); break; case "SimpleInstantMessage": if (POST.ContainsKey("IMSessionID")) { client.Self.InstantMessage(new UUID(POST["Target"]), POST["Message"], new UUID(POST["IMSessionID"])); } else { client.Self.InstantMessage(new UUID(POST["Target"]), POST["Message"]); } break; case "GenericInstantMessage": client.Self.InstantMessage( client.Self.FirstName + " " + client.Self.LastName, new UUID(POST["Target"]), POST["Message"], new UUID(POST["IMSessionID"]), (InstantMessageDialog)((byte)int.Parse(POST["Dialog"])), (InstantMessageOnline)int.Parse(POST["Online"]), client.Self.SimPosition, client.Network.CurrentSim.ID, new byte[0]); break; case "NameLookup": client.Avatars.RequestAvatarName(new UUID(POST["ID"])); break; case "Teleport": { Hashtable hash = new Hashtable(); bool status; if (POST.ContainsKey("Landmark")) { status = client.Self.Teleport(new UUID(POST["Landmark"])); } else { status = client.Self.Teleport(POST["Sim"], new Vector3(float.Parse(POST["X"]), float.Parse(POST["Y"]), float.Parse(POST["Z"]))); } if (status) { hash.Add("Success", true); hash.Add("Sim", client.Network.CurrentSim.Name); hash.Add("Position", client.Self.SimPosition); } else { hash.Add("Success", false); hash.Add("Reason", client.Self.TeleportMessage); } textwriter.WriteLine(MakeJson.FromHashtable(hash)); } break; case "GoHome": client.Self.GoHome(); break; case "GetPosition": { Hashtable hash = new Hashtable(); hash.Add("Sim", client.Network.CurrentSim.Name); hash.Add("Position", client.Self.SimPosition); textwriter.WriteLine(JavaScriptConvert.SerializeObject(hash)); } break; case "RequestBalance": client.Self.RequestBalance(); break; case "GetStats": { Hashtable hash = new Hashtable(); hash.Add("FPS", client.Network.CurrentSim.Stats.FPS); hash.Add("TimeDilation", client.Network.CurrentSim.Stats.Dilation); hash.Add("Objects", client.Network.CurrentSim.Stats.Objects); hash.Add("ActiveScripts", client.Network.CurrentSim.Stats.ActiveScripts); hash.Add("Agents", client.Network.CurrentSim.Stats.Agents); hash.Add("ChildAgents", client.Network.CurrentSim.Stats.ChildAgents); hash.Add("AjaxLifeSessions", users.Count); hash.Add("PingSim", client.Network.CurrentSim.Stats.LastLag); hash.Add("IncomingBPS", client.Network.CurrentSim.Stats.IncomingBPS); hash.Add("OutgoingBPS", client.Network.CurrentSim.Stats.OutgoingBPS); hash.Add("DroppedPackets", client.Network.CurrentSim.Stats.ReceivedResends + client.Network.CurrentSim.Stats.ResentPackets); textwriter.WriteLine(MakeJson.FromHashtable(hash)); } break; case "TeleportLureRespond": client.Self.TeleportLureRespond(new UUID(POST["RequesterID"]), new UUID(POST["SessionID"]), bool.Parse(POST["Accept"])); break; case "GodlikeTeleportLureRespond": { UUID lurer = new UUID(POST["RequesterID"]); UUID session = new UUID(POST["SessionID"]); client.Self.InstantMessage(client.Self.Name, lurer, "", UUID.Random(), InstantMessageDialog.AcceptTeleport, InstantMessageOnline.Offline, client.Self.SimPosition, UUID.Zero, new byte[0]); TeleportLureRequestPacket lure = new TeleportLureRequestPacket(); lure.Info.AgentID = client.Self.AgentID; lure.Info.SessionID = client.Self.SessionID; lure.Info.LureID = session; lure.Info.TeleportFlags = (uint)TeleportFlags.ViaGodlikeLure; client.Network.SendPacket(lure); } break; case "FindPeople": { Hashtable hash = new Hashtable(); hash.Add("QueryID", client.Directory.StartPeopleSearch(POST["Search"], int.Parse(POST["Start"]))); textwriter.WriteLine(MakeJson.FromHashtable(hash)); } break; case "FindGroups": { Hashtable hash = new Hashtable(); hash.Add("QueryID", client.Directory.StartGroupSearch(POST["Search"], int.Parse(POST["Start"]))); textwriter.WriteLine(MakeJson.FromHashtable(hash)); } break; case "GetAgentData": client.Avatars.RequestAvatarProperties(new UUID(POST["AgentID"])); break; case "StartAnimation": client.Self.AnimationStart(new UUID(POST["Animation"]), false); break; case "StopAnimation": client.Self.AnimationStop(new UUID(POST["Animation"]), true); break; case "SendAppearance": client.Appearance.RequestSetAppearance(); break; case "GetMapItems": { MapItemRequestPacket req = new MapItemRequestPacket(); req.AgentData.AgentID = client.Self.AgentID; req.AgentData.SessionID = client.Self.SessionID; GridRegion region; client.Grid.GetGridRegion(POST["Region"], GridLayerType.Objects, out region); req.RequestData.RegionHandle = region.RegionHandle; req.RequestData.ItemType = uint.Parse(POST["ItemType"]); client.Network.SendPacket((Packet)req); } break; case "GetMapBlocks": { MapBlockRequestPacket req = new MapBlockRequestPacket(); req.AgentData.AgentID = client.Self.AgentID; req.AgentData.SessionID = client.Self.SessionID; req.PositionData.MinX = ushort.Parse(POST["MinX"]); req.PositionData.MinY = ushort.Parse(POST["MinY"]); req.PositionData.MaxX = ushort.Parse(POST["MaxX"]); req.PositionData.MaxY = ushort.Parse(POST["MaxY"]); client.Network.SendPacket((Packet)req); } break; case "FindRegion": { OpenMetaverse.Packets.MapNameRequestPacket packet = new OpenMetaverse.Packets.MapNameRequestPacket(); packet.NameData = new MapNameRequestPacket.NameDataBlock(); packet.NameData.Name = Utils.StringToBytes(POST["Name"]); packet.AgentData.AgentID = client.Self.AgentID; packet.AgentData.SessionID = client.Self.SessionID; client.Network.SendPacket((Packet)packet); } break; case "GetOfflineMessages": { RetrieveInstantMessagesPacket req = new RetrieveInstantMessagesPacket(); req.AgentData.AgentID = client.Self.AgentID; req.AgentData.SessionID = client.Self.SessionID; client.Network.SendPacket((Packet)req); } break; case "GetFriendList": { InternalDictionary <UUID, FriendInfo> friends = client.Friends.FriendList; List <Hashtable> friendlist = new List <Hashtable>(); friends.ForEach(delegate(FriendInfo friend) { Hashtable friendhash = new Hashtable(); friendhash.Add("ID", friend.UUID.ToString()); friendhash.Add("Name", friend.Name); friendhash.Add("Online", friend.IsOnline); friendhash.Add("MyRights", friend.MyFriendRights); friendhash.Add("TheirRights", friend.TheirFriendRights); friendlist.Add(friendhash); }); textwriter.Write(MakeJson.FromObject(friendlist)); } break; case "ChangeRights": { UUID uuid = new UUID(POST["Friend"]); client.Friends.GrantRights(uuid, (FriendRights)int.Parse(POST["Rights"])); } break; case "RequestLocation": client.Friends.MapFriend(new UUID(POST["Friend"])); break; case "RequestTexture": { // This one's confusing, so it gets some comments. // First, we get the image's UUID. UUID image = new UUID(POST["ID"]); // We prepare a query to ask if S3 has it. HEAD only to avoid wasting // GET requests and bandwidth. bool exists = false; // If we already know we have it, note this. if (AjaxLife.CachedTextures.Contains(image)) { exists = true; } else { // If we're using S3, check the S3 bucket if (AjaxLife.USE_S3) { // Otherwise, make that HEAD request and find out. HttpWebRequest webrequest = (HttpWebRequest)HttpWebRequest.Create(AjaxLife.TEXTURE_ROOT + image + ".png"); webrequest.Method = "HEAD"; webrequest.KeepAlive = false; webrequest.ReadWriteTimeout = 1000; webrequest.Timeout = 2500; HttpWebResponse response = null; try { response = (HttpWebResponse)webrequest.GetResponse(); if (response.StatusCode == HttpStatusCode.OK) { exists = true; } } catch (WebException e) { AjaxLife.Debug("SendMessage", "WebException (" + e.Status.ToString() + "): " + e.Message); } finally { request.Dispose(); if (response != null) { response.Close(); } } } // If we aren't using S3, just check the texture cache. else { exists = File.Exists(AjaxLife.TEXTURE_CACHE + image.ToString() + ".png"); } } // If it exists, reply with Ready = true and the URL to find it at. if (exists) { textwriter.Write("{Ready: true, URL: \"" + AjaxLife.TEXTURE_ROOT + image + ".png\"}"); } // If it doesn't, request the image from SL and note its lack of readiness. // Notification will arrive later in the message queue. else { client.Assets.RequestImage(image, new TextureDownloadCallback(events.Assets_TextureDownloadCallback)); textwriter.Write("{Ready: false}"); } } break; case "AcceptFriendship": client.Friends.AcceptFriendship(client.Self.AgentID, new UUID(POST["IMSessionID"])); break; case "DeclineFriendship": client.Friends.DeclineFriendship(client.Self.AgentID, new UUID(POST["IMSessionID"])); break; case "OfferFriendship": client.Friends.OfferFriendship(new UUID(POST["Target"])); break; case "TerminateFriendship": client.Friends.TerminateFriendship(new UUID(POST["Target"])); break; case "SendAgentMoney": client.Self.GiveAvatarMoney(new UUID(POST["Target"]), int.Parse(POST["Amount"])); break; case "RequestAvatarList": { List <Hashtable> list = new List <Hashtable>(); foreach (KeyValuePair <uint, Avatar> pair in avatars.Avatars) { Avatar avatar = pair.Value; Hashtable hash = new Hashtable(); hash.Add("Name", avatar.Name); hash.Add("ID", avatar.ID); hash.Add("LocalID", avatar.LocalID); hash.Add("Position", avatar.Position); //hash.Add("Rotation", avatar.Rotation); hash.Add("Scale", avatar.Scale); hash.Add("GroupName", avatar.GroupName); list.Add(hash); } textwriter.Write(MakeJson.FromObject(list)); } break; case "LoadInventoryFolder": client.Inventory.RequestFolderContents(new UUID(POST["UUID"]), client.Self.AgentID, true, true, InventorySortOrder.ByDate | InventorySortOrder.SystemFoldersToTop); break; case "RequestAsset": { try { UUID inventoryID = new UUID(POST["InventoryID"]); client.Assets.RequestInventoryAsset(new UUID(POST["AssetID"]), inventoryID, UUID.Zero, new UUID(POST["OwnerID"]), (AssetType)int.Parse(POST["AssetType"]), false, delegate(AssetDownload transfer, OpenMetaverse.Assets.Asset asset) { events.Assets_OnAssetReceived(transfer, asset, inventoryID); } ); } catch // Try catching the error that sometimes gets thrown... but sometimes doesn't. { } } break; case "SendTeleportLure": client.Self.SendTeleportLure(new UUID(POST["Target"]), POST["Message"]); break; case "ScriptPermissionResponse": client.Self.ScriptQuestionReply(client.Network.CurrentSim, new UUID(POST["ItemID"]), new UUID(POST["TaskID"]), (ScriptPermission)int.Parse(POST["Permissions"])); break; case "ScriptDialogReply": { ScriptDialogReplyPacket packet = new ScriptDialogReplyPacket(); packet.AgentData.AgentID = client.Self.AgentID; packet.AgentData.SessionID = client.Self.SessionID; packet.Data.ButtonIndex = int.Parse(POST["ButtonIndex"]); packet.Data.ButtonLabel = Utils.StringToBytes(POST["ButtonLabel"]); packet.Data.ChatChannel = int.Parse(POST["ChatChannel"]); packet.Data.ObjectID = new UUID(POST["ObjectID"]); client.Network.SendPacket((Packet)packet); } break; case "SaveNotecard": client.Inventory.RequestUploadNotecardAsset(Utils.StringToBytes(POST["AssetData"]), new UUID(POST["ItemID"]), new InventoryManager.InventoryUploadedAssetCallback(events.Inventory_OnNoteUploaded)); break; case "CreateInventory": client.Inventory.RequestCreateItem(new UUID(POST["Folder"]), POST["Name"], POST["Description"], (AssetType)int.Parse(POST["AssetType"]), UUID.Random(), (InventoryType)int.Parse(POST["InventoryType"]), PermissionMask.All, new InventoryManager.ItemCreatedCallback(events.Inventory_OnItemCreated)); break; case "CreateFolder": { UUID folder = client.Inventory.CreateFolder(new UUID(POST["Parent"]), POST["Name"]); textwriter.Write("{FolderID: \"" + folder + "\"}"); } break; case "EmptyTrash": client.Inventory.EmptyTrash(); break; case "MoveItem": client.Inventory.MoveItem(new UUID(POST["Item"]), new UUID(POST["TargetFolder"]), POST["NewName"]); break; case "MoveFolder": client.Inventory.MoveFolder(new UUID(POST["Folder"]), new UUID(POST["NewParent"])); break; case "MoveItems": case "MoveFolders": { Dictionary <UUID, UUID> dict = new Dictionary <UUID, UUID>(); string[] moves = POST["ToMove"].Split(','); for (int i = 0; i < moves.Length; ++i) { string[] move = moves[i].Split(' '); dict.Add(new UUID(move[0]), new UUID(move[1])); } if (messagetype == "MoveItems") { client.Inventory.MoveItems(dict); } else if (messagetype == "MoveFolders") { client.Inventory.MoveFolders(dict); } } break; case "DeleteItem": client.Inventory.RemoveItem(new UUID(POST["Item"])); break; case "DeleteFolder": client.Inventory.RemoveFolder(new UUID(POST["Folder"])); break; case "DeleteMultiple": { string[] items = POST["Items"].Split(','); List <UUID> itemlist = new List <UUID>(); for (int i = 0; i < items.Length; ++i) { itemlist.Add(new UUID(items[i])); } string[] folders = POST["Folders"].Split(','); List <UUID> folderlist = new List <UUID>(); for (int i = 0; i < items.Length; ++i) { folderlist.Add(new UUID(folders[i])); } client.Inventory.Remove(itemlist, folderlist); } break; case "GiveInventory": { client.Inventory.GiveItem(new UUID(POST["ItemID"]), POST["ItemName"], (AssetType)int.Parse(POST["AssetType"]), new UUID(POST["Recipient"]), true); } break; case "UpdateItem": { InventoryItem item = client.Inventory.FetchItem(new UUID(POST["ItemID"]), new UUID(POST["OwnerID"]), 1000); if (POST.ContainsKey("Name")) { item.Name = POST["Name"]; } if (POST.ContainsKey("Description")) { item.Description = POST["Description"]; } if (POST.ContainsKey("NextOwnerMask")) { item.Permissions.NextOwnerMask = (PermissionMask)uint.Parse(POST["NextOwnerMask"]); } if (POST.ContainsKey("SalePrice")) { item.SalePrice = int.Parse(POST["SalePrice"]); } if (POST.ContainsKey("SaleType")) { item.SaleType = (SaleType)int.Parse(POST["SaleType"]); // This should be byte.Parse, but this upsets mono's compiler (CS1002) } client.Inventory.RequestUpdateItem(item); } break; case "UpdateFolder": { UpdateInventoryFolderPacket packet = new UpdateInventoryFolderPacket(); packet.AgentData.AgentID = client.Self.AgentID; packet.AgentData.SessionID = client.Self.SessionID; packet.FolderData = new UpdateInventoryFolderPacket.FolderDataBlock[1]; packet.FolderData[0] = new UpdateInventoryFolderPacket.FolderDataBlock(); packet.FolderData[0].FolderID = new UUID(POST["FolderID"]); packet.FolderData[0].ParentID = new UUID(POST["ParentID"]); packet.FolderData[0].Type = sbyte.Parse(POST["Type"]); packet.FolderData[0].Name = Utils.StringToBytes(POST["Name"]); client.Network.SendPacket((Packet)packet); } break; case "FetchItem": client.Inventory.FetchItem(new UUID(POST["Item"]), new UUID(POST["Owner"]), 5000); break; case "ReRotate": user.Rotation = -Math.PI; break; case "StartGroupIM": AjaxLife.Debug("SendMessage", "RequestJoinGroupChat(" + POST["Group"] + ")"); client.Self.RequestJoinGroupChat(new UUID(POST["Group"])); break; case "GroupInstantMessage": client.Self.InstantMessageGroup(new UUID(POST["Group"]), POST["Message"]); break; case "RequestGroupProfile": client.Groups.RequestGroupProfile(new UUID(POST["Group"])); break; case "RequestGroupMembers": client.Groups.RequestGroupMembers(new UUID(POST["Group"])); break; case "RequestGroupName": client.Groups.RequestGroupName(new UUID(POST["ID"])); break; case "JoinGroup": client.Groups.RequestJoinGroup(new UUID(POST["Group"])); break; case "LeaveGroup": client.Groups.LeaveGroup(new UUID(POST["Group"])); break; case "RequestCurrentGroups": client.Groups.RequestCurrentGroups(); break; case "GetParcelID": textwriter.Write("{\"LocalID\": " + client.Parcels.GetParcelLocalID(client.Network.CurrentSim, new Vector3(float.Parse(POST["X"]), float.Parse(POST["Y"]), float.Parse(POST["Z"]))) + "}"); break; case "RequestParcelProperties": client.Parcels.RequestParcelProperties(client.Network.CurrentSim, int.Parse(POST["LocalID"]), int.Parse(POST["SequenceID"])); break; } textwriter.Flush(); }
protected override void StoreFriendships(UUID agentID, UUID friendID) { Boolean agentIsLocal = true; Boolean friendIsLocal = true; if (UserManagementModule != null) { agentIsLocal = UserManagementModule.IsLocalGridUser(agentID); friendIsLocal = UserManagementModule.IsLocalGridUser(friendID); } // Are they both local users? if (agentIsLocal && friendIsLocal) { // local grid users m_log.DebugFormat("[HGFRIENDS MODULE]: Users are both local"); DeletePreviousHGRelations(agentID, friendID); base.StoreFriendships(agentID, friendID); return; } // ok, at least one of them is foreigner, let's get their data IClientAPI agentClient = LocateClientObject(agentID); IClientAPI friendClient = LocateClientObject(friendID); AgentCircuitData agentClientCircuit = null; AgentCircuitData friendClientCircuit = null; string agentUUI = string.Empty; string friendUUI = string.Empty; string agentFriendService = string.Empty; string friendFriendService = string.Empty; if (agentClient != null) { agentClientCircuit = ((Scene)(agentClient.Scene)).AuthenticateHandler.GetAgentCircuitData(agentClient.CircuitCode); agentUUI = Util.ProduceUserUniversalIdentifier(agentClientCircuit); agentFriendService = agentClientCircuit.ServiceURLs["FriendsServerURI"].ToString(); RecacheFriends(agentClient); } if (friendClient != null) { friendClientCircuit = ((Scene)(friendClient.Scene)).AuthenticateHandler.GetAgentCircuitData(friendClient.CircuitCode); friendUUI = Util.ProduceUserUniversalIdentifier(friendClientCircuit); friendFriendService = friendClientCircuit.ServiceURLs["FriendsServerURI"].ToString(); RecacheFriends(friendClient); } m_log.DebugFormat("[HGFRIENDS MODULE] HG Friendship! thisUUI={0}; friendUUI={1}; foreignThisFriendService={2}; foreignFriendFriendService={3}", agentUUI, friendUUI, agentFriendService, friendFriendService); // Generate a random 8-character hex number that will sign this friendship string secret = UUID.Random().ToString().Substring(0, 8); string theFriendUUID = friendUUI + ";" + secret; string agentUUID = agentUUI + ";" + secret; if (agentIsLocal) // agent is local, 'friend' is foreigner { // This may happen when the agent returned home, in which case the friend is not there // We need to look for its information in the friends list itself FriendInfo[] finfos = null; bool confirming = false; if (friendUUI == string.Empty) { finfos = GetFriendsFromCache(agentID); foreach (FriendInfo finfo in finfos) { if (finfo.TheirFlags == -1) { if (finfo.Friend.StartsWith(friendID.ToString())) { friendUUI = finfo.Friend; theFriendUUID = friendUUI; UUID utmp = UUID.Zero; string url = String.Empty; string first = String.Empty; string last = String.Empty; // If it's confirming the friendship, we already have the full UUI with the secret if (Util.ParseUniversalUserIdentifier(theFriendUUID, out utmp, out url, out first, out last, out secret)) { agentUUID = agentUUI + ";" + secret; m_uMan.AddUser(utmp, first, last, url); } confirming = true; break; } } } if (!confirming) { friendUUI = m_uMan.GetUserUUI(friendID); theFriendUUID = friendUUI + ";" + secret; } friendFriendService = m_uMan.GetUserServerURL(friendID, "FriendsServerURI"); // m_log.DebugFormat("[HGFRIENDS MODULE] HG Friendship! thisUUI={0}; friendUUI={1}; foreignThisFriendService={2}; foreignFriendFriendService={3}", // agentUUI, friendUUI, agentFriendService, friendFriendService); } // Delete any previous friendship relations DeletePreviousRelations(agentID, friendID); // store in the local friends service a reference to the foreign friend FriendsService.StoreFriend(agentID.ToString(), theFriendUUID, 1); // and also the converse FriendsService.StoreFriend(theFriendUUID, agentID.ToString(), 1); //if (!confirming) //{ // store in the foreign friends service a reference to the local agent HGFriendsServicesConnector friendsConn = null; if (friendClientCircuit != null) // the friend is here, validate session { friendsConn = new HGFriendsServicesConnector(friendFriendService, friendClientCircuit.SessionID, friendClientCircuit.ServiceSessionID); } else // the friend is not here, he initiated the request in his home world { friendsConn = new HGFriendsServicesConnector(friendFriendService); } friendsConn.NewFriendship(friendID, agentUUID); //} } else if (friendIsLocal) // 'friend' is local, agent is foreigner { // Delete any previous friendship relations DeletePreviousRelations(agentID, friendID); // store in the local friends service a reference to the foreign agent FriendsService.StoreFriend(friendID.ToString(), agentUUI + ";" + secret, 1); // and also the converse FriendsService.StoreFriend(agentUUI + ";" + secret, friendID.ToString(), 1); if (agentClientCircuit != null) { // store in the foreign friends service a reference to the local agent HGFriendsServicesConnector friendsConn = new HGFriendsServicesConnector(agentFriendService, agentClientCircuit.SessionID, agentClientCircuit.ServiceSessionID); friendsConn.NewFriendship(agentID, friendUUI + ";" + secret); } } else // They're both foreigners! { HGFriendsServicesConnector friendsConn; if (agentClientCircuit != null) { friendsConn = new HGFriendsServicesConnector(agentFriendService, agentClientCircuit.SessionID, agentClientCircuit.ServiceSessionID); friendsConn.NewFriendship(agentID, friendUUI + ";" + secret); } if (friendClientCircuit != null) { friendsConn = new HGFriendsServicesConnector(friendFriendService, friendClientCircuit.SessionID, friendClientCircuit.ServiceSessionID); friendsConn.NewFriendship(friendID, agentUUI + ";" + secret); } } // my brain hurts now }
public LoginResponse Login(string firstName, string lastName, string passwd, string startLocation, UUID scopeID, string clientVersion, string channel, string mac, string id0, IPEndPoint clientIP) { bool success = false; UUID session = UUID.Random(); m_log.InfoFormat("[LLOGIN SERVICE]: Login request for {0} {1} at {2} using viewer {3}, channel {4}, IP {5}, Mac {6}, Id0 {7}", firstName, lastName, startLocation, clientVersion, channel, clientIP.Address.ToString(), mac, id0); try { // // Check client // if (m_AllowedClients != string.Empty) { Regex arx = new Regex(m_AllowedClients); Match am = arx.Match(clientVersion); if (!am.Success) { m_log.InfoFormat( "[LLOGIN SERVICE]: Login failed for {0} {1}, reason: client {2} is not allowed", firstName, lastName, clientVersion); return(LLFailedLoginResponse.LoginBlockedProblem); } } if (m_DeniedClients != string.Empty) { Regex drx = new Regex(m_DeniedClients); Match dm = drx.Match(clientVersion); if (dm.Success) { m_log.InfoFormat( "[LLOGIN SERVICE]: Login failed for {0} {1}, reason: client {2} is denied", firstName, lastName, clientVersion); return(LLFailedLoginResponse.LoginBlockedProblem); } } // // Get the account and check that it exists // UserAccount account = m_UserAccountService.GetUserAccount(scopeID, firstName, lastName); if (account == null) { m_log.InfoFormat( "[LLOGIN SERVICE]: Login failed for {0} {1}, reason: user not found", firstName, lastName); return(LLFailedLoginResponse.UserProblem); } if (account.UserLevel < m_MinLoginLevel) { m_log.InfoFormat( "[LLOGIN SERVICE]: Login failed for {0} {1}, reason: user level is {2} but minimum login level is {3}", firstName, lastName, account.UserLevel, m_MinLoginLevel); return(LLFailedLoginResponse.LoginBlockedProblem); } // If a scope id is requested, check that the account is in // that scope, or unscoped. // if (scopeID != UUID.Zero) { if (account.ScopeID != scopeID && account.ScopeID != UUID.Zero) { m_log.InfoFormat( "[LLOGIN SERVICE]: Login failed, reason: user {0} {1} not found", firstName, lastName); return(LLFailedLoginResponse.UserProblem); } } else { scopeID = account.ScopeID; } // // Authenticate this user // if (!passwd.StartsWith("$1$")) { passwd = "$1$" + Util.Md5Hash(passwd); } passwd = passwd.Remove(0, 3); //remove $1$ string token = m_AuthenticationService.Authenticate(account.PrincipalID, passwd, 30); UUID secureSession = UUID.Zero; if ((token == string.Empty) || (token != string.Empty && !UUID.TryParse(token, out secureSession))) { m_log.InfoFormat( "[LLOGIN SERVICE]: Login failed for {0} {1}, reason: authentication failed", firstName, lastName); return(LLFailedLoginResponse.UserProblem); } // // Get the user's inventory // if (m_RequireInventory && m_InventoryService == null) { m_log.WarnFormat( "[LLOGIN SERVICE]: Login failed for {0} {1}, reason: inventory service not set up", firstName, lastName); return(LLFailedLoginResponse.InventoryProblem); } if (m_HGInventoryService != null) { // Give the Suitcase service a chance to create the suitcase folder. // (If we're not using the Suitcase inventory service then this won't do anything.) m_HGInventoryService.GetRootFolder(account.PrincipalID); } List <InventoryFolderBase> inventorySkel = m_InventoryService.GetInventorySkeleton(account.PrincipalID); if (m_RequireInventory && ((inventorySkel == null) || (inventorySkel != null && inventorySkel.Count == 0))) { m_log.InfoFormat( "[LLOGIN SERVICE]: Login failed, for {0} {1}, reason: unable to retrieve user inventory", firstName, lastName); return(LLFailedLoginResponse.InventoryProblem); } // Get active gestures List <InventoryItemBase> gestures = m_InventoryService.GetActiveGestures(account.PrincipalID); // m_log.DebugFormat("[LLOGIN SERVICE]: {0} active gestures", gestures.Count); // // Login the presence // if (m_PresenceService != null) { success = m_PresenceService.LoginAgent(account.PrincipalID.ToString(), session, secureSession); if (!success) { m_log.InfoFormat( "[LLOGIN SERVICE]: Login failed for {0} {1}, reason: could not login presence", firstName, lastName); return(LLFailedLoginResponse.GridProblem); } } // // Change Online status and get the home region // GridRegion home = null; GridUserInfo guinfo = m_GridUserService.LoggedIn(account.PrincipalID.ToString()); // We are only going to complain about no home if the user actually tries to login there, to avoid // spamming the console. if (guinfo != null) { if (guinfo.HomeRegionID == UUID.Zero && startLocation == "home") { m_log.WarnFormat( "[LLOGIN SERVICE]: User {0} tried to login to a 'home' start location but they have none set", account.Name); } else if (m_GridService != null) { home = m_GridService.GetRegionByUUID(scopeID, guinfo.HomeRegionID); if (home == null && startLocation == "home") { m_log.WarnFormat( "[LLOGIN SERVICE]: User {0} tried to login to a 'home' start location with ID {1} but this was not found.", account.Name, guinfo.HomeRegionID); } } } else { // something went wrong, make something up, so that we don't have to test this anywhere else m_log.DebugFormat("{0} Failed to fetch GridUserInfo. Creating empty GridUserInfo as home", LogHeader); guinfo = new GridUserInfo(); guinfo.LastPosition = guinfo.HomePosition = new Vector3(128, 128, 30); } // // Find the destination region/grid // string where = string.Empty; Vector3 position = Vector3.Zero; Vector3 lookAt = Vector3.Zero; GridRegion gatekeeper = null; TeleportFlags flags; GridRegion destination = FindDestination(account, scopeID, guinfo, session, startLocation, home, out gatekeeper, out where, out position, out lookAt, out flags); if (destination == null) { m_PresenceService.LogoutAgent(session); m_log.InfoFormat( "[LLOGIN SERVICE]: Login failed for {0} {1}, reason: destination not found", firstName, lastName); return(LLFailedLoginResponse.GridProblem); } else { m_log.DebugFormat( "[LLOGIN SERVICE]: Found destination {0}, endpoint {1} for {2} {3}", destination.RegionName, destination.ExternalEndPoint, firstName, lastName); } if (account.UserLevel >= 200) { flags |= TeleportFlags.Godlike; } // // Get the avatar // AvatarAppearance avatar = null; if (m_AvatarService != null) { avatar = m_AvatarService.GetAppearance(account.PrincipalID); } // // Instantiate/get the simulation interface and launch an agent at the destination // string reason = string.Empty; GridRegion dest; AgentCircuitData aCircuit = LaunchAgentAtGrid(gatekeeper, destination, account, avatar, session, secureSession, position, where, clientVersion, channel, mac, id0, clientIP, flags, out where, out reason, out dest); destination = dest; if (aCircuit == null) { m_PresenceService.LogoutAgent(session); m_log.InfoFormat("[LLOGIN SERVICE]: Login failed for {0} {1}, reason: {2}", firstName, lastName, reason); return(new LLFailedLoginResponse("key", reason, "false")); } // Get Friends list FriendInfo[] friendsList = new FriendInfo[0]; if (m_FriendsService != null) { friendsList = m_FriendsService.GetFriends(account.PrincipalID); // m_log.DebugFormat("[LLOGIN SERVICE]: Retrieved {0} friends", friendsList.Length); } // // Finally, fill out the response and return it // LLLoginResponse response = new LLLoginResponse( account, aCircuit, guinfo, destination, inventorySkel, friendsList, m_LibraryService, where, startLocation, position, lookAt, gestures, m_WelcomeMessage, home, clientIP, m_MapTileURL, m_ProfileURL, m_OpenIDURL, m_SearchURL, m_Currency, m_DSTZone, m_DestinationGuide, m_AvatarPicker, m_ClassifiedFee); m_log.DebugFormat("[LLOGIN SERVICE]: All clear. Sending login response to {0} {1}", firstName, lastName); return(response); } catch (Exception e) { m_log.WarnFormat("[LLOGIN SERVICE]: Exception processing login for {0} {1}: {2} {3}", firstName, lastName, e.ToString(), e.StackTrace); if (m_PresenceService != null) { m_PresenceService.LogoutAgent(session); } return(LLFailedLoginResponse.InternalError); } }
public BaseOpenSimServer() : base() { // Random uuid for private data m_osSecret = UUID.Random().ToString(); }
/// <summary> /// </summary> /// <param name="assetName"></param> /// <param name="assetDescription"></param> /// <param name="assetID"></param> /// <param name="inventoryItem"></param> /// <param name="parentFolder"></param> /// <param name="data"></param> /// <param name="inventoryType"></param> /// <param name="assetType"></param> /// <param name="everyone_mask"></param> /// <param name="group_mask"></param> /// <param name="next_owner_mask"></param> public UUID UploadCompleteHandler(string assetName, string assetDescription, UUID assetID, UUID inventoryItem, UUID parentFolder, byte[] data, string inventoryType, string assetType, uint everyone_mask, uint group_mask, uint next_owner_mask) { sbyte assType = 0; sbyte inType = 0; switch (inventoryType) { case "sound": inType = 1; assType = 1; break; case "animation": inType = 19; assType = 20; break; case "snapshot": inType = 15; assType = 0; break; case "wearable": inType = 18; switch (assetType) { case "bodypart": assType = 13; break; case "clothing": assType = 5; break; } break; case "object": { inType = (sbyte)InventoryType.Object; assType = (sbyte)AssetType.Object; List <Vector3> positions = new List <Vector3>(); List <Quaternion> rotations = new List <Quaternion>(); OSDMap request = (OSDMap)OSDParser.DeserializeLLSDXml(data); OSDArray instance_list = (OSDArray)request["instance_list"]; OSDArray mesh_list = (OSDArray)request["mesh_list"]; OSDArray texture_list = (OSDArray)request["texture_list"]; SceneObjectGroup grp = null; List <UUID> textures = new List <UUID>(); foreach ( AssetBase textureAsset in texture_list.Select(t => new AssetBase(UUID.Random(), assetName, AssetType.Texture, m_agentID) { Data = t.AsBinary() })) { textureAsset.ID = m_assetService.Store(textureAsset); textures.Add(textureAsset.ID); } InventoryFolderBase meshFolder = m_inventoryService.GetFolderForType(m_agentID, InventoryType.Mesh, AssetType.Mesh); for (int i = 0; i < mesh_list.Count; i++) { PrimitiveBaseShape pbs = PrimitiveBaseShape.CreateBox(); Primitive.TextureEntry textureEntry = new Primitive.TextureEntry(Primitive.TextureEntry.WHITE_TEXTURE); OSDMap inner_instance_list = (OSDMap)instance_list[i]; OSDArray face_list = (OSDArray)inner_instance_list["face_list"]; for (uint face = 0; face < face_list.Count; face++) { OSDMap faceMap = (OSDMap)face_list[(int)face]; Primitive.TextureEntryFace f = pbs.Textures.CreateFace(face); if (faceMap.ContainsKey("fullbright")) { f.Fullbright = faceMap["fullbright"].AsBoolean(); } if (faceMap.ContainsKey("diffuse_color")) { f.RGBA = faceMap["diffuse_color"].AsColor4(); } int textureNum = faceMap["image"].AsInteger(); float imagerot = faceMap["imagerot"].AsInteger(); float offsets = (float)faceMap["offsets"].AsReal(); float offsett = (float)faceMap["offsett"].AsReal(); float scales = (float)faceMap["scales"].AsReal(); float scalet = (float)faceMap["scalet"].AsReal(); if (imagerot != 0) { f.Rotation = imagerot; } if (offsets != 0) { f.OffsetU = offsets; } if (offsett != 0) { f.OffsetV = offsett; } if (scales != 0) { f.RepeatU = scales; } if (scalet != 0) { f.RepeatV = scalet; } f.TextureID = textures.Count > textureNum ? textures[textureNum] : Primitive.TextureEntry.WHITE_TEXTURE; textureEntry.FaceTextures[face] = f; } pbs.TextureEntry = textureEntry.GetBytes(); AssetBase meshAsset = new AssetBase(UUID.Random(), assetName, AssetType.Mesh, m_agentID) { Data = mesh_list[i].AsBinary() }; meshAsset.ID = m_assetService.Store(meshAsset); if (meshFolder == null) { m_inventoryService.CreateUserInventory(m_agentID, false); meshFolder = m_inventoryService.GetFolderForType(m_agentID, InventoryType.Mesh, AssetType.Mesh); } InventoryItemBase itemBase = new InventoryItemBase(UUID.Random(), m_agentID) { AssetType = (sbyte)AssetType.Mesh, AssetID = meshAsset.ID, CreatorId = m_agentID.ToString(), Folder = meshFolder.ID, InvType = (int)InventoryType.Texture, Name = "(Mesh) - " + assetName, CurrentPermissions = (uint)PermissionMask.All, BasePermissions = (uint)PermissionMask.All, EveryOnePermissions = everyone_mask, GroupPermissions = group_mask, NextPermissions = next_owner_mask }; //Bad... but whatever m_inventoryService.AddItem(itemBase); pbs.SculptEntry = true; pbs.SculptTexture = meshAsset.ID; pbs.SculptType = (byte)SculptType.Mesh; pbs.SculptData = meshAsset.Data; Vector3 position = inner_instance_list["position"].AsVector3(); Vector3 scale = inner_instance_list["scale"].AsVector3(); Quaternion rotation = inner_instance_list["rotation"].AsQuaternion(); int physicsShapeType = inner_instance_list["physics_shape_type"].AsInteger(); int material = inner_instance_list["material"].AsInteger(); int mesh = inner_instance_list["mesh"].AsInteger(); SceneObjectPart prim = new SceneObjectPart(m_agentID, pbs, position, Quaternion.Identity, Vector3.Zero, assetName) { Scale = scale, AbsolutePosition = position }; rotations.Add(rotation); positions.Add(position); prim.UUID = UUID.Random(); prim.CreatorID = m_agentID; prim.OwnerID = m_agentID; prim.GroupID = UUID.Zero; prim.LastOwnerID = m_agentID; prim.CreationDate = Util.UnixTimeSinceEpoch(); prim.Name = assetName; prim.Description = ""; prim.PhysicsType = (byte)physicsShapeType; prim.BaseMask = (uint)PermissionMask.All; prim.EveryoneMask = everyone_mask; prim.NextOwnerMask = next_owner_mask; prim.GroupMask = group_mask; prim.OwnerMask = (uint)PermissionMask.All; if (grp == null) { grp = new SceneObjectGroup(prim, null); } else { grp.AddChild(prim, i + 1); } grp.RootPart.IsAttachment = false; } if (grp.ChildrenList.Count > 1) //Fix first link # { grp.RootPart.LinkNum++; } Vector3 rootPos = positions[0]; grp.SetAbsolutePosition(false, rootPos); for (int i = 0; i < positions.Count; i++) { Vector3 offset = positions[i] - rootPos; grp.ChildrenList[i].SetOffsetPosition(offset); } for (int i = 0; i < rotations.Count; i++) { if (i != 0) { grp.ChildrenList[i].SetRotationOffset(false, rotations[i], false); } } grp.UpdateGroupRotationR(rotations[0]); data = Encoding.ASCII.GetBytes(grp.ToXml2()); } break; } AssetBase asset = new AssetBase(assetID, assetName, (AssetType)assType, m_agentID) { Data = data }; asset.ID = m_assetService.Store(asset); assetID = asset.ID; InventoryItemBase item = new InventoryItemBase { Owner = m_agentID, CreatorId = m_agentID.ToString(), ID = inventoryItem, AssetID = asset.ID, Description = assetDescription, Name = assetName, AssetType = assType, InvType = inType, Folder = parentFolder, CurrentPermissions = (uint)PermissionMask.All, BasePermissions = (uint)PermissionMask.All, EveryOnePermissions = everyone_mask, NextPermissions = next_owner_mask, GroupPermissions = group_mask, CreationDate = Util.UnixTimeSinceEpoch() }; m_inventoryService.AddItem(item); return(assetID); }