SceneObjectGroup.Inventory.cs 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602
  1. /*
  2. * Copyright (c) Contributors, http://opensimulator.org/
  3. * See CONTRIBUTORS.TXT for a full list of copyright holders.
  4. *
  5. * Redistribution and use in source and binary forms, with or without
  6. * modification, are permitted provided that the following conditions are met:
  7. * * Redistributions of source code must retain the above copyright
  8. * notice, this list of conditions and the following disclaimer.
  9. * * Redistributions in binary form must reproduce the above copyright
  10. * notice, this list of conditions and the following disclaimer in the
  11. * documentation and/or other materials provided with the distribution.
  12. * * Neither the name of the OpenSimulator Project nor the
  13. * names of its contributors may be used to endorse or promote products
  14. * derived from this software without specific prior written permission.
  15. *
  16. * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
  17. * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  18. * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19. * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
  20. * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  21. * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  22. * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  23. * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24. * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  25. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26. */
  27. using System;
  28. using System.IO;
  29. using System.Reflection;
  30. using OpenMetaverse;
  31. using log4net;
  32. using OpenSim.Framework;
  33. using OpenSim.Region.Framework.Interfaces;
  34. using System.Collections.Generic;
  35. using System.Xml;
  36. using PermissionMask = OpenSim.Framework.PermissionMask;
  37. namespace OpenSim.Region.Framework.Scenes
  38. {
  39. public partial class SceneObjectGroup : EntityBase
  40. {
  41. private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
  42. /// <summary>
  43. /// Force all task inventories of prims in the scene object to persist
  44. /// </summary>
  45. public void ForceInventoryPersistence()
  46. {
  47. SceneObjectPart[] parts = m_parts.GetArray();
  48. for (int i = 0; i < parts.Length; i++)
  49. parts[i].Inventory.ForceInventoryPersistence();
  50. }
  51. /// <summary>
  52. /// Start the scripts contained in all the prims in this group.
  53. /// </summary>
  54. /// <param name="startParam"></param>
  55. /// <param name="postOnRez"></param>
  56. /// <param name="engine"></param>
  57. /// <param name="stateSource"></param>
  58. /// <returns>
  59. /// Number of scripts that were valid for starting. This does not guarantee that all these scripts
  60. /// were actually started, but just that the start could be attempt (e.g. the asset data for the script could be found)
  61. /// </returns>
  62. public int CreateScriptInstances(int startParam, bool postOnRez, string engine, int stateSource)
  63. {
  64. int scriptsStarted = 0;
  65. if (m_scene == null)
  66. {
  67. m_log.DebugFormat("[PRIM INVENTORY]: m_scene is null. Unable to create script instances");
  68. return 0;
  69. }
  70. // Don't start scripts if they're turned off in the region!
  71. if (!m_scene.RegionInfo.RegionSettings.DisableScripts)
  72. {
  73. SceneObjectPart[] parts = m_parts.GetArray();
  74. for (int i = 0; i < parts.Length; i++)
  75. scriptsStarted
  76. += parts[i].Inventory.CreateScriptInstances(startParam, postOnRez, engine, stateSource);
  77. }
  78. return scriptsStarted;
  79. }
  80. /// <summary>
  81. /// Stop and remove the scripts contained in all the prims in this group
  82. /// </summary>
  83. public void RemoveScriptInstances(bool sceneObjectBeingDeleted)
  84. {
  85. SceneObjectPart[] parts = m_parts.GetArray();
  86. for (int i = 0; i < parts.Length; i++)
  87. parts[i].Inventory.RemoveScriptInstances(sceneObjectBeingDeleted);
  88. }
  89. /// <summary>
  90. /// Stop the scripts contained in all the prims in this group
  91. /// </summary>
  92. public void StopScriptInstances()
  93. {
  94. Array.ForEach<SceneObjectPart>(m_parts.GetArray(), p => p.Inventory.StopScriptInstances());
  95. }
  96. /// <summary>
  97. /// Add an inventory item from a user's inventory to a prim in this scene object.
  98. /// </summary>
  99. /// <param name="agentID">The agent adding the item.</param>
  100. /// <param name="localID">The local ID of the part receiving the add.</param>
  101. /// <param name="item">The user inventory item being added.</param>
  102. /// <param name="copyItemID">The item UUID that should be used by the new item.</param>
  103. /// <returns></returns>
  104. public bool AddInventoryItem(UUID agentID, uint localID, InventoryItemBase item, UUID copyItemID, bool withModRights = true)
  105. {
  106. // m_log.DebugFormat(
  107. // "[PRIM INVENTORY]: Adding inventory item {0} from {1} to part with local ID {2}",
  108. // item.Name, remoteClient.Name, localID);
  109. UUID newItemId = (copyItemID != UUID.Zero) ? copyItemID : item.ID;
  110. SceneObjectPart part = GetPart(localID);
  111. if (part == null)
  112. {
  113. m_log.ErrorFormat(
  114. "[PRIM INVENTORY]: " +
  115. "Couldn't find prim local ID {0} in group {1}, {2} to add inventory item ID {3}",
  116. localID, Name, UUID, newItemId);
  117. return false;
  118. }
  119. TaskInventoryItem taskItem = new TaskInventoryItem();
  120. taskItem.ItemID = newItemId;
  121. taskItem.AssetID = item.AssetID;
  122. taskItem.Name = item.Name;
  123. taskItem.Description = item.Description;
  124. taskItem.OwnerID = part.OwnerID; // Transfer ownership
  125. taskItem.CreatorID = item.CreatorIdAsUuid;
  126. taskItem.Type = item.AssetType;
  127. taskItem.InvType = item.InvType;
  128. if (agentID != part.OwnerID && m_scene.Permissions.PropagatePermissions())
  129. {
  130. taskItem.BasePermissions = item.BasePermissions &
  131. item.NextPermissions;
  132. taskItem.CurrentPermissions = item.CurrentPermissions &
  133. item.NextPermissions;
  134. taskItem.EveryonePermissions = item.EveryOnePermissions &
  135. item.NextPermissions;
  136. taskItem.GroupPermissions = item.GroupPermissions &
  137. item.NextPermissions;
  138. taskItem.NextPermissions = item.NextPermissions;
  139. // We're adding this to a prim we don't own. Force
  140. // owner change
  141. taskItem.Flags |= (uint)InventoryItemFlags.ObjectSlamPerm;
  142. taskItem.LastOwnerID = item.Owner;
  143. }
  144. else
  145. {
  146. taskItem.BasePermissions = item.BasePermissions;
  147. taskItem.CurrentPermissions = item.CurrentPermissions;
  148. taskItem.EveryonePermissions = item.EveryOnePermissions;
  149. taskItem.GroupPermissions = item.GroupPermissions;
  150. taskItem.NextPermissions = item.NextPermissions;
  151. }
  152. taskItem.Flags = item.Flags;
  153. // m_log.DebugFormat(
  154. // "[PRIM INVENTORY]: Flags are 0x{0:X} for item {1} added to part {2} by {3}",
  155. // taskItem.Flags, taskItem.Name, localID, remoteClient.Name);
  156. // TODO: These are pending addition of those fields to TaskInventoryItem
  157. // taskItem.SalePrice = item.SalePrice;
  158. // taskItem.SaleType = item.SaleType;
  159. taskItem.CreationDate = (uint)item.CreationDate;
  160. bool addFromAllowedDrop;
  161. if(withModRights)
  162. addFromAllowedDrop = false;
  163. else
  164. addFromAllowedDrop = (part.ParentGroup.RootPart.GetEffectiveObjectFlags() & (uint)PrimFlags.AllowInventoryDrop) != 0;
  165. part.Inventory.AddInventoryItem(taskItem, addFromAllowedDrop);
  166. part.ParentGroup.InvalidateEffectivePerms();
  167. return true;
  168. }
  169. /// <summary>
  170. /// Returns an existing inventory item. Returns the original, so any changes will be live.
  171. /// </summary>
  172. /// <param name="primID"></param>
  173. /// <param name="itemID"></param>
  174. /// <returns>null if the item does not exist</returns>
  175. public TaskInventoryItem GetInventoryItem(uint primID, UUID itemID)
  176. {
  177. SceneObjectPart part = GetPart(primID);
  178. if (part != null)
  179. {
  180. return part.Inventory.GetInventoryItem(itemID);
  181. }
  182. else
  183. {
  184. m_log.ErrorFormat(
  185. "[PRIM INVENTORY]: " +
  186. "Couldn't find prim local ID {0} in prim {1}, {2} to get inventory item ID {3}",
  187. primID, part.Name, part.UUID, itemID);
  188. }
  189. return null;
  190. }
  191. /// <summary>
  192. /// Update an existing inventory item.
  193. /// </summary>
  194. /// <param name="item">The updated item. An item with the same id must already exist
  195. /// in this prim's inventory</param>
  196. /// <returns>false if the item did not exist, true if the update occurred succesfully</returns>
  197. public bool UpdateInventoryItem(TaskInventoryItem item)
  198. {
  199. SceneObjectPart part = GetPart(item.ParentPartID);
  200. if (part != null)
  201. {
  202. part.Inventory.UpdateInventoryItem(item);
  203. return true;
  204. }
  205. else
  206. {
  207. m_log.ErrorFormat(
  208. "[PRIM INVENTORY]: " +
  209. "Couldn't find prim ID {0} to update item {1}, {2}",
  210. item.ParentPartID, item.Name, item.ItemID);
  211. }
  212. return false;
  213. }
  214. public int RemoveInventoryItem(uint localID, UUID itemID)
  215. {
  216. SceneObjectPart part = GetPart(localID);
  217. if (part != null)
  218. {
  219. int type = part.Inventory.RemoveInventoryItem(itemID);
  220. return type;
  221. }
  222. return -1;
  223. }
  224. // new test code, to place in better place later
  225. private object m_PermissionsLock = new object();
  226. private bool m_EffectivePermsInvalid = true;
  227. private bool m_DeepEffectivePermsInvalid = true;
  228. // should called when parts chanced by their contents did not, so we know their cacche is valid
  229. // in case of doubt call InvalidateDeepEffectivePerms(), it only costs a bit more cpu time
  230. public void InvalidateEffectivePerms()
  231. {
  232. lock(m_PermissionsLock)
  233. m_EffectivePermsInvalid = true;
  234. }
  235. // should called when parts chanced and their contents where accounted for
  236. public void InvalidateDeepEffectivePerms()
  237. {
  238. lock(m_PermissionsLock)
  239. {
  240. m_DeepEffectivePermsInvalid = true;
  241. m_EffectivePermsInvalid = true;
  242. }
  243. }
  244. private uint m_EffectiveEveryOnePerms;
  245. public uint EffectiveEveryOnePerms
  246. {
  247. get
  248. {
  249. lock(m_PermissionsLock)
  250. {
  251. if(m_EffectivePermsInvalid)
  252. AggregatePerms();
  253. return m_EffectiveEveryOnePerms;
  254. }
  255. }
  256. }
  257. private uint m_EffectiveGroupPerms;
  258. public uint EffectiveGroupPerms
  259. {
  260. get
  261. {
  262. lock(m_PermissionsLock)
  263. {
  264. if(m_EffectivePermsInvalid)
  265. AggregatePerms();
  266. return m_EffectiveGroupPerms;
  267. }
  268. }
  269. }
  270. private uint m_EffectiveGroupOrEveryOnePerms;
  271. public uint EffectiveGroupOrEveryOnePerms
  272. {
  273. get
  274. {
  275. lock(m_PermissionsLock)
  276. {
  277. if(m_EffectivePermsInvalid)
  278. AggregatePerms();
  279. return m_EffectiveGroupOrEveryOnePerms;
  280. }
  281. }
  282. }
  283. private uint m_EffectiveOwnerPerms;
  284. public uint EffectiveOwnerPerms
  285. {
  286. get
  287. {
  288. lock(m_PermissionsLock)
  289. {
  290. if(m_EffectivePermsInvalid)
  291. AggregatePerms();
  292. return m_EffectiveOwnerPerms;
  293. }
  294. }
  295. }
  296. public void AggregatePerms()
  297. {
  298. lock(m_PermissionsLock)
  299. {
  300. // aux
  301. const uint allmask = (uint)PermissionMask.AllEffective;
  302. const uint movemodmask = (uint)(PermissionMask.Move | PermissionMask.Modify);
  303. const uint copytransfermast = (uint)(PermissionMask.Copy | PermissionMask.Transfer);
  304. uint basePerms = (RootPart.BaseMask & allmask) | (uint)PermissionMask.Move;
  305. bool noBaseTransfer = (basePerms & (uint)PermissionMask.Transfer) == 0;
  306. uint rootOwnerPerms = RootPart.OwnerMask;
  307. uint owner = rootOwnerPerms;
  308. uint rootGroupPerms = RootPart.GroupMask;
  309. uint group = rootGroupPerms;
  310. uint rootEveryonePerms = RootPart.EveryoneMask;
  311. uint everyone = rootEveryonePerms;
  312. bool needUpdate = false;
  313. // date is time of writing april 30th 2017
  314. bool newobj = (RootPart.CreationDate == 0 || RootPart.CreationDate > 1493574994);
  315. SceneObjectPart[] parts = m_parts.GetArray();
  316. for (int i = 0; i < parts.Length; i++)
  317. {
  318. SceneObjectPart part = parts[i];
  319. if(m_DeepEffectivePermsInvalid)
  320. part.AggregatedInnerPermsForGroup();
  321. owner &= part.AggregatedInnerOwnerPerms;
  322. group &= part.AggregatedInnerGroupPerms;
  323. if(newobj)
  324. group &= part.AggregatedInnerGroupPerms;
  325. if(newobj)
  326. everyone &= part.AggregatedInnerEveryonePerms;
  327. }
  328. // recover modify and move
  329. rootOwnerPerms &= movemodmask;
  330. owner |= rootOwnerPerms;
  331. if((owner & copytransfermast) == 0)
  332. owner |= (uint)PermissionMask.Transfer;
  333. owner &= basePerms;
  334. if(owner != m_EffectiveOwnerPerms)
  335. {
  336. needUpdate = true;
  337. m_EffectiveOwnerPerms = owner;
  338. }
  339. uint ownertransfermask = owner & (uint)PermissionMask.Transfer;
  340. // recover modify and move
  341. rootGroupPerms &= movemodmask;
  342. group |= rootGroupPerms;
  343. if(noBaseTransfer)
  344. group &=~(uint)PermissionMask.Copy;
  345. else
  346. group |= ownertransfermask;
  347. uint groupOrEveryone = group;
  348. uint tmpPerms = group & owner;
  349. if(tmpPerms != m_EffectiveGroupPerms)
  350. {
  351. needUpdate = true;
  352. m_EffectiveGroupPerms = tmpPerms;
  353. }
  354. // recover move
  355. rootEveryonePerms &= (uint)PermissionMask.Move;
  356. everyone |= rootEveryonePerms;
  357. everyone &= ~(uint)PermissionMask.Modify;
  358. if(noBaseTransfer)
  359. everyone &=~(uint)PermissionMask.Copy;
  360. else
  361. everyone |= ownertransfermask;
  362. groupOrEveryone |= everyone;
  363. tmpPerms = everyone & owner;
  364. if(tmpPerms != m_EffectiveEveryOnePerms)
  365. {
  366. needUpdate = true;
  367. m_EffectiveEveryOnePerms = tmpPerms;
  368. }
  369. tmpPerms = groupOrEveryone & owner;
  370. if(tmpPerms != m_EffectiveGroupOrEveryOnePerms)
  371. {
  372. needUpdate = true;
  373. m_EffectiveGroupOrEveryOnePerms = tmpPerms;
  374. }
  375. m_DeepEffectivePermsInvalid = false;
  376. m_EffectivePermsInvalid = false;
  377. if(needUpdate)
  378. RootPart.ScheduleFullUpdate();
  379. }
  380. }
  381. public uint CurrentAndFoldedNextPermissions()
  382. {
  383. uint perms=(uint)(PermissionMask.Modify |
  384. PermissionMask.Copy |
  385. PermissionMask.Move |
  386. PermissionMask.Transfer |
  387. PermissionMask.FoldedMask);
  388. uint ownerMask = RootPart.OwnerMask;
  389. SceneObjectPart[] parts = m_parts.GetArray();
  390. for (int i = 0; i < parts.Length; i++)
  391. {
  392. SceneObjectPart part = parts[i];
  393. ownerMask &= part.BaseMask;
  394. perms &= part.Inventory.MaskEffectivePermissions();
  395. }
  396. if ((ownerMask & (uint)PermissionMask.Modify) == 0)
  397. perms &= ~(uint)PermissionMask.Modify;
  398. if ((ownerMask & (uint)PermissionMask.Copy) == 0)
  399. perms &= ~(uint)PermissionMask.Copy;
  400. if ((ownerMask & (uint)PermissionMask.Transfer) == 0)
  401. perms &= ~(uint)PermissionMask.Transfer;
  402. if ((ownerMask & (uint)PermissionMask.Export) == 0)
  403. perms &= ~(uint)PermissionMask.Export;
  404. return perms;
  405. }
  406. public void ApplyNextOwnerPermissions()
  407. {
  408. // m_log.DebugFormat("[PRIM INVENTORY]: Applying next owner permissions to {0} {1}", Name, UUID);
  409. SceneObjectPart[] parts = m_parts.GetArray();
  410. for (int i = 0; i < parts.Length; i++)
  411. parts[i].ApplyNextOwnerPermissions();
  412. }
  413. public string GetStateSnapshot()
  414. {
  415. Dictionary<UUID, string> states = new Dictionary<UUID, string>();
  416. SceneObjectPart[] parts = m_parts.GetArray();
  417. for (int i = 0; i < parts.Length; i++)
  418. {
  419. SceneObjectPart part = parts[i];
  420. foreach (KeyValuePair<UUID, string> s in part.Inventory.GetScriptStates())
  421. states[s.Key] = s.Value;
  422. }
  423. if (states.Count < 1)
  424. return String.Empty;
  425. XmlDocument xmldoc = new XmlDocument();
  426. XmlNode xmlnode = xmldoc.CreateNode(XmlNodeType.XmlDeclaration,
  427. String.Empty, String.Empty);
  428. xmldoc.AppendChild(xmlnode);
  429. XmlElement rootElement = xmldoc.CreateElement("", "ScriptData",
  430. String.Empty);
  431. xmldoc.AppendChild(rootElement);
  432. XmlElement wrapper = xmldoc.CreateElement("", "ScriptStates",
  433. String.Empty);
  434. rootElement.AppendChild(wrapper);
  435. foreach (KeyValuePair<UUID, string> state in states)
  436. {
  437. XmlDocument sdoc = new XmlDocument();
  438. sdoc.LoadXml(state.Value);
  439. XmlNodeList rootL = sdoc.GetElementsByTagName("State");
  440. XmlNode rootNode = rootL[0];
  441. XmlNode newNode = xmldoc.ImportNode(rootNode, true);
  442. wrapper.AppendChild(newNode);
  443. }
  444. return xmldoc.InnerXml;
  445. }
  446. public void SetState(string objXMLData, IScene ins)
  447. {
  448. if (!(ins is Scene))
  449. return;
  450. Scene s = (Scene)ins;
  451. if (objXMLData == String.Empty)
  452. return;
  453. IScriptModule scriptModule = null;
  454. foreach (IScriptModule sm in s.RequestModuleInterfaces<IScriptModule>())
  455. {
  456. if (sm.ScriptEngineName == s.DefaultScriptEngine)
  457. scriptModule = sm;
  458. else if (scriptModule == null)
  459. scriptModule = sm;
  460. }
  461. if (scriptModule == null)
  462. return;
  463. XmlDocument doc = new XmlDocument();
  464. try
  465. {
  466. doc.LoadXml(objXMLData);
  467. }
  468. catch (Exception) // (System.Xml.XmlException)
  469. {
  470. // We will get here if the XML is invalid or in unit
  471. // tests. Really should determine which it is and either
  472. // fail silently or log it
  473. // Fail silently, for now.
  474. // TODO: Fix this
  475. //
  476. return;
  477. }
  478. XmlNodeList rootL = doc.GetElementsByTagName("ScriptData");
  479. if (rootL.Count != 1)
  480. return;
  481. XmlElement rootE = (XmlElement)rootL[0];
  482. XmlNodeList dataL = rootE.GetElementsByTagName("ScriptStates");
  483. if (dataL.Count != 1)
  484. return;
  485. XmlElement dataE = (XmlElement)dataL[0];
  486. foreach (XmlNode n in dataE.ChildNodes)
  487. {
  488. XmlElement stateE = (XmlElement)n;
  489. UUID itemID = new UUID(stateE.GetAttribute("UUID"));
  490. scriptModule.SetXMLState(itemID, n.OuterXml);
  491. }
  492. }
  493. public void ResumeScripts()
  494. {
  495. if (m_scene.RegionInfo.RegionSettings.DisableScripts)
  496. return;
  497. SceneObjectPart[] parts = m_parts.GetArray();
  498. for (int i = 0; i < parts.Length; i++)
  499. parts[i].Inventory.ResumeScripts();
  500. }
  501. /// <summary>
  502. /// Returns true if any part in the scene object contains scripts, false otherwise.
  503. /// </summary>
  504. /// <returns></returns>
  505. public bool ContainsScripts()
  506. {
  507. foreach (SceneObjectPart part in Parts)
  508. if (part.Inventory.ContainsScripts())
  509. return true;
  510. return false;
  511. }
  512. }
  513. }