3 * ===============================================================
4 * SourceMod (C)2004-2007 AlliedModders LLC. All rights reserved.
5 * ===============================================================
7 * This file is part of the SourceMod/SourcePawn SDK. This file may only be used
8 * or modified under the Terms and Conditions of its License Agreement, which is found
9 * in LICENSE.txt. The Terms and Conditions for making SourceMod extensions/plugins
10 * may change at any time. To view the latest information, see:
11 * http://www.sourcemod.net/license.php
16 #if defined _admin_included
19 #define _admin_included
22 * Access levels (flags) for admins.
26 Admin_Reservation = 0, /**< Reserved slot */
27 Admin_Generic, /**< Generic admin abilities */
28 Admin_Kick, /**< Kick another user */
29 Admin_Ban, /**< Ban another user */
30 Admin_Unban, /**< Unban another user */
31 Admin_Slay, /**< Slay/kill/damage another user */
32 Admin_Changemap, /**< Change the map */
33 Admin_Convars, /**< Change basic convars */
34 Admin_Config, /**< Change configuration */
35 Admin_Chat, /**< Special chat privileges */
36 Admin_Vote, /**< Special vote privileges */
37 Admin_Password, /**< Set a server password */
38 Admin_RCON, /**< Use RCON */
39 Admin_Cheats, /**< Change sv_cheats and use its commands */
40 Admin_Root, /**< All access by default */
41 Admin_Custom1, /**< First custom flag type */
42 Admin_Custom2, /**< Second custom flag type */
43 Admin_Custom3, /**< Third custom flag type */
44 Admin_Custom4, /**< Fourth custom flag type */
45 Admin_Custom5, /**< Fifth custom flag type */
46 Admin_Custom6, /**< Sixth custom flag type */
50 #define AdminFlags_TOTAL 21 /**< Total number of admin flags */
53 * @section These define bitwise values for bitstrings (numbers containing bitwise flags).
55 #define ADMFLAG_RESERVATION (1<<0) /**< Convenience macro for Admin_Reservation as a FlagBit */
56 #define ADMFLAG_GENERIC (1<<1) /**< Convenience macro for Admin_Generic as a FlagBit */
57 #define ADMFLAG_KICK (1<<2) /**< Convenience macro for Admin_Kick as a FlagBit */
58 #define ADMFLAG_BAN (1<<3) /**< Convenience macro for Admin_Ban as a FlagBit */
59 #define ADMFLAG_UNBAN (1<<4) /**< Convenience macro for Admin_Unban as a FlagBit */
60 #define ADMFLAG_SLAY (1<<5) /**< Convenience macro for Admin_Slay as a FlagBit */
61 #define ADMFLAG_CHANGEMAP (1<<6) /**< Convenience macro for Admin_Changemap as a FlagBit */
62 #define ADMFLAG_CONVARS (1<<7) /**< Convenience macro for Admin_Convars as a FlagBit */
63 #define ADMFLAG_CONFIG (1<<8) /**< Convenience macro for Admin_Config as a FlagBit */
64 #define ADMFLAG_CHAT (1<<9) /**< Convenience macro for Admin_Chat as a FlagBit */
65 #define ADMFLAG_VOTE (1<<10) /**< Convenience macro for Admin_Vote as a FlagBit */
66 #define ADMFLAG_PASSWORD (1<<11) /**< Convenience macro for Admin_Password as a FlagBit */
67 #define ADMFLAG_RCON (1<<12) /**< Convenience macro for Admin_RCON as a FlagBit */
68 #define ADMFLAG_CHEATS (1<<13) /**< Convenience macro for Admin_Cheats as a FlagBit */
69 #define ADMFLAG_ROOT (1<<14) /**< Convenience macro for Admin_Root as a FlagBit */
70 #define ADMFLAG_CUSTOM1 (1<<15) /**< Convenience macro for Admin_Custom1 as a FlagBit */
71 #define ADMFLAG_CUSTOM2 (1<<16) /**< Convenience macro for Admin_Custom2 as a FlagBit */
72 #define ADMFLAG_CUSTOM3 (1<<17) /**< Convenience macro for Admin_Custom3 as a FlagBit */
73 #define ADMFLAG_CUSTOM4 (1<<18) /**< Convenience macro for Admin_Custom4 as a FlagBit */
74 #define ADMFLAG_CUSTOM5 (1<<19) /**< Convenience macro for Admin_Custom5 as a FlagBit */
75 #define ADMFLAG_CUSTOM6 (1<<20) /**< Convenience macro for Admin_Custom6 as a FlagBit */
82 * @section Hardcoded authentication methods
84 #define AUTHMETHOD_STEAM "steam"
85 #define AUTHMETHOD_IP "ip"
86 #define AUTHMETHOD_NAME "name"
97 Override_Command = 1, /* Command */
98 Override_CommandGroup, /* Command group */
115 Immunity_Default = 1, /* Immune from everyone with no immunity */
116 Immunity_Global, /* Immune from everyone (except root admins) */
119 /** Identifies a unique entry in the group permissions cache. These are not Handles. */
122 INVALID_GROUP_ID = -1,
125 /** Identifies a unique entry in the admin permissions cache. These are not Handles. */
128 INVALID_ADMIN_ID = -1,
131 /** Defines user access modes. */
134 Access_Real, /**< Access the user has inherently */
135 Access_Effective, /**< Access the user has from their groups */
139 * @brief Represents the various cache regions.
143 AdminCache_Overrides = 0, /**< Global overrides */
144 AdminCache_Groups = 1, /**< All groups (automatically invalidates admins too) */
145 AdminCache_Admins = 2, /**< All admins */
149 * Called when part of the cache which needs to be rebuilt.
151 * @param part Part of the admin cache to rebuild.
153 forward OnRebuildAdminCache(AdminCachePart:part);
156 * Tells the admin system to dump a portion of the cache.
158 * @param part Part of the cache to dump. Specifying groups also dumps admins.
159 * @param rebuild If true, the rebuild forwards will fire.
162 native DumpAdminCache(AdminCachePart:part, bool:rebuild);
165 * Adds a global command flag override. Any command registered with this name
166 * will assume the new flag. This is applied retroactively as well.
168 * @param cmd String containing command name (case sensitive).
169 * @param type Override type (specific command or group).
170 * @param flags New admin flag.
173 native AddCommandOverride(const String:cmd[], OverrideType:type, flags);
176 * Returns a command override.
178 * @param cmd String containing command name (case sensitive).
179 * @param type Override type (specific command or group).
180 * @param flags By-reference cell to store the flag (undefined if not found).
181 * @return True if there is an override, false otherwise.
183 native bool:GetCommandOverride(const String:cmd[], OverrideType:type, &flags);
186 * Unsets a command override.
188 * @param cmd String containing command name (case sensitive).
189 * @param type Override type (specific command or group).
192 native UnsetCommandOverride(const String:cmd[], OverrideType:type);
195 * Adds a new group. Name must be unique.
197 * @param group_name String containing the group name.
198 * @return A new group id, INVALID_GROUP_ID if it already exists.
200 native GroupId:CreateAdmGroup(const String:group_name[]);
203 * @brief Finds a group by name.
205 * @param group_name String containing the group name.
206 * @return A group id, or INVALID_GROUP_ID if not found.
208 native GroupId:FindAdmGroup(const String:group_name[]);
211 * Adds or removes a flag from a group's flag set.
212 * @note These are called "add flags" because they add to a user's flags.
214 * @param id Group id.
215 * @param flag Admin flag to toggle.
216 * @param enabled True to set the flag, false to unset/disable.
219 native SetAdmGroupAddFlag(GroupId:id, AdminFlag:flag, bool:enabled);
222 * Gets the set value of an add flag on a group's flag set.
223 * @note These are called "add flags" because they add to a user's flags.
225 * @param id Group id.
226 * @param flag Admin flag to retrieve.
227 * @return True if enabled, false otherwise,
229 native bool:GetAdmGroupAddFlag(GroupId:id, AdminFlag:flag);
232 * Returns the flag set that is added to a user from their group.
233 * @note These are called "add flags" because they add to a user's flags.
235 * @param id GroupId of the group.
236 * @return Bitstring containing the flags enabled.
238 native GetAdmGroupAddFlags(GroupId:id);
241 * Toggles a generic immunity type.
243 * @param id Group id.
244 * @param type Generic immunity type.
245 * @param enabled True to enable, false otherwise.
248 native SetAdmGroupImmunity(GroupId:id, ImmunityType:type, bool:enabled);
251 * Returns whether or not a group has global immunity.
253 * @param id Group id.
254 * @param type Generic immunity type.
255 * @return True if the group has this immunity, false otherwise.
257 native bool:GetAdmGroupImmunity(GroupId:id, ImmunityType:type);
260 * Adds immunity to a specific group.
262 * @param id Group id.
263 * @param other_id Group id to receive immunity to.
266 native SetAdmGroupImmuneFrom(GroupId:id, GroupId:other_id);
269 * Returns the number of specific group immunities.
271 * @param id Group id.
272 * @return Number of group immunities.
274 native GetAdmGroupImmuneCount(GroupId:id);
277 * Returns a group that this group is immune to given an index.
279 * @param id Group id.
280 * @param number Index from 0 to N-1, from GetAdmGroupImmuneCount().
281 * @return GroupId that this group is immune to, or INVALID_GROUP_ID on failure.
283 native GroupId:GetAdmGroupImmuneFrom(GroupId:id, number);
286 * Adds a group-specific override type.
288 * @param id Group id.
289 * @param name String containing command name (case sensitive).
290 * @param type Override type (specific command or group).
291 * @param rule Override allow/deny setting.
294 native AddAdmGroupCmdOverride(GroupId:id, const String:name[], OverrideType:type, OverrideRule:rule);
297 * Retrieves a group-specific command override.
299 * @param id Group id.
300 * @param name String containing command name (case sensitive).
301 * @param type Override type (specific command or group).
302 * @param rule Optional pointer to store allow/deny setting.
303 * @return True if an override exists, false otherwise.
305 native bool:GetAdmGroupCmdOverride(GroupId:id, const String:name[], OverrideType:type, &OverrideRule:rule);
308 * Registers an authentication identity type. You normally never need to call this except for
309 * very specific systems.
311 * @param codename Codename to use for your authentication type.
314 native RegisterAuthIdentType(const String:name[]);
317 * Creates a new admin entry in the permissions cache.
319 * @param name Name for this entry (does not have to be unique).
320 * Specify an empty string for an anonymous admin.
322 native AdminId:CreateAdmin(const String:name[]="");
325 * Retrieves an admin's user name as made with CreateAdmin().
326 * @note This function can return UTF-8 strings, and will safely chop UTF-8 strings.
328 * @param id AdminId of the admin.
329 * @param name String buffer to store name.
330 * @param maxlength Maximum size of string buffer.
331 * @return Number of bytes written.
333 native GetAdminUsername(AdminId:id, const String:name[], maxlength);
336 * Binds an admin to an identity for fast lookup later on. The bind must be unique.
338 * @param id AdminId of the admin.
339 * @param auth Auth method to use, predefined or from RegisterAuthIdentType().
340 * @param ident String containing the arbitrary, unique identity.
341 * @return True on success, false if the auth method was not found,
342 * or ident was already taken.
344 native bool:BindAdminIdentity(AdminId:id, const String:auth[], const String:ident[]);
347 * Sets whether or not a flag is enabled on an admin.
349 * @param id AdminId index of the admin.
350 * @param flag Admin flag to use.
351 * @param enabled True to enable, false to disable.
354 native SetAdminFlag(AdminId:id, AdminFlag:flag, bool:enabled);
357 * Returns whether or not a flag is enabled on an admin.
359 * @param id AdminId index of the admin.
360 * @param flag Admin flag to use.
361 * @param mode Access mode to check.
362 * @return True if enabled, false otherwise.
364 native bool:GetAdminFlag(AdminId:id, AdminFlag:flag, AdmAccessMode:mode);
367 * Returns the bitstring of access flags on an admin.
369 * @param id AdminId index of the admin.
370 * @param mode Access mode to use.
371 * @return A bitstring containing which flags are enabled.
373 native GetAdminFlags(AdminId:id, AdmAccessMode:mode);
376 * Adds a group to an admin's inherited group list. Any flags the group has
377 * will be added to the admin's effective flags.
379 * @param id AdminId index of the admin.
380 * @param gid GroupId index of the group.
381 * @return True on success, false on invalid input or duplicate membership.
383 native bool:AdminInheritGroup(AdminId:id, GroupId:gid);
386 * Returns the number of groups this admin is a member of.
388 * @param id AdminId index of the admin.
389 * @return Number of groups this admin is a member of.
391 native GetAdminGroupCount(AdminId:id);
394 * Returns group information from an admin.
396 * @param id AdminId index of the admin.
397 * @param index Group number to retrieve, from 0 to N-1, where N
398 * is the value of GetAdminGroupCount(id).
399 * @param name Buffer to store the group's name.
400 * Note: This will safely chop UTF-8 strings.
401 * @param maxlength Maximum size of the output name buffer.
402 * @return A GroupId index and a name pointer, or
403 * INVALID_GROUP_ID and NULL if an error occurred.
405 native GroupId:GetAdminGroup(AdminId:id, index, const String:name[], maxlength) =0;
408 * Sets a password on an admin.
410 * @param id AdminId index of the admin.
411 * @param passwd String containing the password.
414 native SetAdminPassword(AdminId:id, const String:password[]);
417 * Gets an admin's password.
419 * @param id AdminId index of the admin.
420 * @param name Optional buffer to store the admin's password.
421 * @param maxlength Maximum size of the output name buffer.
422 * Note: This will safely chop UTF-8 strings.
423 * @return True if there was a password set, false otherwise.
425 native bool:GetAdminPassword(AdminId:id, const String:buffer[]="", maxlength=0);
428 * Attempts to find an admin by an auth method and an identity.
430 * @param auth Auth method to try.
431 * @param identity Identity string to look up.
432 * @return An AdminId index if found, INVALID_ADMIN_ID otherwise.
434 native AdminId:FindAdminByIdentity(const String:auth[], const String:identity[]);
437 * Removes an admin entry from the cache.
438 * @note This will remove any bindings to a specific user.
440 * @param id AdminId index to remove/invalidate.
441 * @return True on success, false otherwise.
443 native bool:RemoveAdmin(AdminId:id);
446 * Converts a flag bit string to a bit array.
448 * @param bits Bit string containing the flags.
449 * @param array Array to write the flags to. Enabled flags will be 'true'.
450 * @param maxSize Maximum number of flags the array can store.
451 * @return Number of flags written.
453 native FlagBitsToBitArray(bits, bool:array[], maxSize);
456 * Converts a flag array to a bit string.
458 * @param array Array containing true or false for each AdminFlag.
459 * @param maxSize Maximum size of the flag array.
460 * @return A bit string composed of the array bits.
462 native FlagBitArrayToBits(const bool:array[], maxSize);
465 * Converts an array of flags to bits.
467 * @param array Array containing flags that are enabled.
468 * @param numFlags Number of flags in the array.
469 * @return A bit string composed of the array flags.
471 native FlagArrayToBits(const AdminFlag:array[], numFlags) =0;
474 * Converts a bit string to an array of flags.
476 * @param bits Bit string containing the flags.
477 * @param array Output array to write flags.
478 * @param maxSize Maximum size of the flag array.
479 * @return Number of flags written.
481 native FlagBitsToArray(bits, AdminFlag:array[], maxSize) =0;
484 * Tests whether one admin can target another.
486 * @param admin Admin doing the targetting (may be INVALID_ADMIN_ID).
487 * @param target Target admin (may be INVALID_ADMIN_ID).
488 * @return True if targetable, false if immune.
490 native CanAdminTarget(AdminId:admin, AdminId:target);
493 * Creates an admin auth method. This does not need to be called more than once
496 * @param method Name of the authentication method.
497 * @return True on success, false on failure.
499 native bool:CreateAuthMethod(const String:method[]);
502 * Converts a flag to its single bit.
504 * @param flag Flag to convert.
505 * @return Bit representation of the flag.
507 stock FlagToBit(AdminFlag:flag)
513 * Converts a bit to an AdminFlag.
515 * @param bit Bit to convert.
516 * @param flag Stores the converted flag by reference.
517 * @return True on success, false otherwise.
519 stock bool:BitToFlag(bit, &AdminFlag:flag)
521 new AdminFlag:array[1];
523 if (FlagBitsToArray(bit, array, 1))
