public GridRegion GetHomeRegion(UUID userID, out Vector3 position, out Vector3 lookAt)
{
position = new Vector3(128, 128, 0);
lookAt = Vector3.UnitY;
MainConsole.Instance.DebugFormat("[USER AGENT SERVICE]: Request to get home region of user {0}", userID);
GridRegion home = null;
UserInfo uinfo = m_PresenceService.GetUserInfo(userID.ToString());
if (uinfo != null)
{
if (uinfo.HomeRegionID != UUID.Zero)
{
home = m_GridService.GetRegionByUUID(null, uinfo.HomeRegionID);
position = uinfo.HomePosition;
lookAt = uinfo.HomeLookAt;
}
if (home == null || ((home.Flags & (int)Aurora.Framework.RegionFlags.Safe)
!= (int)Aurora.Framework.RegionFlags.Safe))
{
home = m_GatekeeperService.GetHyperlinkRegion(UUID.Zero);
if (home != null)
{
position = new Vector3(home.RegionSizeX / 2, home.RegionSizeY / 2, 20);
lookAt = Vector3.Zero;
}
}
}
return(home);
}
public GridRegion GetHyperlinkRegion(UUID regionID)
{
MainConsole.Instance.DebugFormat("[GATEKEEPER SERVICE]: Request to get hyperlink region {0}", regionID);
if (!m_AllowTeleportsToAnyRegion)
{
if (!m_foundDefaultRegion || m_DefaultGatewayRegion == null)
{
m_DefaultGatewayRegion = FindDefaultRegion();
}
// Don't even check the given regionID
return(m_DefaultGatewayRegion);
}
GridRegion region = m_GridService.GetRegionByUUID(null, regionID);
if (region != null && (region.Flags & (int)Aurora.Framework.RegionFlags.Safe) == (int)Aurora.Framework.RegionFlags.Safe)
{
return(region);
}
if (!m_foundDefaultRegion || m_DefaultGatewayRegion == null)
{
m_DefaultGatewayRegion = FindDefaultRegion();
}
if (m_DefaultGatewayRegion != null && (m_DefaultGatewayRegion.Flags & (int)Aurora.Framework.RegionFlags.Safe) == (int)Aurora.Framework.RegionFlags.Safe)
{
return(m_DefaultGatewayRegion);
}
return(m_DefaultGatewayRegion = FindDefaultRegion());
}
public GridRegion GetHomeRegion(UUID userID, out Vector3 position, out Vector3 lookAt)
{
position = new Vector3(128, 128, 0); lookAt = Vector3.UnitY;
m_log.DebugFormat("[USER AGENT SERVICE]: Request to get home region of user {0}", userID);
GridRegion home = null;
GridUserInfo uinfo = m_GridUserService.GetGridUserInfo(userID.ToString());
if (uinfo != null)
{
if (uinfo.HomeRegionID != UUID.Zero)
{
home = m_GridService.GetRegionByUUID(UUID.Zero, uinfo.HomeRegionID);
position = uinfo.HomePosition;
lookAt = uinfo.HomeLookAt;
}
if (home == null)
{
List <GridRegion> defs = m_GridService.GetDefaultRegions(UUID.Zero);
if (defs != null && defs.Count > 0)
{
home = defs[0];
}
}
}
return(home);
}
public GridRegion GetHyperlinkRegion(UUID regionID)
{
m_log.DebugFormat("[GATEKEEPER SERVICE]: Request to get hyperlink region {0}", regionID);
if (!m_AllowTeleportsToAnyRegion)
{
// Don't even check the given regionID
return(m_DefaultGatewayRegion);
}
GridRegion region = m_GridService.GetRegionByUUID(m_ScopeID, regionID);
return(region);
}
private bool ForwardToSim(string op, UUID fromID, string name, String fromUUI, UUID toID, string message)
{
PresenceInfo session = null;
GridRegion region = null;
PresenceInfo[] sessions = m_PresenceService.GetAgents(new string[] { toID.ToString() });
if (sessions != null && sessions.Length > 0)
{
session = sessions[0];
}
if (session != null)
{
region = m_GridService.GetRegionByUUID(UUID.Zero, session.RegionID);
}
switch (op)
{
case "FriendshipOffered":
// Let's store backwards
string secret = UUID.Random().ToString().Substring(0, 8);
m_FriendsService.StoreFriend(toID.ToString(), fromUUI + ";" + secret, 0);
if (m_FriendsLocalSimConnector != null) // standalone
{
GridInstantMessage im = new GridInstantMessage(null, fromID, name, toID,
(byte)InstantMessageDialog.FriendshipOffered, message, false, Vector3.Zero);
// !! HACK
im.imSessionID = im.fromAgentID;
return(m_FriendsLocalSimConnector.LocalFriendshipOffered(toID, im));
}
else if (region != null) // grid
{
return(m_FriendsSimConnector.FriendshipOffered(region, fromID, toID, message, name));
}
break;
case "ApproveFriendshipRequest":
if (m_FriendsLocalSimConnector != null) // standalone
{
return(m_FriendsLocalSimConnector.LocalFriendshipApproved(fromID, name, toID));
}
else if (region != null) //grid
{
return(m_FriendsSimConnector.FriendshipApproved(region, fromID, name, toID));
}
break;
}
return(false);
}
/// <summary>
/// Gets user information for change user info page on site
/// </summary>
/// <param name="map">UUID</param>
/// <returns>Verified, HomeName, HomeUUID, Online, Email, FirstName, LastName</returns>
byte[] GetGridUserInfo(OSDMap map)
{
string uuid = String.Empty;
uuid = map["UUID"].AsString();
IUserAccountService accountService = m_registry.RequestModuleInterface <IUserAccountService>();
UserAccount user = accountService.GetUserAccount(UUID.Zero, map["UUID"].AsUUID());
IAgentInfoService agentService = m_registry.RequestModuleInterface <IAgentInfoService>();
UserInfo userinfo;
OSDMap resp = new OSDMap();
bool verified = user != null;
resp["Verified"] = OSD.FromBoolean(verified);
if (verified)
{
userinfo = agentService.GetUserInfo(uuid);
IGridService gs = m_registry.RequestModuleInterface <IGridService>();
Services.Interfaces.GridRegion gr = gs.GetRegionByUUID(UUID.Zero, userinfo.HomeRegionID);
resp["HomeUUID"] = OSD.FromUUID(userinfo.HomeRegionID);
resp["HomeName"] = OSD.FromString(gr.RegionName);
resp["Online"] = OSD.FromBoolean(userinfo.IsOnline);
resp["Email"] = OSD.FromString(user.Email);
resp["Name"] = OSD.FromString(user.Name);
}
string xmlString = OSDParser.SerializeJsonString(resp);
UTF8Encoding encoding = new UTF8Encoding();
return(encoding.GetBytes(xmlString));
}
/// <summary>
/// Server side
/// </summary>
/// <param name="FunctionName"></param>
/// <param name="parameters"></param>
/// <returns></returns>
protected object OnGenericEvent(string FunctionName, object parameters)
{
if (FunctionName == "EstateUpdated")
{
EstateSettings es = (EstateSettings)parameters;
IEstateConnector estateConnector = Framework.Utilities.DataManager.RequestPlugin <IEstateConnector>();
ISyncMessagePosterService asyncPoster =
m_registry.RequestModuleInterface <ISyncMessagePosterService>();
IGridService gridService = m_registry.RequestModuleInterface <IGridService>();
if (estateConnector != null)
{
List <UUID> regions = estateConnector.GetRegions((int)es.EstateID);
if (regions != null)
{
foreach (UUID region in regions)
{
//Send the message to update all regions that are in this estate, as a setting changed
if (gridService != null && asyncPoster != null)
{
GridRegion r = gridService.GetRegionByUUID(null, region);
if (r != null)
{
asyncPoster.Post(r.ServerURI,
SyncMessageHelper.UpdateEstateInfo(es.EstateID, region));
}
}
}
}
}
}
return(null);
}
private byte[] Deregister(Dictionary <string, object> request)
{
UUID regionID = UUID.Zero;
if (request.ContainsKey("REGIONID"))
{
UUID.TryParse(request["REGIONID"].ToString(), out regionID);
}
else
{
MainConsole.Instance.WarnFormat("[GRID HANDLER]: no regionID in request to deregister region");
}
UUID sessionID = UUID.Zero;
if (request.ContainsKey("SESSIONID"))
{
UUID.TryParse(request["SESSIONID"].ToString(), out sessionID);
}
else
{
MainConsole.Instance.WarnFormat("[GRID HANDLER]: no sessionID in request to deregister region");
}
GridRegion r = m_GridService.GetRegionByUUID(UUID.Zero, regionID);
if (r != null & m_SessionID == r.RegionHandle.ToString())
{
bool result = m_GridService.DeregisterRegion(r.RegionHandle, regionID, sessionID);
if (result)
{
m_registry.RequestModuleInterface <IGridRegistrationService>().RemoveUrlsForClient(
sessionID.ToString());
}
if (result)
{
return(SuccessResult());
}
else
{
return(FailureResult());
}
}
return(FailureResult());
}
private void SendToEstate(uint EstateID, Dictionary <string, object> sendData)
{
List <UUID> regions = m_EstateModule.Scenes[0].GetEstateRegions((int)EstateID);
// Don't send to the same instance twice
List <string> done = new List <string>();
// Handle local regions locally
lock (m_EstateModule.Scenes)
{
foreach (Scene s in m_EstateModule.Scenes)
{
RegionInfo sreg = s.RegionInfo;
if (regions.Contains(sreg.RegionID))
{
string url = sreg.ExternalHostName + ":" + sreg.HttpPort;
regions.Remove(sreg.RegionID);
if (!done.Contains(url)) // we may have older regs with same url lost in dbs
{
done.Add(url);
}
}
}
}
if (regions.Count == 0)
{
return;
}
Scene baseScene = m_EstateModule.Scenes[0];
UUID ScopeID = baseScene.RegionInfo.ScopeID;
IGridService gridService = baseScene.GridService;
if (gridService == null)
{
return;
}
// Send to remote regions
foreach (UUID regionID in regions)
{
GridRegion region = gridService.GetRegionByUUID(ScopeID, regionID);
if (region != null)
{
string url = region.ExternalHostName + ":" + region.HttpPort;
if (done.Contains(url))
{
continue;
}
Call(region, sendData);
done.Add(url);
}
}
}
public GridRegion GetRegionByUUID(UUID scopeID, UUID regionID)
{
GridRegion r = m_localService.GetRegionByUUID(scopeID, regionID);
if (r == null)
{
r = m_remoteService.GetRegionByUUID(scopeID, regionID);
UpdateGridRegionForIWC(ref r);
}
return(r);
}
public override GridRegion GetRegionByUUID(UUID scopeID, UUID regionID)
{
GridRegion rinfo = m_LocalGridService.GetRegionByUUID(scopeID, regionID);
if (rinfo == null)
{
rinfo = base.GetRegionByUUID(scopeID, regionID);
}
return(rinfo);
}
public GridRegion GetHyperlinkRegion(UUID regionID, UUID agentID, string agentHomeURI, out string message)
{
message = null;
if (!m_AllowTeleportsToAnyRegion)
{
// Don't even check the given regionID
m_log.DebugFormat(
"[GATEKEEPER SERVICE]: Returning gateway region {0} {1} @ {2} to user {3}{4} as teleporting to arbitrary regions is not allowed.",
m_DefaultGatewayRegion.RegionName,
m_DefaultGatewayRegion.RegionID,
m_DefaultGatewayRegion.ServerURI,
agentID,
agentHomeURI == null ? "" : " @ " + agentHomeURI);
message = "Teleporting to the default region.";
return(m_DefaultGatewayRegion);
}
GridRegion region = m_GridService.GetRegionByUUID(m_ScopeID, regionID);
if (region == null)
{
m_log.DebugFormat(
"[GATEKEEPER SERVICE]: Could not find region with ID {0} as requested by user {1}{2}. Returning null.",
regionID, agentID, (agentHomeURI == null) ? "" : " @ " + agentHomeURI);
message = "The teleport destination could not be found.";
return(null);
}
m_log.DebugFormat(
"[GATEKEEPER SERVICE]: Returning region {0} {1} @ {2} to user {3}{4}.",
region.RegionName,
region.RegionID,
region.ServerURI,
agentID,
agentHomeURI == null ? "" : " @ " + agentHomeURI);
return(region);
}
public GridRegion GetRegionByUUID(UUID scopeID, UUID regionID)
{
bool inCache = false;
GridRegion rinfo = m_RegionInfoCache.Get(scopeID, regionID, out inCache);
if (inCache)
return rinfo;
rinfo = m_GridService.GetRegionByUUID(scopeID, regionID);
if (rinfo != null)
m_RegionInfoCache.Cache(scopeID, rinfo);
return rinfo;
}
bool SendIMToRegion(PresenceInfo upd, GridInstantMessage im, UUID toAgentID, bool foreigner)
{
bool imresult = false;
GridRegion reginfo = null;
if (!m_RegionCache.TryGetValue(upd.RegionID, out reginfo))
{
reginfo = m_GridService.GetRegionByUUID(UUID.Zero /*!!!*/, upd.RegionID);
if (reginfo != null)
{
m_RegionCache.AddOrUpdate(upd.RegionID, reginfo, CACHE_EXPIRATION_SECONDS);
}
}
if (reginfo != null)
{
imresult = InstantMessageServiceConnector.SendInstantMessage(reginfo.ServerURI, im, m_messageKey);
}
else
{
m_log.DebugFormat("[HG IM SERVICE]: Failed to deliver message to {0}", reginfo.ServerURI);
return(false);
}
if (imresult)
{
// IM delivery successful, so store the Agent's location in our local cache.
lock (m_UserLocationMap)
{
if (m_UserLocationMap.ContainsKey(toAgentID))
{
m_UserLocationMap[toAgentID] = upd;
}
else
{
m_UserLocationMap.Add(toAgentID, upd);
}
}
return(true);
}
else
{
// try again, but lookup user this time.
// Warning, this must call the Async version
// of this method or we'll be making thousands of threads
// The version within the spawned thread is SendGridInstantMessageViaXMLRPCAsync
// The version that spawns the thread is SendGridInstantMessageViaXMLRPC
// This is recursive!!!!!
return(TrySendInstantMessage(im, upd, false, foreigner));
}
}
protected void ForwardStatusNotificationToSim(UUID regionID, UUID foreignUserID, string user, bool online)
{
UUID userID;
if (UUID.TryParse(user, out userID))
{
if (m_FriendsLocalSimConnector != null)
{
m_log.DebugFormat("[HGFRIENDS SERVICE]: Local Notify, user {0} is {1}", foreignUserID, (online ? "online" : "offline"));
m_FriendsLocalSimConnector.StatusNotify(foreignUserID, userID, online);
}
else
{
GridRegion region = m_GridService.GetRegionByUUID(UUID.Zero /* !!! */, regionID);
if (region != null)
{
m_log.DebugFormat("[HGFRIENDS SERVICE]: Remote Notify to region {0}, user {1} is {2}", region.RegionName, foreignUserID, (online ? "online" : "offline"));
m_FriendsSimConnector.StatusNotify(region, foreignUserID, userID.ToString(), online);
}
}
}
}
public GridRegion GetRegionByUUID(UUID scopeID, UUID regionID)
{
GridRegion rinfo = m_LocalGridService.GetRegionByUUID(scopeID, regionID);
if (rinfo != null)
{
return(rinfo);
}
rinfo = m_RemoteGridService.GetRegionByUUID(scopeID, regionID);
m_RegionInfoCache.Cache(scopeID, rinfo);
return(rinfo);
}
private string GetRegionService(UUID regionID)
{
IGridService gs = m_registry.RequestModuleInterface <IGridService>();
if (gs != null && regionID != UUID.Zero)
{
GridRegion region = gs.GetRegionByUUID(UUID.Zero, regionID);
if (region != null)
{
return(region.ServerURI);
}
}
return("NonExistant");
}
protected object OnGenericEvent(string FunctionName, object parameters)
{
if (FunctionName == "UserStatusChange")
{
//A user has logged in or out... we need to update friends lists across the grid
IAsyncMessagePostService asyncPoster = m_registry.RequestModuleInterface <IAsyncMessagePostService>();
IFriendsService friendsService = m_registry.RequestModuleInterface <IFriendsService>();
ICapsService capsService = m_registry.RequestModuleInterface <ICapsService>();
IGridService gridService = m_registry.RequestModuleInterface <IGridService>();
if (asyncPoster != null && friendsService != null && capsService != null && gridService != null)
{
//Get all friends
UserInfo info = (UserInfo)parameters;
FriendInfo[] friends = friendsService.GetFriends(UUID.Parse(info.UserID));
List <UUID> OnlineFriends = new List <UUID>();
UUID us = UUID.Parse(info.UserID);
foreach (FriendInfo friend in friends)
{
UUID FriendToInform = UUID.Parse(friend.Friend);
//Now find their caps service so that we can find where they are root (and if they are logged in)
IClientCapsService clientCaps = capsService.GetClientCapsService(FriendToInform);
if (clientCaps != null)
{
OnlineFriends.Add(FriendToInform);
//Find the root agent
IRegionClientCapsService regionClientCaps = clientCaps.GetRootCapsService();
if (regionClientCaps != null)
{
//Post!
asyncPoster.Post(regionClientCaps.RegionHandle, SyncMessageHelper.AgentStatusChange(us, FriendToInform, info.IsOnline));
}
}
}
//If they are online, send all friends online statuses to them
if (info.IsOnline)
{
GridRegion ourRegion = gridService.GetRegionByUUID(UUID.Zero, info.CurrentRegionID);
if (ourRegion != null)
{
foreach (UUID onlineFriend in OnlineFriends)
{
asyncPoster.Post(ourRegion.RegionHandle, SyncMessageHelper.AgentStatusChange(onlineFriend, us, info.IsOnline));
}
}
}
}
}
return(null);
}
public GridRegion GetHyperlinkRegion(UUID regionID, UUID agentID, string agentHomeURI, out string message)
{
m_log.DebugFormat("[GATEKEEPER SERVICE]: Request to get hyperlink region {0} for user {1}{2}",
regionID, agentID, (agentHomeURI == null) ? "" : " @ " + agentHomeURI);
message = null;
if (!m_AllowTeleportsToAnyRegion)
{
// Don't even check the given regionID
message = "Teleporting to the default region.";
return(m_DefaultGatewayRegion);
}
GridRegion region = m_GridService.GetRegionByUUID(m_ScopeID, regionID);
if (region == null)
{
message = "The teleport destination could not be found.";
return(null);
}
return(region);
}
/* #region IService implementation
*
* public void Initialize(IConfigSource config, IRegistryCore registry)
* {
* throw new System.NotImplementedException();
* }
*
* public void Start(IConfigSource config, IRegistryCore registry)
* {
* throw new System.NotImplementedException();
* }
*
* public void FinishedStartup()
* {
* throw new System.NotImplementedException();
* }
*
#endregion
*/
#region user
/// <summary>
/// Gets user information for change user info page on site
/// </summary>
/// <param name="map">UUID</param>
/// <returns>Verified, HomeName, HomeUUID, Online, Email, FirstName, LastName</returns>
OSDMap GetGridUserInfo(OSDMap map)
{
string uuid = string.Empty;
uuid = map ["UUID"].AsString();
IUserAccountService accountService = m_registry.RequestModuleInterface <IUserAccountService> ();
UserAccount userAcct = accountService.GetUserAccount(null, map ["UUID"].AsUUID());
IAgentInfoService agentService = m_registry.RequestModuleInterface <IAgentInfoService> ();
UserInfo userinfo;
OSDMap resp = new OSDMap();
bool usr_verified = userAcct.Valid;
resp ["Verified"] = OSD.FromBoolean(usr_verified);
resp ["UUID"] = OSD.FromUUID(userAcct.PrincipalID);
resp ["Email"] = OSD.FromString(userAcct.Email);
resp ["Name"] = OSD.FromString(userAcct.Name);
resp ["FirstName"] = OSD.FromString(userAcct.FirstName);
resp ["LastName"] = OSD.FromString(userAcct.LastName);
// just some defaults
resp ["HomeUUID"] = OSD.FromUUID(UUID.Zero);
resp ["HomeName"] = OSD.FromString("");
resp ["Online"] = OSD.FromBoolean(false);
if (verified)
{
userinfo = agentService.GetUserInfo(uuid);
if (userinfo != null)
{
resp ["HomeUUID"] = OSD.FromUUID(userinfo.HomeRegionID);
resp ["Online"] = OSD.FromBoolean(userinfo.IsOnline);
}
IGridService gs = m_registry.RequestModuleInterface <IGridService> ();
if (gs != null)
{
GridRegion gr = gs.GetRegionByUUID(null, userinfo.HomeRegionID);
if (gr != null)
{
resp ["HomeName"] = OSD.FromString(gr.RegionName);
}
}
}
return(resp);
}
/// <summary>
/// Get all the neighboring regions of the given region
/// </summary>
/// <param name="region"></param>
/// <returns></returns>
private List <GridRegion> FindNewNeighbors(GridRegion region)
{
int startX = (int)(region.RegionLocX - 8192); //Give 8196 by default so that we pick up neighbors next to us
int startY = (int)(region.RegionLocY - 8192);
if (m_gridService.MaxRegionSize != 0)
{
startX = (int)(region.RegionLocX - m_gridService.MaxRegionSize);
startY = (int)(region.RegionLocY - m_gridService.MaxRegionSize);
}
//-1 so that we don't get size (256) + viewsize (256) and get a region two 256 blocks over
int endX = (region.RegionLocX + RegionViewSize + region.RegionSizeX - 1);
int endY = (region.RegionLocY + RegionViewSize + region.RegionSizeY - 1);
List <GridRegion> neighbors = m_gridService.GetRegionRange(region.ScopeID, startX, endX, startY, endY);
//If we arn't supposed to close local regions, add all of the scene ones if they are not already there
if (!CloseLocalRegions)
{
foreach (Scene scene in m_Scenes)
{
GridRegion gregion = m_gridService.GetRegionByUUID(scene.RegionInfo.ScopeID, scene.RegionInfo.RegionID);
if (!neighbors.Contains(gregion))
{
neighbors.Add(gregion);
}
}
}
neighbors.RemoveAll(delegate(GridRegion r)
{
if (r.RegionID == region.RegionID)
{
return(true);
}
if (r.RegionLocX + r.RegionSizeX - 1 < (region.RegionLocX - RegionViewSize) ||
r.RegionLocY + r.RegionSizeY - 1 < (region.RegionLocY - RegionViewSize)) //Check for regions outside of the boundry (created above when checking for large regions next to us)
{
return(true);
}
return(false);
});
return(neighbors);
}
byte[] GetRegionByUUID(Dictionary <string, object> request)
{
UUID scopeID = UUID.Zero;
if (request.ContainsKey("SCOPEID"))
{
UUID.TryParse(request["SCOPEID"].ToString(), out scopeID);
}
else
{
m_log.WarnFormat("[GRID HANDLER]: no scopeID in request to get neighbours");
}
UUID regionID = UUID.Zero;
if (request.ContainsKey("REGIONID"))
{
UUID.TryParse(request["REGIONID"].ToString(), out regionID);
}
else
{
m_log.WarnFormat("[GRID HANDLER]: no regionID in request to get neighbours");
}
GridRegion rinfo = m_GridService.GetRegionByUUID(scopeID, regionID);
//m_log.DebugFormat("[GRID HANDLER]: neighbours for region {0}: {1}", regionID, rinfos.Count);
Dictionary <string, object> result = new Dictionary <string, object>();
if (rinfo == null)
{
result["result"] = "null";
}
else
{
result["result"] = rinfo.ToKeyValuePairs();
}
string xmlString = ServerUtils.BuildXmlResponse(result);
//m_log.DebugFormat("[GRID HANDLER]: resp string: {0}", xmlString);
UTF8Encoding encoding = new UTF8Encoding();
return(encoding.GetBytes(xmlString));
}
public GridRegion GetRegionByUUID(UUID scopeID, UUID regionID)
{
bool inCache = false;
GridRegion rinfo = m_RegionInfoCache.Get(scopeID, regionID, out inCache);
if (inCache)
{
return(rinfo);
}
rinfo = m_LocalGridService.GetRegionByUUID(scopeID, regionID);
if (rinfo == null)
{
rinfo = m_RemoteGridService.GetRegionByUUID(scopeID, regionID);
}
m_RegionInfoCache.Cache(scopeID, regionID, rinfo);
return(rinfo);
}
/* #region IService implementation
*
* public void Initialize(IConfigSource config, IRegistryCore registry)
* {
* throw new System.NotImplementedException();
* }
*
* public void Start(IConfigSource config, IRegistryCore registry)
* {
* throw new System.NotImplementedException();
* }
*
* public void FinishedStartup()
* {
* throw new System.NotImplementedException();
* }
*
#endregion
*/
#region user
/// <summary>
/// Gets user information for change user info page on site
/// </summary>
/// <param name="map">UUID</param>
/// <returns>Verified, HomeName, HomeUUID, Online, Email, FirstName, LastName</returns>
OSDMap GetGridUserInfo(OSDMap map)
{
string uuid = string.Empty;
uuid = map ["UUID"].AsString();
IUserAccountService accountService = m_registry.RequestModuleInterface <IUserAccountService> ();
UserAccount user = accountService.GetUserAccount(null, map ["UUID"].AsUUID());
IAgentInfoService agentService = m_registry.RequestModuleInterface <IAgentInfoService> ();
UserInfo userinfo;
OSDMap resp = new OSDMap();
bool verified = user != null;
resp ["Verified"] = OSD.FromBoolean(verified);
if (verified)
{
userinfo = agentService.GetUserInfo(uuid);
IGridService gs = m_registry.RequestModuleInterface <IGridService> ();
GridRegion gr = null;
if (userinfo != null)
{
gr = gs.GetRegionByUUID(null, userinfo.HomeRegionID);
}
resp ["UUID"] = OSD.FromUUID(user.PrincipalID);
resp ["HomeUUID"] = OSD.FromUUID((userinfo == null) ? UUID.Zero : userinfo.HomeRegionID);
resp ["HomeName"] = OSD.FromString((userinfo == null) ? "" : gr.RegionName);
resp ["Online"] = OSD.FromBoolean((userinfo == null) ? false : userinfo.IsOnline);
resp ["Email"] = OSD.FromString(user.Email);
resp ["Name"] = OSD.FromString(user.Name);
resp ["FirstName"] = OSD.FromString(user.FirstName);
resp ["LastName"] = OSD.FromString(user.LastName);
}
return(resp);
}
bool SendIMToRegion(PresenceInfo upd, GridInstantMessage im, UUID toAgentID, bool foreigner)
{
GridRegion reginfo = null;
if (!m_RegionCache.TryGetValue(upd.RegionID, REGIONCACHE_EXPIRATION, out reginfo))
{
reginfo = m_GridService.GetRegionByUUID(UUID.Zero /*!!!*/, upd.RegionID);
m_RegionCache.AddOrUpdate(upd.RegionID, reginfo, reginfo == null ? 60000 : REGIONCACHE_EXPIRATION);
}
if (reginfo == null)
{
return(false);
}
bool imresult = InstantMessageServiceConnector.SendInstantMessage(reginfo.ServerURI, im, m_messageKey);
if (imresult)
{
// IM delivery successful, so store the Agent's location in our local cache.
lock (m_UserLocationMap)
m_UserLocationMap[toAgentID] = upd;
return(true);
}
else
{
// try again, but lookup user this time.
// Warning, this must call the Async version
// of this method or we'll be making thousands of threads
// The version within the spawned thread is SendGridInstantMessageViaXMLRPCAsync
// The version that spawns the thread is SendGridInstantMessageViaXMLRPC
// This is recursive!!!!!
return(TrySendInstantMessage(im, upd, false, foreigner));
}
}
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);
}
}
/// <summary>
/// Shows estate regions.
/// </summary>
/// <param name="scene">Scene.</param>
/// <param name="cmd">Cmd.</param>
void ShowEstateRegionsCommand(IScene scene, string [] cmd)
{
IEstateConnector estateConnector = Framework.Utilities.DataManager.RequestPlugin <IEstateConnector> ();
IGridService gridService = m_registry.RequestModuleInterface <IGridService> ();
// check for passed estate name
string estateName;
if (cmd.Length < 4)
{
do
{
estateName = MainConsole.Instance.Prompt("Estate name (? for list)", "");
if (estateName == "?")
{
var estates = estateConnector.GetEstateNames();
MainConsole.Instance.CleanInfo(" Available estates are : ");
foreach (string estate in estates)
{
MainConsole.Instance.CleanInfo(" " + estate);
}
}
} while (estateName == "?");
if (estateName == "")
{
return;
}
}
else
{
estateName = cmd [3];
}
// verify that the estate does exist
EstateSettings ES = estateConnector.GetEstateSettings(estateName);
if (ES == null)
{
MainConsole.Instance.ErrorFormat("[EstateService]: The estate '{0}' does not exist!", estateName);
return;
}
var estateregions = estateConnector.GetRegions((int)ES.EstateID);
int estRegions = 0;
float estateArea = 0;
int offLine = 0;
string regionInfo;
regionInfo = string.Format("{0, -20}", "Region");
regionInfo += string.Format("{0, -12}", "Location");
regionInfo += string.Format("{0, -14}", "Size");
regionInfo += string.Format("{0, -12}", "Area");
regionInfo += string.Format("{0, -26}", "Type");
regionInfo += string.Format("{0, -10}", "Online");
MainConsole.Instance.CleanInfo(regionInfo);
MainConsole.Instance.CleanInfo(
"----------------------------------------------------------------------------------------------------");
foreach (UUID regionID in estateregions)
{
var region = gridService.GetRegionByUUID(null, regionID);
if (region == null) // deleted??
{
continue;
}
estRegions++;
estateArea = estateArea + region.RegionArea;
if (!region.IsOnline)
{
offLine++;
}
// TODO ... change hardcoded field sizes to public constants
regionInfo = string.Format("{0, -20}", region.RegionName);
regionInfo += string.Format("{0, -12}", region.RegionLocX / Constants.RegionSize + "," + region.RegionLocY / Constants.RegionSize);
regionInfo += string.Format("{0, -14}", region.RegionSizeX + "x" + region.RegionSizeY);
regionInfo += string.Format("{0, -12}", region.RegionArea < 1000000 ? region.RegionArea + " m2" : (region.RegionArea / 1000000) + " km2");
regionInfo += string.Format("{0, -26}", region.RegionType);
regionInfo += string.Format("{0, -10}", region.IsOnline ? "yes" : "no");
MainConsole.Instance.CleanInfo(regionInfo);
}
MainConsole.Instance.CleanInfo("");
MainConsole.Instance.CleanInfo(
"----------------------------------------------------------------------------------------------------");
MainConsole.Instance.CleanInfo("Regions : " + estRegions + " regions with an area of " + (estateArea / 1000000) + " km2");
MainConsole.Instance.CleanInfo("Offline : " + offLine);
MainConsole.Instance.CleanInfo(string.Empty);
MainConsole.Instance.CleanInfo(
"----------------------------------------------------------------------------------------------------");
MainConsole.Instance.CleanInfo("\n");
}
public Dictionary <string, object> Fill(WebInterface webInterface, string filename, OSHttpRequest httpRequest,
OSHttpResponse httpResponse, Dictionary <string, object> requestParameters,
ITranslator translator, out string response)
{
response = null;
var vars = new Dictionary <string, object>();
UserAccount account = null;
if (httpRequest.Query.ContainsKey("regionid"))
{
var regionService = webInterface.Registry.RequestModuleInterface <IGridService> ();
var region = regionService.GetRegionByUUID(null, UUID.Parse(httpRequest.Query ["regionid"].ToString()));
UUID userid = region.EstateOwner;
account = webInterface.Registry.RequestModuleInterface <IUserAccountService>().GetUserAccount(null, userid);
}
if (account == null)
{
return(vars);
}
vars.Add("UserName", account.Name);
// TODO: User Profile inworld shows this as the standard mm/dd/yyyy
// Do we want this to be localised into the users Localisation or keep it as standard ?
vars.Add("UserBorn", Util.ToDateTime(account.Created).ToShortDateString());
IUserProfileInfo profile = Framework.Utilities.DataManager.RequestPlugin <IProfileConnector>().GetUserProfile(account.PrincipalID);
if (profile != null)
{
vars.Add("UserType", profile.MembershipGroup == "" ? "Resident" : profile.MembershipGroup);
if (profile != null)
{
if (profile.Partner != UUID.Zero)
{
account = webInterface.Registry.RequestModuleInterface <IUserAccountService> ().GetUserAccount(null, profile.Partner);
vars.Add("UserPartner", account.Name);
}
else
{
vars.Add("UserPartner", "No partner");
}
vars.Add("UserAboutMe", profile.AboutText == "" ? "Nothing here" : profile.AboutText);
string url = "../images/icons/no_avatar.jpg";
IWebHttpTextureService webhttpService = webInterface.Registry.RequestModuleInterface <IWebHttpTextureService> ();
if (webhttpService != null && profile.Image != UUID.Zero)
{
url = webhttpService.GetTextureURL(profile.Image);
}
vars.Add("UserPictureURL", url);
}
}
else
{
// no profile yet for this user
vars.Add("UserType", "Unknown");
vars.Add("UserPartner", "Unknown");
vars.Add("UserPictureURL", "../images/icons/no_avatar.jpg");
}
UserAccount ourAccount = Authenticator.GetAuthentication(httpRequest);
if (ourAccount != null)
{
IFriendsService friendsService = webInterface.Registry.RequestModuleInterface <IFriendsService>();
var friends = friendsService.GetFriends(account.PrincipalID);
UUID friendID = UUID.Zero;
if (friends.Any(f => UUID.TryParse(f.Friend, out friendID) && friendID == ourAccount.PrincipalID))
{
IAgentInfoService agentInfoService = webInterface.Registry.RequestModuleInterface <IAgentInfoService>();
IGridService gridService = webInterface.Registry.RequestModuleInterface <IGridService>();
UserInfo ourInfo = agentInfoService.GetUserInfo(account.PrincipalID.ToString());
if (ourInfo != null && ourInfo.IsOnline)
{
vars.Add("OnlineLocation", gridService.GetRegionByUUID(null, ourInfo.CurrentRegionID).RegionName);
}
vars.Add("UserIsOnline", ourInfo != null && ourInfo.IsOnline);
vars.Add("IsOnline", ourInfo != null && ourInfo.IsOnline
? translator.GetTranslatedString("Online")
: translator.GetTranslatedString("Offline"));
}
else
{
vars.Add("OnlineLocation", "");
vars.Add("UserIsOnline", false);
vars.Add("IsOnline", translator.GetTranslatedString("Offline"));
}
}
else
{
vars.Add("OnlineLocation", "");
vars.Add("UserIsOnline", false);
vars.Add("IsOnline", translator.GetTranslatedString("Offline"));
}
vars.Add("UserProfileFor", translator.GetTranslatedString("UserProfileFor"));
vars.Add("ResidentSince", translator.GetTranslatedString("ResidentSince"));
vars.Add("AccountType", translator.GetTranslatedString("AccountType"));
vars.Add("PartnersName", translator.GetTranslatedString("PartnersName"));
vars.Add("AboutMe", translator.GetTranslatedString("AboutMe"));
vars.Add("IsOnlineText", translator.GetTranslatedString("IsOnlineText"));
vars.Add("OnlineLocationText", translator.GetTranslatedString("OnlineLocationText"));
return(vars);
}
public bool CrossAgent(GridRegion crossingRegion, Vector3 pos,
Vector3 velocity, AgentCircuitData circuit, AgentData cAgent, UUID AgentID, ulong requestingRegion, out string reason)
{
try
{
IClientCapsService clientCaps = m_registry.RequestModuleInterface <ICapsService>().GetClientCapsService(AgentID);
IRegionClientCapsService requestingRegionCaps = clientCaps.GetCapsService(requestingRegion);
ISimulationService SimulationService = m_registry.RequestModuleInterface <ISimulationService>();
if (SimulationService != null)
{
//Note: we have to pull the new grid region info as the one from the region cannot be trusted
IGridService GridService = m_registry.RequestModuleInterface <IGridService>();
if (GridService != null)
{
//Set the user in transit so that we block duplicate tps and reset any cancelations
if (!SetUserInTransit(AgentID))
{
reason = "Already in a teleport";
return(false);
}
bool result = false;
crossingRegion = GridService.GetRegionByUUID(UUID.Zero, crossingRegion.RegionID);
if (!SimulationService.UpdateAgent(crossingRegion, cAgent))
{
m_log.Warn("[AgentProcessing]: Failed to cross agent " + AgentID + " because region did not accept it. Resetting.");
reason = "Failed to update an agent";
}
else
{
IEventQueueService EQService = m_registry.RequestModuleInterface <IEventQueueService>();
//Add this for the viewer, but not for the sim, seems to make the viewer happier
int XOffset = crossingRegion.RegionLocX - requestingRegionCaps.RegionX;
pos.X += XOffset;
int YOffset = crossingRegion.RegionLocY - requestingRegionCaps.RegionY;
pos.Y += YOffset;
IRegionClientCapsService otherRegion = clientCaps.GetCapsService(crossingRegion.RegionHandle);
//Tell the client about the transfer
EQService.CrossRegion(crossingRegion.RegionHandle, pos, velocity, crossingRegion.ExternalEndPoint, otherRegion.CapsUrl,
AgentID, circuit.SessionID,
crossingRegion.RegionSizeX, crossingRegion.RegionSizeY,
requestingRegion);
result = WaitForCallback(AgentID);
if (!result)
{
m_log.Warn("[AgentProcessing]: Callback never came in crossing agent " + circuit.AgentID + ". Resetting.");
reason = "Crossing timed out";
}
else
{
// Next, let's close the child agent connections that are too far away.
INeighborService service = m_registry.RequestModuleInterface <INeighborService>();
if (service != null)
{
//Fix the root agent status
otherRegion.RootAgent = true;
requestingRegionCaps.RootAgent = false;
CloseNeighborAgents(requestingRegionCaps.Region, crossingRegion, AgentID);
}
reason = "";
}
}
//All done
ResetFromTransit(AgentID);
return(result);
}
else
{
reason = "Could not find the GridService";
}
}
else
{
reason = "Could not find the SimulationService";
}
}
catch (Exception ex)
{
m_log.WarnFormat("[AgentProcessing]: Failed to cross an agent into a new region. {0}", ex.ToString());
}
ResetFromTransit(AgentID);
reason = "Exception occured";
return(false);
}
public bool TeleportAgent(GridRegion destination, uint TeleportFlags, int DrawDistance,
AgentCircuitData circuit, AgentData agentData, UUID AgentID, ulong requestingRegion,
out string reason)
{
IClientCapsService clientCaps = m_registry.RequestModuleInterface <ICapsService>().GetClientCapsService(AgentID);
IRegionClientCapsService regionCaps = clientCaps.GetCapsService(requestingRegion);
if (regionCaps == null || !regionCaps.RootAgent)
{
reason = "";
return(false);
}
bool result = false;
try
{
bool callWasCanceled = false;
ISimulationService SimulationService = m_registry.RequestModuleInterface <ISimulationService>();
if (SimulationService != null)
{
//Set the user in transit so that we block duplicate tps and reset any cancelations
if (!SetUserInTransit(AgentID))
{
reason = "Already in a teleport";
return(false);
}
//Note: we have to pull the new grid region info as the one from the region cannot be trusted
IGridService GridService = m_registry.RequestModuleInterface <IGridService>();
if (GridService != null)
{
destination = GridService.GetRegionByUUID(UUID.Zero, destination.RegionID);
//Inform the client of the neighbor if needed
circuit.child = false; //Force child status to the correct type
if (!InformClientOfNeighbor(AgentID, requestingRegion, circuit, destination, TeleportFlags,
agentData, out reason))
{
ResetFromTransit(AgentID);
return(false);
}
}
else
{
reason = "Could not find the grid service";
ResetFromTransit(AgentID);
return(false);
}
IEventQueueService EQService = m_registry.RequestModuleInterface <IEventQueueService>();
IRegionClientCapsService otherRegion = clientCaps.GetCapsService(destination.RegionHandle);
EQService.TeleportFinishEvent(destination.RegionHandle, destination.Access, destination.ExternalEndPoint, otherRegion.CapsUrl,
4, AgentID, TeleportFlags,
destination.RegionSizeX, destination.RegionSizeY,
requestingRegion);
// TeleportFinish makes the client send CompleteMovementIntoRegion (at the destination), which
// trigers a whole shebang of things there, including MakeRoot. So let's wait for confirmation
// that the client contacted the destination before we send the attachments and close things here.
result = WaitForCallback(AgentID, out callWasCanceled);
if (!result)
{
//It says it failed, lets call the sim and check
IAgentData data = null;
result = SimulationService.RetrieveAgent(destination, AgentID, out data);
}
if (!result)
{
if (!callWasCanceled)
{
m_log.Warn("[AgentProcessing]: Callback never came for teleporting agent " +
AgentID + ". Resetting.");
}
INeighborService service = m_registry.RequestModuleInterface <INeighborService>();
if (service != null)
{
//Close the agent at the place we just created if it isn't a neighbor
if (service.IsOutsideView(regionCaps.RegionX, destination.RegionLocX, regionCaps.Region.RegionSizeX, destination.RegionSizeX,
regionCaps.RegionY, destination.RegionLocY, regionCaps.Region.RegionSizeY, destination.RegionSizeY))
{
SimulationService.CloseAgent(destination, AgentID);
}
}
clientCaps.RemoveCAPS(destination.RegionHandle);
if (!callWasCanceled)
{
reason = "The teleport timed out";
}
else
{
reason = "Cancelled";
}
}
else
{
//Fix the root agent status
otherRegion.RootAgent = true;
regionCaps.RootAgent = false;
// Next, let's close the child agent connections that are too far away.
CloseNeighborAgents(regionCaps.Region, destination, AgentID);
reason = "";
}
}
else
{
reason = "No SimulationService found!";
}
}
catch (Exception ex)
{
m_log.WarnFormat("[AgentProcessing]: Exception occured during agent teleport, {0}", ex.ToString());
reason = "Exception occured.";
}
//All done
ResetFromTransit(AgentID);
return(result);
}
