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

Update svn properties.

0.6.6-post-fixes
Jeff Ames 2009-06-09 17:48:22 +00:00
parent 28324e5174
commit 135ff63c3d
4 changed files with 1538 additions and 1538 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

932
OpenSim/Framework/InventoryFolderImpl.cs
View File

@ -1,466 +1,466 @@
/* /*
* Copyright (c) Contributors, http://opensimulator.org/ * Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders. * See CONTRIBUTORS.TXT for a full list of copyright holders.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met: * modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright * * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer. * notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright * * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the * notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution. * documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSimulator Project nor the * * Neither the name of the OpenSimulator Project nor the
* names of its contributors may be used to endorse or promote products * names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission. * derived from this software without specific prior written permission.
* *
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using OpenMetaverse; using OpenMetaverse;
namespace OpenSim.Framework namespace OpenSim.Framework
{ {
public class InventoryFolderImpl : InventoryFolderBase public class InventoryFolderImpl : InventoryFolderBase
{ {
//private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); //private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
public static readonly string PATH_DELIMITER = "/"; public static readonly string PATH_DELIMITER = "/";
/// <summary> /// <summary>
/// Items that are contained in this folder /// Items that are contained in this folder
/// </summary> /// </summary>
public Dictionary<UUID, InventoryItemBase> Items = new Dictionary<UUID, InventoryItemBase>(); public Dictionary<UUID, InventoryItemBase> Items = new Dictionary<UUID, InventoryItemBase>();
/// <summary> /// <summary>
/// Child folders that are contained in this folder /// Child folders that are contained in this folder
/// </summary> /// </summary>
protected Dictionary<UUID, InventoryFolderImpl> m_childFolders = new Dictionary<UUID, InventoryFolderImpl>(); protected Dictionary<UUID, InventoryFolderImpl> m_childFolders = new Dictionary<UUID, InventoryFolderImpl>();
// Constructors // Constructors
public InventoryFolderImpl(InventoryFolderBase folderbase) public InventoryFolderImpl(InventoryFolderBase folderbase)
{ {
Owner = folderbase.Owner; Owner = folderbase.Owner;
ID = folderbase.ID; ID = folderbase.ID;
Name = folderbase.Name; Name = folderbase.Name;
ParentID = folderbase.ParentID; ParentID = folderbase.ParentID;
Type = folderbase.Type; Type = folderbase.Type;
Version = folderbase.Version; Version = folderbase.Version;
} }
public InventoryFolderImpl() public InventoryFolderImpl()
{ {
} }
/// <summary> /// <summary>
/// Create a new subfolder. /// Create a new subfolder.
/// </summary> /// </summary>
/// <param name="folderID"></param> /// <param name="folderID"></param>
/// <param name="folderName"></param> /// <param name="folderName"></param>
/// <param name="type"></param> /// <param name="type"></param>
/// <returns>The newly created subfolder. Returns null if the folder already exists</returns> /// <returns>The newly created subfolder. Returns null if the folder already exists</returns>
public InventoryFolderImpl CreateChildFolder(UUID folderID, string folderName, ushort type) public InventoryFolderImpl CreateChildFolder(UUID folderID, string folderName, ushort type)
{ {
lock (m_childFolders) lock (m_childFolders)
{ {
if (!m_childFolders.ContainsKey(folderID)) if (!m_childFolders.ContainsKey(folderID))
{ {
InventoryFolderImpl subFold = new InventoryFolderImpl(); InventoryFolderImpl subFold = new InventoryFolderImpl();
subFold.Name = folderName; subFold.Name = folderName;
subFold.ID = folderID; subFold.ID = folderID;
subFold.Type = (short)type; subFold.Type = (short)type;
subFold.ParentID = this.ID; subFold.ParentID = this.ID;
subFold.Owner = Owner; subFold.Owner = Owner;
m_childFolders.Add(subFold.ID, subFold); m_childFolders.Add(subFold.ID, subFold);
return subFold; return subFold;
} }
} }
return null; return null;
} }
/// <summary> /// <summary>
/// Add a folder that already exists. /// Add a folder that already exists.
/// </summary> /// </summary>
/// <param name="folder"></param> /// <param name="folder"></param>
public void AddChildFolder(InventoryFolderImpl folder) public void AddChildFolder(InventoryFolderImpl folder)
{ {
lock (m_childFolders) lock (m_childFolders)
{ {
folder.ParentID = ID; folder.ParentID = ID;
m_childFolders[folder.ID] = folder; m_childFolders[folder.ID] = folder;
} }
} }
/// <summary> /// <summary>
/// Does this folder contain the given child folder? /// Does this folder contain the given child folder?
/// </summary> /// </summary>
/// <param name="folderID"></param> /// <param name="folderID"></param>
/// <returns></returns> /// <returns></returns>
public bool ContainsChildFolder(UUID folderID) public bool ContainsChildFolder(UUID folderID)
{ {
return m_childFolders.ContainsKey(folderID); return m_childFolders.ContainsKey(folderID);
} }
/// <summary> /// <summary>
/// Get a child folder /// Get a child folder
/// </summary> /// </summary>
/// <param name="folderID"></param> /// <param name="folderID"></param>
/// <returns>The folder if it exists, null if it doesn't</returns> /// <returns>The folder if it exists, null if it doesn't</returns>
public InventoryFolderImpl GetChildFolder(UUID folderID) public InventoryFolderImpl GetChildFolder(UUID folderID)
{ {
InventoryFolderImpl folder = null; InventoryFolderImpl folder = null;
lock (m_childFolders) lock (m_childFolders)
{ {
m_childFolders.TryGetValue(folderID, out folder); m_childFolders.TryGetValue(folderID, out folder);
} }
return folder; return folder;
} }
/// <summary> /// <summary>
/// Removes the given child subfolder. /// Removes the given child subfolder.
/// </summary> /// </summary>
/// <param name="folderID"></param> /// <param name="folderID"></param>
/// <returns> /// <returns>
/// The folder removed, or null if the folder was not present. /// The folder removed, or null if the folder was not present.
/// </returns> /// </returns>
public InventoryFolderImpl RemoveChildFolder(UUID folderID) public InventoryFolderImpl RemoveChildFolder(UUID folderID)
{ {
InventoryFolderImpl removedFolder = null; InventoryFolderImpl removedFolder = null;
lock (m_childFolders) lock (m_childFolders)
{ {
if (m_childFolders.ContainsKey(folderID)) if (m_childFolders.ContainsKey(folderID))
{ {
removedFolder = m_childFolders[folderID]; removedFolder = m_childFolders[folderID];
m_childFolders.Remove(folderID); m_childFolders.Remove(folderID);
} }
} }
return removedFolder; return removedFolder;
} }
/// <summary> /// <summary>
/// Delete all the folders and items in this folder. /// Delete all the folders and items in this folder.
/// </summary> /// </summary>
public void Purge() public void Purge()
{ {
foreach (InventoryFolderImpl folder in m_childFolders.Values) foreach (InventoryFolderImpl folder in m_childFolders.Values)
{ {
folder.Purge(); folder.Purge();
} }
m_childFolders.Clear(); m_childFolders.Clear();
Items.Clear(); Items.Clear();
} }
/// <summary> /// <summary>
/// Returns the item if it exists in this folder or in any of this folder's descendant folders /// Returns the item if it exists in this folder or in any of this folder's descendant folders
/// </summary> /// </summary>
/// <param name="itemID"></param> /// <param name="itemID"></param>
/// <returns>null if the item is not found</returns> /// <returns>null if the item is not found</returns>
public InventoryItemBase FindItem(UUID itemID) public InventoryItemBase FindItem(UUID itemID)
{ {
lock (Items) lock (Items)
{ {
if (Items.ContainsKey(itemID)) if (Items.ContainsKey(itemID))
{ {
return Items[itemID]; return Items[itemID];
} }
} }
lock (m_childFolders) lock (m_childFolders)
{ {
foreach (InventoryFolderImpl folder in m_childFolders.Values) foreach (InventoryFolderImpl folder in m_childFolders.Values)
{ {
InventoryItemBase item = folder.FindItem(itemID); InventoryItemBase item = folder.FindItem(itemID);
if (item != null) if (item != null)
{ {
return item; return item;
} }
} }
} }
return null; return null;
} }
public InventoryItemBase FindAsset(UUID assetID) public InventoryItemBase FindAsset(UUID assetID)
{ {
lock (Items) lock (Items)
{ {
foreach (InventoryItemBase item in Items.Values) foreach (InventoryItemBase item in Items.Values)
{ {
if (item.AssetID == assetID) if (item.AssetID == assetID)
return item; return item;
} }
} }
lock (m_childFolders) lock (m_childFolders)
{ {
foreach (InventoryFolderImpl folder in m_childFolders.Values) foreach (InventoryFolderImpl folder in m_childFolders.Values)
{ {
InventoryItemBase item = folder.FindAsset(assetID); InventoryItemBase item = folder.FindAsset(assetID);
if (item != null) if (item != null)
{ {
return item; return item;
} }
} }
} }
return null; return null;
} }
/// <summary> /// <summary>
/// Deletes an item if it exists in this folder or any children /// Deletes an item if it exists in this folder or any children
/// </summary> /// </summary>
/// <param name="folderID"></param> /// <param name="folderID"></param>
/// <returns></returns> /// <returns></returns>
public bool DeleteItem(UUID itemID) public bool DeleteItem(UUID itemID)
{ {
bool found = false; bool found = false;
lock (Items) lock (Items)
{ {
if (Items.ContainsKey(itemID)) if (Items.ContainsKey(itemID))
{ {
Items.Remove(itemID); Items.Remove(itemID);
return true; return true;
} }
} }
lock (m_childFolders) lock (m_childFolders)
{ {
foreach (InventoryFolderImpl folder in m_childFolders.Values) foreach (InventoryFolderImpl folder in m_childFolders.Values)
{ {
found = folder.DeleteItem(itemID); found = folder.DeleteItem(itemID);
if (found == true) if (found == true)
{ {
break; break;
} }
} }
} }
return found; return found;
} }
/// <summary> /// <summary>
/// Returns the folder requested if it is this folder or is a descendent of this folder. The search is depth /// Returns the folder requested if it is this folder or is a descendent of this folder. The search is depth
/// first. /// first.
/// </summary> /// </summary>
/// <returns>The requested folder if it exists, null if it does not.</returns> /// <returns>The requested folder if it exists, null if it does not.</returns>
public InventoryFolderImpl FindFolder(UUID folderID) public InventoryFolderImpl FindFolder(UUID folderID)
{ {
if (folderID == ID) if (folderID == ID)
return this; return this;
lock (m_childFolders) lock (m_childFolders)
{ {
foreach (InventoryFolderImpl folder in m_childFolders.Values) foreach (InventoryFolderImpl folder in m_childFolders.Values)
{ {
InventoryFolderImpl returnFolder = folder.FindFolder(folderID); InventoryFolderImpl returnFolder = folder.FindFolder(folderID);
if (returnFolder != null) if (returnFolder != null)
return returnFolder; return returnFolder;
} }
} }
return null; return null;
} }
/// <summary> /// <summary>
/// Look through all child subfolders for a folder marked as one for a particular asset type, and return it. /// Look through all child subfolders for a folder marked as one for a particular asset type, and return it.
/// </summary> /// </summary>
/// <param name="type"></param> /// <param name="type"></param>
/// <returns>Returns null if no such folder is found</returns> /// <returns>Returns null if no such folder is found</returns>
public InventoryFolderImpl FindFolderForType(int type) public InventoryFolderImpl FindFolderForType(int type)
{ {
lock (m_childFolders) lock (m_childFolders)
{ {
foreach (InventoryFolderImpl f in m_childFolders.Values) foreach (InventoryFolderImpl f in m_childFolders.Values)
{ {
if (f.Type == type) if (f.Type == type)
return f; return f;
} }
} }
return null; return null;
} }
/// <summary> /// <summary>
/// Find a folder given a PATH_DELIMITER delimited path starting from this folder /// Find a folder given a PATH_DELIMITER delimited path starting from this folder
/// </summary> /// </summary>
/// ///
/// This method does not handle paths that contain multiple delimitors /// This method does not handle paths that contain multiple delimitors
/// ///
/// FIXME: We do not yet handle situations where folders have the same name. We could handle this by some /// FIXME: We do not yet handle situations where folders have the same name. We could handle this by some
/// XPath like expression /// XPath like expression
/// ///
/// FIXME: Delimitors which occur in names themselves are not currently escapable. /// FIXME: Delimitors which occur in names themselves are not currently escapable.
/// ///
/// <param name="path"> /// <param name="path">
/// The path to the required folder. /// The path to the required folder.
/// It this is empty or consists only of the PATH_DELIMTER then this folder itself is returned. /// It this is empty or consists only of the PATH_DELIMTER then this folder itself is returned.
/// </param> /// </param>
/// <returns>null if the folder is not found</returns> /// <returns>null if the folder is not found</returns>
public InventoryFolderImpl FindFolderByPath(string path) public InventoryFolderImpl FindFolderByPath(string path)
{ {
if (path == string.Empty) if (path == string.Empty)
return this; return this;
path = path.Trim(); path = path.Trim();
if (path == PATH_DELIMITER) if (path == PATH_DELIMITER)
return this; return this;
string[] components = path.Split(new string[] { PATH_DELIMITER }, 2, StringSplitOptions.None); string[] components = path.Split(new string[] { PATH_DELIMITER }, 2, StringSplitOptions.None);
lock (m_childFolders) lock (m_childFolders)
{ {
foreach (InventoryFolderImpl folder in m_childFolders.Values) foreach (InventoryFolderImpl folder in m_childFolders.Values)
{ {
if (folder.Name == components[0]) if (folder.Name == components[0])
if (components.Length > 1) if (components.Length > 1)
return folder.FindFolderByPath(components[1]); return folder.FindFolderByPath(components[1]);
else else
return folder; return folder;
} }
} }
// We didn't find a folder with the given name // We didn't find a folder with the given name
return null; return null;
} }
/// <summary> /// <summary>
/// Find an item given a PATH_DELIMITOR delimited path starting from this folder. /// Find an item given a PATH_DELIMITOR delimited path starting from this folder.
/// ///
/// This method does not handle paths that contain multiple delimitors /// This method does not handle paths that contain multiple delimitors
/// ///
/// FIXME: We do not yet handle situations where folders or items have the same name. We could handle this by some /// FIXME: We do not yet handle situations where folders or items have the same name. We could handle this by some
/// XPath like expression /// XPath like expression
/// ///
/// FIXME: Delimitors which occur in names themselves are not currently escapable. /// FIXME: Delimitors which occur in names themselves are not currently escapable.
/// </summary> /// </summary>
/// <param name="path"> /// <param name="path">
/// The path to the required item. /// The path to the required item.
/// </param> /// </param>
/// <returns>null if the item is not found</returns> /// <returns>null if the item is not found</returns>
public InventoryItemBase FindItemByPath(string path) public InventoryItemBase FindItemByPath(string path)
{ {
string[] components = path.Split(new string[] { PATH_DELIMITER }, 2, StringSplitOptions.None); string[] components = path.Split(new string[] { PATH_DELIMITER }, 2, StringSplitOptions.None);
if (components.Length == 1) if (components.Length == 1)
{ {
lock (Items) lock (Items)
{ {
foreach (InventoryItemBase item in Items.Values) foreach (InventoryItemBase item in Items.Values)
{ {
if (item.Name == components[0]) if (item.Name == components[0])
return item; return item;
} }
} }
} }
else else
{ {
lock (m_childFolders) lock (m_childFolders)
{ {
foreach (InventoryFolderImpl folder in m_childFolders.Values) foreach (InventoryFolderImpl folder in m_childFolders.Values)
{ {
if (folder.Name == components[0]) if (folder.Name == components[0])
return folder.FindItemByPath(components[1]); return folder.FindItemByPath(components[1]);
} }
} }
} }
// We didn't find an item or intermediate folder with the given name // We didn't find an item or intermediate folder with the given name
return null; return null;
} }
/// <summary> /// <summary>
/// Return a copy of the list of child items in this folder. The items themselves are the originals. /// Return a copy of the list of child items in this folder. The items themselves are the originals.
/// </summary> /// </summary>
public List<InventoryItemBase> RequestListOfItems() public List<InventoryItemBase> RequestListOfItems()
{ {
List<InventoryItemBase> itemList = new List<InventoryItemBase>(); List<InventoryItemBase> itemList = new List<InventoryItemBase>();
lock (Items) lock (Items)
{ {
foreach (InventoryItemBase item in Items.Values) foreach (InventoryItemBase item in Items.Values)
{ {
itemList.Add(item); itemList.Add(item);
} }
} }
//m_log.DebugFormat("[INVENTORY FOLDER IMPL]: Found {0} items", itemList.Count); //m_log.DebugFormat("[INVENTORY FOLDER IMPL]: Found {0} items", itemList.Count);
return itemList; return itemList;
} }
/// <summary> /// <summary>
/// Return a copy of the list of child folders in this folder. The folders themselves are the originals. /// Return a copy of the list of child folders in this folder. The folders themselves are the originals.
/// </summary> /// </summary>
public List<InventoryFolderBase> RequestListOfFolders() public List<InventoryFolderBase> RequestListOfFolders()
{ {
List<InventoryFolderBase> folderList = new List<InventoryFolderBase>(); List<InventoryFolderBase> folderList = new List<InventoryFolderBase>();
lock (m_childFolders) lock (m_childFolders)
{ {
foreach (InventoryFolderBase folder in m_childFolders.Values) foreach (InventoryFolderBase folder in m_childFolders.Values)
{ {
folderList.Add(folder); folderList.Add(folder);
} }
} }
return folderList; return folderList;
} }
public List<InventoryFolderImpl> RequestListOfFolderImpls() public List<InventoryFolderImpl> RequestListOfFolderImpls()
{ {
List<InventoryFolderImpl> folderList = new List<InventoryFolderImpl>(); List<InventoryFolderImpl> folderList = new List<InventoryFolderImpl>();
lock (m_childFolders) lock (m_childFolders)
{ {
foreach (InventoryFolderImpl folder in m_childFolders.Values) foreach (InventoryFolderImpl folder in m_childFolders.Values)
{ {
folderList.Add(folder); folderList.Add(folder);
} }
} }
return folderList; return folderList;
} }
/// <value> /// <value>
/// The total number of items in this folder and in the immediate child folders (though not from other /// The total number of items in this folder and in the immediate child folders (though not from other
/// descendants). /// descendants).
/// </value> /// </value>
public int TotalCount public int TotalCount
{ {
get get
{ {
int total = Items.Count; int total = Items.Count;
foreach (InventoryFolderImpl folder in m_childFolders.Values) foreach (InventoryFolderImpl folder in m_childFolders.Values)
{ {
total = total + folder.TotalCount; total = total + folder.TotalCount;
} }
return total; return total;
} }
} }
} }
} }

1046
OpenSim/Region/CoreModules/Asset/FlotsamAssetCache.cs
View File

File diff suppressed because it is too large Load Diff

546
OpenSim/Region/CoreModules/ServiceConnectors/Inventory/LocalInventoryServiceConnector.cs
View File

@ -1,273 +1,273 @@
/* /*
* Copyright (c) Contributors, http://opensimulator.org/ * Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders. * See CONTRIBUTORS.TXT for a full list of copyright holders.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met: * modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright * * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer. * notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright * * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the * notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution. * documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSimulator Project nor the * * Neither the name of the OpenSimulator Project nor the
* names of its contributors may be used to endorse or promote products * names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission. * derived from this software without specific prior written permission.
* *
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
using log4net; using log4net;
using Nini.Config; using Nini.Config;
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Reflection; using System.Reflection;
using OpenSim.Framework; using OpenSim.Framework;
using OpenSim.Data; using OpenSim.Data;
using OpenSim.Server.Base; using OpenSim.Server.Base;
using OpenSim.Region.Framework.Interfaces; using OpenSim.Region.Framework.Interfaces;
using OpenSim.Region.Framework.Scenes; using OpenSim.Region.Framework.Scenes;
using OpenSim.Services.Interfaces; using OpenSim.Services.Interfaces;
using OpenMetaverse; using OpenMetaverse;
namespace OpenSim.Region.CoreModules.ServiceConnectors.Inventory namespace OpenSim.Region.CoreModules.ServiceConnectors.Inventory
{ {
public class LocalInventoryServicesConnector : public class LocalInventoryServicesConnector :
ISharedRegionModule, IInventoryService ISharedRegionModule, IInventoryService
{ {
private static readonly ILog m_log = private static readonly ILog m_log =
LogManager.GetLogger( LogManager.GetLogger(
MethodBase.GetCurrentMethod().DeclaringType); MethodBase.GetCurrentMethod().DeclaringType);
private IInventoryService m_InventoryService; private IInventoryService m_InventoryService;
private bool m_Enabled = false; private bool m_Enabled = false;
public string Name public string Name
{ {
get { return "LocalInventoryServicesConnector"; } get { return "LocalInventoryServicesConnector"; }
} }
public void Initialise(IConfigSource source) public void Initialise(IConfigSource source)
{ {
IConfig moduleConfig = source.Configs["Modules"]; IConfig moduleConfig = source.Configs["Modules"];
if (moduleConfig != null) if (moduleConfig != null)
{ {
string name = moduleConfig.GetString("InventoryServices", ""); string name = moduleConfig.GetString("InventoryServices", "");
if (name == Name) if (name == Name)
{ {
IConfig assetConfig = source.Configs["InventoryService"]; IConfig assetConfig = source.Configs["InventoryService"];
if (assetConfig == null) if (assetConfig == null)
{ {
m_log.Error("[INVENTORY CONNECTOR]: InventoryService missing from OpenSim.ini"); m_log.Error("[INVENTORY CONNECTOR]: InventoryService missing from OpenSim.ini");
return; return;
} }
string serviceDll = assetConfig.GetString("LocalServiceModule", string serviceDll = assetConfig.GetString("LocalServiceModule",
String.Empty); String.Empty);
if (serviceDll == String.Empty) if (serviceDll == String.Empty)
{ {
m_log.Error("[INVENTORY CONNECTOR]: No LocalServiceModule named in section InventoryService"); m_log.Error("[INVENTORY CONNECTOR]: No LocalServiceModule named in section InventoryService");
return; return;
} }
Object[] args = new Object[] { source }; Object[] args = new Object[] { source };
m_InventoryService = m_InventoryService =
ServerUtils.LoadPlugin<IInventoryService>(serviceDll, ServerUtils.LoadPlugin<IInventoryService>(serviceDll,
args); args);
if (m_InventoryService == null) if (m_InventoryService == null)
{ {
m_log.Error("[INVENTORY CONNECTOR]: Can't load asset service"); m_log.Error("[INVENTORY CONNECTOR]: Can't load asset service");
return; return;
} }
//List<IInventoryDataPlugin> plugins //List<IInventoryDataPlugin> plugins
// = DataPluginFactory.LoadDataPlugins<IInventoryDataPlugin>( // = DataPluginFactory.LoadDataPlugins<IInventoryDataPlugin>(
// configSettings.StandaloneInventoryPlugin, // configSettings.StandaloneInventoryPlugin,
// configSettings.StandaloneInventorySource); // configSettings.StandaloneInventorySource);
//foreach (IInventoryDataPlugin plugin in plugins) //foreach (IInventoryDataPlugin plugin in plugins)
//{ //{
// // Using the OSP wrapper plugin for database plugins should be made configurable at some point // // Using the OSP wrapper plugin for database plugins should be made configurable at some point
// m_InventoryService.AddPlugin(new OspInventoryWrapperPlugin(plugin, this)); // m_InventoryService.AddPlugin(new OspInventoryWrapperPlugin(plugin, this));
//} //}
m_Enabled = true; m_Enabled = true;
m_log.Info("[INVENTORY CONNECTOR]: Local asset connector enabled"); m_log.Info("[INVENTORY CONNECTOR]: Local asset connector enabled");
} }
} }
} }
public void PostInitialise() public void PostInitialise()
{ {
} }
public void Close() public void Close()
{ {
} }
public void AddRegion(Scene scene) public void AddRegion(Scene scene)
{ {
if (!m_Enabled) if (!m_Enabled)
return; return;
scene.RegisterModuleInterface<IInventoryService>(this); scene.RegisterModuleInterface<IInventoryService>(this);
} }
public void RemoveRegion(Scene scene) public void RemoveRegion(Scene scene)
{ {
} }
public void RegionLoaded(Scene scene) public void RegionLoaded(Scene scene)
{ {
if (!m_Enabled) if (!m_Enabled)
return; return;
m_log.InfoFormat("[INVENTORY CONNECTOR]: Enabled local assets for region {0}", scene.RegionInfo.RegionName); m_log.InfoFormat("[INVENTORY CONNECTOR]: Enabled local assets for region {0}", scene.RegionInfo.RegionName);
} }
#region IInventoryService #region IInventoryService
public bool CreateUserInventory(UUID user) public bool CreateUserInventory(UUID user)
{ {
return m_InventoryService.CreateUserInventory(user); return m_InventoryService.CreateUserInventory(user);
} }
public List<InventoryFolderBase> GetInventorySkeleton(UUID userId) public List<InventoryFolderBase> GetInventorySkeleton(UUID userId)
{ {
return m_InventoryService.GetInventorySkeleton(userId); return m_InventoryService.GetInventorySkeleton(userId);
} }
public InventoryCollection GetUserInventory(UUID id) public InventoryCollection GetUserInventory(UUID id)
{ {
return m_InventoryService.GetUserInventory(id); return m_InventoryService.GetUserInventory(id);
} }
public void GetUserInventory(UUID userID, InventoryReceiptCallback callback) public void GetUserInventory(UUID userID, InventoryReceiptCallback callback)
{ {
m_InventoryService.GetUserInventory(userID, callback); m_InventoryService.GetUserInventory(userID, callback);
} }
public List<InventoryItemBase> GetFolderItems(UUID folderID) public List<InventoryItemBase> GetFolderItems(UUID folderID)
{ {
return m_InventoryService.GetFolderItems(folderID); return m_InventoryService.GetFolderItems(folderID);
} }
/// <summary> /// <summary>
/// Add a new folder to the user's inventory /// Add a new folder to the user's inventory
/// </summary> /// </summary>
/// <param name="folder"></param> /// <param name="folder"></param>
/// <returns>true if the folder was successfully added</returns> /// <returns>true if the folder was successfully added</returns>
public bool AddFolder(InventoryFolderBase folder) public bool AddFolder(InventoryFolderBase folder)
{ {
return m_InventoryService.AddFolder(folder); return m_InventoryService.AddFolder(folder);
} }
/// <summary> /// <summary>
/// Update a folder in the user's inventory /// Update a folder in the user's inventory
/// </summary> /// </summary>
/// <param name="folder"></param> /// <param name="folder"></param>
/// <returns>true if the folder was successfully updated</returns> /// <returns>true if the folder was successfully updated</returns>
public bool UpdateFolder(InventoryFolderBase folder) public bool UpdateFolder(InventoryFolderBase folder)
{ {
return m_InventoryService.UpdateFolder(folder); return m_InventoryService.UpdateFolder(folder);
} }
/// <summary> /// <summary>
/// Move an inventory folder to a new location /// Move an inventory folder to a new location
/// </summary> /// </summary>
/// <param name="folder">A folder containing the details of the new location</param> /// <param name="folder">A folder containing the details of the new location</param>
/// <returns>true if the folder was successfully moved</returns> /// <returns>true if the folder was successfully moved</returns>
public bool MoveFolder(InventoryFolderBase folder) public bool MoveFolder(InventoryFolderBase folder)
{ {
return m_InventoryService.MoveFolder(folder); return m_InventoryService.MoveFolder(folder);
} }
/// <summary> /// <summary>
/// Purge an inventory folder of all its items and subfolders. /// Purge an inventory folder of all its items and subfolders.
/// </summary> /// </summary>
/// <param name="folder"></param> /// <param name="folder"></param>
/// <returns>true if the folder was successfully purged</returns> /// <returns>true if the folder was successfully purged</returns>
public bool PurgeFolder(InventoryFolderBase folder) public bool PurgeFolder(InventoryFolderBase folder)
{ {
return m_InventoryService.PurgeFolder(folder); return m_InventoryService.PurgeFolder(folder);
} }
/// <summary> /// <summary>
/// Add a new item to the user's inventory /// Add a new item to the user's inventory
/// </summary> /// </summary>
/// <param name="item"></param> /// <param name="item"></param>
/// <returns>true if the item was successfully added</returns> /// <returns>true if the item was successfully added</returns>
public bool AddItem(InventoryItemBase item) public bool AddItem(InventoryItemBase item)
{ {
return m_InventoryService.AddItem(item); return m_InventoryService.AddItem(item);
} }
/// <summary> /// <summary>
/// Update an item in the user's inventory /// Update an item in the user's inventory
/// </summary> /// </summary>
/// <param name="item"></param> /// <param name="item"></param>
/// <returns>true if the item was successfully updated</returns> /// <returns>true if the item was successfully updated</returns>
public bool UpdateItem(InventoryItemBase item) public bool UpdateItem(InventoryItemBase item)
{ {
return m_InventoryService.UpdateItem(item); return m_InventoryService.UpdateItem(item);
} }
/// <summary> /// <summary>
/// Delete an item from the user's inventory /// Delete an item from the user's inventory
/// </summary> /// </summary>
/// <param name="item"></param> /// <param name="item"></param>
/// <returns>true if the item was successfully deleted</returns> /// <returns>true if the item was successfully deleted</returns>
public bool DeleteItem(InventoryItemBase item) public bool DeleteItem(InventoryItemBase item)
{ {
return m_InventoryService.DeleteItem(item); return m_InventoryService.DeleteItem(item);
} }
public InventoryItemBase QueryItem(InventoryItemBase item) public InventoryItemBase QueryItem(InventoryItemBase item)
{ {
return m_InventoryService.QueryItem(item); return m_InventoryService.QueryItem(item);
} }
public InventoryFolderBase QueryFolder(InventoryFolderBase folder) public InventoryFolderBase QueryFolder(InventoryFolderBase folder)
{ {
return m_InventoryService.QueryFolder(folder); return m_InventoryService.QueryFolder(folder);
} }
/// <summary> /// <summary>
/// Does the given user have an inventory structure? /// Does the given user have an inventory structure?
/// </summary> /// </summary>
/// <param name="userID"></param> /// <param name="userID"></param>
/// <returns></returns> /// <returns></returns>
public bool HasInventoryForUser(UUID userID) public bool HasInventoryForUser(UUID userID)
{ {
return m_InventoryService.HasInventoryForUser(userID); return m_InventoryService.HasInventoryForUser(userID);
} }
/// <summary> /// <summary>
/// Retrieve the root inventory folder for the given user. /// Retrieve the root inventory folder for the given user.
/// </summary> /// </summary>
/// <param name="userID"></param> /// <param name="userID"></param>
/// <returns>null if no root folder was found</returns> /// <returns>null if no root folder was found</returns>
public InventoryFolderBase RequestRootFolder(UUID userID) public InventoryFolderBase RequestRootFolder(UUID userID)
{ {
return m_InventoryService.RequestRootFolder(userID); return m_InventoryService.RequestRootFolder(userID);
} }
public List<InventoryItemBase> GetActiveGestures(UUID userId) public List<InventoryItemBase> GetActiveGestures(UUID userId)
{ {
return m_InventoryService.GetActiveGestures(userId); return m_InventoryService.GetActiveGestures(userId);
} }
#endregion IInventoryService #endregion IInventoryService
} }
} }

552
OpenSim/Server/Handlers/Inventory/InventoryServerInConnector.cs
View File

@ -1,276 +1,276 @@
/* /*
* Copyright (c) Contributors, http://opensimulator.org/ * Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders. * See CONTRIBUTORS.TXT for a full list of copyright holders.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met: * modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright * * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer. * notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright * * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the * notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution. * documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSimulator Project nor the * * Neither the name of the OpenSimulator Project nor the
* names of its contributors may be used to endorse or promote products * names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission. * derived from this software without specific prior written permission.
* *
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
using System; using System;
using System.Collections; using System.Collections;
using System.Collections.Generic; using System.Collections.Generic;
using System.Net; using System.Net;
using System.Reflection; using System.Reflection;
using log4net; using log4net;
using Nini.Config; using Nini.Config;
using Nwc.XmlRpc; using Nwc.XmlRpc;
using OpenSim.Server.Base; using OpenSim.Server.Base;
using OpenSim.Services.Interfaces; using OpenSim.Services.Interfaces;
using OpenSim.Framework; using OpenSim.Framework;
using OpenSim.Framework.Servers.HttpServer; using OpenSim.Framework.Servers.HttpServer;
using OpenSim.Server.Handlers.Base; using OpenSim.Server.Handlers.Base;
using OpenMetaverse; using OpenMetaverse;
namespace OpenSim.Server.Handlers.Inventory namespace OpenSim.Server.Handlers.Inventory
{ {
public class InventoryServiceInConnector : ServiceConnector public class InventoryServiceInConnector : ServiceConnector
{ {
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
private IInventoryService m_InventoryService; private IInventoryService m_InventoryService;
private bool m_doLookup = false; private bool m_doLookup = false;
//private static readonly int INVENTORY_DEFAULT_SESSION_TIME = 30; // secs //private static readonly int INVENTORY_DEFAULT_SESSION_TIME = 30; // secs
//private AuthedSessionCache m_session_cache = new AuthedSessionCache(INVENTORY_DEFAULT_SESSION_TIME); //private AuthedSessionCache m_session_cache = new AuthedSessionCache(INVENTORY_DEFAULT_SESSION_TIME);
private string m_userserver_url; private string m_userserver_url;
public InventoryServiceInConnector(IConfigSource config, IHttpServer server) : public InventoryServiceInConnector(IConfigSource config, IHttpServer server) :
base(config, server) base(config, server)
{ {
IConfig serverConfig = config.Configs["InventoryService"]; IConfig serverConfig = config.Configs["InventoryService"];
if (serverConfig == null) if (serverConfig == null)
throw new Exception("No section 'InventoryService' in config file"); throw new Exception("No section 'InventoryService' in config file");
string inventoryService = serverConfig.GetString("LocalServiceModule", string inventoryService = serverConfig.GetString("LocalServiceModule",
String.Empty); String.Empty);
if (inventoryService == String.Empty) if (inventoryService == String.Empty)
throw new Exception("No InventoryService in config file"); throw new Exception("No InventoryService in config file");
Object[] args = new Object[] { config }; Object[] args = new Object[] { config };
m_InventoryService = m_InventoryService =
ServerUtils.LoadPlugin<IInventoryService>(inventoryService, args); ServerUtils.LoadPlugin<IInventoryService>(inventoryService, args);
m_userserver_url = serverConfig.GetString("UserServerURI", String.Empty); m_userserver_url = serverConfig.GetString("UserServerURI", String.Empty);
m_doLookup = serverConfig.GetBoolean("SessionAuthentication", false); m_doLookup = serverConfig.GetBoolean("SessionAuthentication", false);
AddHttpHandlers(server); AddHttpHandlers(server);
} }
protected virtual void AddHttpHandlers(IHttpServer m_httpServer) protected virtual void AddHttpHandlers(IHttpServer m_httpServer)
{ {
m_httpServer.AddStreamHandler( m_httpServer.AddStreamHandler(
new RestDeserialiseSecureHandler<Guid, InventoryCollection>( new RestDeserialiseSecureHandler<Guid, InventoryCollection>(
"POST", "/GetInventory/", GetUserInventory, CheckAuthSession)); "POST", "/GetInventory/", GetUserInventory, CheckAuthSession));
m_httpServer.AddStreamHandler( m_httpServer.AddStreamHandler(
new RestDeserialiseSecureHandler<InventoryFolderBase, bool>( new RestDeserialiseSecureHandler<InventoryFolderBase, bool>(
"POST", "/UpdateFolder/", m_InventoryService.UpdateFolder, CheckAuthSession)); "POST", "/UpdateFolder/", m_InventoryService.UpdateFolder, CheckAuthSession));
m_httpServer.AddStreamHandler( m_httpServer.AddStreamHandler(
new RestDeserialiseSecureHandler<InventoryFolderBase, bool>( new RestDeserialiseSecureHandler<InventoryFolderBase, bool>(
"POST", "/MoveFolder/", m_InventoryService.MoveFolder, CheckAuthSession)); "POST", "/MoveFolder/", m_InventoryService.MoveFolder, CheckAuthSession));
m_httpServer.AddStreamHandler( m_httpServer.AddStreamHandler(
new RestDeserialiseSecureHandler<InventoryFolderBase, bool>( new RestDeserialiseSecureHandler<InventoryFolderBase, bool>(
"POST", "/PurgeFolder/", m_InventoryService.PurgeFolder, CheckAuthSession)); "POST", "/PurgeFolder/", m_InventoryService.PurgeFolder, CheckAuthSession));
m_httpServer.AddStreamHandler( m_httpServer.AddStreamHandler(
new RestDeserialiseSecureHandler<InventoryItemBase, bool>( new RestDeserialiseSecureHandler<InventoryItemBase, bool>(
"POST", "/DeleteItem/", m_InventoryService.DeleteItem, CheckAuthSession)); "POST", "/DeleteItem/", m_InventoryService.DeleteItem, CheckAuthSession));
m_httpServer.AddStreamHandler( m_httpServer.AddStreamHandler(
new RestDeserialiseSecureHandler<InventoryItemBase, InventoryItemBase>( new RestDeserialiseSecureHandler<InventoryItemBase, InventoryItemBase>(
"POST", "/QueryItem/", m_InventoryService.QueryItem, CheckAuthSession)); "POST", "/QueryItem/", m_InventoryService.QueryItem, CheckAuthSession));
m_httpServer.AddStreamHandler( m_httpServer.AddStreamHandler(
new RestDeserialiseSecureHandler<InventoryFolderBase, InventoryFolderBase>( new RestDeserialiseSecureHandler<InventoryFolderBase, InventoryFolderBase>(
"POST", "/QueryFolder/", m_InventoryService.QueryFolder, CheckAuthSession)); "POST", "/QueryFolder/", m_InventoryService.QueryFolder, CheckAuthSession));
m_httpServer.AddStreamHandler( m_httpServer.AddStreamHandler(
new RestDeserialiseTrustedHandler<Guid, bool>( new RestDeserialiseTrustedHandler<Guid, bool>(
"POST", "/CreateInventory/", CreateUsersInventory, CheckTrustSource)); "POST", "/CreateInventory/", CreateUsersInventory, CheckTrustSource));
m_httpServer.AddStreamHandler( m_httpServer.AddStreamHandler(
new RestDeserialiseSecureHandler<InventoryFolderBase, bool>( new RestDeserialiseSecureHandler<InventoryFolderBase, bool>(
"POST", "/NewFolder/", m_InventoryService.AddFolder, CheckAuthSession)); "POST", "/NewFolder/", m_InventoryService.AddFolder, CheckAuthSession));
m_httpServer.AddStreamHandler( m_httpServer.AddStreamHandler(
new RestDeserialiseTrustedHandler<InventoryFolderBase, bool>( new RestDeserialiseTrustedHandler<InventoryFolderBase, bool>(
"POST", "/CreateFolder/", m_InventoryService.AddFolder, CheckTrustSource)); "POST", "/CreateFolder/", m_InventoryService.AddFolder, CheckTrustSource));
m_httpServer.AddStreamHandler( m_httpServer.AddStreamHandler(
new RestDeserialiseSecureHandler<InventoryItemBase, bool>( new RestDeserialiseSecureHandler<InventoryItemBase, bool>(
"POST", "/NewItem/", m_InventoryService.AddItem, CheckAuthSession)); "POST", "/NewItem/", m_InventoryService.AddItem, CheckAuthSession));
m_httpServer.AddStreamHandler( m_httpServer.AddStreamHandler(
new RestDeserialiseTrustedHandler<InventoryItemBase, bool>( new RestDeserialiseTrustedHandler<InventoryItemBase, bool>(
"POST", "/AddNewItem/", m_InventoryService.AddItem, CheckTrustSource)); "POST", "/AddNewItem/", m_InventoryService.AddItem, CheckTrustSource));
m_httpServer.AddStreamHandler( m_httpServer.AddStreamHandler(
new RestDeserialiseTrustedHandler<Guid, List<InventoryItemBase>>( new RestDeserialiseTrustedHandler<Guid, List<InventoryItemBase>>(
"POST", "/GetItems/", GetFolderItems, CheckTrustSource)); "POST", "/GetItems/", GetFolderItems, CheckTrustSource));
// for persistent active gestures // for persistent active gestures
m_httpServer.AddStreamHandler( m_httpServer.AddStreamHandler(
new RestDeserialiseTrustedHandler<Guid, List<InventoryItemBase>> new RestDeserialiseTrustedHandler<Guid, List<InventoryItemBase>>
("POST", "/ActiveGestures/", GetActiveGestures, CheckTrustSource)); ("POST", "/ActiveGestures/", GetActiveGestures, CheckTrustSource));
// WARNING: Root folders no longer just delivers the root and immediate child folders (e.g // WARNING: Root folders no longer just delivers the root and immediate child folders (e.g
// system folders such as Objects, Textures), but it now returns the entire inventory skeleton. // system folders such as Objects, Textures), but it now returns the entire inventory skeleton.
// It would have been better to rename this request, but complexities in the BaseHttpServer // It would have been better to rename this request, but complexities in the BaseHttpServer
// (e.g. any http request not found is automatically treated as an xmlrpc request) make it easier // (e.g. any http request not found is automatically treated as an xmlrpc request) make it easier
// to do this for now. // to do this for now.
m_httpServer.AddStreamHandler( m_httpServer.AddStreamHandler(
new RestDeserialiseTrustedHandler<Guid, List<InventoryFolderBase>> new RestDeserialiseTrustedHandler<Guid, List<InventoryFolderBase>>
("POST", "/RootFolders/", GetInventorySkeleton, CheckTrustSource)); ("POST", "/RootFolders/", GetInventorySkeleton, CheckTrustSource));
} }
#region Wrappers for converting the Guid parameter #region Wrappers for converting the Guid parameter
public InventoryCollection GetUserInventory(Guid guid) public InventoryCollection GetUserInventory(Guid guid)
{ {
UUID userID = new UUID(guid); UUID userID = new UUID(guid);
return m_InventoryService.GetUserInventory(userID); return m_InventoryService.GetUserInventory(userID);
} }
public List<InventoryItemBase> GetFolderItems(Guid folderID) public List<InventoryItemBase> GetFolderItems(Guid folderID)
{ {
List<InventoryItemBase> allItems = new List<InventoryItemBase>(); List<InventoryItemBase> allItems = new List<InventoryItemBase>();
List<InventoryItemBase> items = m_InventoryService.GetFolderItems(new UUID(folderID)); List<InventoryItemBase> items = m_InventoryService.GetFolderItems(new UUID(folderID));
if (items != null) if (items != null)
{ {
allItems.InsertRange(0, items); allItems.InsertRange(0, items);
} }
return allItems; return allItems;
} }
public bool CreateUsersInventory(Guid rawUserID) public bool CreateUsersInventory(Guid rawUserID)
{ {
UUID userID = new UUID(rawUserID); UUID userID = new UUID(rawUserID);
return m_InventoryService.CreateUserInventory(userID); return m_InventoryService.CreateUserInventory(userID);
} }
public List<InventoryItemBase> GetActiveGestures(Guid rawUserID) public List<InventoryItemBase> GetActiveGestures(Guid rawUserID)
{ {
UUID userID = new UUID(rawUserID); UUID userID = new UUID(rawUserID);
return m_InventoryService.GetActiveGestures(userID); return m_InventoryService.GetActiveGestures(userID);
} }
public List<InventoryFolderBase> GetInventorySkeleton(Guid rawUserID) public List<InventoryFolderBase> GetInventorySkeleton(Guid rawUserID)
{ {
UUID userID = new UUID(rawUserID); UUID userID = new UUID(rawUserID);
return m_InventoryService.GetInventorySkeleton(userID); return m_InventoryService.GetInventorySkeleton(userID);
} }
#endregion #endregion
/// <summary> /// <summary>
/// Check that the source of an inventory request is one that we trust. /// Check that the source of an inventory request is one that we trust.
/// </summary> /// </summary>
/// <param name="peer"></param> /// <param name="peer"></param>
/// <returns></returns> /// <returns></returns>
public bool CheckTrustSource(IPEndPoint peer) public bool CheckTrustSource(IPEndPoint peer)
{ {
if (m_doLookup) if (m_doLookup)
{ {
m_log.InfoFormat("[INVENTORY IN CONNECTOR]: Checking trusted source {0}", peer); m_log.InfoFormat("[INVENTORY IN CONNECTOR]: Checking trusted source {0}", peer);
UriBuilder ub = new UriBuilder(m_userserver_url); UriBuilder ub = new UriBuilder(m_userserver_url);
IPAddress[] uaddrs = Dns.GetHostAddresses(ub.Host); IPAddress[] uaddrs = Dns.GetHostAddresses(ub.Host);
foreach (IPAddress uaddr in uaddrs) foreach (IPAddress uaddr in uaddrs)
{ {
if (uaddr.Equals(peer.Address)) if (uaddr.Equals(peer.Address))
{ {
return true; return true;
} }
} }
m_log.WarnFormat( m_log.WarnFormat(
"[INVENTORY IN CONNECTOR]: Rejecting request since source {0} was not in the list of trusted sources", "[INVENTORY IN CONNECTOR]: Rejecting request since source {0} was not in the list of trusted sources",
peer); peer);
return false; return false;
} }
else else
{ {
return true; return true;
} }
} }
/// <summary> /// <summary>
/// Check that the source of an inventory request for a particular agent is a current session belonging to /// Check that the source of an inventory request for a particular agent is a current session belonging to
/// that agent. /// that agent.
/// </summary> /// </summary>
/// <param name="session_id"></param> /// <param name="session_id"></param>
/// <param name="avatar_id"></param> /// <param name="avatar_id"></param>
/// <returns></returns> /// <returns></returns>
public bool CheckAuthSession(string session_id, string avatar_id) public bool CheckAuthSession(string session_id, string avatar_id)
{ {
if (m_doLookup) if (m_doLookup)
{ {
m_log.InfoFormat("[INVENTORY IN CONNECTOR]: checking authed session {0} {1}", session_id, avatar_id); m_log.InfoFormat("[INVENTORY IN CONNECTOR]: checking authed session {0} {1}", session_id, avatar_id);
//if (m_session_cache.getCachedSession(session_id, avatar_id) == null) //if (m_session_cache.getCachedSession(session_id, avatar_id) == null)
//{ //{
// cache miss, ask userserver // cache miss, ask userserver
Hashtable requestData = new Hashtable(); Hashtable requestData = new Hashtable();
requestData["avatar_uuid"] = avatar_id; requestData["avatar_uuid"] = avatar_id;
requestData["session_id"] = session_id; requestData["session_id"] = session_id;
ArrayList SendParams = new ArrayList(); ArrayList SendParams = new ArrayList();
SendParams.Add(requestData); SendParams.Add(requestData);
XmlRpcRequest UserReq = new XmlRpcRequest("check_auth_session", SendParams); XmlRpcRequest UserReq = new XmlRpcRequest("check_auth_session", SendParams);
XmlRpcResponse UserResp = UserReq.Send(m_userserver_url, 3000); XmlRpcResponse UserResp = UserReq.Send(m_userserver_url, 3000);
Hashtable responseData = (Hashtable)UserResp.Value; Hashtable responseData = (Hashtable)UserResp.Value;
if (responseData.ContainsKey("auth_session") && responseData["auth_session"].ToString() == "TRUE") if (responseData.ContainsKey("auth_session") && responseData["auth_session"].ToString() == "TRUE")
{ {
m_log.Info("[INVENTORY IN CONNECTOR]: got authed session from userserver"); m_log.Info("[INVENTORY IN CONNECTOR]: got authed session from userserver");
//// add to cache; the session time will be automatically renewed //// add to cache; the session time will be automatically renewed
//m_session_cache.Add(session_id, avatar_id); //m_session_cache.Add(session_id, avatar_id);
return true; return true;
} }
//} //}
//else //else
//{ //{
// // cache hits // // cache hits
// m_log.Info("[GRID AGENT INVENTORY]: got authed session from cache"); // m_log.Info("[GRID AGENT INVENTORY]: got authed session from cache");
// return true; // return true;
//} //}
m_log.Warn("[INVENTORY IN CONNECTOR]: unknown session_id, request rejected"); m_log.Warn("[INVENTORY IN CONNECTOR]: unknown session_id, request rejected");
return false; return false;
} }
else else
{ {
return true; return true;
} }
} }
} }
} }