Home - sourcemod-central - file revision - core/smn_admin.cpp@2fc3152c3118 Mercurial
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
core/smn_admin.cpp
author David Anderson <dvander@alliedmods.net>
Thu Jun 21 23:06:37 2007 +0000 (2007-06-21)
changeset 997 2fc3152c3118
parent 653 ef60870067ff
child 1231 17badaf66ce4
permissions -rw-r--r--
bumped menu api again - added feature to get menu end reason 
     1 /**
     2  * vim: set ts=4 :
     3  * ===============================================================
     4  * SourceMod (C)2004-2007 AlliedModders LLC.  All rights reserved.
     5  * ===============================================================
     6  *
     7  * This file is not open source and may not be copied without explicit
     8  * written permission of AlliedModders LLC.  This file may not be redistributed 
     9  * in whole or significant part.
    10  * For information, see LICENSE.txt or http://www.sourcemod.net/license.php
    11  *
    12  * Version: $Id$
    13  */
    14 
    15 #include "sm_globals.h"
    16 #include "AdminCache.h"
    17 #include "ForwardSys.h"
    18 
    19 static cell_t DumpAdminCache(IPluginContext *pContext, const cell_t *params)
    20 {
    21 	g_Admins.DumpAdminCache((AdminCachePart)params[1], (params[2] == 1) ? true : false);
    22 	return 1;
    23 }
    24 
    25 static cell_t AddCommandOverride(IPluginContext *pContext, const cell_t *params)
    26 {
    27 	char *str;
    28 
    29 	pContext->LocalToString(params[1], &str);
    30 	g_Admins.AddCommandOverride(str, (OverrideType)params[2], (AdminFlag)params[3]);
    31 
    32 	return 1;
    33 }
    34 
    35 static cell_t GetCommandOverride(IPluginContext *pContext, const cell_t *params)
    36 {
    37 	char *cmd;
    38 	FlagBits flags;
    39 
    40 	pContext->LocalToString(params[1], &cmd);
    41 
    42 	if (!g_Admins.GetCommandOverride(cmd, (OverrideType)params[2], &flags))
    43 	{
    44 		return 0;
    45 	}
    46 
    47 	cell_t *addr;
    48 	pContext->LocalToPhysAddr(params[3], &addr);
    49 
    50 	*addr = (cell_t)flags;
    51 
    52 	return 1;
    53 }
    54 
    55 static cell_t UnsetCommandOverride(IPluginContext *pContext, const cell_t *params)
    56 {
    57 	char *cmd;
    58 
    59 	pContext->LocalToString(params[1], &cmd);
    60 
    61 	g_Admins.UnsetCommandOverride(cmd, (OverrideType)params[2]);
    62 
    63 	return 1;
    64 }
    65 
    66 static cell_t CreateAdmGroup(IPluginContext *pContext, const cell_t *params)
    67 {
    68 	char *str;
    69 
    70 	pContext->LocalToString(params[1], &str);
    71 
    72 	return g_Admins.AddGroup(str);
    73 }
    74 
    75 static cell_t FindAdmGroup(IPluginContext *pContext, const cell_t *params)
    76 {
    77 	char *str;
    78 
    79 	pContext->LocalToString(params[1], &str);
    80 
    81 	return g_Admins.FindGroupByName(str);
    82 }
    83 
    84 static cell_t SetAdmGroupAddFlag(IPluginContext *pContext, const cell_t *params)
    85 {
    86 	GroupId id = (GroupId)params[1];
    87 	AdminFlag flag = (AdminFlag)params[2];
    88 	bool enabled = params[3] ? 1 : 0;
    89 
    90 	g_Admins.SetGroupAddFlag(id, flag, enabled);
    91 
    92 	return 1;
    93 }
    94 
    95 static cell_t GetAdmGroupAddFlag(IPluginContext *pContext, const cell_t *params)
    96 {
    97 	GroupId id = (GroupId)params[1];
    98 	AdminFlag flag = (AdminFlag)params[2];
    99 	
   100 	return g_Admins.GetGroupAddFlag(id, flag) ? 1 : 0;
   101 }
   102 
   103 static cell_t SetAdmGroupImmunity(IPluginContext *pContext, const cell_t *params)
   104 {
   105 	GroupId id = (GroupId)params[1];
   106 	ImmunityType type = (ImmunityType)params[2];
   107 	bool enabled = params[3] ? 1 : 0;
   108 
   109 	g_Admins.SetGroupGenericImmunity(id, type, enabled);
   110 
   111 	return 1;
   112 }
   113 
   114 static cell_t GetAdmGroupImmunity(IPluginContext *pContext, const cell_t *params)
   115 {
   116 	GroupId id = (GroupId)params[1];
   117 	ImmunityType type = (ImmunityType)params[2];
   118 
   119 	return g_Admins.GetGroupGenericImmunity(id, type) ? 1 : 0;
   120 }
   121 
   122 static cell_t SetAdmGroupImmuneFrom(IPluginContext *pContext, const cell_t *params)
   123 {
   124 	GroupId id = (GroupId)params[1];
   125 	GroupId other_id = (GroupId)params[2];
   126 
   127 	g_Admins.AddGroupImmunity(id, other_id);
   128 
   129 	return 1;
   130 }
   131 
   132 static cell_t GetAdmGroupImmuneCount(IPluginContext *pContext, const cell_t *params)
   133 {
   134 	GroupId id = (GroupId)params[1];
   135 
   136 	return g_Admins.GetGroupImmunityCount(id);
   137 }
   138 
   139 static cell_t GetAdmGroupImmuneFrom(IPluginContext *pContext, const cell_t *params)
   140 {
   141 	GroupId id = (GroupId)params[1];
   142 
   143 	return g_Admins.GetGroupImmunity(id, params[2]);
   144 }
   145 
   146 static cell_t AddAdmGroupCmdOverride(IPluginContext *pContext, const cell_t *params)
   147 {
   148 	GroupId id = (GroupId)params[1];
   149 	OverrideType type = (OverrideType)params[3];
   150 	OverrideRule rule = (OverrideRule)params[4];
   151 	char *cmd;
   152 
   153 	pContext->LocalToString(params[2], &cmd);
   154 
   155 	g_Admins.AddGroupCommandOverride(id, cmd, type, rule);
   156 
   157 	return 1;
   158 }
   159 
   160 static cell_t GetAdmGroupCmdOverride(IPluginContext *pContext, const cell_t *params)
   161 {
   162 	GroupId id = (GroupId)params[1];
   163 	OverrideType type = (OverrideType)params[3];
   164 	OverrideRule rule;
   165 	char *cmd;
   166 
   167 	pContext->LocalToString(params[2], &cmd);
   168 
   169 	if (!g_Admins.GetGroupCommandOverride(id, cmd, type, &rule))
   170 	{
   171 		return 0;
   172 	}
   173 
   174 	cell_t *addr;
   175 	pContext->LocalToPhysAddr(params[4], &addr);
   176 	*addr = (cell_t)rule;
   177 
   178 	return 1;
   179 }
   180 
   181 static cell_t GetAdmGroupAddFlags(IPluginContext *pContext, const cell_t *params)
   182 {
   183 	GroupId id = (GroupId)params[1];
   184 	return g_Admins.GetGroupAddFlags(id);
   185 }
   186 
   187 static cell_t RegisterAuthIdentType(IPluginContext *pContext, const cell_t *params)
   188 {
   189 	char *type;
   190 	pContext->LocalToString(params[1], &type);
   191 
   192 	g_Admins.RegisterAuthIdentType(type);
   193 
   194 	return 1;
   195 }
   196 
   197 static cell_t CreateAdmin(IPluginContext *pContext, const cell_t *params)
   198 {
   199 	char *admin;
   200 	pContext->LocalToString(params[1], &admin);
   201 
   202 	if (admin[0] == '\0')
   203 	{
   204 		admin = NULL;
   205 	}
   206 
   207 	return g_Admins.CreateAdmin(admin);
   208 }
   209 
   210 static cell_t GetAdminUsername(IPluginContext *pContext, const cell_t *params)
   211 {
   212 	AdminId id = params[1];
   213 	size_t written;
   214 	const char *name = g_Admins.GetAdminName(id);
   215 
   216 	if (!name)
   217 	{
   218 		return 0;
   219 	}
   220 
   221 	pContext->StringToLocalUTF8(params[2], params[3], name, &written);
   222 
   223 	return written;
   224 }
   225 
   226 static cell_t BindAdminIdentity(IPluginContext *pContext, const cell_t *params)
   227 {
   228 	AdminId id = params[1];
   229 	char *auth, *ident;
   230 
   231 	pContext->LocalToString(params[2], &auth);
   232 	pContext->LocalToString(params[3], &ident);
   233 
   234 	return g_Admins.BindAdminIdentity(id, auth, ident);
   235 }
   236 
   237 static cell_t SetAdminFlag(IPluginContext *pContext, const cell_t *params)
   238 {
   239 	AdminId id = params[1];
   240 	AdminFlag flag = (AdminFlag)params[2];
   241 	bool enabled = params[3] ? true : false;
   242 
   243 	g_Admins.SetAdminFlag(id, flag, enabled);
   244 
   245 	return 1;
   246 }
   247 
   248 static cell_t GetAdminFlag(IPluginContext *pContext, const cell_t *params)
   249 {
   250 	AdminId id = params[1];
   251 	AdminFlag flag = (AdminFlag)params[2];
   252 	AccessMode mode = (AccessMode)params[3];
   253 
   254 	return g_Admins.GetAdminFlag(id, flag, mode);
   255 }
   256 
   257 static cell_t GetAdminFlags(IPluginContext *pContext, const cell_t *params)
   258 {
   259 	AdminId id = params[1];
   260 	AccessMode mode = (AccessMode)params[2];
   261 
   262 	return g_Admins.GetAdminFlags(id, mode);
   263 }
   264 
   265 static cell_t AdminInheritGroup(IPluginContext *pContext, const cell_t *params)
   266 {
   267 	AdminId id = params[1];
   268 	GroupId gid = params[2];
   269 
   270 	return g_Admins.AdminInheritGroup(id, gid);
   271 }
   272 
   273 static cell_t GetAdminGroupCount(IPluginContext *pContext, const cell_t *params)
   274 {
   275 	AdminId id = params[1];
   276 
   277 	return g_Admins.GetAdminGroupCount(id);
   278 }
   279 
   280 static cell_t GetAdminGroup(IPluginContext *pContext, const cell_t *params)
   281 {
   282 	AdminId id = params[1];
   283 	unsigned int index = params[2];
   284 	const char *name;
   285 	GroupId gid;
   286 
   287 	if ((gid=g_Admins.GetAdminGroup(id, index, &name)) == INVALID_GROUP_ID)
   288 	{
   289 		return gid;
   290 	}
   291 
   292 	if (name == NULL)
   293 	{
   294 		name = "";
   295 	}
   296 
   297 	pContext->StringToLocalUTF8(params[3], params[4], name, NULL);
   298 
   299 	return gid;
   300 }
   301 
   302 static cell_t SetAdminPassword(IPluginContext *pContext, const cell_t *params)
   303 {
   304 	AdminId id = params[1];
   305 	char *password;
   306 
   307 	pContext->LocalToString(params[2], &password);
   308 
   309 	g_Admins.SetAdminPassword(id, password);
   310 
   311 	return 1;
   312 }
   313 
   314 static cell_t GetAdminPassword(IPluginContext *pContext, const cell_t *params)
   315 {
   316 	AdminId id = params[1];
   317 	const char *password = g_Admins.GetAdminPassword(id);
   318 
   319 	if (!password)
   320 	{
   321 		return 0;
   322 	}
   323 
   324 	pContext->StringToLocalUTF8(params[2], params[3], password, NULL);
   325 
   326 	return 1;
   327 }
   328 
   329 static cell_t FindAdminByIdentity(IPluginContext *pContext, const cell_t *params)
   330 {
   331 	char *auth, *ident;
   332 
   333 	pContext->LocalToString(params[1], &auth);
   334 	pContext->LocalToString(params[2], &ident);
   335 
   336 	return g_Admins.FindAdminByIdentity(auth, ident);
   337 }
   338 
   339 static cell_t RemoveAdmin(IPluginContext *pContext, const cell_t *params)
   340 {
   341 	AdminId id = params[1];
   342 
   343 	return g_Admins.InvalidateAdmin(id);
   344 }
   345 
   346 static cell_t FlagBitsToBitArray(IPluginContext *pContext, const cell_t *params)
   347 {
   348 	FlagBits bits = (FlagBits)params[1];
   349 	bool array[AdminFlags_TOTAL];
   350 	cell_t *addr;
   351 	unsigned int numWr = g_Admins.FlagBitsToBitArray(bits, array, AdminFlags_TOTAL);
   352 
   353 	pContext->LocalToPhysAddr(params[2], &addr);
   354 
   355 	unsigned int i;
   356 	for (i=0; i<numWr && i<(unsigned int)params[3]; i++)
   357 	{
   358 		addr[i] = array[i] ? 1 : 0;
   359 	}
   360 
   361 	return i;
   362 }
   363 
   364 static cell_t FlagBitArrayToBits(IPluginContext *pContext, const cell_t *params)
   365 {
   366 	bool array[AdminFlags_TOTAL];
   367 	unsigned int num = ((unsigned int)params[2] > AdminFlags_TOTAL ? params[2] : AdminFlags_TOTAL);
   368 	cell_t *addr;
   369 
   370 	pContext->LocalToPhysAddr(params[1], &addr);
   371 
   372 	for (unsigned int i=0; i<num; i++)
   373 	{
   374 		array[i] = addr[i] ? true : false;
   375 	}
   376 
   377 	return g_Admins.FlagBitArrayToBits(array, num);
   378 }
   379 
   380 static cell_t FlagArrayToBits(IPluginContext *pContext, const cell_t *params)
   381 {
   382 	cell_t *addr;
   383 	pContext->LocalToPhysAddr(params[1], &addr);
   384 
   385 	if (sizeof(AdminFlag) == sizeof(cell_t))
   386 	{
   387 		return g_Admins.FlagArrayToBits((const AdminFlag *)addr, params[2]);
   388 	} else {
   389 		AdminFlag flags[AdminFlags_TOTAL];
   390 		unsigned int num = ((unsigned)params[2] > AdminFlags_TOTAL ? AdminFlags_TOTAL : params[2]);
   391 
   392 		for (unsigned int i=0; i<num; i++)
   393 		{
   394 			flags[i] = (AdminFlag)addr[i];
   395 		}
   396 		return g_Admins.FlagArrayToBits(flags, num);
   397 	}
   398 }
   399 
   400 static cell_t FlagBitsToArray(IPluginContext *pContext, const cell_t *params)
   401 {
   402 	cell_t *addr;
   403 	pContext->LocalToPhysAddr(params[2], &addr);
   404 
   405 	if (sizeof(AdminFlag) == sizeof(cell_t))
   406 	{
   407 		return g_Admins.FlagBitsToArray(params[1], (AdminFlag *)addr, params[3]);
   408 	} else {
   409 		AdminFlag flags[AdminFlags_TOTAL];
   410 		unsigned int num = ((unsigned)params[2] > AdminFlags_TOTAL ? AdminFlags_TOTAL : params[2]);
   411 		num = g_Admins.FlagBitsToArray(params[1], flags, num);
   412 
   413 		for (unsigned int i=0; i<num; i++)
   414 		{
   415 			addr[i] = flags[i];
   416 		}
   417 
   418 		return num;
   419 	}
   420 }
   421 
   422 static cell_t CanAdminTarget(IPluginContext *pContext, const cell_t *params)
   423 {
   424 	return g_Admins.CanAdminTarget(params[1], params[2]) ? 1 : 0;
   425 }
   426 
   427 static cell_t CreateAuthMethod(IPluginContext *pContext, const cell_t *params)
   428 {
   429 	char *name;
   430 	pContext->LocalToString(params[1], &name);
   431 	g_Admins.RegisterAuthIdentType(name);
   432 
   433 	return 1;
   434 }
   435 
   436 REGISTER_NATIVES(adminNatives)
   437 {
   438 	{"DumpAdminCache",			DumpAdminCache},
   439 	{"AddCommandOverride",		AddCommandOverride},
   440 	{"GetCommandOverride",		GetCommandOverride},
   441 	{"UnsetCommandOverride",	UnsetCommandOverride},
   442 	{"CreateAdmGroup",			CreateAdmGroup},
   443 	{"FindAdmGroup",			FindAdmGroup},
   444 	{"SetAdmGroupAddFlag",		SetAdmGroupAddFlag},
   445 	{"GetAdmGroupAddFlag",		GetAdmGroupAddFlag},
   446 	{"SetAdmGroupImmunity",		SetAdmGroupImmunity},
   447 	{"GetAdmGroupImmunity",		GetAdmGroupImmunity},
   448 	{"SetAdmGroupImmuneFrom",	SetAdmGroupImmuneFrom},
   449 	{"GetAdmGroupImmuneFrom",	GetAdmGroupImmuneFrom},
   450 	{"GetAdmGroupImmuneCount",	GetAdmGroupImmuneCount},
   451 	{"AddAdmGroupCmdOverride",	AddAdmGroupCmdOverride},
   452 	{"GetAdmGroupCmdOverride",	GetAdmGroupCmdOverride},
   453 	{"GetAdmGroupAddFlags",		GetAdmGroupAddFlags},
   454 	{"RegisterAuthIdentType",	RegisterAuthIdentType},
   455 	{"CreateAdmin",				CreateAdmin},
   456 	{"GetAdminUsername",		GetAdminUsername},
   457 	{"BindAdminIdentity",		BindAdminIdentity},
   458 	{"SetAdminFlag",			SetAdminFlag},
   459 	{"GetAdminFlag",			GetAdminFlag},
   460 	{"GetAdminFlags",			GetAdminFlags},
   461 	{"AdminInheritGroup",		AdminInheritGroup},
   462 	{"GetAdminGroupCount",		GetAdminGroupCount},
   463 	{"GetAdminGroup",			GetAdminGroup},
   464 	{"SetAdminPassword",		SetAdminPassword},
   465 	{"GetAdminPassword",		GetAdminPassword},
   466 	{"FindAdminByIdentity",		FindAdminByIdentity},
   467 	{"RemoveAdmin",				RemoveAdmin},
   468 	{"FlagBitsToBitArray",		FlagBitsToBitArray},
   469 	{"FlagBitArrayToBits",		FlagBitArrayToBits},
   470 	{"FlagArrayToBits",			FlagArrayToBits},
   471 	{"FlagBitsToArray",			FlagBitsToArray},
   472 	{"CanAdminTarget",			CanAdminTarget},
   473 	{"CreateAuthMethod",		CreateAuthMethod},
   474 	/* -------------------------------------------------- */
   475 	{NULL,						NULL},
   476 };
sourcemod-central
Feed