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

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

游戏引擎

开发平台：

C++ Builder

llpermissions.cpp：源码内容
  1. /** 
  2.  * @file llpermissions.cpp
  3.  * @author Phoenix
  4.  * @brief Permissions for objects and inventory.
  5.  *
  6.  * $LicenseInfo:firstyear=2002&license=viewergpl$
  7.  * 
  8.  * Copyright (c) 2002-2010, Linden Research, Inc.
  9.  * 
  10.  * Second Life Viewer Source Code
  11.  * The source code in this file ("Source Code") is provided by Linden Lab
  12.  * to you under the terms of the GNU General Public License, version 2.0
  13.  * ("GPL"), unless you have obtained a separate licensing agreement
  14.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  15.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  16.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  17.  * 
  18.  * There are special exceptions to the terms and conditions of the GPL as
  19.  * it is applied to this Source Code. View the full text of the exception
  20.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  21.  * online at
  22.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  23.  * 
  24.  * By copying, modifying or distributing this software, you acknowledge
  25.  * that you have read and understood your obligations described above,
  26.  * and agree to abide by those obligations.
  27.  * 
  28.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  29.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  30.  * COMPLETENESS OR PERFORMANCE.
  31.  * $/LicenseInfo$
  32.  */
  34. #include "linden_common.h"
  36. #include "llpermissions.h"
  38. // library includes
  39. #include "message.h"
  40. #include "metapropertyt.h"
  41. #include "llsd.h"
  43. ///----------------------------------------------------------------------------
  44. /// Class LLPermissions
  45. ///----------------------------------------------------------------------------
  47. const LLPermissions LLPermissions::DEFAULT;
  49. // No creator = created by system
  50. LLPermissions::LLPermissions()
  51. {
  52. init(LLUUID::null, LLUUID::null, LLUUID::null, LLUUID::null);
  53. }
  56. // Default to created by system
  57. void LLPermissions::init(const LLUUID& creator, const LLUUID& owner, const LLUUID& last_owner, const LLUUID& group)
  58. {
  59. mCreator = creator;
  60. mOwner = owner;
  61. mLastOwner = last_owner;
  62. mGroup = group;
  64. mMaskBase = PERM_ALL;
  65. mMaskOwner = PERM_ALL;
  66. mMaskEveryone = PERM_ALL;
  67. mMaskGroup = PERM_ALL;
  68. mMaskNextOwner = PERM_ALL;
  69. fixOwnership();
  70. }
  73. void LLPermissions::initMasks(PermissionMask base, PermissionMask owner,
  74.   PermissionMask everyone, PermissionMask group,
  75.   PermissionMask next)
  76. {
  77. mMaskBase = base;
  78. mMaskOwner = owner;
  79. mMaskEveryone = everyone;
  80. mMaskGroup = group;
  81. mMaskNextOwner = next;
  82. fixFairUse();
  83. fix();
  84. }
  86. // ! BACKWARDS COMPATIBILITY ! Override masks for inventory types that
  87. // no longer can have restricted permissions.  This takes care of previous
  88. // version landmarks that could have had no copy/mod/transfer bits set.
  89. void LLPermissions::initMasks(LLInventoryType::EType type)
  90. {
  91. if (LLInventoryType::cannotRestrictPermissions(type))
  92. {
  93. initMasks(PERM_ALL, PERM_ALL, PERM_ALL, PERM_ALL, PERM_ALL);
  94. }
  95. }
  97. BOOL LLPermissions::getOwnership(LLUUID& owner_id, BOOL& is_group_owned) const
  98. {
  99. if(mOwner.notNull())
  100. {
  101. owner_id = mOwner;
  102. is_group_owned = FALSE;
  103. return TRUE;
  104. }
  105. else if(mIsGroupOwned)
  106. {
  107. owner_id = mGroup;
  108. is_group_owned = TRUE;
  109. return TRUE;
  110. }
  111. return FALSE;
  112. }
  114. LLUUID LLPermissions::getSafeOwner() const
  115. {
  116. if(mOwner.notNull())
  117. {
  118. return mOwner;
  119. }
  120. else if(mIsGroupOwned)
  121. {
  122. return mGroup;
  123. }
  124. else
  125. {
  126. llwarns << "LLPermissions::getSafeOwner() called with no valid owner!" << llendl;
  127. LLUUID unused_uuid;
  128. unused_uuid.generate();
  130. return unused_uuid;
  131. }
  132. }
  134. U32 LLPermissions::getCRC32() const
  135. {
  136. U32 rv = mCreator.getCRC32();
  137. rv += mOwner.getCRC32();
  138. rv += mLastOwner.getCRC32();
  139. rv += mGroup.getCRC32();
  140. rv += mMaskBase + mMaskOwner + mMaskEveryone + mMaskGroup;
  141. return rv;
  142. }
  144. void LLPermissions::set(const LLPermissions& from)
  145. {
  146. mCreator = from.mCreator;
  147. mOwner = from.mOwner;
  148. mLastOwner = from.mLastOwner;
  149. mGroup = from.mGroup;
  151. mMaskBase = from.mMaskBase;
  152. mMaskOwner = from.mMaskOwner;
  153. mMaskEveryone = from.mMaskEveryone;
  154. mMaskGroup = from.mMaskGroup;
  155. mMaskNextOwner = from.mMaskNextOwner;
  156. mIsGroupOwned = from.mIsGroupOwned;
  157. }
  159. // Fix hierarchy of permissions. 
  160. void LLPermissions::fix()
  161. {
  162. mMaskOwner &= mMaskBase;
  163. mMaskGroup &= mMaskOwner;
  164. // next owner uses base, since you may want to sell locked objects.
  165. mMaskNextOwner &= mMaskBase;
  166. mMaskEveryone &= mMaskOwner;
  167. mMaskEveryone &= ~PERM_MODIFY;
  168. if(!(mMaskBase & PERM_TRANSFER) && !mIsGroupOwned)
  169. {
  170. mMaskGroup &= ~PERM_COPY;
  171. mMaskEveryone &= ~PERM_COPY;
  172. // Do not set mask next owner to too restrictive because if we
  173. // rez an object, it may require an ownership transfer during
  174. // rez, which will note the overly restrictive perms, and then
  175. // fix them to allow fair use, which may be different than the
  176. // original intention.
  177. }
  178. }
  180. // Correct for fair use - you can never take away the right to move
  181. // stuff you own, and you can never take away the right to transfer
  182. // something you cannot otherwise copy.
  183. void LLPermissions::fixFairUse()
  184. {
  185. mMaskBase |= PERM_MOVE;
  186. if(!(mMaskBase & PERM_COPY))
  187. {
  188. mMaskBase |= PERM_TRANSFER;
  189. }
  190. // (mask next owner == PERM_NONE) iff mask base is no transfer
  191. if(mMaskNextOwner != PERM_NONE)
  192. {
  193. mMaskNextOwner |= PERM_MOVE;
  194. }
  195. }
  197. void LLPermissions::fixOwnership()
  198. {
  199. if(mOwner.isNull() && mGroup.notNull())
  200. {
  201. mIsGroupOwned = true;
  202. }
  203. else
  204. {
  205. mIsGroupOwned = false;
  206. }
  207. }
  209. // Allow accumulation of permissions. Results in the tightest
  210. // permissions possible. In the case of clashing UUIDs, it sets the ID
  211. // to LLUUID::null.
  212. void LLPermissions::accumulate(const LLPermissions& perm)
  213. {
  214. if(perm.mCreator != mCreator)
  215. {
  216. mCreator = LLUUID::null;
  217. }
  218. if(perm.mOwner != mOwner)
  219. {
  220. mOwner = LLUUID::null;
  221. }
  222. if(perm.mLastOwner != mLastOwner)
  223. {
  224. mLastOwner = LLUUID::null;
  225. }
  226. if(perm.mGroup != mGroup)
  227. {
  228. mGroup = LLUUID::null;
  229. }
  231. mMaskBase &= perm.mMaskBase;
  232. mMaskOwner &= perm.mMaskOwner;
  233. mMaskGroup &= perm.mMaskGroup;
  234. mMaskEveryone &= perm.mMaskEveryone;
  235. mMaskNextOwner &= perm.mMaskNextOwner;
  236. fix();
  237. }
  239. // saves last owner, sets current owner, and sets the group.  note
  240. // that this function has to more cleverly apply the fair use
  241. // permissions.
  242. BOOL LLPermissions::setOwnerAndGroup(
  243. const LLUUID& agent,
  244. const LLUUID& owner,
  245. const LLUUID& group,
  246. bool is_atomic)
  247. {
  248. BOOL allowed = FALSE;
  250. if( agent.isNull() || mOwner.isNull()
  251.    || ((agent == mOwner) && ((owner == mOwner) || (mMaskOwner & PERM_TRANSFER)) ) )
  252. {
  253. // ...system can alway set owner
  254. // ...public objects can be claimed by anyone
  255. // ...otherwise, agent must own it and have transfer ability
  256. allowed = TRUE;
  257. }
  259. if (allowed)
  260. {
  261. if(mLastOwner.isNull() || (!mOwner.isNull() && (owner != mLastOwner)))
  262. {
  263. mLastOwner = mOwner;
  264. }
  265. if((mOwner != owner)
  266.    || (mOwner.isNull() && owner.isNull() && (mGroup != group)))
  267. {
  268. mMaskBase = mMaskNextOwner;
  269. mOwner = owner;
  270. // this is a selective use of fair use for atomic
  271. // permissions.
  272. if(is_atomic && !(mMaskBase & PERM_COPY))
  273. {
  274. mMaskBase |= PERM_TRANSFER;
  275. }
  276. }
  277. mGroup = group;
  278. fixOwnership();
  279. // if it's not atomic and we fix fair use, it blows away
  280. //objects as inventory items which have different permissions
  281. //than it's contents. :(
  282. // fixFairUse();
  283. mMaskBase |= PERM_MOVE;
  284. if(mMaskNextOwner != PERM_NONE) mMaskNextOwner |= PERM_MOVE;
  285. fix();
  286. }
  288. return allowed;
  289. }
  291. //Fix for DEV-33917, last owner isn't used much and has little impact on
  292. //permissions so it's reasonably safe to do this, however, for now, 
  293. //limiting the functionality of this routine to objects which are 
  294. //group owned.
  295. void LLPermissions::setLastOwner(const LLUUID& last_owner)
  296. {
  297. if (isGroupOwned())
  298. mLastOwner = last_owner;
  299. }
  301.  
  302. // only call this if you know what you're doing
  303. // there are usually perm-bit consequences when the 
  304. // ownerhsip changes
  305. void LLPermissions::yesReallySetOwner(const LLUUID& owner, bool group_owned)
  306. {
  307. mOwner = owner;
  308. mIsGroupOwned = group_owned;
  309. }
  311. BOOL LLPermissions::deedToGroup(const LLUUID& agent, const LLUUID& group)
  312. {
  313. if(group.notNull() && (agent.isNull() || ((group == mGroup)
  314.   && (mMaskOwner & PERM_TRANSFER)
  315.   && (mMaskGroup & PERM_MOVE))))
  316. {
  317. if(mOwner.notNull())
  318. {
  319. mLastOwner = mOwner;
  320. mOwner.setNull();
  321. }
  322. mMaskBase = mMaskNextOwner;
  323. mMaskGroup = PERM_NONE;
  324. mGroup = group;
  325. mIsGroupOwned = true;
  326. fixFairUse();
  327. fix();
  328. return TRUE;
  329. }
  330. return FALSE;
  331. }
  333. BOOL LLPermissions::setBaseBits(const LLUUID& agent, BOOL set, PermissionMask bits)
  334. {
  335. BOOL ownership = FALSE;
  336. if(agent.isNull())
  337. {
  338. // only the system is always allowed to change base bits
  339. ownership = TRUE;
  340. }
  342. if (ownership)
  343. {
  344. if (set)
  345. {
  346. mMaskBase |= bits; // turn on bits
  347. }
  348. else
  349. {
  350. mMaskBase &= ~bits; // turn off bits
  351. }
  352. fix();
  353. }
  355. return ownership;
  356. }
  359. // Note: If you attempt to set bits that the base bits doesn't allow,
  360. // the function will succeed, but those bits will not be set.
  361. BOOL LLPermissions::setOwnerBits(const LLUUID& agent, BOOL set, PermissionMask bits)
  362. {
  363. BOOL ownership = FALSE;
  365. if(agent.isNull())
  366. {
  367. // ...system always allowed to change things
  368. ownership = TRUE;
  369. }
  370. else if (agent == mOwner)
  371. {
  372. // ...owner bits can only be set by owner
  373. ownership = TRUE;
  374. }
  376. // If we have correct ownership and 
  377. if (ownership)
  378. {
  379. if (set)
  380. {
  381. mMaskOwner |= bits; // turn on bits
  382. }
  383. else
  384. {
  385. mMaskOwner &= ~bits; // turn off bits
  386. }
  387. fix();
  388. }
  390. return (ownership);
  391. }
  393. BOOL LLPermissions::setGroupBits(const LLUUID& agent, const LLUUID& group, BOOL set, PermissionMask bits)
  394. {
  395. BOOL ownership = FALSE;
  396. if((agent.isNull()) || (agent == mOwner)
  397.    || ((group == mGroup) && (!mGroup.isNull())))
  398. {
  399. // The group bits can be set by the system, the owner, or a
  400. // group member.
  401. ownership = TRUE;
  402. }
  404. if (ownership)
  405. {
  406. if (set)
  407. {
  408. mMaskGroup |= bits;
  409. }
  410. else
  411. {
  412. mMaskGroup &= ~bits;
  413. }
  414. fix();
  415. }
  416. return ownership;
  417. }
  420. // Note: If you attempt to set bits that the creator or owner doesn't allow,
  421. // the function will succeed, but those bits will not be set.
  422. BOOL LLPermissions::setEveryoneBits(const LLUUID& agent, const LLUUID& group, BOOL set, PermissionMask bits)
  423. {
  424. BOOL ownership = FALSE;
  425. if((agent.isNull()) || (agent == mOwner)
  426.    || ((group == mGroup) && (!mGroup.isNull())))
  427. {
  428. // The everyone bits can be set by the system, the owner, or a
  429. // group member.
  430. ownership = TRUE;
  431. }
  432. if (ownership)
  433. {
  434. if (set)
  435. {
  436. mMaskEveryone |= bits;
  437. }
  438. else
  439. {
  440. mMaskEveryone &= ~bits;
  441. }
  443. // Fix hierarchy of permissions
  444. fix();
  445. }
  446. return ownership;
  447. }
  449. // Note: If you attempt to set bits that the creator or owner doesn't allow,
  450. // the function will succeed, but those bits will not be set.
  451. BOOL LLPermissions::setNextOwnerBits(const LLUUID& agent, const LLUUID& group, BOOL set, PermissionMask bits)
  452. {
  453. BOOL ownership = FALSE;
  454. if((agent.isNull()) || (agent == mOwner)
  455.    || ((group == mGroup) && (!mGroup.isNull())))
  456. {
  457. // The next owner bits can be set by the system, the owner, or
  458. // a group member.
  459. ownership = TRUE;
  460. }
  461. if (ownership)
  462. {
  463. if (set)
  464. {
  465. mMaskNextOwner |= bits;
  466. }
  467. else
  468. {
  469. mMaskNextOwner &= ~bits;
  470. }
  472. // Fix-up permissions
  473. if(!(mMaskNextOwner & PERM_COPY))
  474. {
  475. mMaskNextOwner |= PERM_TRANSFER;
  476. }
  477. fix();
  478. }
  479. return ownership;
  480. }
  482. BOOL LLPermissions::allowOperationBy(PermissionBit op, const LLUUID& requester, const LLUUID& group) const
  483. {
  484. if(requester.isNull())
  485. {
  486. // ...system making request
  487. // ...not owned
  488. return TRUE;
  489. }
  490. else if (mIsGroupOwned && (mGroup == requester))
  491. {
  492. // group checking ownership permissions
  493. return (mMaskOwner & op);
  494. }
  495. else if (!mIsGroupOwned && (mOwner == requester))
  496. {
  497. // ...owner making request
  498. return (mMaskOwner & op);
  499. }
  500. else if(mGroup.notNull() && (mGroup == group))
  501. {
  502. // group member making request
  503. return ((mMaskGroup & op) || (mMaskEveryone & op));
  504. }
  505. return (mMaskEveryone & op);
  506. }
  508. //
  509. // LLSD support for HTTP messages.
  510. //
  511. LLSD LLPermissions::packMessage() const
  512. {
  513. LLSD result;
  514. result["creator-id"] = mCreator;
  515. result["owner-id"] = mOwner;
  516. result["group-id"] = mGroup;
  518. result["base-mask"] = (S32)mMaskBase;
  519. result["owner-mask"] = (S32)mMaskOwner;
  520. result["group-mask"] = (S32)mMaskGroup;
  521. result["everyone-mask"] = (S32)mMaskEveryone;
  522. result["next-owner-mask"]= (S32)mMaskNextOwner;
  523. result["group-owned"] = (BOOL)mIsGroupOwned;
  524. return result;
  525. }
  527. //
  528. // Messaging support
  529. //
  530. void LLPermissions::packMessage(LLMessageSystem* msg) const
  531. {
  532. msg->addUUIDFast(_PREHASH_CreatorID, mCreator);
  533. msg->addUUIDFast(_PREHASH_OwnerID, mOwner);
  534. msg->addUUIDFast(_PREHASH_GroupID, mGroup);
  536. msg->addU32Fast(_PREHASH_BaseMask, mMaskBase );
  537. msg->addU32Fast(_PREHASH_OwnerMask, mMaskOwner );
  538. msg->addU32Fast(_PREHASH_GroupMask, mMaskGroup );
  539. msg->addU32Fast(_PREHASH_EveryoneMask, mMaskEveryone );
  540. msg->addU32Fast(_PREHASH_NextOwnerMask, mMaskNextOwner );
  541. msg->addBOOLFast(_PREHASH_GroupOwned, (BOOL)mIsGroupOwned);
  542. }
  544. void LLPermissions::unpackMessage(LLSD perms)
  545. {
  546. mCreator = perms["creator-id"];
  547. mOwner = perms["owner-id"];
  548. mGroup = perms["group-id"];
  550. mMaskBase = (U32)perms["base-mask"].asInteger();
  551. mMaskOwner = (U32)perms["owner-mask"].asInteger();
  552. mMaskGroup = (U32)perms["group-mask"].asInteger();
  553. mMaskEveryone = (U32)perms["everyone-mask"].asInteger();
  554. mMaskNextOwner = (U32)perms["next-owner-mask"].asInteger();
  555. mIsGroupOwned = perms["group-owned"].asBoolean();
  556. }
  558. void LLPermissions::unpackMessage(LLMessageSystem* msg, const char* block, S32 block_num)
  559. {
  560. msg->getUUIDFast(block, _PREHASH_CreatorID, mCreator, block_num);
  561. msg->getUUIDFast(block, _PREHASH_OwnerID, mOwner, block_num);
  562. msg->getUUIDFast(block, _PREHASH_GroupID, mGroup, block_num);
  564. msg->getU32Fast(block, _PREHASH_BaseMask, mMaskBase, block_num );
  565. msg->getU32Fast(block, _PREHASH_OwnerMask, mMaskOwner, block_num );
  566. msg->getU32Fast(block, _PREHASH_GroupMask, mMaskGroup, block_num );
  567. msg->getU32Fast(block, _PREHASH_EveryoneMask, mMaskEveryone, block_num );
  568. msg->getU32Fast(block, _PREHASH_NextOwnerMask, mMaskNextOwner, block_num );
  569. BOOL tmp;
  570. msg->getBOOLFast(block, _PREHASH_GroupOwned, tmp, block_num);
  571. mIsGroupOwned = (bool)tmp;
  572. }
  575. //
  576. // File support
  577. //
  579. BOOL LLPermissions::importFile(LLFILE* fp)
  580. {
  581. init(LLUUID::null, LLUUID::null, LLUUID::null, LLUUID::null);
  582. const S32 BUFSIZE = 16384;
  584. // *NOTE: Changing the buffer size will require changing the scanf
  585. // calls below.
  586. char buffer[BUFSIZE]; /* Flawfinder: ignore */
  587. char keyword[256]; /* Flawfinder: ignore */
  588. char valuestr[256]; /* Flawfinder: ignore */
  589. char uuid_str[256]; /* Flawfinder: ignore */
  590. U32 mask;
  592. keyword[0]  = '';
  593. valuestr[0] = '';
  595. while (!feof(fp))
  596. {
  597. if (fgets(buffer, BUFSIZE, fp) == NULL)
  598. {
  599. buffer[0] = '';
  600. }
  602. sscanf( /* Flawfinder: ignore */
  603. buffer,
  604. " %255s %255s",
  605. keyword, valuestr);
  606. if (!strcmp("{", keyword))
  607. {
  608. continue;
  609. }
  610. if (!strcmp("}",keyword))
  611. {
  612. break;
  613. }
  614. else if (!strcmp("creator_mask", keyword))
  615. {
  616. // legacy support for "creator" masks
  617. sscanf(valuestr, "%x", &mask);
  618. mMaskBase = mask;
  619. fixFairUse();
  620. }
  621. else if (!strcmp("base_mask", keyword))
  622. {
  623. sscanf(valuestr, "%x", &mask);
  624. mMaskBase = mask;
  625. //fixFairUse();
  626. }
  627. else if (!strcmp("owner_mask", keyword))
  628. {
  629. sscanf(valuestr, "%x", &mask);
  630. mMaskOwner = mask;
  631. }
  632. else if (!strcmp("group_mask", keyword))
  633. {
  634. sscanf(valuestr, "%x", &mask);
  635. mMaskGroup = mask;
  636. }
  637. else if (!strcmp("everyone_mask", keyword))
  638. {
  639. sscanf(valuestr, "%x", &mask);
  640. mMaskEveryone = mask;
  641. }
  642. else if (!strcmp("next_owner_mask", keyword))
  643. {
  644. sscanf(valuestr, "%x", &mask);
  645. mMaskNextOwner = mask;
  646. }
  647. else if (!strcmp("creator_id", keyword))
  648. {
  649. sscanf(valuestr, "%255s", uuid_str); /* Flawfinder: ignore */
  650. mCreator.set(uuid_str);
  651. }
  652. else if (!strcmp("owner_id", keyword))
  653. {
  654. sscanf(valuestr, "%255s", uuid_str); /* Flawfinder: ignore */
  655. mOwner.set(uuid_str);
  656. }
  657. else if (!strcmp("last_owner_id", keyword))
  658. {
  659. sscanf(valuestr, "%255s", uuid_str); /* Flawfinder: ignore */
  660. mLastOwner.set(uuid_str);
  661. }
  662. else if (!strcmp("group_id", keyword))
  663. {
  664. sscanf(valuestr, "%255s", uuid_str); /* Flawfinder: ignore */
  665. mGroup.set(uuid_str);
  666. }
  667. else if (!strcmp("group_owned", keyword))
  668. {
  669. sscanf(valuestr, "%d", &mask);
  670. if(mask) mIsGroupOwned = true;
  671. else mIsGroupOwned = false;
  672. }
  673. else
  674. {
  675. llinfos << "unknown keyword " << keyword << " in permissions import" << llendl;
  676. }
  677. }
  678. fix();
  679. return TRUE;
  680. }
  683. BOOL LLPermissions::exportFile(LLFILE* fp) const
  684. {
  685. std::string uuid_str;
  687. fprintf(fp, "tpermissions 0n");
  688. fprintf(fp, "t{n");
  690. fprintf(fp, "ttbase_maskt%08xn", mMaskBase);
  691. fprintf(fp, "ttowner_maskt%08xn", mMaskOwner);
  692. fprintf(fp, "ttgroup_maskt%08xn", mMaskGroup);
  693. fprintf(fp, "tteveryone_maskt%08xn", mMaskEveryone);
  694. fprintf(fp, "ttnext_owner_maskt%08xn", mMaskNextOwner);
  696. mCreator.toString(uuid_str);
  697. fprintf(fp, "ttcreator_idt%sn", uuid_str.c_str());
  699. mOwner.toString(uuid_str);
  700. fprintf(fp, "ttowner_idt%sn", uuid_str.c_str());
  702. mLastOwner.toString(uuid_str);
  703. fprintf(fp, "ttlast_owner_idt%sn", uuid_str.c_str());
  705. mGroup.toString(uuid_str);
  706. fprintf(fp, "ttgroup_idt%sn", uuid_str.c_str());
  708. if(mIsGroupOwned)
  709. {
  710. fprintf(fp, "ttgroup_ownedt1n");
  711. }
  712. fprintf(fp,"t}n");
  713. return TRUE;
  714. }
  717. BOOL LLPermissions::importLegacyStream(std::istream& input_stream)
  718. {
  719. init(LLUUID::null, LLUUID::null, LLUUID::null, LLUUID::null);
  720. const S32 BUFSIZE = 16384;
  722. // *NOTE: Changing the buffer size will require changing the scanf
  723. // calls below.
  724. char buffer[BUFSIZE]; /* Flawfinder: ignore */
  725. char keyword[256]; /* Flawfinder: ignore */
  726. char valuestr[256]; /* Flawfinder: ignore */
  727. char uuid_str[256]; /* Flawfinder: ignore */
  728. U32 mask;
  730. keyword[0]  = '';
  731. valuestr[0] = '';
  733. while (input_stream.good())
  734. {
  735. input_stream.getline(buffer, BUFSIZE);
  736. sscanf( /* Flawfinder: ignore */
  737. buffer,
  738. " %255s %255s",
  739. keyword, valuestr);
  740. if (!strcmp("{", keyword))
  741. {
  742. continue;
  743. }
  744. if (!strcmp("}",keyword))
  745. {
  746. break;
  747. }
  748. else if (!strcmp("creator_mask", keyword))
  749. {
  750. // legacy support for "creator" masks
  751. sscanf(valuestr, "%x", &mask);
  752. mMaskBase = mask;
  753. fixFairUse();
  754. }
  755. else if (!strcmp("base_mask", keyword))
  756. {
  757. sscanf(valuestr, "%x", &mask);
  758. mMaskBase = mask;
  759. //fixFairUse();
  760. }
  761. else if (!strcmp("owner_mask", keyword))
  762. {
  763. sscanf(valuestr, "%x", &mask);
  764. mMaskOwner = mask;
  765. }
  766. else if (!strcmp("group_mask", keyword))
  767. {
  768. sscanf(valuestr, "%x", &mask);
  769. mMaskGroup = mask;
  770. }
  771. else if (!strcmp("everyone_mask", keyword))
  772. {
  773. sscanf(valuestr, "%x", &mask);
  774. mMaskEveryone = mask;
  775. }
  776. else if (!strcmp("next_owner_mask", keyword))
  777. {
  778. sscanf(valuestr, "%x", &mask);
  779. mMaskNextOwner = mask;
  780. }
  781. else if (!strcmp("creator_id", keyword))
  782. {
  783. sscanf(valuestr, "%255s", uuid_str); /* Flawfinder: ignore */
  784. mCreator.set(uuid_str);
  785. }
  786. else if (!strcmp("owner_id", keyword))
  787. {
  788. sscanf(valuestr, "%255s", uuid_str); /* Flawfinder: ignore */
  789. mOwner.set(uuid_str);
  790. }
  791. else if (!strcmp("last_owner_id", keyword))
  792. {
  793. sscanf(valuestr, "%255s", uuid_str); /* Flawfinder: ignore */
  794. mLastOwner.set(uuid_str);
  795. }
  796. else if (!strcmp("group_id", keyword))
  797. {
  798. sscanf(valuestr, "%255s", uuid_str); /* Flawfinder: ignore */
  799. mGroup.set(uuid_str);
  800. }
  801. else if (!strcmp("group_owned", keyword))
  802. {
  803. sscanf(valuestr, "%d", &mask);
  804. if(mask) mIsGroupOwned = true;
  805. else mIsGroupOwned = false;
  806. }
  807. else
  808. {
  809. llinfos << "unknown keyword " << keyword << " in permissions import" << llendl;
  810. }
  811. }
  812. fix();
  813. return TRUE;
  814. }
  817. BOOL LLPermissions::exportLegacyStream(std::ostream& output_stream) const
  818. {
  819. std::string uuid_str;
  821. output_stream <<  "tpermissions 0n";
  822. output_stream <<  "t{n";
  824. std::string buffer;
  825. buffer = llformat( "ttbase_maskt%08xn", mMaskBase);
  826. output_stream << buffer;
  827. buffer = llformat( "ttowner_maskt%08xn", mMaskOwner);
  828. output_stream << buffer;
  829. buffer = llformat( "ttgroup_maskt%08xn", mMaskGroup);
  830. output_stream << buffer;
  831. buffer = llformat( "tteveryone_maskt%08xn", mMaskEveryone);
  832. output_stream << buffer;
  833. buffer = llformat( "ttnext_owner_maskt%08xn", mMaskNextOwner);
  834. output_stream << buffer;
  836. mCreator.toString(uuid_str);
  837. output_stream <<  "ttcreator_idt" << uuid_str << "n";
  839. mOwner.toString(uuid_str);
  840. output_stream <<  "ttowner_idt" << uuid_str << "n";
  842. mLastOwner.toString(uuid_str);
  843. output_stream <<  "ttlast_owner_idt" << uuid_str << "n";
  845. mGroup.toString(uuid_str);
  846. output_stream <<  "ttgroup_idt" << uuid_str << "n";
  848. if(mIsGroupOwned)
  849. {
  850. output_stream <<  "ttgroup_ownedt1n";
  851. }
  852. output_stream << "t}n";
  853. return TRUE;
  854. }
  856. // Deleted LLPermissions::exportFileXML() and LLPermissions::importXML()
  857. // because I can't find any non-test code references to it. 2009-05-04 JC
  859. bool LLPermissions::operator==(const LLPermissions &rhs) const
  860. {   
  861. return 
  862. (mCreator == rhs.mCreator) &&
  863. (mOwner == rhs.mOwner) &&
  864. (mLastOwner == rhs.mLastOwner ) &&
  865. (mGroup == rhs.mGroup ) &&
  866. (mMaskBase == rhs.mMaskBase ) &&
  867. (mMaskOwner == rhs.mMaskOwner ) &&
  868. (mMaskGroup == rhs.mMaskGroup ) &&
  869. (mMaskEveryone == rhs.mMaskEveryone ) &&
  870. (mMaskNextOwner == rhs.mMaskNextOwner ) &&
  871. (mIsGroupOwned == rhs.mIsGroupOwned);
  872. }
  875. bool LLPermissions::operator!=(const LLPermissions &rhs) const
  876. {   
  877. return 
  878. (mCreator != rhs.mCreator) ||
  879. (mOwner != rhs.mOwner) ||
  880. (mLastOwner != rhs.mLastOwner ) ||
  881. (mGroup != rhs.mGroup ) ||
  882. (mMaskBase != rhs.mMaskBase ) ||
  883. (mMaskOwner != rhs.mMaskOwner ) ||
  884. (mMaskGroup != rhs.mMaskGroup ) ||
  885. (mMaskEveryone != rhs.mMaskEveryone ) ||
  886. (mMaskNextOwner != rhs.mMaskNextOwner) ||
  887. (mIsGroupOwned != rhs.mIsGroupOwned);
  888. }
  890. std::ostream& operator<<(std::ostream &s, const LLPermissions &perm)
  891. {
  892. s << "{Creator="  << perm.getCreator();
  893. s << ", Owner="  << perm.getOwner();
  894. s << ", Group="  << perm.getGroup();
  895. s << std::hex << ", BaseMask=0x" << perm.getMaskBase();
  896. s << ", OwnerMask=0x" << perm.getMaskOwner();
  897. s << ", EveryoneMask=0x" << perm.getMaskEveryone();
  898. s << ", GroupMask=0x" << perm.getMaskGroup();
  899. s << ", NextOwnerMask=0x" << perm.getMaskNextOwner() << std::dec;
  900. s << "}";
  901. return s;
  902. }
  904. template <>
  905. void LLMetaClassT<LLPermissions>::reflectProperties(LLMetaClass& meta_class)
  906. {
  907. reflectProperty(meta_class, "mCreator", &LLPermissions::mCreator);
  908. reflectProperty(meta_class, "mOwner", &LLPermissions::mOwner);
  909. reflectProperty(meta_class, "mGroup", &LLPermissions::mGroup);
  910. reflectProperty(meta_class, "mIsGroupOwned", &LLPermissions::mIsGroupOwned);
  911. }
  913. // virtual
  914. const LLMetaClass& LLPermissions::getMetaClass() const
  915. {
  916. return LLMetaClassT<LLPermissions>::instance();
  917. }
  919. ///----------------------------------------------------------------------------
  920. /// Class LLAggregatePermissions
  921. ///----------------------------------------------------------------------------
  923. const LLAggregatePermissions LLAggregatePermissions::empty;
  926. LLAggregatePermissions::LLAggregatePermissions()
  927. {
  928. for(S32 i = 0; i < PI_COUNT; ++i)
  929. {
  930. mBits[i] = AP_EMPTY;
  931. }
  932. }
  934. LLAggregatePermissions::EValue LLAggregatePermissions::getValue(PermissionBit bit) const
  935. {
  936. EPermIndex idx = perm2PermIndex(bit);
  937. EValue rv = AP_EMPTY;
  938. if(idx != PI_END)
  939. {
  940. rv = (LLAggregatePermissions::EValue)(mBits[idx]);
  941. }
  942. return rv;
  943. }
  945. // returns the bits compressed into a single byte: 00TTMMCC
  946. // where TT = transfer, MM = modify, and CC = copy
  947. // LSB is to the right
  948. U8 LLAggregatePermissions::getU8() const
  949. {
  950. U8 byte = mBits[PI_TRANSFER];
  951. byte <<= 2;
  952. byte |= mBits[PI_MODIFY];
  953. byte <<= 2;
  954. byte |= mBits[PI_COPY];
  955. return byte;
  956. }
  958. BOOL LLAggregatePermissions::isEmpty() const
  959. {
  960. for(S32 i = 0; i < PI_END; ++i)
  961. {
  962. if(mBits[i] != AP_EMPTY)
  963. {
  964. return FALSE;
  965. }
  966. }
  967. return TRUE;
  968. }
  970. void LLAggregatePermissions::aggregate(PermissionMask mask)
  971. {
  972. BOOL is_allowed = mask & PERM_COPY;
  973. aggregateBit(PI_COPY, is_allowed);
  974. is_allowed = mask & PERM_MODIFY;
  975. aggregateBit(PI_MODIFY, is_allowed);
  976. is_allowed = mask & PERM_TRANSFER;
  977. aggregateBit(PI_TRANSFER, is_allowed);
  978. }
  980. void LLAggregatePermissions::aggregate(const LLAggregatePermissions& ag)
  981. {
  982. for(S32 idx = PI_COPY; idx != PI_END; ++idx)
  983. {
  984. aggregateIndex((EPermIndex)idx, ag.mBits[idx]);
  985. }
  986. }
  988. void LLAggregatePermissions::aggregateBit(EPermIndex idx, BOOL allowed)
  989. {
  990. //if(AP_SOME == mBits[idx]) return; // P4 branch prediction optimization
  991. switch(mBits[idx])
  992. {
  993. case AP_EMPTY:
  994. mBits[idx] = allowed ? AP_ALL : AP_NONE;
  995. break;
  996. case AP_NONE:
  997. mBits[idx] = allowed ? AP_SOME: AP_NONE;
  998. break;
  999. case AP_SOME:
  1000. // no-op
  1001. break;
  1002. case AP_ALL:
  1003. mBits[idx] = allowed ? AP_ALL : AP_SOME;
  1004. break;
  1005. default:
  1006. llwarns << "Bad aggregateBit " << (S32)idx << " "
  1007. << (allowed ? "true" : "false") << llendl;
  1008. break;
  1009. }
  1010. }
  1012. void LLAggregatePermissions::aggregateIndex(EPermIndex idx, U8 bits)
  1013. {
  1014. switch(mBits[idx])
  1015. {
  1016. case AP_EMPTY:
  1017. mBits[idx] = bits;
  1018. break;
  1019. case AP_NONE:
  1020. switch(bits)
  1021. {
  1022. case AP_SOME:
  1023. case AP_ALL:
  1024. mBits[idx] = AP_SOME;
  1025. break;
  1026. case AP_EMPTY:
  1027. case AP_NONE:
  1028. default:
  1029. // no-op
  1030. break;
  1031. }
  1032. break;
  1033. case AP_SOME:
  1034. // no-op
  1035. break;
  1036. case AP_ALL:
  1037. switch(bits)
  1038. {
  1039. case AP_NONE:
  1040. case AP_SOME:
  1041. mBits[idx] = AP_SOME;
  1042. break;
  1043. case AP_EMPTY:
  1044. case AP_ALL:
  1045. default:
  1046. // no-op
  1047. break;
  1048. }
  1049. break;
  1050. default:
  1051. llwarns << "Bad aggregate index " << (S32)idx << " "
  1052. <<  (S32)bits << llendl;
  1053. break;
  1054. }
  1055. }
  1057. // static
  1058. LLAggregatePermissions::EPermIndex LLAggregatePermissions::perm2PermIndex(PermissionBit bit)
  1059. {
  1060. EPermIndex idx = PI_END; // past any good value.
  1061. switch(bit)
  1062. {
  1063. case PERM_COPY:
  1064. idx = PI_COPY;
  1065. break;
  1066. case PERM_MODIFY:
  1067. idx = PI_MODIFY;
  1068. break;
  1069. case PERM_TRANSFER:
  1070. idx = PI_TRANSFER;
  1071. break;
  1072. default:
  1073. break;
  1074. }
  1075. return idx;
  1076. }
  1079. void LLAggregatePermissions::packMessage(LLMessageSystem* msg, const char* field) const
  1080. {
  1081. msg->addU8Fast(field, getU8());
  1082. }
  1084. void LLAggregatePermissions::unpackMessage(LLMessageSystem* msg, const char* block, const char* field, S32 block_num)
  1085. {
  1086. const U8 TWO_BITS = 0x3; // binary 00000011
  1087. U8 bits = 0;
  1088. msg->getU8Fast(block, field, bits, block_num);
  1089. mBits[PI_COPY] = bits & TWO_BITS;
  1090. bits >>= 2;
  1091. mBits[PI_MODIFY] = bits & TWO_BITS;
  1092. bits >>= 2;
  1093. mBits[PI_TRANSFER] = bits & TWO_BITS;
  1094. }
  1096. const std::string AGGREGATE_VALUES[4] =
  1097. {
  1098. std::string( "Empty" ),
  1099. std::string( "None" ),
  1100. std::string( "Some" ),
  1101. std::string( "All" )
  1102. };
  1104. std::ostream& operator<<(std::ostream &s, const LLAggregatePermissions &perm)
  1105. {
  1106. s << "{PI_COPY=" << AGGREGATE_VALUES[perm.mBits[LLAggregatePermissions::PI_COPY]];
  1107. s << ", PI_MODIFY=" << AGGREGATE_VALUES[perm.mBits[LLAggregatePermissions::PI_MODIFY]];
  1108. s << ", PI_TRANSFER=" << AGGREGATE_VALUES[perm.mBits[LLAggregatePermissions::PI_TRANSFER]];
  1109. s << "}";
  1110. return s;
  1111. }
  1113. // This converts a permissions mask into a string for debugging use.
  1114. void mask_to_string(U32 mask, char* str)
  1115. {
  1116. if (mask & PERM_MOVE)
  1117. {
  1118. *str = 'V';
  1119. }
  1120. else
  1121. {
  1122. *str = ' ';
  1123. }
  1124. str++;
  1126. if (mask & PERM_MODIFY)
  1127. {
  1128. *str = 'M';
  1129. }
  1130. else
  1131. {
  1132. *str = ' ';
  1133. }
  1134. str++;
  1136. if (mask & PERM_COPY)
  1137. {
  1138. *str = 'C';
  1139. }
  1140. else
  1141. {
  1142. *str = ' ';
  1143. }
  1144. str++;
  1146. if (mask & PERM_TRANSFER)
  1147. {
  1148. *str = 'T';
  1149. }
  1150. else
  1151. {
  1152. *str = ' ';
  1153. }
  1154. str++;
  1155. *str = '';
  1156. }
  1158. std::string mask_to_string(U32 mask)
  1159. {
  1160. char str[16];
  1161. mask_to_string(mask, str);
  1162. return std::string(str);
  1163. }
  1165. ///----------------------------------------------------------------------------
  1166. /// exported functions
  1167. ///----------------------------------------------------------------------------
  1168. static const std::string PERM_CREATOR_ID_LABEL("creator_id");
  1169. static const std::string PERM_OWNER_ID_LABEL("owner_id");
  1170. static const std::string PERM_LAST_OWNER_ID_LABEL("last_owner_id");
  1171. static const std::string PERM_GROUP_ID_LABEL("group_id");
  1172. static const std::string PERM_IS_OWNER_GROUP_LABEL("is_owner_group");
  1173. static const std::string PERM_BASE_MASK_LABEL("base_mask");
  1174. static const std::string PERM_OWNER_MASK_LABEL("owner_mask");
  1175. static const std::string PERM_GROUP_MASK_LABEL("group_mask");
  1176. static const std::string PERM_EVERYONE_MASK_LABEL("everyone_mask");
  1177. static const std::string PERM_NEXT_OWNER_MASK_LABEL("next_owner_mask");
  1179. LLSD ll_create_sd_from_permissions(const LLPermissions& perm)
  1180. {
  1181. LLSD rv;
  1182. rv[PERM_CREATOR_ID_LABEL] = perm.getCreator();
  1183. rv[PERM_OWNER_ID_LABEL] = perm.getOwner();
  1184. rv[PERM_LAST_OWNER_ID_LABEL] = perm.getLastOwner();
  1185. rv[PERM_GROUP_ID_LABEL] = perm.getGroup();
  1186. rv[PERM_IS_OWNER_GROUP_LABEL] = perm.isGroupOwned();
  1187. rv[PERM_BASE_MASK_LABEL] = (S32)perm.getMaskBase();
  1188. rv[PERM_OWNER_MASK_LABEL] = (S32)perm.getMaskOwner();
  1189. rv[PERM_GROUP_MASK_LABEL] = (S32)perm.getMaskGroup();
  1190. rv[PERM_EVERYONE_MASK_LABEL] = (S32)perm.getMaskEveryone();
  1191. rv[PERM_NEXT_OWNER_MASK_LABEL] = (S32)perm.getMaskNextOwner();
  1192. return rv;
  1193. }
  1195. LLPermissions ll_permissions_from_sd(const LLSD& sd_perm)
  1196. {
  1197. LLPermissions rv;
  1198. rv.init(
  1199. sd_perm[PERM_CREATOR_ID_LABEL].asUUID(),
  1200. sd_perm[PERM_OWNER_ID_LABEL].asUUID(),
  1201. sd_perm[PERM_LAST_OWNER_ID_LABEL].asUUID(),
  1202. sd_perm[PERM_GROUP_ID_LABEL].asUUID());
  1204. // We do a cast to U32 here since LLSD does not attempt to
  1205. // represent unsigned ints.
  1206. PermissionMask mask;
  1207. mask = (U32)(sd_perm[PERM_BASE_MASK_LABEL].asInteger());
  1208. rv.setMaskBase(mask);
  1209. mask = (U32)(sd_perm[PERM_OWNER_MASK_LABEL].asInteger());
  1210. rv.setMaskOwner(mask);
  1211. mask = (U32)(sd_perm[PERM_EVERYONE_MASK_LABEL].asInteger());
  1212. rv.setMaskEveryone(mask);
  1213. mask = (U32)(sd_perm[PERM_GROUP_MASK_LABEL].asInteger());
  1214. rv.setMaskGroup(mask);
  1215. mask = (U32)(sd_perm[PERM_NEXT_OWNER_MASK_LABEL].asInteger());
  1216. rv.setMaskNext(mask);
  1217. rv.fix();
  1218. return rv;
  1219. }