Home - sourcemod-central - file revision - core/logic/smn_admin.cpp@ea2275fd135f Mercurial
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
core/logic/smn_admin.cpp
author David Anderson <dvander@alliedmods.net>
Fri May 14 17:46:19 2010 -0700 (2010-05-14)
changeset 3000 ea2275fd135f
parent 2289 core/smn_admin.cpp@44045ead61cd
child 3055 4c81256cac43
permissions -rw-r--r--
Move admin natives from core to logic (bug 4406 part 2, r=ds). 
     1 /**
     2  * vim: set ts=4 :
     3  * =============================================================================
     4  * SourceMod
     5  * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.
     6  * =============================================================================
     7  *
     8  * This program is free software; you can redistribute it and/or modify it under
     9  * the terms of the GNU General Public License, version 3.0, as published by the
    10  * Free Software Foundation.
    11  * 
    12  * This program is distributed in the hope that it will be useful, but WITHOUT
    13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    14  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
    15  * details.
    16  *
    17  * You should have received a copy of the GNU General Public License along with
    18  * this program.  If not, see <http://www.gnu.org/licenses/>.
    19  *
    20  * As a special exception, AlliedModders LLC gives you permission to link the
    21  * code of this program (as well as its derivative works) to "Half-Life 2," the
    22  * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
    23  * by the Valve Corporation.  You must obey the GNU General Public License in
    24  * all respects for all other code used.  Additionally, AlliedModders LLC grants
    25  * this exception to all derivative works.  AlliedModders LLC defines further
    26  * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
    27  * or <http://www.sourcemod.net/license.php>.
    28  *
    29  * Version: $Id$
    30  */
    31 
    32 #include "common_logic.h"
    33 #include <IAdminSystem.h>
    34 #include <IForwardSys.h>
    35 
    36 using namespace SourceMod;
    37 
    38 static cell_t DumpAdminCache(IPluginContext *pContext, const cell_t *params)
    39 {
    40 	adminsys->DumpAdminCache((AdminCachePart)params[1], (params[2] == 1) ? true : false);
    41 	return 1;
    42 }
    43 
    44 static cell_t AddCommandOverride(IPluginContext *pContext, const cell_t *params)
    45 {
    46 	char *str;
    47 
    48 	pContext->LocalToString(params[1], &str);
    49 	adminsys->AddCommandOverride(str, (OverrideType)params[2], (AdminFlag)params[3]);
    50 
    51 	return 1;
    52 }
    53 
    54 static cell_t GetCommandOverride(IPluginContext *pContext, const cell_t *params)
    55 {
    56 	char *cmd;
    57 	FlagBits flags;
    58 
    59 	pContext->LocalToString(params[1], &cmd);
    60 
    61 	if (!adminsys->GetCommandOverride(cmd, (OverrideType)params[2], &flags))
    62 	{
    63 		return 0;
    64 	}
    65 
    66 	cell_t *addr;
    67 	pContext->LocalToPhysAddr(params[3], &addr);
    68 
    69 	*addr = (cell_t)flags;
    70 
    71 	return 1;
    72 }
    73 
    74 static cell_t UnsetCommandOverride(IPluginContext *pContext, const cell_t *params)
    75 {
    76 	char *cmd;
    77 
    78 	pContext->LocalToString(params[1], &cmd);
    79 
    80 	adminsys->UnsetCommandOverride(cmd, (OverrideType)params[2]);
    81 
    82 	return 1;
    83 }
    84 
    85 static cell_t CreateAdmGroup(IPluginContext *pContext, const cell_t *params)
    86 {
    87 	char *str;
    88 
    89 	pContext->LocalToString(params[1], &str);
    90 
    91 	return adminsys->AddGroup(str);
    92 }
    93 
    94 static cell_t FindAdmGroup(IPluginContext *pContext, const cell_t *params)
    95 {
    96 	char *str;
    97 
    98 	pContext->LocalToString(params[1], &str);
    99 
   100 	return adminsys->FindGroupByName(str);
   101 }
   102 
   103 static cell_t SetAdmGroupAddFlag(IPluginContext *pContext, const cell_t *params)
   104 {
   105 	GroupId id = (GroupId)params[1];
   106 	AdminFlag flag = (AdminFlag)params[2];
   107 	bool enabled = params[3] ? 1 : 0;
   108 
   109 	adminsys->SetGroupAddFlag(id, flag, enabled);
   110 
   111 	return 1;
   112 }
   113 
   114 static cell_t GetAdmGroupAddFlag(IPluginContext *pContext, const cell_t *params)
   115 {
   116 	GroupId id = (GroupId)params[1];
   117 	AdminFlag flag = (AdminFlag)params[2];
   118 	
   119 	return adminsys->GetGroupAddFlag(id, flag) ? 1 : 0;
   120 }
   121 
   122 static cell_t SetAdmGroupImmunity(IPluginContext *pContext, const cell_t *params)
   123 {
   124 	GroupId id = (GroupId)params[1];
   125 	ImmunityType type = (ImmunityType)params[2];
   126 	bool enabled = params[3] ? 1 : 0;
   127 
   128 	adminsys->SetGroupGenericImmunity(id, type, enabled);
   129 
   130 	return 1;
   131 }
   132 
   133 static cell_t GetAdmGroupImmunity(IPluginContext *pContext, const cell_t *params)
   134 {
   135 	GroupId id = (GroupId)params[1];
   136 	ImmunityType type = (ImmunityType)params[2];
   137 
   138 	return adminsys->GetGroupGenericImmunity(id, type) ? 1 : 0;
   139 }
   140 
   141 static cell_t SetAdmGroupImmuneFrom(IPluginContext *pContext, const cell_t *params)
   142 {
   143 	GroupId id = (GroupId)params[1];
   144 	GroupId other_id = (GroupId)params[2];
   145 
   146 	adminsys->AddGroupImmunity(id, other_id);
   147 
   148 	return 1;
   149 }
   150 
   151 static cell_t GetAdmGroupImmuneCount(IPluginContext *pContext, const cell_t *params)
   152 {
   153 	GroupId id = (GroupId)params[1];
   154 
   155 	return adminsys->GetGroupImmunityCount(id);
   156 }
   157 
   158 static cell_t GetAdmGroupImmuneFrom(IPluginContext *pContext, const cell_t *params)
   159 {
   160 	GroupId id = (GroupId)params[1];
   161 
   162 	return adminsys->GetGroupImmunity(id, params[2]);
   163 }
   164 
   165 static cell_t AddAdmGroupCmdOverride(IPluginContext *pContext, const cell_t *params)
   166 {
   167 	GroupId id = (GroupId)params[1];
   168 	OverrideType type = (OverrideType)params[3];
   169 	OverrideRule rule = (OverrideRule)params[4];
   170 	char *cmd;
   171 
   172 	pContext->LocalToString(params[2], &cmd);
   173 
   174 	adminsys->AddGroupCommandOverride(id, cmd, type, rule);
   175 
   176 	return 1;
   177 }
   178 
   179 static cell_t GetAdmGroupCmdOverride(IPluginContext *pContext, const cell_t *params)
   180 {
   181 	GroupId id = (GroupId)params[1];
   182 	OverrideType type = (OverrideType)params[3];
   183 	OverrideRule rule;
   184 	char *cmd;
   185 
   186 	pContext->LocalToString(params[2], &cmd);
   187 
   188 	if (!adminsys->GetGroupCommandOverride(id, cmd, type, &rule))
   189 	{
   190 		return 0;
   191 	}
   192 
   193 	cell_t *addr;
   194 	pContext->LocalToPhysAddr(params[4], &addr);
   195 	*addr = (cell_t)rule;
   196 
   197 	return 1;
   198 }
   199 
   200 static cell_t GetAdmGroupAddFlags(IPluginContext *pContext, const cell_t *params)
   201 {
   202 	GroupId id = (GroupId)params[1];
   203 	return adminsys->GetGroupAddFlags(id);
   204 }
   205 
   206 static cell_t RegisterAuthIdentType(IPluginContext *pContext, const cell_t *params)
   207 {
   208 	char *type;
   209 	pContext->LocalToString(params[1], &type);
   210 
   211 	adminsys->RegisterAuthIdentType(type);
   212 
   213 	return 1;
   214 }
   215 
   216 static cell_t CreateAdmin(IPluginContext *pContext, const cell_t *params)
   217 {
   218 	char *admin;
   219 	pContext->LocalToString(params[1], &admin);
   220 
   221 	if (admin[0] == '\0')
   222 	{
   223 		admin = NULL;
   224 	}
   225 
   226 	return adminsys->CreateAdmin(admin);
   227 }
   228 
   229 static cell_t GetAdminUsername(IPluginContext *pContext, const cell_t *params)
   230 {
   231 	AdminId id = params[1];
   232 	size_t written;
   233 	const char *name = adminsys->GetAdminName(id);
   234 
   235 	if (!name)
   236 	{
   237 		return 0;
   238 	}
   239 
   240 	pContext->StringToLocalUTF8(params[2], params[3], name, &written);
   241 
   242 	return written;
   243 }
   244 
   245 static cell_t BindAdminIdentity(IPluginContext *pContext, const cell_t *params)
   246 {
   247 	AdminId id = params[1];
   248 	char *auth, *ident;
   249 
   250 	pContext->LocalToString(params[2], &auth);
   251 	pContext->LocalToString(params[3], &ident);
   252 
   253 	return adminsys->BindAdminIdentity(id, auth, ident);
   254 }
   255 
   256 static cell_t SetAdminFlag(IPluginContext *pContext, const cell_t *params)
   257 {
   258 	AdminId id = params[1];
   259 	AdminFlag flag = (AdminFlag)params[2];
   260 	bool enabled = params[3] ? true : false;
   261 
   262 	adminsys->SetAdminFlag(id, flag, enabled);
   263 
   264 	return 1;
   265 }
   266 
   267 static cell_t GetAdminFlag(IPluginContext *pContext, const cell_t *params)
   268 {
   269 	AdminId id = params[1];
   270 	AdminFlag flag = (AdminFlag)params[2];
   271 	AccessMode mode = (AccessMode)params[3];
   272 
   273 	return adminsys->GetAdminFlag(id, flag, mode);
   274 }
   275 
   276 static cell_t GetAdminFlags(IPluginContext *pContext, const cell_t *params)
   277 {
   278 	AdminId id = params[1];
   279 	AccessMode mode = (AccessMode)params[2];
   280 
   281 	return adminsys->GetAdminFlags(id, mode);
   282 }
   283 
   284 static cell_t AdminInheritGroup(IPluginContext *pContext, const cell_t *params)
   285 {
   286 	AdminId id = params[1];
   287 	GroupId gid = params[2];
   288 
   289 	return adminsys->AdminInheritGroup(id, gid);
   290 }
   291 
   292 static cell_t GetAdminGroupCount(IPluginContext *pContext, const cell_t *params)
   293 {
   294 	AdminId id = params[1];
   295 
   296 	return adminsys->GetAdminGroupCount(id);
   297 }
   298 
   299 static cell_t GetAdminGroup(IPluginContext *pContext, const cell_t *params)
   300 {
   301 	AdminId id = params[1];
   302 	unsigned int index = params[2];
   303 	const char *name;
   304 	GroupId gid;
   305 
   306 	if ((gid=adminsys->GetAdminGroup(id, index, &name)) == INVALID_GROUP_ID)
   307 	{
   308 		return gid;
   309 	}
   310 
   311 	if (name == NULL)
   312 	{
   313 		name = "";
   314 	}
   315 
   316 	pContext->StringToLocalUTF8(params[3], params[4], name, NULL);
   317 
   318 	return gid;
   319 }
   320 
   321 static cell_t SetAdminPassword(IPluginContext *pContext, const cell_t *params)
   322 {
   323 	AdminId id = params[1];
   324 	char *password;
   325 
   326 	pContext->LocalToString(params[2], &password);
   327 
   328 	adminsys->SetAdminPassword(id, password);
   329 
   330 	return 1;
   331 }
   332 
   333 static cell_t GetAdminPassword(IPluginContext *pContext, const cell_t *params)
   334 {
   335 	AdminId id = params[1];
   336 	const char *password = adminsys->GetAdminPassword(id);
   337 
   338 	if (!password)
   339 	{
   340 		return 0;
   341 	}
   342 
   343 	pContext->StringToLocalUTF8(params[2], params[3], password, NULL);
   344 
   345 	return 1;
   346 }
   347 
   348 static cell_t FindAdminByIdentity(IPluginContext *pContext, const cell_t *params)
   349 {
   350 	char *auth, *ident;
   351 
   352 	pContext->LocalToString(params[1], &auth);
   353 	pContext->LocalToString(params[2], &ident);
   354 
   355 	return adminsys->FindAdminByIdentity(auth, ident);
   356 }
   357 
   358 static cell_t RemoveAdmin(IPluginContext *pContext, const cell_t *params)
   359 {
   360 	AdminId id = params[1];
   361 
   362 	return adminsys->InvalidateAdmin(id);
   363 }
   364 
   365 static cell_t FlagBitsToBitArray(IPluginContext *pContext, const cell_t *params)
   366 {
   367 	FlagBits bits = (FlagBits)params[1];
   368 	bool array[AdminFlags_TOTAL];
   369 	cell_t *addr;
   370 	unsigned int numWr = adminsys->FlagBitsToBitArray(bits, array, AdminFlags_TOTAL);
   371 
   372 	pContext->LocalToPhysAddr(params[2], &addr);
   373 
   374 	unsigned int i;
   375 	for (i=0; i<numWr && i<(unsigned int)params[3]; i++)
   376 	{
   377 		addr[i] = array[i] ? 1 : 0;
   378 	}
   379 
   380 	return i;
   381 }
   382 
   383 static cell_t FlagBitArrayToBits(IPluginContext *pContext, const cell_t *params)
   384 {
   385 	bool array[AdminFlags_TOTAL];
   386 	unsigned int num = ((unsigned int)params[2] > AdminFlags_TOTAL ? params[2] : AdminFlags_TOTAL);
   387 	cell_t *addr;
   388 
   389 	pContext->LocalToPhysAddr(params[1], &addr);
   390 
   391 	for (unsigned int i=0; i<num; i++)
   392 	{
   393 		array[i] = addr[i] ? true : false;
   394 	}
   395 
   396 	return adminsys->FlagBitArrayToBits(array, num);
   397 }
   398 
   399 static cell_t FlagArrayToBits(IPluginContext *pContext, const cell_t *params)
   400 {
   401 	cell_t *addr;
   402 	pContext->LocalToPhysAddr(params[1], &addr);
   403 
   404 	if (sizeof(AdminFlag) == sizeof(cell_t))
   405 	{
   406 		return adminsys->FlagArrayToBits((const AdminFlag *)addr, params[2]);
   407 	} else {
   408 		AdminFlag flags[AdminFlags_TOTAL];
   409 		unsigned int num = ((unsigned)params[2] > AdminFlags_TOTAL ? AdminFlags_TOTAL : params[2]);
   410 
   411 		for (unsigned int i=0; i<num; i++)
   412 		{
   413 			flags[i] = (AdminFlag)addr[i];
   414 		}
   415 		return adminsys->FlagArrayToBits(flags, num);
   416 	}
   417 }
   418 
   419 static cell_t FlagBitsToArray(IPluginContext *pContext, const cell_t *params)
   420 {
   421 	cell_t *addr;
   422 	pContext->LocalToPhysAddr(params[2], &addr);
   423 
   424 	if (sizeof(AdminFlag) == sizeof(cell_t))
   425 	{
   426 		return adminsys->FlagBitsToArray(params[1], (AdminFlag *)addr, params[3]);
   427 	} else {
   428 		AdminFlag flags[AdminFlags_TOTAL];
   429 		unsigned int num = ((unsigned)params[2] > AdminFlags_TOTAL ? AdminFlags_TOTAL : params[2]);
   430 		num = adminsys->FlagBitsToArray(params[1], flags, num);
   431 
   432 		for (unsigned int i=0; i<num; i++)
   433 		{
   434 			addr[i] = flags[i];
   435 		}
   436 
   437 		return num;
   438 	}
   439 }
   440 
   441 static cell_t CanAdminTarget(IPluginContext *pContext, const cell_t *params)
   442 {
   443 	return adminsys->CanAdminTarget(params[1], params[2]) ? 1 : 0;
   444 }
   445 
   446 static cell_t CreateAuthMethod(IPluginContext *pContext, const cell_t *params)
   447 {
   448 	char *name;
   449 	pContext->LocalToString(params[1], &name);
   450 	adminsys->RegisterAuthIdentType(name);
   451 
   452 	return 1;
   453 }
   454 
   455 static cell_t SetAdmGroupImmunityLevel(IPluginContext *pContext, const cell_t *params)
   456 {
   457 	return adminsys->SetGroupImmunityLevel(params[1], params[2]);
   458 }
   459 
   460 static cell_t GetAdmGroupImmunityLevel(IPluginContext *pContext, const cell_t *params)
   461 {
   462 	return adminsys->GetGroupImmunityLevel(params[1]);
   463 }
   464 
   465 static cell_t SetAdminImmunityLevel(IPluginContext *pContext, const cell_t *params)
   466 {
   467 	return adminsys->SetAdminImmunityLevel(params[1], params[2]);
   468 }
   469 
   470 static cell_t GetAdminImmunityLevel(IPluginContext *pContext, const cell_t *params)
   471 {
   472 	return adminsys->GetAdminImmunityLevel(params[1]);
   473 }
   474 
   475 static cell_t FindFlagByName(IPluginContext *pContext, const cell_t *params)
   476 {
   477 	char *flag;
   478 	pContext->LocalToString(params[1], &flag);
   479 
   480 	cell_t *addr;
   481 	pContext->LocalToPhysAddr(params[2], &addr);
   482 
   483 	AdminFlag admflag;
   484 	if (!adminsys->FindFlag(flag, &admflag))
   485 	{
   486 		return 0;
   487 	}
   488 
   489 	*addr = (cell_t)admflag;
   490 
   491 	return 1;
   492 }
   493 
   494 static cell_t FindFlagByChar(IPluginContext *pContext, const cell_t *params)
   495 {
   496 	cell_t *addr;
   497 	pContext->LocalToPhysAddr(params[2], &addr);
   498 
   499 	AdminFlag admflag;
   500 	if (!adminsys->FindFlag((char)params[1], &admflag))
   501 	{
   502 		return 0;
   503 	}
   504 
   505 	*addr = (cell_t)admflag;
   506 
   507 	return 1;
   508 }
   509 
   510 static cell_t ReadFlagString(IPluginContext *pContext, const cell_t *params)
   511 {
   512 	char *flag;
   513 	pContext->LocalToString(params[1], &flag);
   514 
   515 	cell_t *addr;
   516 	pContext->LocalToPhysAddr(params[2], &addr);
   517 
   518 	const char *end = flag;
   519 	FlagBits bits = adminsys->ReadFlagString(flag, &end);
   520 
   521 	*addr = end - flag;
   522 
   523 	return bits;
   524 }
   525 
   526 REGISTER_NATIVES(adminNatives)
   527 {
   528 	{"DumpAdminCache",			DumpAdminCache},
   529 	{"AddCommandOverride",		AddCommandOverride},
   530 	{"GetCommandOverride",		GetCommandOverride},
   531 	{"UnsetCommandOverride",	UnsetCommandOverride},
   532 	{"CreateAdmGroup",			CreateAdmGroup},
   533 	{"FindAdmGroup",			FindAdmGroup},
   534 	{"SetAdmGroupAddFlag",		SetAdmGroupAddFlag},
   535 	{"GetAdmGroupAddFlag",		GetAdmGroupAddFlag},
   536 	{"SetAdmGroupImmunity",		SetAdmGroupImmunity},
   537 	{"GetAdmGroupImmunity",		GetAdmGroupImmunity},
   538 	{"SetAdmGroupImmuneFrom",	SetAdmGroupImmuneFrom},
   539 	{"GetAdmGroupImmuneFrom",	GetAdmGroupImmuneFrom},
   540 	{"GetAdmGroupImmuneCount",	GetAdmGroupImmuneCount},
   541 	{"AddAdmGroupCmdOverride",	AddAdmGroupCmdOverride},
   542 	{"GetAdmGroupCmdOverride",	GetAdmGroupCmdOverride},
   543 	{"GetAdmGroupAddFlags",		GetAdmGroupAddFlags},
   544 	{"RegisterAuthIdentType",	RegisterAuthIdentType},
   545 	{"CreateAdmin",				CreateAdmin},
   546 	{"GetAdminUsername",		GetAdminUsername},
   547 	{"BindAdminIdentity",		BindAdminIdentity},
   548 	{"SetAdminFlag",			SetAdminFlag},
   549 	{"GetAdminFlag",			GetAdminFlag},
   550 	{"GetAdminFlags",			GetAdminFlags},
   551 	{"AdminInheritGroup",		AdminInheritGroup},
   552 	{"GetAdminGroupCount",		GetAdminGroupCount},
   553 	{"GetAdminGroup",			GetAdminGroup},
   554 	{"SetAdminPassword",		SetAdminPassword},
   555 	{"GetAdminPassword",		GetAdminPassword},
   556 	{"FindAdminByIdentity",		FindAdminByIdentity},
   557 	{"RemoveAdmin",				RemoveAdmin},
   558 	{"FlagBitsToBitArray",		FlagBitsToBitArray},
   559 	{"FlagBitArrayToBits",		FlagBitArrayToBits},
   560 	{"FlagArrayToBits",			FlagArrayToBits},
   561 	{"FlagBitsToArray",			FlagBitsToArray},
   562 	{"CanAdminTarget",			CanAdminTarget},
   563 	{"CreateAuthMethod",		CreateAuthMethod},
   564 	{"FindFlagByName",			FindFlagByName},
   565 	{"FindFlagByChar",			FindFlagByChar},
   566 	{"ReadFlagString",			ReadFlagString},
   567 	{"GetAdmGroupImmunityLevel",GetAdmGroupImmunityLevel},
   568 	{"SetAdmGroupImmunityLevel",SetAdmGroupImmunityLevel},
   569 	{"GetAdminImmunityLevel",	GetAdminImmunityLevel},
   570 	{"SetAdminImmunityLevel",	SetAdminImmunityLevel},
   571 	/* -------------------------------------------------- */
   572 	{NULL,						NULL},
   573 };
   574
sourcemod-central
Feed