/// <summary>
/// Cache the friends list or increment the refcount for the existing friends list.
/// </summary>
/// <param name="client">
/// </param>
/// <returns>
/// Returns true if the list was fetched, false if it wasn't
/// </returns>
protected virtual bool CacheFriends(IClientAPI client)
{
bool result = false;
UserFriendData friendsData;
UUID agentID = client.AgentId;
if (!m_Friends.TryGetValue(agentID, out friendsData))
{
/* better to do some unnecessary fetches outside of an WriterLock instead of trying to reduce that and locking up the FriendsModule */
friendsData = new UserFriendData();
friendsData.PrincipalID = agentID;
friendsData.Friends = GetFriendsFromService(client);
try
{
m_Friends.AddIfNotExists(agentID, delegate()
{
result = true;
return(friendsData);
});
}
catch (ThreadedClasses.RwLockedDictionary <UUID, UserFriendData> .KeyAlreadyExistsException)
{
}
}
return(result);
}
// Legacy. Just don't do this.
// Returns 'null' if region not found
public double[,] LoadTerrain(UUID regionID)
{
HeightMapTerrainData data;
if (m_terrains.TryGetValue(regionID, out data))
{
return(data.GetDoubles());
}
return(null);
}
// -----------------------------------------------------------------
/// <summary>
///
/// </summary>
// -----------------------------------------------------------------
public JsonStoreNodeType GetNodeType(UUID storeID, string path)
{
if (!m_enabled)
{
return(JsonStoreNodeType.Undefined);
}
JsonStore map = null;
if (!m_JsonValueStore.TryGetValue(storeID, out map))
{
m_log.InfoFormat("[JsonStore] Missing store {0}", storeID);
return(JsonStoreNodeType.Undefined);
}
try
{
lock (map)
return(map.GetNodeType(path));
}
catch (Exception e)
{
m_log.Error(string.Format("[JsonStore]: Path test failed for {0} in {1}", path, storeID), e);
}
return(JsonStoreNodeType.Undefined);
}
private bool HasEvents(UUID RequestID, UUID sessionID)
{
ConsoleConnection c = null;
if (!m_Connections.TryGetValue(sessionID, out c))
{
return(false);
}
c.last = System.Environment.TickCount;
if (c.lastLineSeen < m_LineNumber)
{
return(true);
}
return(false);
}
/// <summary>
/// Returns the item if it exists in this folder or in any of this folder's descendant folders
/// </summary>
/// <param name="itemID"></param>
/// <returns>null if the item is not found</returns>
public InventoryItemBase FindItem(UUID itemID)
{
InventoryItemBase ret;
if (Items.TryGetValue(itemID, out ret))
{
return(ret);
}
try
{
foreach (InventoryFolderImpl folder in m_childFolders.Values)
{
InventoryItemBase item = folder.FindItem(itemID);
if (item != null)
{
throw new ThreadedClasses.ReturnValueException <InventoryItemBase>(item);
}
}
}
catch (ThreadedClasses.ReturnValueException <InventoryItemBase> e)
{
return(e.Value);
}
return(null);
}
/**********************************************
* Remote Data Reply
*
* Response to RPC message
*
*********************************************/
public void RemoteDataReply(string channel, string message_id, string sdata, int idata)
{
UUID message_key = new UUID(message_id);
UUID channel_key = new UUID(channel);
RPCRequestInfo rpcInfo = null;
if (message_key == UUID.Zero)
{
m_rpcPendingResponses.ForEach(delegate(RPCRequestInfo oneRpcInfo)
{
if (oneRpcInfo.GetChannelKey() == channel_key)
{
rpcInfo = oneRpcInfo;
}
});
}
else
{
m_rpcPendingResponses.TryGetValue(message_key, out rpcInfo);
}
if (rpcInfo != null)
{
rpcInfo.SetStrRetval(sdata);
rpcInfo.SetIntRetval(idata);
rpcInfo.SetProcessed(true);
m_rpcPendingResponses.Remove(message_key);
}
else
{
m_log.Warn("[XML RPC MODULE]: Channel or message_id not found");
}
}
public XGroup GetGroup(UUID groupID)
{
XGroup group = null;
m_groups.TryGetValue(groupID, out group);
return(group);
}
/// <summary>
/// Get a child folder
/// </summary>
/// <param name="folderID"></param>
/// <returns>The folder if it exists, null if it doesn't</returns>
public InventoryFolderImpl GetChildFolder(UUID folderID)
{
InventoryFolderImpl folder = null;
m_childFolders.TryGetValue(folderID, out folder);
return(folder);
}
void HandleUUIDNameRequest(UUID uuid, IClientAPI client)
{
// m_log.DebugFormat(
// "[USER MANAGEMENT MODULE]: Handling request for name binding of UUID {0} from {1}",
// uuid, remote_client.Name);
if (m_Scenes[0].LibraryService != null && (m_Scenes[0].LibraryService.LibraryRootFolder.Owner == uuid))
{
client.SendNameReply(uuid, "Mr", "OpenSim");
}
else
{
UserData user;
/* bypass that continuation here when entry is already available */
if (m_UserCache.TryGetValue(uuid, out user))
{
if (!user.IsUnknownUser && user.HasGridUserTried)
{
client.SendNameReply(uuid, user.FirstName, user.LastName);
return;
}
}
// Not found in cache, queue continuation
m_ServiceThrottle.Enqueue("name", uuid.ToString(), delegate
{
//m_log.DebugFormat("[YYY]: Name request {0}", uuid);
// As least upto September 2013, clients permanently cache UUID -> Name bindings. Some clients
// appear to clear this when the user asks it to clear the cache, but others may not.
//
// So to avoid clients
// (particularly Hypergrid clients) permanently binding "Unknown User" to a given UUID, we will
// instead drop the request entirely.
if (GetUser(uuid, out user))
{
client.SendNameReply(uuid, user.FirstName, user.LastName);
}
// else
// m_log.DebugFormat(
// "[USER MANAGEMENT MODULE]: No bound name for {0} found, ignoring request from {1}",
// uuid, client.Name);
});
}
}
public string GetInventoryServiceURL(UUID userID)
{
string inventoryURL;
if (m_InventoryURLs.TryGetValue(userID, out inventoryURL))
{
return(inventoryURL);
}
CacheInventoryServiceURL(userID);
if (m_InventoryURLs.TryGetValue(userID, out inventoryURL))
{
return(inventoryURL);
}
return(null); //it means that the methods should forward to local grid's inventory
}
/// <summary>
/// May return a null queue
/// </summary>
/// <param name="agentId"></param>
/// <returns></returns>
private ThreadedClasses.BlockingQueue <OSD> GetQueue(UUID agentId)
{
ThreadedClasses.BlockingQueue <OSD> queue = null;
if (queues.TryGetValue(agentId, out queue))
{
return(queue);
}
return(null);
}
public XmlRpcResponse XmlRpcRemoteData(XmlRpcRequest request, IPEndPoint remoteClient)
{
XmlRpcResponse response = new XmlRpcResponse();
Hashtable requestData = (Hashtable)request.Params[0];
bool GoodXML = (requestData.Contains("Channel") && requestData.Contains("IntValue") &&
requestData.Contains("StringValue"));
if (GoodXML)
{
UUID channel = new UUID((string)requestData["Channel"]);
RPCChannelInfo rpcChanInfo;
if (m_openChannels.TryGetValue(channel, out rpcChanInfo))
{
string intVal = Convert.ToInt32(requestData["IntValue"]).ToString();
string strVal = (string)requestData["StringValue"];
RPCRequestInfo rpcInfo;
rpcInfo =
new RPCRequestInfo(rpcChanInfo.GetLocalID(), rpcChanInfo.GetItemID(), channel, strVal,
intVal);
m_rpcPending.Add(rpcInfo.GetMessageID(), rpcInfo);
int timeoutCtr = 0;
while (!rpcInfo.IsProcessed() && (timeoutCtr < RemoteReplyScriptTimeout))
{
Thread.Sleep(RemoteReplyScriptWait);
timeoutCtr += RemoteReplyScriptWait;
}
if (rpcInfo.IsProcessed())
{
Hashtable param = new Hashtable();
param["StringValue"] = rpcInfo.GetStrRetval();
param["IntValue"] = rpcInfo.GetIntRetval();
ArrayList parameters = new ArrayList();
parameters.Add(param);
response.Value = parameters;
rpcInfo = null;
}
else
{
response.SetFault(-1, "Script timeout");
rpcInfo = null;
}
}
else
{
response.SetFault(-1, "Invalid channel");
}
}
return(response);
}
public void InsertEmail(UUID to, Email email)
{
// It's tempting to create the queue here. Don't; objects which have
// not yet called GetNextEmail should have no queue, and emails to them
// should be silently dropped.
EmailQueue val;
if (m_MailQueues.TryGetValue(to, out val))
{
if (val.m_Queue.Count >= m_MaxQueueSize)
{
// fail silently
return;
}
val.m_LastCall = DateTime.Now;
val.m_Queue.Add(email);
}
}
public UUID GetAsset(UUID itemID)
{
UUID result;
if (m_items.TryGetValue(itemID, out result))
{
return(result);
}
return(UUID.Zero);
}
public string LoadRegionEnvironmentSettings(UUID regionUUID)
{
string val;
if (EnvironmentSettings.TryGetValue(regionUUID, out val))
{
return(val);
}
return(string.Empty);
}
/// <summary>
/// Get a module commander
/// </summary>
/// <param name="name"></param>
/// <returns>The module commander, null if no module commander with that name was found</returns>
public ICommander GetCommander(string name)
{
ICommander val;
if (m_moduleCommanders.TryGetValue(name, out val))
{
return(val);
}
return(null);
}
public void RemoveCompletedRequest(UUID id)
{
HttpRequestClass tmpReq;
if (m_pendingRequests.TryGetValue(id, out tmpReq))
{
tmpReq.Stop();
tmpReq = null;
m_pendingRequests.Remove(id);
}
}
public Hashtable FreeSwitchSLVoiceSigninHTTPHandler(Hashtable request)
{
m_log.Debug("[FreeSwitchVoice]: FreeSwitchSLVoiceSigninHTTPHandler called");
// string requestbody = (string)request["body"];
// string uri = (string)request["uri"];
// string contenttype = (string)request["content-type"];
Hashtable requestBody = ParseRequestBody((string)request["body"]);
//string pwd = (string) requestBody["pwd"];
string userid = (string)requestBody["userid"];
string avatarName = string.Empty;
int pos = -1;
if (m_UUIDName.TryGetValue(userid, out avatarName))
{
foreach (string s in m_UUIDName.Keys)
{
pos++;
if (s == userid)
{
break;
}
}
}
//m_log.DebugFormat("[FreeSwitchVoice]: AUTH, URI: {0}, Content-Type:{1}, Body{2}", uri, contenttype,
// requestbody);
Hashtable response = new Hashtable();
response["str_response_string"] = string.Format(@"<response xsi:schemaLocation=""/xsd/signin.xsd"">
<level0>
<status>OK</status>
<body>
<code>200</code>
<cookie_name>lib_session</cookie_name>
<cookie>{0}:{1}:9303959503950::</cookie>
<auth_token>{0}:{1}:9303959503950::</auth_token>
<primary>1</primary>
<account_id>{1}</account_id>
<displayname>{2}</displayname>
<msg>auth successful</msg>
</body>
</level0>
</response>", userid, pos, avatarName);
response["int_response_code"] = 200;
// m_log.DebugFormat("[FreeSwitchVoice]: Sending FreeSwitchSLVoiceSigninHTTPHandler response");
return(response);
}
public bool TryGet <T>(out T iface)
{
object o;
if (m_moduleInterfaces.TryGetValue(typeof(T), out o))
{
iface = (T)o;
return(true);
}
iface = default(T);
return(false);
}
public string LookupModInvocation(string fname)
{
ScriptInvocationData sid;
if (m_scriptInvocation.TryGetValue(fname, out sid))
{
if (sid.ReturnType == typeof(string))
{
return("modInvokeS");
}
else if (sid.ReturnType == typeof(int))
{
return("modInvokeI");
}
else if (sid.ReturnType == typeof(float))
{
return("modInvokeF");
}
else if (sid.ReturnType == typeof(UUID))
{
return("modInvokeK");
}
else if (sid.ReturnType == typeof(OpenMetaverse.Vector3))
{
return("modInvokeV");
}
else if (sid.ReturnType == typeof(OpenMetaverse.Quaternion))
{
return("modInvokeR");
}
else if (sid.ReturnType == typeof(object[]))
{
return("modInvokeL");
}
m_log.WarnFormat("[MODULE COMMANDS] failed to find match for {0} with return type {1}", fname, sid.ReturnType.Name);
}
return(null);
}
public bool QueryAccess(GridRegion destination, UUID agentID, string agentHomeURI, Vector3 position, string theirversion, out string version, out string reason)
{
reason = "Communications failure";
version = ServiceVersion;
if (destination == null)
{
return(false);
}
Scene scene;
if (m_scenes.TryGetValue(destination.RegionID, out scene))
{
// m_log.DebugFormat(
// "[LOCAL SIMULATION CONNECTOR]: Found region {0} {1} to send AgentUpdate",
// s.RegionInfo.RegionName, destination.RegionHandle);
uint size = scene.RegionInfo.RegionSizeX;
float theirVersionNumber = 0f;
string[] versionComponents = theirversion.Split(new char[] { '/' });
if (versionComponents.Length >= 2)
{
float.TryParse(versionComponents[1], out theirVersionNumber);
}
// Var regions here, and the requesting simulator is in an older version.
// We will forbide this, because it crashes the viewers
if (theirVersionNumber < 0.3f && size > 256)
{
reason = "Destination is a variable-sized region, and source is an old simulator. Consider upgrading.";
m_log.DebugFormat("[LOCAL SIMULATION CONNECTOR]: Request to access this variable-sized region from {0} simulator was denied", theirVersionNumber);
return(false);
}
return(scene.QueryAccess(agentID, agentHomeURI, position, out reason));
}
//m_log.Debug("[LOCAL COMMS]: region not found for QueryAccess");
return(false);
}
/// <summary>
/// Operation to check for a registered constant
/// </summary>
public object LookupModConstant(string cname)
{
// m_log.DebugFormat("[MODULE COMMANDS] lookup constant <{0}>",cname);
object value = null;
if (m_constants.TryGetValue(cname, out value))
{
return(value);
}
return(null);
}
public static void Remove(KeyframeMotion motion)
{
KeyframeTimer timer;
if (motion.Scene == null)
{
return;
}
if (m_timers.TryGetValue(motion.Scene, out timer))
{
timer.m_motions.Remove(motion);
}
}
// private void OnInstantMessage(IClientAPI client, GridInstantMessage im)
// {
// }
// private void OnGridInstantMessage(GridInstantMessage msg)
// {
// // Trigger the above event handler
// OnInstantMessage(null, msg);
// }
private void HandleUUIDGroupNameRequest(UUID id, IClientAPI remote_client)
{
string groupnamereply = "Unknown";
UUID groupUUID = UUID.Zero;
GroupMembershipData grp;
if (m_GroupMap.TryGetValue(id, out grp))
{
groupnamereply = grp.GroupName;
groupUUID = grp.GroupID;
}
remote_client.SendGroupNameReply(groupUUID, groupnamereply);
}
public InventoryFolderBase GetFolderForType(UUID userID, AssetType type)
{
ThreadedClasses.RwLockedDictionary <AssetType, InventoryFolderBase> ff = null;
if (m_FolderTypes.TryGetValue(userID, out ff))
{
InventoryFolderBase f = null;
if (ff.TryGetValue(type, out f))
{
return(f);
}
}
return(null);
}
private string ChannelUri(Scene scene, LandData land)
{
string channelUri = null;
string landUUID;
string landName;
// Create parcel voice channel. If no parcel exists, then the voice channel ID is the same
// as the directory ID. Otherwise, it reflects the parcel's ID.
string parcelAddress;
if (m_ParcelAddress.TryGetValue(land.GlobalID.ToString(), out parcelAddress))
{
m_log.DebugFormat("[FreeSwitchVoice]: parcel id {0}: using sip address {1}",
land.GlobalID, parcelAddress);
return(parcelAddress);
}
if (land.LocalID != 1 && (land.Flags & (uint)ParcelFlags.UseEstateVoiceChan) == 0)
{
landName = String.Format("{0}:{1}", scene.RegionInfo.RegionName, land.Name);
landUUID = land.GlobalID.ToString();
m_log.DebugFormat("[FreeSwitchVoice]: Region:Parcel \"{0}\": parcel id {1}: using channel name {2}",
landName, land.LocalID, landUUID);
}
else
{
landName = String.Format("{0}:{1}", scene.RegionInfo.RegionName, scene.RegionInfo.RegionName);
landUUID = scene.RegionInfo.RegionID.ToString();
m_log.DebugFormat("[FreeSwitchVoice]: Region:Parcel \"{0}\": parcel id {1}: using channel name {2}",
landName, land.LocalID, landUUID);
}
// slvoice handles the sip address differently if it begins with confctl, hiding it from the user in the friends list. however it also disables
// the personal speech indicators as well unless some siren14-3d codec magic happens. we dont have siren143d so we'll settle for the personal speech indicator.
channelUri = String.Format("sip:conf-{0}@{1}", "x" + Convert.ToBase64String(Encoding.ASCII.GetBytes(landUUID)), m_freeSwitchRealm);
try
{
m_ParcelAddress.Add(land.GlobalID.ToString(), channelUri);
}
catch
{
}
return(channelUri);
}
private static void UpdateThread(int threadID)
{
ThreadWatchdogInfo threadInfo;
// Although TryGetValue is not a thread safe operation, we use a try/catch here instead
// of a lock for speed. Adding/removing threads is a very rare operation compared to
// UpdateThread(), and a single UpdateThread() failure here and there won't break
// anything
if (m_threads.TryGetValue(threadID, out threadInfo))
{
threadInfo.LastTick = Environment.TickCount;
threadInfo.IsTimedOut = false;
}
else
{
m_log.WarnFormat("[WATCHDOG]: Asked to update thread {0} which is not being monitored", threadID);
}
}
/// <summary>
/// Get listeners matching the input parameters.
/// </summary>
/// <remarks>
/// Theres probably a more clever and efficient way to do this, maybe
/// with regex.
/// PM2008: Ha, one could even be smart and define a specialized
/// Enumerator.
/// </remarks>
/// <param name="itemID"></param>
/// <param name="channel"></param>
/// <param name="name"></param>
/// <param name="id"></param>
/// <param name="msg"></param>
/// <returns></returns>
public List <ListenerInfo> GetListeners(UUID itemID, int channel,
string name, UUID id, string msg)
{
List <ListenerInfo> collection = new List <ListenerInfo>();
ThreadedClasses.RwLockedList <ListenerInfo> listeners;
if (!m_listeners.TryGetValue(channel, out listeners))
{
return(collection);
}
listeners.ForEach(delegate(ListenerInfo li)
{
if (!li.IsActive())
{
return;
}
if (!itemID.Equals(UUID.Zero) &&
!li.GetItemID().Equals(itemID))
{
return;
}
if (li.GetName().Length > 0 && (
((li.RegexBitfield & OS_LISTEN_REGEX_NAME) != OS_LISTEN_REGEX_NAME && !li.GetName().Equals(name)) ||
((li.RegexBitfield & OS_LISTEN_REGEX_NAME) == OS_LISTEN_REGEX_NAME && !Regex.IsMatch(name, li.GetName()))
))
{
return;
}
if (!li.GetID().Equals(UUID.Zero) && !li.GetID().Equals(id))
{
return;
}
if (li.GetMessage().Length > 0 && (
((li.RegexBitfield & OS_LISTEN_REGEX_MESSAGE) != OS_LISTEN_REGEX_MESSAGE && !li.GetMessage().Equals(msg)) ||
((li.RegexBitfield & OS_LISTEN_REGEX_MESSAGE) == OS_LISTEN_REGEX_MESSAGE && !Regex.IsMatch(msg, li.GetMessage()))
))
{
return;
}
collection.Add(li);
});
return(collection);
}
public void HttpContentType(UUID request, string type)
{
UrlData urlData;
if (m_RequestMap.TryGetValue(request, out urlData))
{
urlData.requests[request].responseType = type;
}
else
{
m_log.Info("[HttpRequestHandler] There is no http-in request with id " + request.ToString());
}
}
public IServiceRequest GetNextCompletedSRDRequest()
{
try
{
m_pendingSRDResponses.ForEach(delegate(UUID luid)
{
SendRemoteDataRequest tmpReq;
if (m_pendingSRDResponses.TryGetValue(luid, out tmpReq))
{
if (tmpReq.Finished)
{
throw new ThreadedClasses.ReturnValueException <SendRemoteDataRequest>(tmpReq);
}
}
});
}
catch (ThreadedClasses.ReturnValueException <SendRemoteDataRequest> e)
{
return(e.Value);
}
return(null);
}