llpermissions.h
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:17k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llpermissions.h
  3.  * @brief Permissions structures for objects.
  4.  *
  5.  * $LicenseInfo:firstyear=2002&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2002-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.  */
  32. #ifndef LL_LLPERMISSIONS_H
  33. #define LL_LLPERMISSIONS_H
  34. #include "llpermissionsflags.h"
  35. #include "llsd.h"
  36. #include "lluuid.h"
  37. #include "llxmlnode.h"
  38. #include "reflective.h"
  39. #include "llinventorytype.h"
  40. // prototypes
  41. class LLMessageSystem;
  42. extern void mask_to_string(U32 mask, char* str);
  43. extern std::string mask_to_string(U32 mask);
  44. template<class T> class LLMetaClassT;
  45. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  46. // Class LLPermissions
  47. //
  48. // Class which encapsulates object and inventory permissions/ownership/etc.
  49. //
  50. // Permissions where originally a static state creator/owner and set
  51. // of cap bits. Since then, it has grown to include group information,
  52. // last owner, masks for different people. The implementation has been
  53. // chosen such that a uuid is stored for each current/past owner, and
  54. // a bitmask is stored for the base permissions, owner permissions,
  55. // group permissions, and everyone else permissions.
  56. //
  57. // The base permissions represent the most permissive state that the
  58. // permissions can possibly be in. Thus, if the base permissions do
  59. // not allow copying, no one can ever copy the object. The permissions
  60. // also maintain a tree-like hierarchy of permissions, thus, if we
  61. // (for sake of discussions) denote more permissive as '>', then this
  62. // is invariant:
  63. //
  64. // base mask >= owner mask >= group mask
  65. //                         >= everyone mask
  66. //                         >= next owner mask
  67. // NOTE: the group mask does not effect everyone or next, everyone
  68. // does not effect group or next, etc.
  69. //
  70. // It is considered a fair use right to move or delete any object you
  71. // own.  Another fair use right is the ability to give away anything
  72. // which you cannot copy. One way to look at that is that if you have
  73. // a unique item, you can always give that one copy you have to
  74. // someone else.
  75. //
  76. // Most of the bitmask is easy to understand, PERM_COPY means you can
  77. // copy !PERM_TRANSFER means you cannot transfer, etc. Given that we
  78. // now track the concept of 'next owner' inside of the permissions
  79. // object, we can describe some new meta-meaning to the PERM_MODIFY
  80. // flag. PERM_MODIFY is usually meant to note if you can change an
  81. // item, but since we record next owner permissions, we can interpret
  82. // a no-modify object as 'you cannot modify this object and you cannot
  83. // make derivative works.' When evaluating functionality, and
  84. // comparisons against permissions, keep this concept in mind for
  85. // logical consistency.
  86. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  87. class LLPermissions : public LLReflective
  88. {
  89. private:
  90. LLUUID mCreator; // null if object created by system
  91. LLUUID mOwner; // null if object "unowned" (owned by system)
  92. LLUUID mLastOwner; // object's last owner
  93. LLUUID mGroup; // The group association
  94. PermissionMask mMaskBase; // initially permissive, progressively AND restricted by each owner
  95. PermissionMask mMaskOwner; // set by owner, applies to owner only, restricts lower permissions
  96. PermissionMask mMaskEveryone; // set by owner, applies to everyone else
  97. PermissionMask mMaskGroup; // set by owner, applies to group that is associated with permissions
  98. PermissionMask mMaskNextOwner; // set by owner, applied to base on transfer.
  99. // Usually set in the fixOwnership() method based on current uuid
  100. // values.
  101. bool mIsGroupOwned;
  102. // Correct for fair use - you can never take away the right to
  103. // move stuff you own, and you can never take away the right to
  104. // transfer something you cannot otherwise copy.
  105. void fixFairUse();
  106. // Fix internal consistency for group/agent ownership
  107. void fixOwnership();
  108. public:
  109. static const LLPermissions DEFAULT;
  110. LLPermissions(); // defaults to created by system
  111. //~LLPermissions();
  112. // base initialization code
  113. void init(const LLUUID& creator, const LLUUID& owner,
  114.   const LLUUID& last_owner, const LLUUID& group);
  115. void initMasks(PermissionMask base, PermissionMask owner,
  116.    PermissionMask everyone, PermissionMask group,
  117.    PermissionMask next);
  118. // adjust permissions based on inventory type.
  119. void initMasks(LLInventoryType::EType type);
  120. //
  121. // ACCESSORS
  122. //
  123. // return the agent_id of the agent that created the item
  124. const LLUUID& getCreator()  const { return mCreator; }
  125. // return the agent_id of the owner. returns LLUUID::null if group
  126. // owned or public (a really big group).
  127. const LLUUID& getOwner()  const { return mOwner; }
  128. // return the group_id of the group associated with the
  129. // object.
  130. const LLUUID& getGroup()  const { return mGroup; }
  131. // return the agent_id of the last agent owner. Only returns
  132. // LLUUID::null if there has never been a previous owner.
  133. const LLUUID& getLastOwner()  const { return mLastOwner; }
  134. U32 getMaskBase()  const { return mMaskBase; }
  135. U32 getMaskOwner()  const { return mMaskOwner; }
  136. U32 getMaskGroup()  const { return mMaskGroup; }
  137. U32 getMaskEveryone()  const { return mMaskEveryone; }
  138. U32 getMaskNextOwner() const { return mMaskNextOwner; }
  139. // return TRUE if the object has any owner
  140. bool isOwned() const { return (mOwner.notNull() || mIsGroupOwned); }
  141. // return TRUE if group_id is owner.
  142. bool isGroupOwned() const { return mIsGroupOwned; }
  143. // This API returns TRUE if the object is owned at all, and FALSE
  144. // otherwise. If it is owned at all, owner id is filled with
  145. // either the owner id or the group id, and the is_group_owned
  146. // parameter is appropriately filled. The values of owner_id and
  147. // is_group_owned are not changed if the object is not owned.
  148. BOOL getOwnership(LLUUID& owner_id, BOOL& is_group_owned) const;
  149. // Gets the 'safe' owner.  This should never return LLUUID::null.
  150. // If no group owned, return the agent owner id normally.
  151. // If group owned, return the group id.
  152. // If not owned, return a random uuid which should have no power.
  153. LLUUID getSafeOwner() const;
  154. // return a cheap crc
  155. U32 getCRC32() const;
  156. //
  157. // MANIPULATORS
  158. //
  159. // Fix hierarchy of permissions, applies appropriate permissions
  160. // at each level to ensure that base permissions are respected,
  161. // and also ensures that if base cannot transfer, then group and
  162. // other cannot copy.
  163. void fix();
  164. // All of these methods just do exactly what they say. There is no
  165. // permissions checking to see if the operation is allowed, and do
  166. // not fix the permissions hierarchy. So please only use these
  167. // methods when you are know what you're doing and coding on
  168. // behalf of the system - ie, acting as god.
  169. void set(const LLPermissions& permissions);
  170. void setMaskBase(U32 mask)    { mMaskBase = mask; }
  171. void setMaskOwner(U32 mask)    { mMaskOwner = mask; }
  172. void setMaskEveryone(U32 mask) { mMaskEveryone = mask;}
  173. void setMaskGroup(U32 mask)    { mMaskGroup = mask;}
  174. void setMaskNext(U32 mask) { mMaskNextOwner = mask; }
  175. // Allow accumulation of permissions. Results in the tightest
  176. // permissions possible. In the case of clashing UUIDs, it sets
  177. // the ID to LLUUID::null.
  178. void accumulate(const LLPermissions& perm);
  179. //
  180. // CHECKED MANIPULATORS 
  181. //
  182. // These functions return true on success.  They return false if
  183. // the given agent isn't allowed to make the change.  You can pass
  184. // LLUUID::null as the agent id if the change is being made by the
  185. // simulator itself, not on behalf of any agent - this will always
  186. // succeed. Passing in group id of LLUUID:null means no group, and
  187. // does not offer special permission to do anything.
  188. // saves last owner, sets current owner, and sets the group.
  189. // set is_atomic = true means that this permission represents
  190. // an atomic permission and not a collection of permissions.
  191. // Currently, the only way to have a collection is when an object
  192. // has inventory and is then itself rolled up into an inventory
  193. // item.
  194. BOOL setOwnerAndGroup(const LLUUID& agent, const LLUUID& owner, const LLUUID& group, bool is_atomic);
  195. // only call this if you know what you're doing
  196. // there are usually perm-bit consequences when the 
  197. // ownerhsip changes
  198. void yesReallySetOwner(const LLUUID& owner, bool group_owned);
  199. // Last owner doesn't have much in the way of permissions so it's 
  200. //not too dangerous to do this. 
  201. void setLastOwner(const LLUUID& last_owner);
  202. // saves last owner, sets owner to uuid null, sets group
  203. // owned. group_id must be the group of the object (that's who it
  204. // is being deeded to) and the object must be group
  205. // modify. Technically, the agent id and group id are not
  206. // necessary, but I wanted this function to look like the other
  207. // checked manipulators (since that is how it is used.) If the
  208. // agent is the system or (group == mGroup and group modify and
  209. // owner transfer) then this function will deed the permissions,
  210. // set the next owner mask, and return TRUE. Otherwise, no change
  211. // is effected, and the function returns FALSE.
  212. BOOL deedToGroup(const LLUUID& agent, const LLUUID& group);
  213. // Attempt to set or clear the given bitmask.  Returns TRUE if you
  214. // are allowed to modify the permissions.  If you attempt to turn
  215. // on bits not allowed by the base bits, the function will return
  216. // TRUE, but those bits will not be set.
  217. BOOL setBaseBits( const LLUUID& agent, BOOL set, PermissionMask bits);
  218. BOOL setOwnerBits( const LLUUID& agent, BOOL set, PermissionMask bits);
  219. BOOL setGroupBits( const LLUUID& agent, const LLUUID& group, BOOL set, PermissionMask bits);
  220. BOOL setEveryoneBits(const LLUUID& agent, const LLUUID& group, BOOL set, PermissionMask bits);
  221. BOOL setNextOwnerBits(const LLUUID& agent, const LLUUID& group, BOOL set, PermissionMask bits);
  222. // This is currently only used in the Viewer to handle calling cards
  223. // where the creator is actually used to store the target. Use with care.
  224. void setCreator(const LLUUID& creator) { mCreator = creator; }
  225. //
  226. // METHODS
  227. //
  228. // All the allow* functions return true if the given agent or
  229. // group can perform the function. Prefer using this set of
  230. // operations to check permissions on an object.  These return
  231. // true if the given agent or group can perform the function.
  232. // They also return true if the object isn't owned, or the
  233. // requesting agent is a system agent.  See llpermissionsflags.h
  234. // for bits.
  235. BOOL allowOperationBy(PermissionBit op, const LLUUID& agent, const LLUUID& group = LLUUID::null) const;
  236. inline BOOL allowModifyBy(const LLUUID &agent_id) const;
  237. inline BOOL allowCopyBy(const LLUUID& agent_id) const;
  238. inline BOOL allowMoveBy(const LLUUID& agent_id) const;
  239. inline BOOL allowModifyBy(const LLUUID &agent_id, const LLUUID& group) const;
  240. inline BOOL allowCopyBy(const LLUUID& agent_id, const LLUUID& group) const;
  241. inline BOOL allowMoveBy(const LLUUID &agent_id, const LLUUID &group) const;
  242. // This somewhat specialized function is meant for testing if the
  243. // current owner is allowed to transfer to the specified agent id.
  244. inline BOOL allowTransferTo(const LLUUID &agent_id) const;
  245. //
  246. // DEPRECATED.
  247. //
  248. // These return true if the given agent can perform the function.
  249. // They also return true if the object isn't owned, or the
  250. // requesting agent is a system agent.  See llpermissionsflags.h
  251. // for bits.
  252. //BOOL allowDeleteBy(const LLUUID& agent_id)  const { return allowModifyBy(agent_id); }
  253. //BOOL allowEditBy(const LLUUID& agent_id)  const { return allowModifyBy(agent_id); }
  254. // saves last owner and sets current owner
  255. //BOOL setOwner(const LLUUID& agent, const LLUUID& owner);
  256. // This method saves the last owner, sets the current owner to the
  257. // one provided, and sets the base mask as indicated.
  258. //BOOL setOwner(const LLUUID& agent, const LLUUID& owner, U32 new_base_mask);
  259. // Attempt to set or clear the given bitmask.  Returns TRUE if you
  260. // are allowed to modify the permissions.  If you attempt to turn
  261. // on bits not allowed by the base bits, the function will return
  262. // TRUE, but those bits will not be set.
  263. //BOOL setGroupBits( const LLUUID& agent, BOOL set, PermissionMask bits);
  264. //BOOL setEveryoneBits(const LLUUID& agent, BOOL set, PermissionMask bits);
  265. //
  266. // MISC METHODS and OPERATORS
  267. //
  268. LLSD packMessage() const;
  269. void unpackMessage(LLSD perms);
  270. // For messaging system support
  271. void packMessage(LLMessageSystem* msg) const;
  272. void unpackMessage(LLMessageSystem* msg, const char* block, S32 block_num = 0);
  273. // Load/save support
  274. BOOL importFile(LLFILE* fp);
  275. BOOL exportFile(LLFILE* fp) const;
  276. BOOL importLegacyStream(std::istream& input_stream);
  277. BOOL exportLegacyStream(std::ostream& output_stream) const;
  278. bool operator==(const LLPermissions &rhs) const;
  279. bool operator!=(const LLPermissions &rhs) const;
  280. friend std::ostream& operator<<(std::ostream &s, const LLPermissions &perm);
  281. // Reflection.
  282. friend class LLMetaClassT<LLPermissions>;
  283. virtual const LLMetaClass& getMetaClass() const;
  284. };
  285. // Inlines
  286. BOOL LLPermissions::allowModifyBy(const LLUUID& agent, const LLUUID& group) const
  287. {
  288. return allowOperationBy(PERM_MODIFY, agent, group);
  289. }
  290. BOOL LLPermissions::allowCopyBy(const LLUUID& agent, const LLUUID& group) const
  291. {
  292. return allowOperationBy(PERM_COPY, agent, group);
  293. }
  294. BOOL LLPermissions::allowMoveBy(const LLUUID& agent, const LLUUID& group) const
  295. {
  296. return allowOperationBy(PERM_MOVE, agent, group);
  297. }
  298. BOOL LLPermissions::allowModifyBy(const LLUUID& agent) const
  299. {
  300. return allowOperationBy(PERM_MODIFY, agent, LLUUID::null);
  301. }
  302. BOOL LLPermissions::allowCopyBy(const LLUUID& agent) const
  303. {
  304. return allowOperationBy(PERM_COPY, agent, LLUUID::null);
  305. }
  306. BOOL LLPermissions::allowMoveBy(const LLUUID& agent) const
  307. {
  308. return allowOperationBy(PERM_MOVE, agent, LLUUID::null);
  309. }
  310. BOOL LLPermissions::allowTransferTo(const LLUUID &agent_id) const
  311. {
  312. if (mIsGroupOwned)
  313. {
  314. return allowOperationBy(PERM_TRANSFER, mGroup, mGroup);
  315. }
  316. else
  317. {
  318. return ((mOwner == agent_id) ? TRUE : allowOperationBy(PERM_TRANSFER, mOwner));
  319. }
  320. }
  321. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  322. // Class LLAggregatePermissions
  323. //
  324. // Class which encapsulates object and inventory permissions,
  325. // ownership, etc. Currently, it only aggregates PERM_COPY,
  326. // PERM_MODIFY, and PERM_TRANSFER.
  327. //
  328. // Usually you will construct an instance and hand the object several
  329. // permissions masks to aggregate the copy, modify, and
  330. // transferability into a nice trinary value.
  331. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  332. class LLAggregatePermissions
  333. {
  334. public:
  335. enum EValue
  336. {
  337. AP_EMPTY = 0x00,
  338. AP_NONE = 0x01,
  339. AP_SOME = 0x02,
  340. AP_ALL = 0x03
  341. };
  342. // construct an empty aggregate permissions
  343. LLAggregatePermissions();
  344. // pass in a PERM_COPY, PERM_TRANSFER, etc, and get out a EValue
  345. // enumeration describing the current aggregate permissions.
  346. EValue getValue(PermissionBit bit) const;
  347. // returns the permissions packed into the 6 LSB of a U8:
  348. // 00TTMMCC
  349. // where TT = transfer, MM = modify, and CC = copy
  350. // LSB is to the right
  351. U8 getU8() const;
  352. // return TRUE is the aggregate permissions are empty, otherwise FALSE.
  353. BOOL isEmpty() const ;
  354. // pass in a PERM_COPY, PERM_TRANSFER, etc, and an EValue
  355. // enumeration to specifically set that value. Not implemented
  356. // because I'm not sure it's a useful api.
  357. //void setValue(PermissionBit bit, EValue);
  358. // Given a mask, aggregate the useful permissions.
  359. void aggregate(PermissionMask mask);
  360. // Aggregate aggregates
  361. void aggregate(const LLAggregatePermissions& ag);
  362. // message handling
  363. void packMessage(LLMessageSystem* msg, const char* field) const;
  364. void unpackMessage(LLMessageSystem* msg, const char* block, const char *field, S32 block_num = 0);
  365. static const LLAggregatePermissions empty;
  366. friend std::ostream& operator<<(std::ostream &s, const LLAggregatePermissions &perm);
  367. protected:
  368. enum EPermIndex
  369. {
  370. PI_COPY = 0,
  371. PI_MODIFY = 1,
  372. PI_TRANSFER = 2,
  373. PI_END = 3,
  374. PI_COUNT = 3
  375. };
  376. void aggregateBit(EPermIndex idx, BOOL allowed);
  377. void aggregateIndex(EPermIndex idx, U8 bits);
  378. static EPermIndex perm2PermIndex(PermissionBit bit);
  379. // structure used to store the aggregate so far.
  380. U8 mBits[PI_COUNT];
  381. };
  382. // These functions convert between structured data and permissions as
  383. // appropriate for serialization. The permissions are a map of things
  384. // like 'creator_id', 'owner_id', etc, with the value copied from the
  385. // permission object.
  386. LLSD ll_create_sd_from_permissions(const LLPermissions& perm);
  387. LLPermissions ll_permissions_from_sd(const LLSD& sd_perm);
  388. #endif