public InventoryArchiveReadRequest(
Scene scene, CachedUserInfo userInfo, string invPath, Stream loadStream)
{
m_scene = scene;
m_userInfo = userInfo;
m_invPath = invPath;
m_loadStream = loadStream;
}
public InventoryArchiveReadRequest(
CachedUserInfo userInfo, string invPath, Stream loadStream, CommunicationsManager commsManager, IAssetService assetService)
{
m_userInfo = userInfo;
m_invPath = invPath;
m_loadStream = loadStream;
m_commsManager = commsManager;
m_assetService = assetService;
}
public InventoryArchiveReadRequest(
CachedUserInfo userInfo, string invPath, string loadPath, CommunicationsManager commsManager, IAssetService assetService)
: this(
userInfo,
invPath,
new GZipStream(new FileStream(loadPath, FileMode.Open), CompressionMode.Decompress),
commsManager, assetService)
{
}
public InventoryArchiveReadRequest(
Scene scene, CachedUserInfo userInfo, string invPath, string loadPath)
: this(
scene,
userInfo,
invPath,
new GZipStream(new FileStream(loadPath, FileMode.Open), CompressionMode.Decompress))
{
}
private void UpdateCachedInfo(UUID agentID, CachedUserInfo info)
{
lock (MuteListCache)
MuteListCache[agentID] = info.MuteList.ToArray();
}
private void UpdateCachedInfo(UUID agentID, CachedUserInfo info)
{
lock (m_offlineMessagesCache)
m_offlineMessagesCache[agentID] = info.OfflineMessages;
}
private void GridInventoryOffer(GridInstantMessage im)
{
if (im.binaryBucket.Length < 1) // Invalid
{
m_log.WarnFormat("[INVENTORY TRANSFER]: Invalid IM (binary bucket length {0}).", im.binaryBucket.Length);
return;
}
Scene scene = FindScene(new UUID(im.toAgentID));
ScenePresence user = scene.GetScenePresence(new UUID(im.toAgentID));
if (user == null) // Shouldn't happen
{
m_log.Warn("[INVENTORY TRANSFER]: Can't find recipient");
return;
}
CachedUserInfo userInfo =
scene.CommsManager.UserService.
GetUserDetails(user.ControllingClient.AgentId);
if (userInfo == null)
{
m_log.Warn("[INVENTORY TRANSFER]: Can't find user info of recipient");
return;
}
AssetType assetType = (AssetType)im.binaryBucket[0];
UUID inventoryEntityID = UUID.Zero;
if (im.binaryBucket.Length >= 17) // includes UUID
{
inventoryEntityID = new UUID(im.binaryBucket, 1);
}
if (AssetType.Folder == assetType)
{
if (inventoryEntityID != UUID.Zero)
{
// Get folder info
InventoryFolderBase folder = userInfo.GetFolder(inventoryEntityID);
if (folder == null)
{
m_log.WarnFormat("[INVENTORY TRANSFER]: Can't retrieve folder {0} to give.", inventoryEntityID);
return;
}
// Update folder to viewer (makes it appear to user)
user.ControllingClient.SendBulkUpdateInventory(folder);
userInfo.SendInventoryDecendents(user.ControllingClient, folder.ID, false, true);
}
// Deliver message
user.ControllingClient.SendInstantMessage(im);
}
else
{
if (inventoryEntityID != UUID.Zero)
{
// Get item info
InventoryItemBase item = userInfo.FindItem(inventoryEntityID);
if (item == null)
{
m_log.WarnFormat("[INVENTORY TRANSFER]: Can't retrieve item {0} to give.", inventoryEntityID);
return;
}
// Update item to viewer (makes it appear in proper folder)
user.ControllingClient.SendInventoryItemCreateUpdate(item, 0);
}
// Deliver message
user.ControllingClient.SendInstantMessage(im);
}
}
protected bool IsLocalUser(CachedUserInfo uinfo)
{
if (uinfo == null)
return false;
return !(uinfo.UserProfile is ForeignUserProfileData);
}
/// <summary>
/// Notify the client of loaded nodes if they are logged in
/// </summary>
/// <param name="loadedNodes">Can be empty. In which case, nothing happens</param>
private void UpdateClientWithLoadedNodes(CachedUserInfo userInfo, List<InventoryNodeBase> loadedNodes)
{
if (loadedNodes.Count == 0)
return;
foreach (Scene scene in m_scenes.Values)
{
ScenePresence user = scene.GetScenePresence(userInfo.UserProfile.ID);
if (user != null && !user.IsChildAgent)
{
foreach (InventoryNodeBase node in loadedNodes)
{
m_log.DebugFormat(
"[INVENTORY ARCHIVER]: Notifying {0} of loaded inventory node {1}",
user.Name, node.Name);
user.ControllingClient.SendBulkUpdateInventory(node);
}
break;
}
}
}
/// <summary>
/// Test saving a V0.1 OpenSim Inventory Archive (subject to change since there is no fixed format yet).
/// </summary>
//[Test]
public void TestSaveIarV0_1()
{
TestHelper.InMethod();
log4net.Config.XmlConfigurator.Configure();
InventoryArchiverModule archiverModule = new InventoryArchiverModule();
Scene scene = SceneSetupHelpers.SetupScene(false);
SceneSetupHelpers.SetupSceneModules(scene, archiverModule);
CommunicationsManager cm = scene.CommsManager;
// Create user
string userFirstName = "Jock";
string userLastName = "Stirrup";
UUID userId = UUID.Parse("00000000-0000-0000-0000-000000000020");
cm.UserAdminService.AddUser(userFirstName, userLastName, string.Empty, string.Empty, 1000, 1000, userId);
CachedUserInfo userInfo = cm.UserProfileCacheService.GetUserDetails(userId);
userInfo.FetchInventory();
for (int i = 0; i < 50; i++)
{
if (userInfo.HasReceivedInventory == true)
{
break;
}
Thread.Sleep(200);
}
Assert.That(userInfo.HasReceivedInventory, Is.True, "FetchInventory timed out (10 seconds)");
// Create asset
SceneObjectGroup object1;
SceneObjectPart part1;
{
string partName = "My Little Dog Object";
UUID ownerId = UUID.Parse("00000000-0000-0000-0000-000000000040");
PrimitiveBaseShape shape = PrimitiveBaseShape.CreateSphere();
Vector3 groupPosition = new Vector3(10, 20, 30);
Quaternion rotationOffset = new Quaternion(20, 30, 40, 50);
Vector3 offsetPosition = new Vector3(5, 10, 15);
part1
= new SceneObjectPart(
ownerId, shape, groupPosition, rotationOffset, offsetPosition);
part1.Name = partName;
object1 = new SceneObjectGroup(part1);
scene.AddNewSceneObject(object1, false);
}
UUID asset1Id = UUID.Parse("00000000-0000-0000-0000-000000000060");
AssetBase asset1 = new AssetBase();
asset1.FullID = asset1Id;
asset1.Data = Encoding.ASCII.GetBytes(SceneObjectSerializer.ToXml2Format(object1));
scene.AssetService.Store(asset1);
// Create item
UUID item1Id = UUID.Parse("00000000-0000-0000-0000-000000000080");
InventoryItemBase item1 = new InventoryItemBase();
item1.Name = "My Little Dog";
item1.AssetID = asset1.FullID;
item1.ID = item1Id;
item1.Folder = userInfo.RootFolder.FindFolderByPath("Objects").ID;
scene.AddInventoryItem(userId, item1);
MemoryStream archiveWriteStream = new MemoryStream();
archiverModule.OnInventoryArchiveSaved += SaveCompleted;
lock (this)
{
archiverModule.ArchiveInventory(userFirstName, userLastName, "Objects", archiveWriteStream);
Monitor.Wait(this, 60000);
}
byte[] archive = archiveWriteStream.ToArray();
MemoryStream archiveReadStream = new MemoryStream(archive);
TarArchiveReader tar = new TarArchiveReader(archiveReadStream);
InventoryFolderImpl objectsFolder = userInfo.RootFolder.FindFolderByPath("Objects");
//bool gotControlFile = false;
bool gotObject1File = false;
//bool gotObject2File = false;
string expectedObject1FilePath = string.Format(
"{0}{1}/{2}_{3}.xml",
ArchiveConstants.INVENTORY_PATH,
string.Format(
"Objects{0}{1}", ArchiveConstants.INVENTORY_NODE_NAME_COMPONENT_SEPARATOR, objectsFolder.ID),
item1.Name,
item1Id);
// string expectedObject2FileName = string.Format(
// "{0}_{1:000}-{2:000}-{3:000}__{4}.xml",
// part2.Name,
// Math.Round(part2.GroupPosition.X), Math.Round(part2.GroupPosition.Y), Math.Round(part2.GroupPosition.Z),
// part2.UUID);
string filePath;
TarArchiveReader.TarEntryType tarEntryType;
Console.WriteLine("Reading archive");
while (tar.ReadEntry(out filePath, out tarEntryType) != null)
{
Console.WriteLine("Got {0}", filePath);
// if (ArchiveConstants.CONTROL_FILE_PATH == filePath)
// {
// gotControlFile = true;
// }
if (filePath.StartsWith(ArchiveConstants.INVENTORY_PATH) && filePath.EndsWith(".xml"))
{
// string fileName = filePath.Remove(0, "Objects/".Length);
//
// if (fileName.StartsWith(part1.Name))
// {
Assert.That(filePath, Is.EqualTo(expectedObject1FilePath));
gotObject1File = true;
// }
// else if (fileName.StartsWith(part2.Name))
// {
// Assert.That(fileName, Is.EqualTo(expectedObject2FileName));
// gotObject2File = true;
// }
}
}
// Assert.That(gotControlFile, Is.True, "No control file in archive");
Assert.That(gotObject1File, Is.True, "No item1 file in archive");
// Assert.That(gotObject2File, Is.True, "No object2 file in archive");
// TODO: Test presence of more files and contents of files.
}
public InventoryArchiveReadRequest(
CachedUserInfo userInfo, string invPath, Stream loadStream, CommunicationsManager commsManager)
{
m_userInfo = userInfo;
m_commsManager = commsManager;
}
/// <summary>
/// Handle the caps inventory descendents fetch.
///
/// Since the folder structure is sent to the client on login, I believe we only need to handle items.
/// </summary>
/// <param name="agentID"></param>
/// <param name="folderID"></param>
/// <param name="ownerID"></param>
/// <param name="fetchFolders"></param>
/// <param name="fetchItems"></param>
/// <param name="sortOrder"></param>
/// <returns>null if the inventory look up failed</returns>
public List <InventoryItemBase> HandleFetchInventoryDescendentsCAPS(UUID agentID, UUID folderID, UUID ownerID,
bool fetchFolders, bool fetchItems, int sortOrder)
{
// m_log.DebugFormat(
// "[INVENTORY CACHE]: Fetching folders ({0}), items ({1}) from {2} for agent {3}",
// fetchFolders, fetchItems, folderID, agentID);
// FIXME MAYBE: We're not handling sortOrder!
// TODO: This code for looking in the folder for the library should be folded back into the
// CachedUserInfo so that this class doesn't have to know the details (and so that multiple libraries, etc.
// can be handled transparently).
InventoryFolderImpl fold;
if ((fold = CommsManager.UserProfileCacheService.LibraryRoot.FindFolder(folderID)) != null)
{
return(fold.RequestListOfItems());
}
CachedUserInfo userProfile = CommsManager.UserProfileCacheService.GetUserDetails(agentID);
if (null == userProfile)
{
m_log.ErrorFormat("[AGENT INVENTORY]: Could not find user profile for {0}", agentID);
return(null);
}
// XXX: When a client crosses into a scene, their entire inventory is fetched
// asynchronously. If the client makes a request before the inventory is received, we need
// to give the inventory a chance to come in.
//
// This is a crude way of dealing with that by retrying the lookup. It's not quite as bad
// in CAPS as doing this with the udp request, since here it won't hold up other packets.
// In fact, here we'll be generous and try for longer.
if (!userProfile.HasReceivedInventory)
{
int attempts = 0;
while (attempts++ < 30)
{
m_log.DebugFormat(
"[INVENTORY CACHE]: Poll number {0} for inventory items in folder {1} for user {2}",
attempts, folderID, agentID);
Thread.Sleep(2000);
if (userProfile.HasReceivedInventory)
{
break;
}
}
}
if (userProfile.HasReceivedInventory)
{
if ((fold = userProfile.RootFolder.FindFolder(folderID)) != null)
{
return(fold.RequestListOfItems());
}
else
{
m_log.WarnFormat(
"[AGENT INVENTORY]: Could not find folder {0} requested by user {1}",
folderID, agentID);
return(null);
}
}
else
{
m_log.ErrorFormat("[INVENTORY CACHE]: Could not find root folder for user {0}", agentID);
return(null);
}
}
protected bool IsLocalUser(CachedUserInfo uinfo)
{
if (uinfo == null)
return true;
if (uinfo.UserProfile is ForeignUserProfileData)
return HGNetworkServersInfo.Singleton.IsLocalUser(((ForeignUserProfileData)uinfo.UserProfile).UserServerURI);
else
return true;
}
protected bool IsGoingHome(CachedUserInfo uinfo, RegionInfo rinfo)
{
if (uinfo.UserProfile == null)
return false;
string userUserServerURI = String.Empty;
if (uinfo.UserProfile is ForeignUserProfileData)
{
userUserServerURI = HGNetworkServersInfo.ServerURI(((ForeignUserProfileData)uinfo.UserProfile).UserServerURI);
}
return ((uinfo.UserProfile.HomeRegionID == rinfo.RegionID) &&
(userUserServerURI != HGNetworkServersInfo.Singleton.LocalUserServerURI));
}
private void SaveCompleted(
Guid id, bool succeeded, CachedUserInfo userInfo, string invPath, Stream saveStream,
Exception reportedException)
{
mre.Set();
}
protected void LoadLibrariesFromArchives()
{
InventoryFolderImpl lib = m_Scene.CommsManager.UserProfileCacheService.LibraryRoot;
if (lib == null)
{
m_log.Debug("[LIBRARY MODULE]: No library. Ignoring Library Module");
return;
}
lib.Name = m_LibraryName;
RegionInfo regInfo = new RegionInfo();
Scene m_MockScene = new Scene(regInfo);
m_MockScene.CommsManager = m_Scene.CommsManager;
LocalInventoryService invService = new LocalInventoryService((LibraryRootFolder)lib);
m_MockScene.RegisterModuleInterface<IInventoryService>(invService);
m_MockScene.RegisterModuleInterface<IAssetService>(m_Scene.AssetService);
UserProfileData profile = new UserProfileData();
profile.FirstName = "OpenSim";
profile.ID = lib.Owner;
profile.SurName = "Library";
CachedUserInfo uinfo = new CachedUserInfo(invService, profile);
foreach (string iarFileName in Directory.GetFiles(pathToLibraries, "*.iar"))
{
string simpleName = Path.GetFileNameWithoutExtension(iarFileName);
m_log.InfoFormat("[LIBRARY MODULE]: Loading library archive {0} ({1})...", iarFileName, simpleName);
simpleName = GetInventoryPathFromName(simpleName);
try
{
InventoryArchiveReadRequest archread = new InventoryArchiveReadRequest(m_MockScene, uinfo, simpleName, iarFileName);
List<InventoryNodeBase> nodes = archread.Execute();
if (nodes.Count == 0)
{
// didn't find the subfolder with the given name; place it on the top
m_log.InfoFormat("[LIBRARY MODULE]: Didn't find {0} in library. Placing archive on the top level", simpleName);
archread.Close();
archread = new InventoryArchiveReadRequest(m_MockScene, uinfo, "/", iarFileName);
archread.Execute();
}
archread.Close();
}
catch (Exception e)
{
m_log.DebugFormat("[LIBRARY MODULE]: Exception when processing archive {0}: {1}", iarFileName, e.Message);
}
}
}
/// <summary>
/// Trigger the inventory archive saved event.
/// </summary>
protected internal void TriggerInventoryArchiveSaved(
Guid id, bool succeeded, CachedUserInfo userInfo, string invPath, Stream saveStream,
Exception reportedException)
{
InventoryArchiveSaved handlerInventoryArchiveSaved = OnInventoryArchiveSaved;
if (handlerInventoryArchiveSaved != null)
handlerInventoryArchiveSaved(id, succeeded, userInfo, invPath, saveStream, reportedException);
}
public XmlNode RequestSnapshotData(XmlDocument factory)
{
//Estate data section - contains who owns a set of sims and the name of the set.
//Now in DataSnapshotProvider module form!
XmlNode estatedata = factory.CreateNode(XmlNodeType.Element, "estate", "");
UUID ownerid = m_scene.RegionInfo.MasterAvatarAssignedUUID;
if (m_scene.RegionInfo.EstateSettings.EstateOwner != UUID.Zero)
{
ownerid = m_scene.RegionInfo.EstateSettings.EstateOwner;
}
CachedUserInfo userInfo = m_scene.CommsManager.UserProfileCacheService.GetUserDetails(ownerid);
//TODO: Change to query userserver about the master avatar UUID ?
String firstname;
String lastname;
if (userInfo != null)
{
UserProfileData userProfile = userInfo.UserProfile;
firstname = userProfile.FirstName;
lastname = userProfile.SurName;
//TODO: Fix the marshalling system to have less copypasta gruntwork
XmlNode user = factory.CreateNode(XmlNodeType.Element, "user", "");
// XmlAttribute type = (XmlAttribute)factory.CreateNode(XmlNodeType.Attribute, "type", "");
// type.Value = "owner";
// user.Attributes.Append(type);
//TODO: Create more TODOs
XmlNode username = factory.CreateNode(XmlNodeType.Element, "name", "");
username.InnerText = firstname + " " + lastname;
user.AppendChild(username);
XmlNode useruuid = factory.CreateNode(XmlNodeType.Element, "uuid", "");
useruuid.InnerText = ownerid.ToString();
user.AppendChild(useruuid);
estatedata.AppendChild(user);
}
XmlNode estatename = factory.CreateNode(XmlNodeType.Element, "name", "");
estatename.InnerText = m_scene.RegionInfo.EstateSettings.EstateName.ToString();
estatedata.AppendChild(estatename);
XmlNode estateid = factory.CreateNode(XmlNodeType.Element, "id", "");
estateid.InnerText = m_scene.RegionInfo.EstateSettings.EstateID.ToString();
estatedata.AppendChild(estateid);
XmlNode parentid = factory.CreateNode(XmlNodeType.Element, "parentid", "");
parentid.InnerText = m_scene.RegionInfo.EstateSettings.ParentEstateID.ToString();
estatedata.AppendChild(parentid);
XmlNode flags = factory.CreateNode(XmlNodeType.Element, "flags", "");
XmlAttribute teleport = (XmlAttribute)factory.CreateNode(XmlNodeType.Attribute, "teleport", "");
teleport.Value = m_scene.RegionInfo.EstateSettings.AllowDirectTeleport.ToString();
flags.Attributes.Append(teleport);
XmlAttribute publicaccess = (XmlAttribute)factory.CreateNode(XmlNodeType.Attribute, "public", "");
publicaccess.Value = m_scene.RegionInfo.EstateSettings.PublicAccess.ToString();
flags.Attributes.Append(publicaccess);
estatedata.AppendChild(flags);
this.Stale = false;
return(estatedata);
}
/// <summary>
/// Test loading a V0.1 OpenSim Inventory Archive (subject to change since there is no fixed format yet) where
/// no account exists with the creator name
/// </summary>
//[Test]
public void TestLoadIarV0_1TempProfiles()
{
TestHelper.InMethod();
log4net.Config.XmlConfigurator.Configure();
string userFirstName = "Dennis";
string userLastName = "Menace";
UUID userUuid = UUID.Parse("00000000-0000-0000-0000-000000000aaa");
string user2FirstName = "Walter";
string user2LastName = "Mitty";
string itemName = "b.lsl";
string archiveItemName
= string.Format("{0}{1}{2}", itemName, "_", UUID.Random());
MemoryStream archiveWriteStream = new MemoryStream();
TarArchiveWriter tar = new TarArchiveWriter(archiveWriteStream);
InventoryItemBase item1 = new InventoryItemBase();
item1.Name = itemName;
item1.AssetID = UUID.Random();
item1.GroupID = UUID.Random();
item1.CreatorId = OspResolver.MakeOspa(user2FirstName, user2LastName);
item1.Owner = UUID.Zero;
string item1FileName
= string.Format("{0}{1}", ArchiveConstants.INVENTORY_PATH, archiveItemName);
tar.WriteFile(item1FileName, UserInventoryItemSerializer.Serialize(item1));
tar.Close();
MemoryStream archiveReadStream = new MemoryStream(archiveWriteStream.ToArray());
SerialiserModule serialiserModule = new SerialiserModule();
InventoryArchiverModule archiverModule = new InventoryArchiverModule();
// Annoyingly, we have to set up a scene even though inventory loading has nothing to do with a scene
Scene scene = SceneSetupHelpers.SetupScene();
IUserAdminService userAdminService = scene.CommsManager.UserAdminService;
SceneSetupHelpers.SetupSceneModules(scene, serialiserModule, archiverModule);
userAdminService.AddUser(
userFirstName, userLastName, "meowfood", String.Empty, 1000, 1000, userUuid);
archiverModule.DearchiveInventory(userFirstName, userLastName, "/", archiveReadStream);
// Check that a suitable temporary user profile has been created.
UserProfileData user2Profile
= scene.CommsManager.UserService.GetUserProfile(
OspResolver.HashName(user2FirstName + " " + user2LastName));
Assert.That(user2Profile, Is.Not.Null);
Assert.That(user2Profile.FirstName == user2FirstName);
Assert.That(user2Profile.SurName == user2LastName);
CachedUserInfo userInfo
= scene.CommsManager.UserProfileCacheService.GetUserDetails(userFirstName, userLastName);
userInfo.FetchInventory();
for (int i = 0; i < 50; i++)
{
if (userInfo.HasReceivedInventory == true)
{
break;
}
Thread.Sleep(200);
}
Assert.That(userInfo.HasReceivedInventory, Is.True, "FetchInventory timed out (10 seconds)");
InventoryItemBase foundItem = userInfo.RootFolder.FindItemByPath(itemName);
Assert.That(foundItem.CreatorId, Is.EqualTo(item1.CreatorId));
Assert.That(
foundItem.CreatorIdAsUuid, Is.EqualTo(OspResolver.HashName(user2FirstName + " " + user2LastName)));
Assert.That(foundItem.Owner, Is.EqualTo(userUuid));
Console.WriteLine("### Successfully completed {0} ###", MethodBase.GetCurrentMethod());
}
private void CreateLink()
{
if (!_scene.Permissions.CanCreateUserInventory((int)InventoryType.Wearable, _avatarID))
{
return;
}
ScenePresence presence;
if ((presence = _scene.GetScenePresence(_avatarID)) != null)
{
// Don't link to default items
if ((_wearableInventoryItemID == AvatarWearable.DEFAULT_EYES_ITEM) ||
(_wearableInventoryItemID == AvatarWearable.DEFAULT_BODY_ITEM) ||
(_wearableInventoryItemID == AvatarWearable.DEFAULT_HAIR_ITEM) ||
(_wearableInventoryItemID == AvatarWearable.DEFAULT_PANTS_ITEM) ||
(_wearableInventoryItemID == AvatarWearable.DEFAULT_SHIRT_ITEM) ||
(_wearableInventoryItemID == AvatarWearable.DEFAULT_SKIN_ITEM))
{
return;
}
CachedUserInfo userInfo = _scene.CommsManager.UserService.GetUserDetails(_avatarID);
if (userInfo != null)
{
InventoryItemBase oldItem = null;
try
{
oldItem = userInfo.FindItem(_wearableInventoryItemID);
}
catch { }
if (oldItem == null)
{
return;//Item doesn't exist?
}
InventoryFolderBase CurrentOutfitFolder = GetCurrentOutfitFolder(userInfo);
if (CurrentOutfitFolder == null)
{
return; //No COF, just ignore
}
CurrentOutfitFolder.Version++;
userInfo.UpdateFolder(CurrentOutfitFolder);
InventoryItemBase item = new InventoryItemBase();
item.Owner = _avatarID;
item.CreatorId = _avatarID.ToString();
item.ID = UUID.Random();
item.AssetID = _wearableInventoryItemID;
item.Description = oldItem.Description;
item.Name = oldItem.Name;
item.Flags = oldItem.Flags;
item.AssetType = (int)AssetType.Link;
item.InvType = (int)InventoryType.Wearable;
item.Folder = CurrentOutfitFolder.ID;
item.CreationDate = Util.UnixTimeSinceEpoch();
item.BasePermissions = (uint)(PermissionMask.All | PermissionMask.Export);
item.CurrentPermissions = (uint)(PermissionMask.All | PermissionMask.Export);
item.GroupPermissions = (uint)PermissionMask.None;
item.EveryOnePermissions = (uint)PermissionMask.None;
item.NextPermissions = (uint)PermissionMask.All;
userInfo.AddItem(item);
presence.ControllingClient.SendInventoryItemCreateUpdate(item, 0);
}
else
{
m_log.WarnFormat(
"No user details associated with client {0} uuid {1} in CreateNewInventoryItem!",
presence.Name, presence.UUID);
}
}
else
{
m_log.ErrorFormat(
"ScenePresence for agent uuid {0} unexpectedly not found in HandleLinkInventoryItem",
_avatarID);
}
}
private void SaveInvConsoleCommandCompleted(
Guid id, bool succeeded, CachedUserInfo userInfo, string invPath, Stream saveStream,
Exception reportedException)
{
lock (m_pendingConsoleSaves)
{
if (m_pendingConsoleSaves.Contains(id))
m_pendingConsoleSaves.Remove(id);
else
return;
}
if (succeeded)
{
m_log.InfoFormat("[INVENTORY ARCHIVER]: Saved archive for {0}", userInfo.UserProfile.Name);
}
else
{
m_log.ErrorFormat(
"[INVENTORY ARCHIVER]: Archive save for {0} failed - {1}",
userInfo.UserProfile.Name, reportedException.Message);
}
}
/// <summary>
/// Update what the avatar is wearing using an item from their inventory.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public void AvatarIsWearing(Object sender, AvatarWearingArgs e)
{
IClientAPI clientView = (IClientAPI)sender;
ScenePresence avatar = m_scene.GetScenePresence(clientView.AgentId);
if (avatar == null)
{
m_log.Error("[APPEARANCE]: Avatar is child agent, ignoring AvatarIsWearing event");
return;
}
CachedUserInfo profile = m_scene.CommsManager.UserService.GetUserDetails(clientView.AgentId);
if (profile != null)
{
AvatarAppearance appearance = avatar.Appearance;
// we need to clean out the existing textures
appearance.Texture = AvatarAppearance.GetDefaultTexture();
List <AvatarWearable> wearables = new List <AvatarWearable>();
lock (_currentlyWaitingCOFBuilds)
{
//Check to see whether the client can manage itself
if (_cofSyncEnabled && !_viewer2Users.Contains(clientView.AgentId))
{
foreach (AvatarWearingArgs.Wearable wear in e.NowWearing)
{
wearables.Add(new AvatarWearable(wear.Type, wear.ItemID, UUID.Zero));
AvatarWearable oldWearable = appearance.GetWearableOfType(wear.Type);
if (wear.ItemID != UUID.Zero)
{
if (oldWearable == null || oldWearable.ItemID == UUID.Zero || wear.ItemID != oldWearable.ItemID)
{
bool add = false;
Dictionary <UUID, BuildCOF> waitingCOFs = new Dictionary <UUID, BuildCOF>();
if ((add = !_currentlyWaitingCOFBuilds.TryGetValue(clientView.AgentId, out waitingCOFs)))
{
waitingCOFs = new Dictionary <UUID, BuildCOF>();
}
//Make sure that the new item is added
if (waitingCOFs.ContainsKey(wear.ItemID))
{
BuildCOF cof = waitingCOFs[wear.ItemID];
cof.SetWearableToLookFor(wear.ItemID, m_scene, clientView.AgentId, true);
if (cof.Finished())
{
waitingCOFs.Remove(wear.ItemID);
}
}
else
{
BuildCOF cof = new BuildCOF(ClearWaitingCOF);
cof.SetWearableToLookFor(wear.ItemID, m_scene, clientView.AgentId, true);
waitingCOFs.Add(wear.ItemID, cof);
}
if (add)
{
_currentlyWaitingCOFBuilds.Add(clientView.AgentId, waitingCOFs);
}
}
if (oldWearable != null && oldWearable.ItemID != UUID.Zero && wear.ItemID != oldWearable.ItemID)
{
bool add = false;
Dictionary <UUID, BuildCOF> waitingCOFs = new Dictionary <UUID, BuildCOF>();
if ((add = !_currentlyWaitingCOFBuilds.TryGetValue(clientView.AgentId, out waitingCOFs)))
{
waitingCOFs = new Dictionary <UUID, BuildCOF>();
}
//Check for removal of old item
if (waitingCOFs.ContainsKey(oldWearable.ItemID))
{
BuildCOF cof = waitingCOFs[oldWearable.ItemID];
cof.SetWearableToLookFor(oldWearable.ItemID, m_scene, clientView.AgentId, false);
if (cof.Finished())
{
waitingCOFs.Remove(oldWearable.ItemID);
}
}
else
{
BuildCOF cof = new BuildCOF(ClearWaitingCOF);
cof.SetWearableToLookFor(oldWearable.ItemID, m_scene, clientView.AgentId, false);
waitingCOFs.Add(oldWearable.ItemID, cof);
}
if (add)
{
_currentlyWaitingCOFBuilds.Add(clientView.AgentId, waitingCOFs);
}
}
}
else if (oldWearable != null && oldWearable.ItemID != UUID.Zero)
{
bool add = false;
Dictionary <UUID, BuildCOF> waitingCOFs = new Dictionary <UUID, BuildCOF>();
if ((add = !_currentlyWaitingCOFBuilds.TryGetValue(clientView.AgentId, out waitingCOFs)))
{
waitingCOFs = new Dictionary <UUID, BuildCOF>();
}
//Remove the item if it was just removed
if (waitingCOFs.ContainsKey(oldWearable.ItemID))
{
BuildCOF cof = waitingCOFs[oldWearable.ItemID];
cof.SetWearableToLookFor(oldWearable.ItemID, m_scene, clientView.AgentId, false);
if (cof.Finished())
{
waitingCOFs.Remove(oldWearable.ItemID);
}
}
else
{
BuildCOF cof = new BuildCOF(ClearWaitingCOF);
cof.SetWearableToLookFor(oldWearable.ItemID, m_scene, clientView.AgentId, false);
waitingCOFs.Add(oldWearable.ItemID, cof);
}
if (add)
{
_currentlyWaitingCOFBuilds.Add(clientView.AgentId, waitingCOFs);
}
}
}
}
else
{
foreach (AvatarWearingArgs.Wearable wear in e.NowWearing)
{
wearables.Add(new AvatarWearable(wear.Type, wear.ItemID, UUID.Zero));
}
}
}
// Wearables are a stack. The entries we have represent the current "top" stack state. Apply them
SetAppearanceAssets(profile, ref wearables, clientView);
avatar.Appearance.SetWearables(wearables);
this.UpdateDatabase(clientView.AgentId, avatar.Appearance, null, null);
}
else
{
m_log.WarnFormat("[APPEARANCE]: Cannot set wearables for {0}, no user profile found", clientView.Name);
}
}
// Is the user going back to the home region or the home grid?
protected bool IsGoingHome(CachedUserInfo uinfo, GridRegion rinfo)
{
if (uinfo.UserProfile == null)
return false;
if (!(uinfo.UserProfile is ForeignUserProfileData))
// it's a home user, can't be outside to return home
return false;
// OK, it's a foreign user with a ForeignUserProfileData
// and is going back to exactly the home region.
// We can't check if it's going back to a non-home region
// of the home grid. That will be dealt with in the
// receiving end
return (uinfo.UserProfile.HomeRegionID == rinfo.RegionID);
}
private bool CheckFolderHeirarchyIsAppropriateForPurge(InventoryFolderBase folder, CachedUserInfo userProfile)
{
if (folder.Type == (short)AssetType.TrashFolder ||
folder.Type == (short)AssetType.LostAndFoundFolder)
{
return(true);
}
if (folder.ParentID == UUID.Zero ||
folder.Type == (short)AssetType.RootFolder)
{
//got to the top, didnt find squat
return(false);
}
InventoryFolderBase parent = userProfile.GetFolderAttributes(folder.ParentID);
return(CheckFolderHeirarchyIsAppropriateForPurge(parent, userProfile));
}
/// <summary>
/// Update an existing profile
/// </summary>
/// <param name="userProfile"></param>
/// <returns>true if a user profile was found to update, false otherwise</returns>
// Commented out for now. The implementation needs to be improved by protecting against race conditions,
// probably by making sure that the update doesn't use the UserCacheInfo.UserProfile directly (possibly via
// returning a read only class from the cache).
// public bool StoreProfile(UserProfileData userProfile)
// {
// lock (m_userProfilesById)
// {
// CachedUserInfo userInfo = GetUserDetails(userProfile.ID);
//
// if (userInfo != null)
// {
// userInfo.m_userProfile = userProfile;
// m_commsManager.UserService.UpdateUserProfile(userProfile);
//
// return true;
// }
// }
//
// return false;
// }
/// <summary>
/// Populate caches with the given user profile
/// </summary>
/// <param name="userProfile"></param>
protected CachedUserInfo AddToCaches(UserProfileData userProfile)
{
CachedUserInfo createdUserInfo = new CachedUserInfo(m_InventoryService, userProfile);
lock (m_userProfilesById)
{
m_userProfilesById[createdUserInfo.UserProfile.ID] = createdUserInfo;
lock (m_userProfilesByName)
{
m_userProfilesByName[createdUserInfo.UserProfile.Name] = createdUserInfo;
}
}
return createdUserInfo;
}
////////////////////////////////////////////////
// User-to-user inventory offers
private void UserInventoryOffer(IClientAPI client, Scene scene, GridInstantMessage im)
{
InventoryFolderBase folder = null;
InventoryItemBase item = null;
UUID toAgentID = new UUID(im.toAgentID);
IMuteListModule m_muteListModule = scene.RequestModuleInterface <IMuteListModule>();
if (m_muteListModule != null)
{
if (m_muteListModule.IsMuted(client.AgentId, toAgentID))
{
client.SendAgentAlertMessage("Inventory offer was automatically declined.", false);
return; // recipient has sender muted
}
}
// Unpack the binary bucket
AssetType assetType = (AssetType)im.binaryBucket[0];
UUID destID = new UUID(im.binaryBucket, 1);
UUID copyID;
bool isFolder = (assetType == AssetType.Folder);
ScenePresence recipient = scene.GetScenePresence(toAgentID);
if (recipient != null && recipient.IsBot)
{
client.SendAgentAlertMessage("Can't give inventory to bots.", false);
return;//can't give objects to bots
}
if (assetType == AssetType.Folder)
{
folder = scene.GiveInventoryFolder(toAgentID, client.AgentId, destID, UUID.Zero);
if (folder == null)
{
client.SendAgentAlertMessage("Can't find folder to give. Nothing given.", false);
return;
}
copyID = folder.ID;
}
else
{
item = scene.GiveInventoryItem(toAgentID, client.AgentId, destID);
if (item == null)
{
client.SendAgentAlertMessage("Can't find item to give. Nothing given.", false);
return;
}
copyID = item.ID;
}
// m_log.InfoFormat("[AGENT INVENTORY]: Offering {0} {1} to user {2} inventory as {3}", isFolder ? "folder" : "item", destID, toAgentID, copyID);
// Update the asset type and destination ID into the outgoing IM.
im.binaryBucket = new byte[17];
im.binaryBucket[0] = (byte)assetType;
Array.Copy(copyID.GetBytes(), 0, im.binaryBucket, 1, 16);
// Also stuff the destination ID into the session ID field for retrieval in accept/decline
im.imSessionID = copyID.Guid;
CachedUserInfo recipientInfo = scene.CommsManager.UserService.GetUserDetails(toAgentID);
if (recipientInfo != null && recipient != null)
{
if ((!isFolder) && (item != null))
{
// item offer?
recipient.ControllingClient.SendInventoryItemCreateUpdate(item, 0);
}
if (isFolder && (folder != null))
{
// folder offer?
folder = recipientInfo.GetFolder(folder.ID);
if (folder != null)
{
recipient.ControllingClient.SendBulkUpdateInventory(folder);
recipientInfo.SendInventoryDecendents(recipient.ControllingClient, folder.ID, false, true);
}
}
}
// Send the IM to the recipient. The item is already in their inventory, so
// it will not be lost if they are offline. Transaction ID is the item ID.
// We get that same ID back on the reply so we know what to act on.
RelayInventoryOfferIM(scene, recipient, im);
}
