开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llinventory.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：44k
源码类别：

游戏引擎

开发平台：

C++ Builder

llinventory.cpp：源码内容
  1. /** 
  2.  * @file llinventory.cpp
  3.  * @brief Implementation of the inventory system.
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "linden_common.h"
  35. #include "llinventory.h"
  37. #include "lldbstrings.h"
  38. #include "llxorcipher.h"
  39. #include "llsd.h"
  40. #include "message.h"
  41. #include <boost/tokenizer.hpp>
  43. #include "llsdutil.h"
  45. ///----------------------------------------------------------------------------
  46. /// exported functions
  47. ///----------------------------------------------------------------------------
  49. static const std::string INV_ITEM_ID_LABEL("item_id");
  50. static const std::string INV_FOLDER_ID_LABEL("folder_id");
  51. static const std::string INV_PARENT_ID_LABEL("parent_id");
  52. static const std::string INV_ASSET_TYPE_LABEL("type");
  53. static const std::string INV_PREFERRED_TYPE_LABEL("preferred_type");
  54. static const std::string INV_INVENTORY_TYPE_LABEL("inv_type");
  55. static const std::string INV_NAME_LABEL("name");
  56. static const std::string INV_DESC_LABEL("desc");
  57. static const std::string INV_PERMISSIONS_LABEL("permissions");
  58. static const std::string INV_SHADOW_ID_LABEL("shadow_id");
  59. static const std::string INV_ASSET_ID_LABEL("asset_id");
  60. static const std::string INV_SALE_INFO_LABEL("sale_info");
  61. static const std::string INV_FLAGS_LABEL("flags");
  62. static const std::string INV_CREATION_DATE_LABEL("created_at");
  64. // key used by agent-inventory-service
  65. static const std::string INV_ASSET_TYPE_LABEL_WS("type_default");
  66. static const std::string INV_FOLDER_ID_LABEL_WS("category_id");
  67. ///----------------------------------------------------------------------------
  68. /// Local function declarations, constants, enums, and typedefs
  69. ///----------------------------------------------------------------------------
  71. const U8 TASK_INVENTORY_ITEM_KEY = 0;
  72. const U8 TASK_INVENTORY_ASSET_KEY = 1;
  74. const LLUUID MAGIC_ID("3c115e51-04f4-523c-9fa6-98aff1034730");
  77. ///----------------------------------------------------------------------------
  78. /// Class LLInventoryObject
  79. ///----------------------------------------------------------------------------
  81. LLInventoryObject::LLInventoryObject(
  82. const LLUUID& uuid,
  83. const LLUUID& parent_uuid,
  84. LLAssetType::EType type,
  85. const std::string& name) :
  86. mUUID(uuid),
  87. mParentUUID(parent_uuid),
  88. mType(type),
  89. mName(name)
  90. {
  91. LLStringUtil::replaceNonstandardASCII(mName, ' ');
  92. LLStringUtil::replaceChar(mName, '|', ' ');
  93. LLStringUtil::trim(mName);
  94. LLStringUtil::truncate(mName, DB_INV_ITEM_NAME_STR_LEN);
  95. }
  97. LLInventoryObject::LLInventoryObject() :
  98. mType(LLAssetType::AT_NONE)
  99. {
  100. }
  102. LLInventoryObject::~LLInventoryObject( void )
  103. {
  104. }
  106. void LLInventoryObject::copyObject(const LLInventoryObject* other)
  107. {
  108. mUUID = other->mUUID;
  109. mParentUUID = other->mParentUUID;
  110. mType = other->mType;
  111. mName = other->mName;
  112. }
  114. const LLUUID& LLInventoryObject::getUUID() const
  115. {
  116. return mUUID;
  117. }
  119. const LLUUID& LLInventoryObject::getParentUUID() const
  120. {
  121. return mParentUUID;
  122. }
  124. const std::string& LLInventoryObject::getName() const
  125. {
  126. return mName;
  127. }
  129. // To bypass linked items, since llviewerinventory's getType
  130. // will return the linked-to item's type instead of this object's type.
  131. LLAssetType::EType LLInventoryObject::getActualType() const
  132. {
  133. return mType;
  134. }
  136. BOOL LLInventoryObject::getIsLinkType() const
  137. {
  138. return LLAssetType::lookupIsLinkType(mType);
  139. }
  141. // See LLInventoryItem override.
  142. // virtual
  143. const LLUUID& LLInventoryObject::getLinkedUUID() const
  144. {
  145. return mUUID;
  146. }
  148. LLAssetType::EType LLInventoryObject::getType() const
  149. {
  150. return mType;
  151. }
  153. void LLInventoryObject::setUUID(const LLUUID& new_uuid)
  154. {
  155. mUUID = new_uuid;
  156. }
  158. void LLInventoryObject::rename(const std::string& n)
  159. {
  160. std::string new_name(n);
  161. LLStringUtil::replaceNonstandardASCII(new_name, ' ');
  162. LLStringUtil::replaceChar(new_name, '|', ' ');
  163. LLStringUtil::trim(new_name);
  164. LLStringUtil::truncate(new_name, DB_INV_ITEM_NAME_STR_LEN);
  166. if( new_name != mName )
  167. {
  168. mName = new_name;
  169. }
  170. }
  172. void LLInventoryObject::setParent(const LLUUID& new_parent)
  173. {
  174. mParentUUID = new_parent;
  175. }
  177. void LLInventoryObject::setType(LLAssetType::EType type)
  178. {
  179. mType = type;
  180. }
  183. // virtual
  184. BOOL LLInventoryObject::importLegacyStream(std::istream& input_stream)
  185. {
  186. // *NOTE: Changing the buffer size will require changing the scanf
  187. // calls below.
  188. char buffer[MAX_STRING]; /* Flawfinder: ignore */
  189. char keyword[MAX_STRING]; /* Flawfinder: ignore */
  190. char valuestr[MAX_STRING]; /* Flawfinder: ignore */
  192. keyword[0] = '';
  193. valuestr[0] = '';
  194. while(input_stream.good())
  195. {
  196. input_stream.getline(buffer, MAX_STRING);
  197. sscanf(buffer, " %254s %254s", keyword, valuestr); /* Flawfinder: ignore */
  198. if(0 == strcmp("{",keyword))
  199. {
  200. continue;
  201. }
  202. if(0 == strcmp("}", keyword))
  203. {
  204. break;
  205. }
  206. else if(0 == strcmp("obj_id", keyword))
  207. {
  208. mUUID.set(valuestr);
  209. }
  210. else if(0 == strcmp("parent_id", keyword))
  211. {
  212. mParentUUID.set(valuestr);
  213. }
  214. else if(0 == strcmp("type", keyword))
  215. {
  216. mType = LLAssetType::lookup(valuestr);
  217. }
  218. else if(0 == strcmp("name", keyword))
  219. {
  220. //strcpy(valuestr, buffer + strlen(keyword) + 3);
  221. // *NOTE: Not ANSI C, but widely supported.
  222. sscanf( /* Flawfinder: ignore */
  223. buffer,
  224. " %254s %254[^|]",
  225. keyword, valuestr);
  226. mName.assign(valuestr);
  227. LLStringUtil::replaceNonstandardASCII(mName, ' ');
  228. LLStringUtil::replaceChar(mName, '|', ' ');
  229. LLStringUtil::trim(mName);
  230. LLStringUtil::truncate(mName, DB_INV_ITEM_NAME_STR_LEN);
  231. }
  232. else
  233. {
  234. llwarns << "unknown keyword '" << keyword
  235. << "' in LLInventoryObject::importLegacyStream() for object " << mUUID << llendl;
  236. }
  237. }
  238. return TRUE;
  239. }
  241. // exportFile should be replaced with exportLegacyStream
  242. // not sure whether exportLegacyStream(llofstream(fp)) would work, fp may need to get icramented...
  243. BOOL LLInventoryObject::exportFile(LLFILE* fp, BOOL) const
  244. {
  245. std::string uuid_str;
  246. fprintf(fp, "tinv_objectt0nt{n");
  247. mUUID.toString(uuid_str);
  248. fprintf(fp, "ttobj_idt%sn", uuid_str.c_str());
  249. mParentUUID.toString(uuid_str);
  250. fprintf(fp, "ttparent_idt%sn", uuid_str.c_str());
  251. fprintf(fp, "tttypet%sn", LLAssetType::lookup(mType));
  252. fprintf(fp, "ttnamet%s|n", mName.c_str());
  253. fprintf(fp,"t}n");
  254. return TRUE;
  255. }
  257. BOOL LLInventoryObject::exportLegacyStream(std::ostream& output_stream, BOOL) const
  258. {
  259. std::string uuid_str;
  260. output_stream <<  "tinv_objectt0nt{n";
  261. mUUID.toString(uuid_str);
  262. output_stream << "ttobj_idt" << uuid_str << "n";
  263. mParentUUID.toString(uuid_str);
  264. output_stream << "ttparent_idt" << uuid_str << "n";
  265. output_stream << "tttypet" << LLAssetType::lookup(mType) << "n";
  266. output_stream << "ttnamet" << mName.c_str() << "|n";
  267. output_stream << "t}n";
  268. return TRUE;
  269. }
  272. void LLInventoryObject::removeFromServer()
  273. {
  274. // don't do nothin'
  275. llwarns << "LLInventoryObject::removeFromServer() called.  Doesn't do anything." << llendl;
  276. }
  278. void LLInventoryObject::updateParentOnServer(BOOL) const
  279. {
  280. // don't do nothin'
  281. llwarns << "LLInventoryObject::updateParentOnServer() called.  Doesn't do anything." << llendl;
  282. }
  284. void LLInventoryObject::updateServer(BOOL) const
  285. {
  286. // don't do nothin'
  287. llwarns << "LLInventoryObject::updateServer() called.  Doesn't do anything." << llendl;
  288. }
  291. ///----------------------------------------------------------------------------
  292. /// Class LLInventoryItem
  293. ///----------------------------------------------------------------------------
  295. LLInventoryItem::LLInventoryItem(
  296. const LLUUID& uuid,
  297. const LLUUID& parent_uuid,
  298. const LLPermissions& permissions,
  299. const LLUUID& asset_uuid,
  300. LLAssetType::EType type,
  301. LLInventoryType::EType inv_type,
  302. const std::string& name, 
  303. const std::string& desc,
  304. const LLSaleInfo& sale_info,
  305. U32 flags,
  306. S32 creation_date_utc) :
  307. LLInventoryObject(uuid, parent_uuid, type, name),
  308. mPermissions(permissions),
  309. mAssetUUID(asset_uuid),
  310. mDescription(desc),
  311. mSaleInfo(sale_info),
  312. mInventoryType(inv_type),
  313. mFlags(flags),
  314. mCreationDate(creation_date_utc)
  315. {
  316. LLStringUtil::replaceNonstandardASCII(mDescription, ' ');
  317. LLStringUtil::replaceChar(mDescription, '|', ' ');
  318. mPermissions.initMasks(inv_type);
  319. }
  321. LLInventoryItem::LLInventoryItem() :
  322. LLInventoryObject(),
  323. mPermissions(),
  324. mAssetUUID(),
  325. mDescription(),
  326. mSaleInfo(),
  327. mInventoryType(LLInventoryType::IT_NONE),
  328. mFlags(0),
  329. mCreationDate(0)
  330. {
  331. }
  333. LLInventoryItem::LLInventoryItem(const LLInventoryItem* other) :
  334. LLInventoryObject()
  335. {
  336. copyItem(other);
  337. }
  339. LLInventoryItem::~LLInventoryItem()
  340. {
  341. }
  343. // virtual
  344. void LLInventoryItem::copyItem(const LLInventoryItem* other)
  345. {
  346. copyObject(other);
  347. mPermissions = other->mPermissions;
  348. mAssetUUID = other->mAssetUUID;
  349. mDescription = other->mDescription;
  350. mSaleInfo = other->mSaleInfo;
  351. mInventoryType = other->mInventoryType;
  352. mFlags = other->mFlags;
  353. mCreationDate = other->mCreationDate;
  354. }
  356. // If this is a linked item, then the UUID of the base object is
  357. // this item's assetID.
  358. // virtual
  359. const LLUUID& LLInventoryItem::getLinkedUUID() const
  360. {
  361. if (LLAssetType::lookupIsLinkType(getActualType()))
  362. {
  363. return mAssetUUID;
  364. }
  366. return LLInventoryObject::getLinkedUUID();
  367. }
  369. const LLPermissions& LLInventoryItem::getPermissions() const
  370. {
  371. return mPermissions;
  372. }
  374. const LLUUID& LLInventoryItem::getCreatorUUID() const
  375. {
  376. return mPermissions.getCreator();
  377. }
  379. const LLUUID& LLInventoryItem::getAssetUUID() const
  380. {
  381. return mAssetUUID;
  382. }
  384. void LLInventoryItem::setAssetUUID(const LLUUID& asset_id)
  385. {
  386. mAssetUUID = asset_id;
  387. }
  390. const std::string& LLInventoryItem::getDescription() const
  391. {
  392. return mDescription;
  393. }
  395. time_t LLInventoryItem::getCreationDate() const
  396. {
  397. return mCreationDate;
  398. }
  400. U32 LLInventoryItem::getCRC32() const
  401. {
  402. // *FIX: Not a real crc - more of a checksum.
  403. // *NOTE: We currently do not validate the name or description,
  404. // but if they change in transit, it's no big deal.
  405. U32 crc = mUUID.getCRC32();
  406. //lldebugs << "1 crc: " << std::hex << crc << std::dec << llendl;
  407. crc += mParentUUID.getCRC32();
  408. //lldebugs << "2 crc: " << std::hex << crc << std::dec << llendl;
  409. crc += mPermissions.getCRC32();
  410. //lldebugs << "3 crc: " << std::hex << crc << std::dec << llendl;
  411. crc += mAssetUUID.getCRC32();
  412. //lldebugs << "4 crc: " << std::hex << crc << std::dec << llendl;
  413. crc += mType;
  414. //lldebugs << "5 crc: " << std::hex << crc << std::dec << llendl;
  415. crc += mInventoryType;
  416. //lldebugs << "6 crc: " << std::hex << crc << std::dec << llendl;
  417. crc += mFlags;
  418. //lldebugs << "7 crc: " << std::hex << crc << std::dec << llendl;
  419. crc += mSaleInfo.getCRC32();
  420. //lldebugs << "8 crc: " << std::hex << crc << std::dec << llendl;
  421. crc += mCreationDate;
  422. //lldebugs << "9 crc: " << std::hex << crc << std::dec << llendl;
  423. return crc;
  424. }
  427. void LLInventoryItem::setDescription(const std::string& d)
  428. {
  429. std::string new_desc(d);
  430. LLStringUtil::replaceNonstandardASCII(new_desc, ' ');
  431. LLStringUtil::replaceChar(new_desc, '|', ' ');
  432. if( new_desc != mDescription )
  433. {
  434. mDescription = new_desc;
  435. }
  436. }
  438. void LLInventoryItem::setPermissions(const LLPermissions& perm)
  439. {
  440. mPermissions = perm;
  442. // Override permissions to unrestricted if this is a landmark
  443. mPermissions.initMasks(mInventoryType);
  444. }
  446. void LLInventoryItem::setInventoryType(LLInventoryType::EType inv_type)
  447. {
  448. mInventoryType = inv_type;
  449. }
  451. void LLInventoryItem::setFlags(U32 flags)
  452. {
  453. mFlags = flags;
  454. }
  456. void LLInventoryItem::setCreationDate(time_t creation_date_utc)
  457. {
  458. mCreationDate = creation_date_utc;
  459. }
  461. void LLInventoryItem::accumulatePermissionSlamBits(const LLInventoryItem& old_item)
  462. {
  463. // Remove any pre-existing II_FLAGS_PERM_OVERWRITE_MASK flags 
  464. // because we now detect when they should be set.
  465. setFlags( old_item.getFlags() | (getFlags() & ~(LLInventoryItem::II_FLAGS_PERM_OVERWRITE_MASK)) );
  467. // Enforce the PERM_OVERWRITE flags for any masks that are different
  468. // but only for AT_OBJECT's since that is the only asset type that can 
  469. // exist in-world (instead of only in-inventory or in-object-contents).
  470. if (LLAssetType::AT_OBJECT == getType())
  471. {
  472. LLPermissions old_permissions = old_item.getPermissions();
  473. U32 flags_to_be_set = 0;
  474. if(old_permissions.getMaskNextOwner() != getPermissions().getMaskNextOwner())
  475. {
  476. flags_to_be_set |= LLInventoryItem::II_FLAGS_OBJECT_SLAM_PERM;
  477. }
  478. if(old_permissions.getMaskEveryone() != getPermissions().getMaskEveryone())
  479. {
  480. flags_to_be_set |= LLInventoryItem::II_FLAGS_OBJECT_PERM_OVERWRITE_EVERYONE;
  481. }
  482. if(old_permissions.getMaskGroup() != getPermissions().getMaskGroup())
  483. {
  484. flags_to_be_set |= LLInventoryItem::II_FLAGS_OBJECT_PERM_OVERWRITE_GROUP;
  485. }
  486. LLSaleInfo old_sale_info = old_item.getSaleInfo();
  487. if(old_sale_info != getSaleInfo())
  488. {
  489. flags_to_be_set |= LLInventoryItem::II_FLAGS_OBJECT_SLAM_SALE;
  490. }
  491. setFlags(getFlags() | flags_to_be_set);
  492. }
  493. }
  495. const LLSaleInfo& LLInventoryItem::getSaleInfo() const
  496. {
  497. return mSaleInfo;
  498. }
  500. void LLInventoryItem::setSaleInfo(const LLSaleInfo& sale_info)
  501. {
  502. mSaleInfo = sale_info;
  503. }
  505. LLInventoryType::EType LLInventoryItem::getInventoryType() const
  506. {
  507. return mInventoryType;
  508. }
  510. U32 LLInventoryItem::getFlags() const
  511. {
  512. return mFlags;
  513. }
  515. // virtual
  516. void LLInventoryItem::packMessage(LLMessageSystem* msg) const
  517. {
  518. msg->addUUIDFast(_PREHASH_ItemID, mUUID);
  519. msg->addUUIDFast(_PREHASH_FolderID, mParentUUID);
  520. mPermissions.packMessage(msg);
  521. msg->addUUIDFast(_PREHASH_AssetID, mAssetUUID);
  522. S8 type = static_cast<S8>(mType);
  523. msg->addS8Fast(_PREHASH_Type, type);
  524. type = static_cast<S8>(mInventoryType);
  525. msg->addS8Fast(_PREHASH_InvType, type);
  526. msg->addU32Fast(_PREHASH_Flags, mFlags);
  527. mSaleInfo.packMessage(msg);
  528. msg->addStringFast(_PREHASH_Name, mName);
  529. msg->addStringFast(_PREHASH_Description, mDescription);
  530. msg->addS32Fast(_PREHASH_CreationDate, mCreationDate);
  531. U32 crc = getCRC32();
  532. msg->addU32Fast(_PREHASH_CRC, crc);
  533. }
  535. // virtual
  536. BOOL LLInventoryItem::unpackMessage(LLMessageSystem* msg, const char* block, S32 block_num)
  537. {
  538. msg->getUUIDFast(block, _PREHASH_ItemID, mUUID, block_num);
  539. msg->getUUIDFast(block, _PREHASH_FolderID, mParentUUID, block_num);
  540. mPermissions.unpackMessage(msg, block, block_num);
  541. msg->getUUIDFast(block, _PREHASH_AssetID, mAssetUUID, block_num);
  543. S8 type;
  544. msg->getS8Fast(block, _PREHASH_Type, type, block_num);
  545. mType = static_cast<LLAssetType::EType>(type);
  546. msg->getS8(block, "InvType", type, block_num);
  547. mInventoryType = static_cast<LLInventoryType::EType>(type);
  548. mPermissions.initMasks(mInventoryType);
  550. msg->getU32Fast(block, _PREHASH_Flags, mFlags, block_num);
  552. mSaleInfo.unpackMultiMessage(msg, block, block_num);
  554. msg->getStringFast(block, _PREHASH_Name, mName, block_num);
  555. LLStringUtil::replaceNonstandardASCII(mName, ' ');
  557. msg->getStringFast(block, _PREHASH_Description, mDescription, block_num);
  558. LLStringUtil::replaceNonstandardASCII(mDescription, ' ');
  560. S32 date;
  561. msg->getS32(block, "CreationDate", date, block_num);
  562. mCreationDate = date;
  564. U32 local_crc = getCRC32();
  565. U32 remote_crc = 0;
  566. msg->getU32(block, "CRC", remote_crc, block_num);
  567. //#define CRC_CHECK
  568. #ifdef CRC_CHECK
  569. if(local_crc == remote_crc)
  570. {
  571. lldebugs << "crc matches" << llendl;
  572. return TRUE;
  573. }
  574. else
  575. {
  576. llwarns << "inventory crc mismatch: local=" << std::hex << local_crc
  577. << " remote=" << remote_crc << std::dec << llendl;
  578. return FALSE;
  579. }
  580. #else
  581. return (local_crc == remote_crc);
  582. #endif
  583. }
  585. // virtual
  586. BOOL LLInventoryItem::importFile(LLFILE* fp)
  587. {
  588. // *NOTE: Changing the buffer size will require changing the scanf
  589. // calls below.
  590. char buffer[MAX_STRING]; /* Flawfinder: ignore */
  591. char keyword[MAX_STRING]; /* Flawfinder: ignore */
  592. char valuestr[MAX_STRING]; /* Flawfinder: ignore */
  593. char junk[MAX_STRING]; /* Flawfinder: ignore */
  594. BOOL success = TRUE;
  596. keyword[0] = '';
  597. valuestr[0] = '';
  599. mInventoryType = LLInventoryType::IT_NONE;
  600. mAssetUUID.setNull();
  601. while(success && (!feof(fp)))
  602. {
  603. if (fgets(buffer, MAX_STRING, fp) == NULL)
  604. {
  605. buffer[0] = '';
  606. }
  608. sscanf(buffer, " %254s %254s", keyword, valuestr); /* Flawfinder: ignore */
  609. if(0 == strcmp("{",keyword))
  610. {
  611. continue;
  612. }
  613. if(0 == strcmp("}", keyword))
  614. {
  615. break;
  616. }
  617. else if(0 == strcmp("item_id", keyword))
  618. {
  619. mUUID.set(valuestr);
  620. }
  621. else if(0 == strcmp("parent_id", keyword))
  622. {
  623. mParentUUID.set(valuestr);
  624. }
  625. else if(0 == strcmp("permissions", keyword))
  626. {
  627. success = mPermissions.importFile(fp);
  628. }
  629. else if(0 == strcmp("sale_info", keyword))
  630. {
  631. // Sale info used to contain next owner perm. It is now in
  632. // the permissions. Thus, we read that out, and fix legacy
  633. // objects. It's possible this op would fail, but it
  634. // should pick up the vast majority of the tasks.
  635. BOOL has_perm_mask = FALSE;
  636. U32 perm_mask = 0;
  637. success = mSaleInfo.importFile(fp, has_perm_mask, perm_mask);
  638. if(has_perm_mask)
  639. {
  640. if(perm_mask == PERM_NONE)
  641. {
  642. perm_mask = mPermissions.getMaskOwner();
  643. }
  644. // fair use fix.
  645. if(!(perm_mask & PERM_COPY))
  646. {
  647. perm_mask |= PERM_TRANSFER;
  648. }
  649. mPermissions.setMaskNext(perm_mask);
  650. }
  651. }
  652. else if(0 == strcmp("shadow_id", keyword))
  653. {
  654. mAssetUUID.set(valuestr);
  655. LLXORCipher cipher(MAGIC_ID.mData, UUID_BYTES);
  656. cipher.decrypt(mAssetUUID.mData, UUID_BYTES);
  657. }
  658. else if(0 == strcmp("asset_id", keyword))
  659. {
  660. mAssetUUID.set(valuestr);
  661. }
  662. else if(0 == strcmp("type", keyword))
  663. {
  664. mType = LLAssetType::lookup(valuestr);
  665. }
  666. else if(0 == strcmp("inv_type", keyword))
  667. {
  668. mInventoryType = LLInventoryType::lookup(std::string(valuestr));
  669. }
  670. else if(0 == strcmp("flags", keyword))
  671. {
  672. sscanf(valuestr, "%x", &mFlags);
  673. }
  674. else if(0 == strcmp("name", keyword))
  675. {
  676. //strcpy(valuestr, buffer + strlen(keyword) + 3);
  677. // *NOTE: Not ANSI C, but widely supported.
  678. sscanf( /* Flawfinder: ignore */
  679. buffer,
  680. " %254s%254[t]%254[^|]",
  681. keyword, junk, valuestr);
  683. // IW: sscanf chokes and puts | in valuestr if there's no name
  684. if (valuestr[0] == '|')
  685. {
  686. valuestr[0] = '00';
  687. }
  689. mName.assign(valuestr);
  690. LLStringUtil::replaceNonstandardASCII(mName, ' ');
  691. LLStringUtil::replaceChar(mName, '|', ' ');
  692. }
  693. else if(0 == strcmp("desc", keyword))
  694. {
  695. //strcpy(valuestr, buffer + strlen(keyword) + 3);
  696. // *NOTE: Not ANSI C, but widely supported.
  697. sscanf( /* Flawfinder: ignore */
  698. buffer,
  699. " %254s%254[t]%254[^|]",
  700. keyword, junk, valuestr);
  702. if (valuestr[0] == '|')
  703. {
  704. valuestr[0] = '00';
  705. }
  707. mDescription.assign(valuestr);
  708. LLStringUtil::replaceNonstandardASCII(mDescription, ' ');
  709. /* TODO -- ask Ian about this code
  710. const char *donkey = mDescription.c_str();
  711. if (donkey[0] == '|')
  712. {
  713. llerrs << "Donkey" << llendl;
  714. }
  715. */
  716. }
  717. else if(0 == strcmp("creation_date", keyword))
  718. {
  719. S32 date;
  720. sscanf(valuestr, "%d", &date);
  721. mCreationDate = date;
  722. }
  723. else
  724. {
  725. llwarns << "unknown keyword '" << keyword
  726. << "' in inventory import of item " << mUUID << llendl;
  727. }
  728. }
  730. // Need to convert 1.0 simstate files to a useful inventory type
  731. // and potentially deal with bad inventory tyes eg, a landmark
  732. // marked as a texture.
  733. if((LLInventoryType::IT_NONE == mInventoryType)
  734.    || !inventory_and_asset_types_match(mInventoryType, mType))
  735. {
  736. lldebugs << "Resetting inventory type for " << mUUID << llendl;
  737. mInventoryType = LLInventoryType::defaultForAssetType(mType);
  738. }
  740. mPermissions.initMasks(mInventoryType);
  742. return success;
  743. }
  745. BOOL LLInventoryItem::exportFile(LLFILE* fp, BOOL include_asset_key) const
  746. {
  747. std::string uuid_str;
  748. fprintf(fp, "tinv_itemt0nt{n");
  749. mUUID.toString(uuid_str);
  750. fprintf(fp, "ttitem_idt%sn", uuid_str.c_str());
  751. mParentUUID.toString(uuid_str);
  752. fprintf(fp, "ttparent_idt%sn", uuid_str.c_str());
  753. mPermissions.exportFile(fp);
  755. // Check for permissions to see the asset id, and if so write it
  756. // out as an asset id. Otherwise, apply our cheesy encryption.
  757. if(include_asset_key)
  758. {
  759. U32 mask = mPermissions.getMaskBase();
  760. if(((mask & PERM_ITEM_UNRESTRICTED) == PERM_ITEM_UNRESTRICTED)
  761.    || (mAssetUUID.isNull()))
  762. {
  763. mAssetUUID.toString(uuid_str);
  764. fprintf(fp, "ttasset_idt%sn", uuid_str.c_str());
  765. }
  766. else
  767. {
  768. LLUUID shadow_id(mAssetUUID);
  769. LLXORCipher cipher(MAGIC_ID.mData, UUID_BYTES);
  770. cipher.encrypt(shadow_id.mData, UUID_BYTES);
  771. shadow_id.toString(uuid_str);
  772. fprintf(fp, "ttshadow_idt%sn", uuid_str.c_str());
  773. }
  774. }
  775. else
  776. {
  777. LLUUID::null.toString(uuid_str);
  778. fprintf(fp, "ttasset_idt%sn", uuid_str.c_str());
  779. }
  780. fprintf(fp, "tttypet%sn", LLAssetType::lookup(mType));
  781. const std::string inv_type_str = LLInventoryType::lookup(mInventoryType);
  782. if(!inv_type_str.empty()) fprintf(fp, "ttinv_typet%sn", inv_type_str.c_str());
  783. fprintf(fp, "ttflagst%08xn", mFlags);
  784. mSaleInfo.exportFile(fp);
  785. fprintf(fp, "ttnamet%s|n", mName.c_str());
  786. fprintf(fp, "ttdesct%s|n", mDescription.c_str());
  787. fprintf(fp, "ttcreation_datet%dn", (S32) mCreationDate);
  788. fprintf(fp,"t}n");
  789. return TRUE;
  790. }
  792. // virtual
  793. BOOL LLInventoryItem::importLegacyStream(std::istream& input_stream)
  794. {
  795. // *NOTE: Changing the buffer size will require changing the scanf
  796. // calls below.
  797. char buffer[MAX_STRING]; /* Flawfinder: ignore */
  798. char keyword[MAX_STRING]; /* Flawfinder: ignore */
  799. char valuestr[MAX_STRING]; /* Flawfinder: ignore */
  800. char junk[MAX_STRING]; /* Flawfinder: ignore */
  801. BOOL success = TRUE;
  803. keyword[0] = '';
  804. valuestr[0] = '';
  806. mInventoryType = LLInventoryType::IT_NONE;
  807. mAssetUUID.setNull();
  808. while(success && input_stream.good())
  809. {
  810. input_stream.getline(buffer, MAX_STRING);
  811. sscanf( /* Flawfinder: ignore */
  812. buffer,
  813. " %254s %254s",
  814. keyword, valuestr);
  815. if(0 == strcmp("{",keyword))
  816. {
  817. continue;
  818. }
  819. if(0 == strcmp("}", keyword))
  820. {
  821. break;
  822. }
  823. else if(0 == strcmp("item_id", keyword))
  824. {
  825. mUUID.set(valuestr);
  826. }
  827. else if(0 == strcmp("parent_id", keyword))
  828. {
  829. mParentUUID.set(valuestr);
  830. }
  831. else if(0 == strcmp("permissions", keyword))
  832. {
  833. success = mPermissions.importLegacyStream(input_stream);
  834. }
  835. else if(0 == strcmp("sale_info", keyword))
  836. {
  837. // Sale info used to contain next owner perm. It is now in
  838. // the permissions. Thus, we read that out, and fix legacy
  839. // objects. It's possible this op would fail, but it
  840. // should pick up the vast majority of the tasks.
  841. BOOL has_perm_mask = FALSE;
  842. U32 perm_mask = 0;
  843. success = mSaleInfo.importLegacyStream(input_stream, has_perm_mask, perm_mask);
  844. if(has_perm_mask)
  845. {
  846. if(perm_mask == PERM_NONE)
  847. {
  848. perm_mask = mPermissions.getMaskOwner();
  849. }
  850. // fair use fix.
  851. if(!(perm_mask & PERM_COPY))
  852. {
  853. perm_mask |= PERM_TRANSFER;
  854. }
  855. mPermissions.setMaskNext(perm_mask);
  856. }
  857. }
  858. else if(0 == strcmp("shadow_id", keyword))
  859. {
  860. mAssetUUID.set(valuestr);
  861. LLXORCipher cipher(MAGIC_ID.mData, UUID_BYTES);
  862. cipher.decrypt(mAssetUUID.mData, UUID_BYTES);
  863. }
  864. else if(0 == strcmp("asset_id", keyword))
  865. {
  866. mAssetUUID.set(valuestr);
  867. }
  868. else if(0 == strcmp("type", keyword))
  869. {
  870. mType = LLAssetType::lookup(valuestr);
  871. }
  872. else if(0 == strcmp("inv_type", keyword))
  873. {
  874. mInventoryType = LLInventoryType::lookup(std::string(valuestr));
  875. }
  876. else if(0 == strcmp("flags", keyword))
  877. {
  878. sscanf(valuestr, "%x", &mFlags);
  879. }
  880. else if(0 == strcmp("name", keyword))
  881. {
  882. //strcpy(valuestr, buffer + strlen(keyword) + 3);
  883. // *NOTE: Not ANSI C, but widely supported.
  884. sscanf( /* Flawfinder: ignore */
  885. buffer,
  886. " %254s%254[t]%254[^|]",
  887. keyword, junk, valuestr);
  889. // IW: sscanf chokes and puts | in valuestr if there's no name
  890. if (valuestr[0] == '|')
  891. {
  892. valuestr[0] = '00';
  893. }
  895. mName.assign(valuestr);
  896. LLStringUtil::replaceNonstandardASCII(mName, ' ');
  897. LLStringUtil::replaceChar(mName, '|', ' ');
  898. }
  899. else if(0 == strcmp("desc", keyword))
  900. {
  901. //strcpy(valuestr, buffer + strlen(keyword) + 3);
  902. // *NOTE: Not ANSI C, but widely supported.
  903. sscanf( /* Flawfinder: ignore */
  904. buffer,
  905. " %254s%254[t]%254[^|]",
  906. keyword, junk, valuestr);
  908. if (valuestr[0] == '|')
  909. {
  910. valuestr[0] = '00';
  911. }
  913. mDescription.assign(valuestr);
  914. LLStringUtil::replaceNonstandardASCII(mDescription, ' ');
  915. /* TODO -- ask Ian about this code
  916. const char *donkey = mDescription.c_str();
  917. if (donkey[0] == '|')
  918. {
  919. llerrs << "Donkey" << llendl;
  920. }
  921. */
  922. }
  923. else if(0 == strcmp("creation_date", keyword))
  924. {
  925. S32 date;
  926. sscanf(valuestr, "%d", &date);
  927. mCreationDate = date;
  928. }
  929. else
  930. {
  931. llwarns << "unknown keyword '" << keyword
  932. << "' in inventory import of item " << mUUID << llendl;
  933. }
  934. }
  936. // Need to convert 1.0 simstate files to a useful inventory type
  937. // and potentially deal with bad inventory tyes eg, a landmark
  938. // marked as a texture.
  939. if((LLInventoryType::IT_NONE == mInventoryType)
  940.    || !inventory_and_asset_types_match(mInventoryType, mType))
  941. {
  942. lldebugs << "Resetting inventory type for " << mUUID << llendl;
  943. mInventoryType = LLInventoryType::defaultForAssetType(mType);
  944. }
  946. mPermissions.initMasks(mInventoryType);
  948. return success;
  949. }
  951. BOOL LLInventoryItem::exportLegacyStream(std::ostream& output_stream, BOOL include_asset_key) const
  952. {
  953. std::string uuid_str;
  954. output_stream << "tinv_itemt0nt{n";
  955. mUUID.toString(uuid_str);
  956. output_stream << "ttitem_idt" << uuid_str << "n";
  957. mParentUUID.toString(uuid_str);
  958. output_stream << "ttparent_idt" << uuid_str << "n";
  959. mPermissions.exportLegacyStream(output_stream);
  961. // Check for permissions to see the asset id, and if so write it
  962. // out as an asset id. Otherwise, apply our cheesy encryption.
  963. if(include_asset_key)
  964. {
  965. U32 mask = mPermissions.getMaskBase();
  966. if(((mask & PERM_ITEM_UNRESTRICTED) == PERM_ITEM_UNRESTRICTED)
  967.    || (mAssetUUID.isNull()))
  968. {
  969. mAssetUUID.toString(uuid_str);
  970. output_stream << "ttasset_idt" << uuid_str << "n";
  971. }
  972. else
  973. {
  974. LLUUID shadow_id(mAssetUUID);
  975. LLXORCipher cipher(MAGIC_ID.mData, UUID_BYTES);
  976. cipher.encrypt(shadow_id.mData, UUID_BYTES);
  977. shadow_id.toString(uuid_str);
  978. output_stream << "ttshadow_idt" << uuid_str << "n";
  979. }
  980. }
  981. else
  982. {
  983. LLUUID::null.toString(uuid_str);
  984. output_stream << "ttasset_idt" << uuid_str << "n";
  985. }
  986. output_stream << "tttypet" << LLAssetType::lookup(mType) << "n";
  987. const std::string inv_type_str = LLInventoryType::lookup(mInventoryType);
  988. if(!inv_type_str.empty()) 
  989. output_stream << "ttinv_typet" << inv_type_str << "n";
  990. std::string buffer;
  991. buffer = llformat( "ttflagst%08xn", mFlags);
  992. output_stream << buffer;
  993. mSaleInfo.exportLegacyStream(output_stream);
  994. output_stream << "ttnamet" << mName.c_str() << "|n";
  995. output_stream << "ttdesct" << mDescription.c_str() << "|n";
  996. output_stream << "ttcreation_datet" << mCreationDate << "n";
  997. output_stream << "t}n";
  998. return TRUE;
  999. }
  1001. LLSD LLInventoryItem::asLLSD() const
  1002. {
  1003. LLSD sd = LLSD();
  1004. asLLSD(sd);
  1005. return sd;
  1006. }
  1008. void LLInventoryItem::asLLSD( LLSD& sd ) const
  1009. {
  1010. sd[INV_ITEM_ID_LABEL] = mUUID;
  1011. sd[INV_PARENT_ID_LABEL] = mParentUUID;
  1012. sd[INV_PERMISSIONS_LABEL] = ll_create_sd_from_permissions(mPermissions);
  1014. U32 mask = mPermissions.getMaskBase();
  1015. if(((mask & PERM_ITEM_UNRESTRICTED) == PERM_ITEM_UNRESTRICTED)
  1016. || (mAssetUUID.isNull()))
  1017. {
  1018. sd[INV_ASSET_ID_LABEL] = mAssetUUID;
  1019. }
  1020. else
  1021. {
  1022. // *TODO: get rid of this. Phoenix 2008-01-30
  1023. LLUUID shadow_id(mAssetUUID);
  1024. LLXORCipher cipher(MAGIC_ID.mData, UUID_BYTES);
  1025. cipher.encrypt(shadow_id.mData, UUID_BYTES);
  1026. sd[INV_SHADOW_ID_LABEL] = shadow_id;
  1027. }
  1028. sd[INV_ASSET_TYPE_LABEL] = LLAssetType::lookup(mType);
  1029. sd[INV_INVENTORY_TYPE_LABEL] = mInventoryType;
  1030. const std::string inv_type_str = LLInventoryType::lookup(mInventoryType);
  1031. if(!inv_type_str.empty())
  1032. {
  1033. sd[INV_INVENTORY_TYPE_LABEL] = inv_type_str;
  1034. }
  1035. //sd[INV_FLAGS_LABEL] = (S32)mFlags;
  1036. sd[INV_FLAGS_LABEL] = ll_sd_from_U32(mFlags);
  1037. sd[INV_SALE_INFO_LABEL] = mSaleInfo;
  1038. sd[INV_NAME_LABEL] = mName;
  1039. sd[INV_DESC_LABEL] = mDescription;
  1040. sd[INV_CREATION_DATE_LABEL] = (S32) mCreationDate;
  1041. }
  1043. bool LLInventoryItem::fromLLSD(const LLSD& sd)
  1044. {
  1045. mInventoryType = LLInventoryType::IT_NONE;
  1046. mAssetUUID.setNull();
  1047. std::string w;
  1049. w = INV_ITEM_ID_LABEL;
  1050. if (sd.has(w))
  1051. {
  1052. mUUID = sd[w];
  1053. }
  1054. w = INV_PARENT_ID_LABEL;
  1055. if (sd.has(w))
  1056. {
  1057. mParentUUID = sd[w];
  1058. }
  1059. w = INV_PERMISSIONS_LABEL;
  1060. if (sd.has(w))
  1061. {
  1062. mPermissions = ll_permissions_from_sd(sd[w]);
  1063. }
  1064. w = INV_SALE_INFO_LABEL;
  1065. if (sd.has(w))
  1066. {
  1067. // Sale info used to contain next owner perm. It is now in
  1068. // the permissions. Thus, we read that out, and fix legacy
  1069. // objects. It's possible this op would fail, but it
  1070. // should pick up the vast majority of the tasks.
  1071. BOOL has_perm_mask = FALSE;
  1072. U32 perm_mask = 0;
  1073. if (!mSaleInfo.fromLLSD(sd[w], has_perm_mask, perm_mask))
  1074. {
  1075. goto fail;
  1076. }
  1077. if (has_perm_mask)
  1078. {
  1079. if(perm_mask == PERM_NONE)
  1080. {
  1081. perm_mask = mPermissions.getMaskOwner();
  1082. }
  1083. // fair use fix.
  1084. if(!(perm_mask & PERM_COPY))
  1085. {
  1086. perm_mask |= PERM_TRANSFER;
  1087. }
  1088. mPermissions.setMaskNext(perm_mask);
  1089. }
  1090. }
  1091. w = INV_SHADOW_ID_LABEL;
  1092. if (sd.has(w))
  1093. {
  1094. mAssetUUID = sd[w];
  1095. LLXORCipher cipher(MAGIC_ID.mData, UUID_BYTES);
  1096. cipher.decrypt(mAssetUUID.mData, UUID_BYTES);
  1097. }
  1098. w = INV_ASSET_ID_LABEL;
  1099. if (sd.has(w))
  1100. {
  1101. mAssetUUID = sd[w];
  1102. }
  1103. w = INV_ASSET_TYPE_LABEL;
  1104. if (sd.has(w))
  1105. {
  1106. if (sd[w].isString())
  1107. {
  1108. mType = LLAssetType::lookup(sd[w].asString().c_str());
  1109. }
  1110. else if (sd[w].isInteger())
  1111. {
  1112. S8 type = (U8)sd[w].asInteger();
  1113. mType = static_cast<LLAssetType::EType>(type);
  1114. }
  1115. }
  1116. w = INV_INVENTORY_TYPE_LABEL;
  1117. if (sd.has(w))
  1118. {
  1119. if (sd[w].isString())
  1120. {
  1121. mInventoryType = LLInventoryType::lookup(sd[w].asString().c_str());
  1122. }
  1123. else if (sd[w].isInteger())
  1124. {
  1125. S8 type = (U8)sd[w].asInteger();
  1126. mInventoryType = static_cast<LLInventoryType::EType>(type);
  1127. }
  1128. }
  1129. w = INV_FLAGS_LABEL;
  1130. if (sd.has(w))
  1131. {
  1132. if (sd[w].isBinary())
  1133. {
  1134. mFlags = ll_U32_from_sd(sd[w]);
  1135. }
  1136. else if(sd[w].isInteger())
  1137. {
  1138. mFlags = sd[w].asInteger();
  1139. }
  1140. }
  1141. w = INV_NAME_LABEL;
  1142. if (sd.has(w))
  1143. {
  1144. mName = sd[w].asString();
  1145. LLStringUtil::replaceNonstandardASCII(mName, ' ');
  1146. LLStringUtil::replaceChar(mName, '|', ' ');
  1147. }
  1148. w = INV_DESC_LABEL;
  1149. if (sd.has(w))
  1150. {
  1151. mDescription = sd[w].asString();
  1152. LLStringUtil::replaceNonstandardASCII(mDescription, ' ');
  1153. }
  1154. w = INV_CREATION_DATE_LABEL;
  1155. if (sd.has(w))
  1156. {
  1157. mCreationDate = sd[w].asInteger();
  1158. }
  1160. // Need to convert 1.0 simstate files to a useful inventory type
  1161. // and potentially deal with bad inventory tyes eg, a landmark
  1162. // marked as a texture.
  1163. if((LLInventoryType::IT_NONE == mInventoryType)
  1164.    || !inventory_and_asset_types_match(mInventoryType, mType))
  1165. {
  1166. lldebugs << "Resetting inventory type for " << mUUID << llendl;
  1167. mInventoryType = LLInventoryType::defaultForAssetType(mType);
  1168. }
  1170. mPermissions.initMasks(mInventoryType);
  1172. return true;
  1173. fail:
  1174. return false;
  1176. }
  1178. // Deleted LLInventoryItem::exportFileXML() and LLInventoryItem::importXML()
  1179. // because I can't find any non-test code references to it. 2009-05-04 JC
  1181. S32 LLInventoryItem::packBinaryBucket(U8* bin_bucket, LLPermissions* perm_override) const
  1182. {
  1183. // Figure out which permissions to use.
  1184. LLPermissions perm;
  1185. if (perm_override)
  1186. {
  1187. // Use the permissions override.
  1188. perm = *perm_override;
  1189. }
  1190. else
  1191. {
  1192. // Use the current permissions.
  1193. perm = getPermissions();
  1194. }
  1196. // describe the inventory item
  1197. char* buffer = (char*) bin_bucket;
  1198. std::string creator_id_str;
  1200. perm.getCreator().toString(creator_id_str);
  1201. std::string owner_id_str;
  1202. perm.getOwner().toString(owner_id_str);
  1203. std::string last_owner_id_str;
  1204. perm.getLastOwner().toString(last_owner_id_str);
  1205. std::string group_id_str;
  1206. perm.getGroup().toString(group_id_str);
  1207. std::string asset_id_str;
  1208. getAssetUUID().toString(asset_id_str);
  1209. S32 size = sprintf(buffer, /* Flawfinder: ignore */
  1210.    "%d|%d|%s|%s|%s|%s|%s|%x|%x|%x|%x|%x|%s|%s|%d|%d|%x",
  1211.    getType(),
  1212.    getInventoryType(),
  1213.    getName().c_str(),
  1214.    creator_id_str.c_str(),
  1215.    owner_id_str.c_str(),
  1216.    last_owner_id_str.c_str(),
  1217.    group_id_str.c_str(),
  1218.    perm.getMaskBase(),
  1219.    perm.getMaskOwner(),
  1220.    perm.getMaskGroup(),
  1221.    perm.getMaskEveryone(),
  1222.    perm.getMaskNextOwner(),
  1223.    asset_id_str.c_str(),
  1224.    getDescription().c_str(),
  1225.    getSaleInfo().getSaleType(),
  1226.    getSaleInfo().getSalePrice(),
  1227.    getFlags()) + 1;
  1229. return size;
  1230. }
  1232. void LLInventoryItem::unpackBinaryBucket(U8* bin_bucket, S32 bin_bucket_size)
  1233. {
  1234. // Early exit on an empty binary bucket.
  1235. if (bin_bucket_size <= 1) return;
  1237. if (NULL == bin_bucket)
  1238. {
  1239. llerrs << "unpackBinaryBucket failed.  bin_bucket is NULL." << llendl;
  1240. return;
  1241. }
  1243. // Convert the bin_bucket into a string.
  1244. std::vector<char> item_buffer(bin_bucket_size+1);
  1245. memcpy(&item_buffer[0], bin_bucket, bin_bucket_size); /* Flawfinder: ignore */
  1246. item_buffer[bin_bucket_size] = '';
  1247. std::string str(&item_buffer[0]);
  1249. lldebugs << "item buffer: " << str << llendl;
  1251. // Tokenize the string.
  1252. typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
  1253. boost::char_separator<char> sep("|", "", boost::keep_empty_tokens);
  1254. tokenizer tokens(str, sep);
  1255. tokenizer::iterator iter = tokens.begin();
  1257. // Extract all values.
  1258. LLUUID item_id;
  1259. item_id.generate();
  1260. setUUID(item_id);
  1262. LLAssetType::EType type;
  1263. type = (LLAssetType::EType)(atoi((*(iter++)).c_str()));
  1264. setType( type );
  1266. LLInventoryType::EType inv_type;
  1267. inv_type = (LLInventoryType::EType)(atoi((*(iter++)).c_str()));
  1268. setInventoryType( inv_type );
  1270. std::string name((*(iter++)).c_str());
  1271. rename( name );
  1273. LLUUID creator_id((*(iter++)).c_str());
  1274. LLUUID owner_id((*(iter++)).c_str());
  1275. LLUUID last_owner_id((*(iter++)).c_str());
  1276. LLUUID group_id((*(iter++)).c_str());
  1277. PermissionMask mask_base = strtoul((*(iter++)).c_str(), NULL, 16);
  1278. PermissionMask mask_owner = strtoul((*(iter++)).c_str(), NULL, 16);
  1279. PermissionMask mask_group = strtoul((*(iter++)).c_str(), NULL, 16);
  1280. PermissionMask mask_every = strtoul((*(iter++)).c_str(), NULL, 16);
  1281. PermissionMask mask_next = strtoul((*(iter++)).c_str(), NULL, 16);
  1282. LLPermissions perm;
  1283. perm.init(creator_id, owner_id, last_owner_id, group_id);
  1284. perm.initMasks(mask_base, mask_owner, mask_group, mask_every, mask_next);
  1285. setPermissions(perm);
  1286. //lldebugs << "perm: " << perm << llendl;
  1288. LLUUID asset_id((*(iter++)).c_str());
  1289. setAssetUUID(asset_id);
  1291. std::string desc((*(iter++)).c_str());
  1292. setDescription(desc);
  1294. LLSaleInfo::EForSale sale_type;
  1295. sale_type = (LLSaleInfo::EForSale)(atoi((*(iter++)).c_str()));
  1296. S32 price = atoi((*(iter++)).c_str());
  1297. LLSaleInfo sale_info(sale_type, price);
  1298. setSaleInfo(sale_info);
  1300. U32 flags = strtoul((*(iter++)).c_str(), NULL, 16);
  1301. setFlags(flags);
  1303. time_t now = time(NULL);
  1304. setCreationDate(now);
  1305. }
  1307. // returns TRUE if a should appear before b
  1308. BOOL item_dictionary_sort( LLInventoryItem* a, LLInventoryItem* b )
  1309. {
  1310. return (LLStringUtil::compareDict( a->getName().c_str(), b->getName().c_str() ) < 0);
  1311. }
  1313. // returns TRUE if a should appear before b
  1314. BOOL item_date_sort( LLInventoryItem* a, LLInventoryItem* b )
  1315. {
  1316. return a->getCreationDate() < b->getCreationDate();
  1317. }
  1320. ///----------------------------------------------------------------------------
  1321. /// Class LLInventoryCategory
  1322. ///----------------------------------------------------------------------------
  1324. LLInventoryCategory::LLInventoryCategory(
  1325. const LLUUID& uuid,
  1326. const LLUUID& parent_uuid,
  1327. LLFolderType::EType preferred_type,
  1328. const std::string& name) :
  1329. LLInventoryObject(uuid, parent_uuid, LLAssetType::AT_CATEGORY, name),
  1330. mPreferredType(preferred_type)
  1331. {
  1332. }
  1334. LLInventoryCategory::LLInventoryCategory() :
  1335. mPreferredType(LLFolderType::FT_NONE)
  1336. {
  1337. mType = LLAssetType::AT_CATEGORY;
  1338. }
  1340. LLInventoryCategory::LLInventoryCategory(const LLInventoryCategory* other) :
  1341. LLInventoryObject()
  1342. {
  1343. copyCategory(other);
  1344. }
  1346. LLInventoryCategory::~LLInventoryCategory()
  1347. {
  1348. }
  1350. // virtual
  1351. void LLInventoryCategory::copyCategory(const LLInventoryCategory* other)
  1352. {
  1353. copyObject(other);
  1354. mPreferredType = other->mPreferredType;
  1355. }
  1357. LLFolderType::EType LLInventoryCategory::getPreferredType() const
  1358. {
  1359. return mPreferredType;
  1360. }
  1362. void LLInventoryCategory::setPreferredType(LLFolderType::EType type)
  1363. {
  1364. mPreferredType = type;
  1365. }
  1367. LLSD LLInventoryCategory::asLLSD() const
  1368. {
  1369.     LLSD sd = LLSD();
  1370.     sd["item_id"] = mUUID;
  1371.     sd["parent_id"] = mParentUUID;
  1372.     S8 type = static_cast<S8>(mPreferredType);
  1373.     sd["type"]      = type;
  1374.     sd["name"] = mName;
  1376.     return sd;
  1377. }
  1380. // virtual
  1381. void LLInventoryCategory::packMessage(LLMessageSystem* msg) const
  1382. {
  1383. msg->addUUIDFast(_PREHASH_FolderID, mUUID);
  1384. msg->addUUIDFast(_PREHASH_ParentID, mParentUUID);
  1385. S8 type = static_cast<S8>(mPreferredType);
  1386. msg->addS8Fast(_PREHASH_Type, type);
  1387. msg->addStringFast(_PREHASH_Name, mName);
  1388. }
  1390. bool LLInventoryCategory::fromLLSD(const LLSD& sd)
  1391. {
  1392.     std::string w;
  1394.     w = INV_FOLDER_ID_LABEL_WS;
  1395.     if (sd.has(w))
  1396.     {
  1397.         mUUID = sd[w];
  1398.     }
  1399.     w = INV_PARENT_ID_LABEL;
  1400.     if (sd.has(w))
  1401.     {
  1402.         mParentUUID = sd[w];
  1403.     }
  1404.     w = INV_ASSET_TYPE_LABEL;
  1405.     if (sd.has(w))
  1406.     {
  1407.         S8 type = (U8)sd[w].asInteger();
  1408.         mPreferredType = static_cast<LLFolderType::EType>(type);
  1409.     }
  1410. w = INV_ASSET_TYPE_LABEL_WS;
  1411. if (sd.has(w))
  1412. {
  1413. S8 type = (U8)sd[w].asInteger();
  1414.         mPreferredType = static_cast<LLFolderType::EType>(type);
  1415. }
  1417.     w = INV_NAME_LABEL;
  1418.     if (sd.has(w))
  1419.     {
  1420.         mName = sd[w].asString();
  1421.         LLStringUtil::replaceNonstandardASCII(mName, ' ');
  1422.         LLStringUtil::replaceChar(mName, '|', ' ');
  1423.     }
  1424.     return true;
  1425. }
  1427. // virtual
  1428. void LLInventoryCategory::unpackMessage(LLMessageSystem* msg,
  1429. const char* block,
  1430. S32 block_num)
  1431. {
  1432. msg->getUUIDFast(block, _PREHASH_FolderID, mUUID, block_num);
  1433. msg->getUUIDFast(block, _PREHASH_ParentID, mParentUUID, block_num);
  1434. S8 type;
  1435. msg->getS8Fast(block, _PREHASH_Type, type, block_num);
  1436. mPreferredType = static_cast<LLFolderType::EType>(type);
  1437. msg->getStringFast(block, _PREHASH_Name, mName, block_num);
  1438. LLStringUtil::replaceNonstandardASCII(mName, ' ');
  1439. }
  1441. // virtual
  1442. BOOL LLInventoryCategory::importFile(LLFILE* fp)
  1443. {
  1444. // *NOTE: Changing the buffer size will require changing the scanf
  1445. // calls below.
  1446. char buffer[MAX_STRING]; /* Flawfinder: ignore */
  1447. char keyword[MAX_STRING]; /* Flawfinder: ignore */
  1448. char valuestr[MAX_STRING]; /* Flawfinder: ignore */
  1450. keyword[0] = '';
  1451. valuestr[0] = '';
  1452. while(!feof(fp))
  1453. {
  1454. if (fgets(buffer, MAX_STRING, fp) == NULL)
  1455. {
  1456. buffer[0] = '';
  1457. }
  1459. sscanf( /* Flawfinder: ignore */
  1460. buffer,
  1461. " %254s %254s",
  1462. keyword, valuestr);
  1463. if(0 == strcmp("{",keyword))
  1464. {
  1465. continue;
  1466. }
  1467. if(0 == strcmp("}", keyword))
  1468. {
  1469. break;
  1470. }
  1471. else if(0 == strcmp("cat_id", keyword))
  1472. {
  1473. mUUID.set(valuestr);
  1474. }
  1475. else if(0 == strcmp("parent_id", keyword))
  1476. {
  1477. mParentUUID.set(valuestr);
  1478. }
  1479. else if(0 == strcmp("type", keyword))
  1480. {
  1481. mType = LLAssetType::lookup(valuestr);
  1482. }
  1483. else if(0 == strcmp("pref_type", keyword))
  1484. {
  1485. mPreferredType = LLFolderType::lookup(valuestr);
  1486. }
  1487. else if(0 == strcmp("name", keyword))
  1488. {
  1489. //strcpy(valuestr, buffer + strlen(keyword) + 3);
  1490. // *NOTE: Not ANSI C, but widely supported.
  1491. sscanf( /* Flawfinder: ignore */
  1492. buffer,
  1493. " %254s %254[^|]",
  1494. keyword, valuestr);
  1495. mName.assign(valuestr);
  1496. LLStringUtil::replaceNonstandardASCII(mName, ' ');
  1497. LLStringUtil::replaceChar(mName, '|', ' ');
  1498. }
  1499. else
  1500. {
  1501. llwarns << "unknown keyword '" << keyword
  1502. << "' in inventory import category "  << mUUID << llendl;
  1503. }
  1504. }
  1505. return TRUE;
  1506. }
  1508. BOOL LLInventoryCategory::exportFile(LLFILE* fp, BOOL) const
  1509. {
  1510. std::string uuid_str;
  1511. fprintf(fp, "tinv_categoryt0nt{n");
  1512. mUUID.toString(uuid_str);
  1513. fprintf(fp, "ttcat_idt%sn", uuid_str.c_str());
  1514. mParentUUID.toString(uuid_str);
  1515. fprintf(fp, "ttparent_idt%sn", uuid_str.c_str());
  1516. fprintf(fp, "tttypet%sn", LLAssetType::lookup(mType));
  1517. fprintf(fp, "ttpref_typet%sn", LLFolderType::lookup(mPreferredType).c_str());
  1518. fprintf(fp, "ttnamet%s|n", mName.c_str());
  1519. fprintf(fp,"t}n");
  1520. return TRUE;
  1521. }
  1524. // virtual
  1525. BOOL LLInventoryCategory::importLegacyStream(std::istream& input_stream)
  1526. {
  1527. // *NOTE: Changing the buffer size will require changing the scanf
  1528. // calls below.
  1529. char buffer[MAX_STRING]; /* Flawfinder: ignore */
  1530. char keyword[MAX_STRING]; /* Flawfinder: ignore */
  1531. char valuestr[MAX_STRING]; /* Flawfinder: ignore */
  1533. keyword[0] = '';
  1534. valuestr[0] = '';
  1535. while(input_stream.good())
  1536. {
  1537. input_stream.getline(buffer, MAX_STRING);
  1538. sscanf( /* Flawfinder: ignore */
  1539. buffer,
  1540. " %254s %254s",
  1541. keyword, valuestr);
  1542. if(0 == strcmp("{",keyword))
  1543. {
  1544. continue;
  1545. }
  1546. if(0 == strcmp("}", keyword))
  1547. {
  1548. break;
  1549. }
  1550. else if(0 == strcmp("cat_id", keyword))
  1551. {
  1552. mUUID.set(valuestr);
  1553. }
  1554. else if(0 == strcmp("parent_id", keyword))
  1555. {
  1556. mParentUUID.set(valuestr);
  1557. }
  1558. else if(0 == strcmp("type", keyword))
  1559. {
  1560. mType = LLAssetType::lookup(valuestr);
  1561. }
  1562. else if(0 == strcmp("pref_type", keyword))
  1563. {
  1564. mPreferredType = LLFolderType::lookup(valuestr);
  1565. }
  1566. else if(0 == strcmp("name", keyword))
  1567. {
  1568. //strcpy(valuestr, buffer + strlen(keyword) + 3);
  1569. // *NOTE: Not ANSI C, but widely supported.
  1570. sscanf( /* Flawfinder: ignore */
  1571. buffer,
  1572. " %254s %254[^|]",
  1573. keyword, valuestr);
  1574. mName.assign(valuestr);
  1575. LLStringUtil::replaceNonstandardASCII(mName, ' ');
  1576. LLStringUtil::replaceChar(mName, '|', ' ');
  1577. }
  1578. else
  1579. {
  1580. llwarns << "unknown keyword '" << keyword
  1581. << "' in inventory import category "  << mUUID << llendl;
  1582. }
  1583. }
  1584. return TRUE;
  1585. }
  1587. BOOL LLInventoryCategory::exportLegacyStream(std::ostream& output_stream, BOOL) const
  1588. {
  1589. std::string uuid_str;
  1590. output_stream << "tinv_categoryt0nt{n";
  1591. mUUID.toString(uuid_str);
  1592. output_stream << "ttcat_idt" << uuid_str << "n";
  1593. mParentUUID.toString(uuid_str);
  1594. output_stream << "ttparent_idt" << uuid_str << "n";
  1595. output_stream << "tttypet" << LLAssetType::lookup(mType) << "n";
  1596. output_stream << "ttpref_typet" << LLFolderType::lookup(mPreferredType) << "n";
  1597. output_stream << "ttnamet" << mName.c_str() << "|n";
  1598. output_stream << "t}n";
  1599. return TRUE;
  1600. }
  1602. ///----------------------------------------------------------------------------
  1603. /// Local function definitions
  1604. ///----------------------------------------------------------------------------
  1606. LLSD ll_create_sd_from_inventory_item(LLPointer<LLInventoryItem> item)
  1607. {
  1608. LLSD rv;
  1609. if(item.isNull()) return rv;
  1610. if (item->getType() == LLAssetType::AT_NONE)
  1611. {
  1612. llwarns << "ll_create_sd_from_inventory_item() for item with AT_NONE"
  1613. << llendl;
  1614. return rv;
  1615. }
  1616. rv[INV_ITEM_ID_LABEL] =  item->getUUID();
  1617. rv[INV_PARENT_ID_LABEL] = item->getParentUUID();
  1618. rv[INV_NAME_LABEL] = item->getName();
  1619. rv[INV_ASSET_TYPE_LABEL] = LLAssetType::lookup(item->getType());
  1620. rv[INV_ASSET_ID_LABEL] = item->getAssetUUID();
  1621. rv[INV_DESC_LABEL] = item->getDescription();
  1622. rv[INV_SALE_INFO_LABEL] = ll_create_sd_from_sale_info(item->getSaleInfo());
  1623. rv[INV_PERMISSIONS_LABEL] =
  1624. ll_create_sd_from_permissions(item->getPermissions());
  1625. rv[INV_INVENTORY_TYPE_LABEL] =
  1626. LLInventoryType::lookup(item->getInventoryType());
  1627. rv[INV_FLAGS_LABEL] = (S32)item->getFlags();
  1628. rv[INV_CREATION_DATE_LABEL] = (S32)item->getCreationDate();
  1629. return rv;
  1630. }
  1632. LLSD ll_create_sd_from_inventory_category(LLPointer<LLInventoryCategory> cat)
  1633. {
  1634. LLSD rv;
  1635. if(cat.isNull()) return rv;
  1636. if (cat->getType() == LLAssetType::AT_NONE)
  1637. {
  1638. llwarns << "ll_create_sd_from_inventory_category() for cat with AT_NONE"
  1639. << llendl;
  1640. return rv;
  1641. }
  1642. rv[INV_FOLDER_ID_LABEL] = cat->getUUID();
  1643. rv[INV_PARENT_ID_LABEL] = cat->getParentUUID();
  1644. rv[INV_NAME_LABEL] = cat->getName();
  1645. rv[INV_ASSET_TYPE_LABEL] = LLAssetType::lookup(cat->getType());
  1646. if(LLFolderType::lookupIsProtectedType(cat->getPreferredType()))
  1647. {
  1648. rv[INV_PREFERRED_TYPE_LABEL] =
  1649. LLFolderType::lookup(cat->getPreferredType()).c_str();
  1650. }
  1651. return rv;
  1652. }
  1654. LLPointer<LLInventoryCategory> ll_create_category_from_sd(const LLSD& sd_cat)
  1655. {
  1656. LLPointer<LLInventoryCategory> rv = new LLInventoryCategory;
  1657. rv->setUUID(sd_cat[INV_FOLDER_ID_LABEL].asUUID());
  1658. rv->setParent(sd_cat[INV_PARENT_ID_LABEL].asUUID());
  1659. rv->rename(sd_cat[INV_NAME_LABEL].asString());
  1660. rv->setType(
  1661. LLAssetType::lookup(sd_cat[INV_ASSET_TYPE_LABEL].asString()));
  1662. rv->setPreferredType(
  1663. LLFolderType::lookup(
  1664. sd_cat[INV_PREFERRED_TYPE_LABEL].asString()));
  1665. return rv;
  1666. }