OpenSim
/
OpenSimMirror
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Fix possible infinite recursion in MessageTransferModule.SendGridInstantMessageViaXMLRPCAsync() whilst preserving retry lookup behaviour. 

This is based on heavily mikemig's original patch in http://opensimulator.org/mantis/view.php?id=7149
but instead of exiting after the first IM delivery failure to presence information retrieved from the presence service
it will retry the lookup until the result matches the previous lookup.
This is to deal with the case where the agent is sent an IM whilst they are teleporting.
bullet-2.82
Justin Clark-Casey (justincc) 2014-05-23 20:14:49 +01:00
parent 5015b0b485
commit 72c67c5091
1 changed files with 57 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

138
OpenSim/Region/CoreModules/Avatar/InstantMessage/MessageTransferModule.cs
View File

@ -428,7 +428,7 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
/// <summary> /// <summary>
/// delegate for sending a grid instant message asynchronously /// delegate for sending a grid instant message asynchronously
/// </summary> /// </summary>
public delegate void GridInstantMessageDelegate(GridInstantMessage im, MessageResultNotification result, UUID prevRegionID); public delegate void GridInstantMessageDelegate(GridInstantMessage im, MessageResultNotification result);
protected virtual void GridInstantMessageCompleted(IAsyncResult iar) protected virtual void GridInstantMessageCompleted(IAsyncResult iar)
{ {
@ -442,139 +442,88 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
{ {
GridInstantMessageDelegate d = SendGridInstantMessageViaXMLRPCAsync; GridInstantMessageDelegate d = SendGridInstantMessageViaXMLRPCAsync;
d.BeginInvoke(im, result, UUID.Zero, GridInstantMessageCompleted, d); d.BeginInvoke(im, result, GridInstantMessageCompleted, d);
} }
/// <summary> /// <summary>
/// Recursive SendGridInstantMessage over XMLRPC method. /// Internal SendGridInstantMessage over XMLRPC method.
/// This is called from within a dedicated thread.
/// The first time this is called, prevRegionHandle will be 0 Subsequent times this is called from
/// itself, prevRegionHandle will be the last region handle that we tried to send.
/// If the handles are the same, we look up the user's location using the grid.
/// If the handles are still the same, we end. The send failed.
/// </summary> /// </summary>
/// <param name="prevRegionHandle"> /// <remarks>
/// Pass in 0 the first time this method is called. It will be called recursively with the last /// This is called from within a dedicated thread.
/// regionhandle tried /// </remarks>
/// </param> private void SendGridInstantMessageViaXMLRPCAsync(GridInstantMessage im, MessageResultNotification result)
protected virtual void SendGridInstantMessageViaXMLRPCAsync(GridInstantMessage im, MessageResultNotification result, UUID prevRegionID)
{ {
UUID toAgentID = new UUID(im.toAgentID); UUID toAgentID = new UUID(im.toAgentID);
UUID regionID;
PresenceInfo upd = null; bool needToLookupAgent;
bool lookupAgent = false;
lock (m_UserRegionMap) lock (m_UserRegionMap)
{ needToLookupAgent = !m_UserRegionMap.TryGetValue(toAgentID, out regionID);
if (m_UserRegionMap.ContainsKey(toAgentID))
{
upd = new PresenceInfo();
upd.RegionID = m_UserRegionMap[toAgentID];
// We need to compare the current regionhandle with the previous region handle while (true)
// or the recursive loop will never end because it will never try to lookup the agent again
if (prevRegionID == upd.RegionID)
{ {
lookupAgent = true; if (needToLookupAgent)
}
}
else
{ {
lookupAgent = true;
}
}
// Are we needing to look-up an agent?
if (lookupAgent)
{
// Non-cached user agent lookup.
PresenceInfo[] presences = PresenceService.GetAgents(new string[] { toAgentID.ToString() }); PresenceInfo[] presences = PresenceService.GetAgents(new string[] { toAgentID.ToString() });
if (presences != null && presences.Length > 0)
UUID foundRegionID = UUID.Zero;
if (presences != null)
{ {
foreach (PresenceInfo p in presences) foreach (PresenceInfo p in presences)
{ {
if (p.RegionID != UUID.Zero) if (p.RegionID != UUID.Zero)
{ {
upd = p; foundRegionID = p.RegionID;
break; break;
} }
} }
} }
if (upd != null) // If not found or the found region is the same as the last lookup, then message is undeliverable
{ if (foundRegionID == UUID.Zero || foundRegionID == regionID)
// check if we've tried this before.. break;
// This is one way to end the recursive loop
//
if (upd.RegionID == prevRegionID)
{
// m_log.Error("[GRID INSTANT MESSAGE]: Unable to deliver an instant message");
HandleUndeliverableMessage(im, result);
return;
}
}
else else
{ regionID = foundRegionID;
// m_log.Error("[GRID INSTANT MESSAGE]: Unable to deliver an instant message");
HandleUndeliverableMessage(im, result);
return;
}
} }
if (upd != null) GridRegion reginfo = m_Scenes[0].GridService.GetRegionByUUID(m_Scenes[0].RegionInfo.ScopeID, regionID);
{ if (reginfo == null)
GridRegion reginfo = m_Scenes[0].GridService.GetRegionByUUID(m_Scenes[0].RegionInfo.ScopeID,
upd.RegionID);
if (reginfo != null)
{ {
m_log.WarnFormat("[GRID INSTANT MESSAGE]: Unable to find region {0}", regionID);
break;
}
// Try to send the message to the agent via the retrieved region.
Hashtable msgdata = ConvertGridInstantMessageToXMLRPC(im); Hashtable msgdata = ConvertGridInstantMessageToXMLRPC(im);
// Not actually used anymore, left in for compatibility
// Remove at next interface change
//
msgdata["region_handle"] = 0; msgdata["region_handle"] = 0;
bool imresult = doIMSending(reginfo, msgdata); bool imresult = doIMSending(reginfo, msgdata);
// If the message delivery was successful, then cache the entry.
if (imresult) if (imresult)
{ {
// IM delivery successful, so store the Agent's location in our local cache.
lock (m_UserRegionMap) lock (m_UserRegionMap)
{ {
if (m_UserRegionMap.ContainsKey(toAgentID)) m_UserRegionMap[toAgentID] = regionID;
{
m_UserRegionMap[toAgentID] = upd.RegionID;
}
else
{
m_UserRegionMap.Add(toAgentID, upd.RegionID);
}
} }
result(true); result(true);
return;
} }
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!!!!! // If we reach this point in the first iteration of the while, then we may have unsuccessfully tried
SendGridInstantMessageViaXMLRPCAsync(im, result, // to use a locally cached region ID. All subsequent attempts need to lookup agent details from
upd.RegionID); // the presence service.
needToLookupAgent = true;
} }
}
else // If we reached this point then the message was not deliverable. Remove the bad cache entry and
{ // signal the delivery failure.
m_log.WarnFormat("[GRID INSTANT MESSAGE]: Unable to find region {0}", upd.RegionID); lock (m_UserRegionMap)
m_UserRegionMap.Remove(toAgentID);
// m_log.Error("[GRID INSTANT MESSAGE]: Unable to deliver an instant message");
HandleUndeliverableMessage(im, result); HandleUndeliverableMessage(im, result);
} }
}
else
{
HandleUndeliverableMessage(im, result);
}
}
/// <summary> /// <summary>
/// This actually does the XMLRPC Request /// This actually does the XMLRPC Request
@ -584,7 +533,6 @@ namespace OpenSim.Region.CoreModules.Avatar.InstantMessage
/// <returns>Bool if the message was successfully delivered at the other side.</returns> /// <returns>Bool if the message was successfully delivered at the other side.</returns>
protected virtual bool doIMSending(GridRegion reginfo, Hashtable xmlrpcdata) protected virtual bool doIMSending(GridRegion reginfo, Hashtable xmlrpcdata)
{ {
ArrayList SendParams = new ArrayList(); ArrayList SendParams = new ArrayList();
SendParams.Add(xmlrpcdata); SendParams.Add(xmlrpcdata);
XmlRpcRequest GridReq = new XmlRpcRequest("grid_instant_message", SendParams); XmlRpcRequest GridReq = new XmlRpcRequest("grid_instant_message", SendParams);