Home - sourcemod-central - file revision - core/smn_admin.cpp@ecbaee393b0b 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>
Mon Oct 15 00:38:25 2007 +0000 (2007-10-15)
changeset 1568 ecbaee393b0b
parent 1403 ecb9c66fd4bb
child 1947 e73a1e51833b
permissions -rw-r--r--
extensions can now be built for multiple engines, and will autoload from auto.X.Y folders 
     1 /**
     2  * vim: set ts=4 :
     3  * =============================================================================
     4  * SourceMod
     5  * Copyright (C) 2004-2007 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 "sm_globals.h"
    33 #include "AdminCache.h"
    34 #include "ForwardSys.h"
    35 
    36 static cell_t DumpAdminCache(IPluginContext *pContext, const cell_t *params)
    37 {
    38 	g_Admins.DumpAdminCache((AdminCachePart)params[1], (params[2] == 1) ? true : false);
    39 	return 1;
    40 }
    41 
    42 static cell_t AddCommandOverride(IPluginContext *pContext, const cell_t *params)
    43 {
    44 	char *str;
    45 
    46 	pContext->LocalToString(params[1], &str);
    47 	g_Admins.AddCommandOverride(str, (OverrideType)params[2], (AdminFlag)params[3]);
    48 
    49 	return 1;
    50 }
    51 
    52 static cell_t GetCommandOverride(IPluginContext *pContext, const cell_t *params)
    53 {
    54 	char *cmd;
    55 	FlagBits flags;
    56 
    57 	pContext->LocalToString(params[1], &cmd);
    58 
    59 	if (!g_Admins.GetCommandOverride(cmd, (OverrideType)params[2], &flags))
    60 	{
    61 		return 0;
    62 	}
    63 
    64 	cell_t *addr;
    65 	pContext->LocalToPhysAddr(params[3], &addr);
    66 
    67 	*addr = (cell_t)flags;
    68 
    69 	return 1;
    70 }
    71 
    72 static cell_t UnsetCommandOverride(IPluginContext *pContext, const cell_t *params)
    73 {
    74 	char *cmd;
    75 
    76 	pContext->LocalToString(params[1], &cmd);
    77 
    78 	g_Admins.UnsetCommandOverride(cmd, (OverrideType)params[2]);
    79 
    80 	return 1;
    81 }
    82 
    83 static cell_t CreateAdmGroup(IPluginContext *pContext, const cell_t *params)
    84 {
    85 	char *str;
    86 
    87 	pContext->LocalToString(params[1], &str);
    88 
    89 	return g_Admins.AddGroup(str);
    90 }
    91 
    92 static cell_t FindAdmGroup(IPluginContext *pContext, const cell_t *params)
    93 {
    94 	char *str;
    95 
    96 	pContext->LocalToString(params[1], &str);
    97 
    98 	return g_Admins.FindGroupByName(str);
    99 }
   100 
   101 static cell_t SetAdmGroupAddFlag(IPluginContext *pContext, const cell_t *params)
   102 {
   103 	GroupId id = (GroupId)params[1];
   104 	AdminFlag flag = (AdminFlag)params[2];
   105 	bool enabled = params[3] ? 1 : 0;
   106 
   107 	g_Admins.SetGroupAddFlag(id, flag, enabled);
   108 
   109 	return 1;
   110 }
   111 
   112 static cell_t GetAdmGroupAddFlag(IPluginContext *pContext, const cell_t *params)
   113 {
   114 	GroupId id = (GroupId)params[1];
   115 	AdminFlag flag = (AdminFlag)params[2];
   116 	
   117 	return g_Admins.GetGroupAddFlag(id, flag) ? 1 : 0;
   118 }
   119 
   120 static cell_t SetAdmGroupImmunity(IPluginContext *pContext, const cell_t *params)
   121 {
   122 	GroupId id = (GroupId)params[1];
   123 	ImmunityType type = (ImmunityType)params[2];
   124 	bool enabled = params[3] ? 1 : 0;
   125 
   126 	g_Admins.SetGroupGenericImmunity(id, type, enabled);
   127 
   128 	return 1;
   129 }
   130 
   131 static cell_t GetAdmGroupImmunity(IPluginContext *pContext, const cell_t *params)
   132 {
   133 	GroupId id = (GroupId)params[1];
   134 	ImmunityType type = (ImmunityType)params[2];
   135 
   136 	return g_Admins.GetGroupGenericImmunity(id, type) ? 1 : 0;
   137 }
   138 
   139 static cell_t SetAdmGroupImmuneFrom(IPluginContext *pContext, const cell_t *params)
   140 {
   141 	GroupId id = (GroupId)params[1];
   142 	GroupId other_id = (GroupId)params[2];
   143 
   144 	g_Admins.AddGroupImmunity(id, other_id);
   145 
   146 	return 1;
   147 }
   148 
   149 static cell_t GetAdmGroupImmuneCount(IPluginContext *pContext, const cell_t *params)
   150 {
   151 	GroupId id = (GroupId)params[1];
   152 
   153 	return g_Admins.GetGroupImmunityCount(id);
   154 }
   155 
   156 static cell_t GetAdmGroupImmuneFrom(IPluginContext *pContext, const cell_t *params)
   157 {
   158 	GroupId id = (GroupId)params[1];
   159 
   160 	return g_Admins.GetGroupImmunity(id, params[2]);
   161 }
   162 
   163 static cell_t AddAdmGroupCmdOverride(IPluginContext *pContext, const cell_t *params)
   164 {
   165 	GroupId id = (GroupId)params[1];
   166 	OverrideType type = (OverrideType)params[3];
   167 	OverrideRule rule = (OverrideRule)params[4];
   168 	char *cmd;
   169 
   170 	pContext->LocalToString(params[2], &cmd);
   171 
   172 	g_Admins.AddGroupCommandOverride(id, cmd, type, rule);
   173 
   174 	return 1;
   175 }
   176 
   177 static cell_t GetAdmGroupCmdOverride(IPluginContext *pContext, const cell_t *params)
   178 {
   179 	GroupId id = (GroupId)params[1];
   180 	OverrideType type = (OverrideType)params[3];
   181 	OverrideRule rule;
   182 	char *cmd;
   183 
   184 	pContext->LocalToString(params[2], &cmd);
   185 
   186 	if (!g_Admins.GetGroupCommandOverride(id, cmd, type, &rule))
   187 	{
   188 		return 0;
   189 	}
   190 
   191 	cell_t *addr;
   192 	pContext->LocalToPhysAddr(params[4], &addr);
   193 	*addr = (cell_t)rule;
   194 
   195 	return 1;
   196 }
   197 
   198 static cell_t GetAdmGroupAddFlags(IPluginContext *pContext, const cell_t *params)
   199 {
   200 	GroupId id = (GroupId)params[1];
   201 	return g_Admins.GetGroupAddFlags(id);
   202 }
   203 
   204 static cell_t RegisterAuthIdentType(IPluginContext *pContext, const cell_t *params)
   205 {
   206 	char *type;
   207 	pContext->LocalToString(params[1], &type);
   208 
   209 	g_Admins.RegisterAuthIdentType(type);
   210 
   211 	return 1;
   212 }
   213 
   214 static cell_t CreateAdmin(IPluginContext *pContext, const cell_t *params)
   215 {
   216 	char *admin;
   217 	pContext->LocalToString(params[1], &admin);
   218 
   219 	if (admin[0] == '\0')
   220 	{
   221 		admin = NULL;
   222 	}
   223 
   224 	return g_Admins.CreateAdmin(admin);
   225 }
   226 
   227 static cell_t GetAdminUsername(IPluginContext *pContext, const cell_t *params)
   228 {
   229 	AdminId id = params[1];
   230 	size_t written;
   231 	const char *name = g_Admins.GetAdminName(id);
   232 
   233 	if (!name)
   234 	{
   235 		return 0;
   236 	}
   237 
   238 	pContext->StringToLocalUTF8(params[2], params[3], name, &written);
   239 
   240 	return written;
   241 }
   242 
   243 static cell_t BindAdminIdentity(IPluginContext *pContext, const cell_t *params)
   244 {
   245 	AdminId id = params[1];
   246 	char *auth, *ident;
   247 
   248 	pContext->LocalToString(params[2], &auth);
   249 	pContext->LocalToString(params[3], &ident);
   250 
   251 	return g_Admins.BindAdminIdentity(id, auth, ident);
   252 }
   253 
   254 static cell_t SetAdminFlag(IPluginContext *pContext, const cell_t *params)
   255 {
   256 	AdminId id = params[1];
   257 	AdminFlag flag = (AdminFlag)params[2];
   258 	bool enabled = params[3] ? true : false;
   259 
   260 	g_Admins.SetAdminFlag(id, flag, enabled);
   261 
   262 	return 1;
   263 }
   264 
   265 static cell_t GetAdminFlag(IPluginContext *pContext, const cell_t *params)
   266 {
   267 	AdminId id = params[1];
   268 	AdminFlag flag = (AdminFlag)params[2];
   269 	AccessMode mode = (AccessMode)params[3];
   270 
   271 	return g_Admins.GetAdminFlag(id, flag, mode);
   272 }
   273 
   274 static cell_t GetAdminFlags(IPluginContext *pContext, const cell_t *params)
   275 {
   276 	AdminId id = params[1];
   277 	AccessMode mode = (AccessMode)params[2];
   278 
   279 	return g_Admins.GetAdminFlags(id, mode);
   280 }
   281 
   282 static cell_t AdminInheritGroup(IPluginContext *pContext, const cell_t *params)
   283 {
   284 	AdminId id = params[1];
   285 	GroupId gid = params[2];
   286 
   287 	return g_Admins.AdminInheritGroup(id, gid);
   288 }
   289 
   290 static cell_t GetAdminGroupCount(IPluginContext *pContext, const cell_t *params)
   291 {
   292 	AdminId id = params[1];
   293 
   294 	return g_Admins.GetAdminGroupCount(id);
   295 }
   296 
   297 static cell_t GetAdminGroup(IPluginContext *pContext, const cell_t *params)
   298 {
   299 	AdminId id = params[1];
   300 	unsigned int index = params[2];
   301 	const char *name;
   302 	GroupId gid;
   303 
   304 	if ((gid=g_Admins.GetAdminGroup(id, index, &name)) == INVALID_GROUP_ID)
   305 	{
   306 		return gid;
   307 	}
   308 
   309 	if (name == NULL)
   310 	{
   311 		name = "";
   312 	}
   313 
   314 	pContext->StringToLocalUTF8(params[3], params[4], name, NULL);
   315 
   316 	return gid;
   317 }
   318 
   319 static cell_t SetAdminPassword(IPluginContext *pContext, const cell_t *params)
   320 {
   321 	AdminId id = params[1];
   322 	char *password;
   323 
   324 	pContext->LocalToString(params[2], &password);
   325 
   326 	g_Admins.SetAdminPassword(id, password);
   327 
   328 	return 1;
   329 }
   330 
   331 static cell_t GetAdminPassword(IPluginContext *pContext, const cell_t *params)
   332 {
   333 	AdminId id = params[1];
   334 	const char *password = g_Admins.GetAdminPassword(id);
   335 
   336 	if (!password)
   337 	{
   338 		return 0;
   339 	}
   340 
   341 	pContext->StringToLocalUTF8(params[2], params[3], password, NULL);
   342 
   343 	return 1;
   344 }
   345 
   346 static cell_t FindAdminByIdentity(IPluginContext *pContext, const cell_t *params)
   347 {
   348 	char *auth, *ident;
   349 
   350 	pContext->LocalToString(params[1], &auth);
   351 	pContext->LocalToString(params[2], &ident);
   352 
   353 	return g_Admins.FindAdminByIdentity(auth, ident);
   354 }
   355 
   356 static cell_t RemoveAdmin(IPluginContext *pContext, const cell_t *params)
   357 {
   358 	AdminId id = params[1];
   359 
   360 	return g_Admins.InvalidateAdmin(id);
   361 }
   362 
   363 static cell_t FlagBitsToBitArray(IPluginContext *pContext, const cell_t *params)
   364 {
   365 	FlagBits bits = (FlagBits)params[1];
   366 	bool array[AdminFlags_TOTAL];
   367 	cell_t *addr;
   368 	unsigned int numWr = g_Admins.FlagBitsToBitArray(bits, array, AdminFlags_TOTAL);
   369 
   370 	pContext->LocalToPhysAddr(params[2], &addr);
   371 
   372 	unsigned int i;
   373 	for (i=0; i<numWr && i<(unsigned int)params[3]; i++)
   374 	{
   375 		addr[i] = array[i] ? 1 : 0;
   376 	}
   377 
   378 	return i;
   379 }
   380 
   381 static cell_t FlagBitArrayToBits(IPluginContext *pContext, const cell_t *params)
   382 {
   383 	bool array[AdminFlags_TOTAL];
   384 	unsigned int num = ((unsigned int)params[2] > AdminFlags_TOTAL ? params[2] : AdminFlags_TOTAL);
   385 	cell_t *addr;
   386 
   387 	pContext->LocalToPhysAddr(params[1], &addr);
   388 
   389 	for (unsigned int i=0; i<num; i++)
   390 	{
   391 		array[i] = addr[i] ? true : false;
   392 	}
   393 
   394 	return g_Admins.FlagBitArrayToBits(array, num);
   395 }
   396 
   397 static cell_t FlagArrayToBits(IPluginContext *pContext, const cell_t *params)
   398 {
   399 	cell_t *addr;
   400 	pContext->LocalToPhysAddr(params[1], &addr);
   401 
   402 	if (sizeof(AdminFlag) == sizeof(cell_t))
   403 	{
   404 		return g_Admins.FlagArrayToBits((const AdminFlag *)addr, params[2]);
   405 	} else {
   406 		AdminFlag flags[AdminFlags_TOTAL];
   407 		unsigned int num = ((unsigned)params[2] > AdminFlags_TOTAL ? AdminFlags_TOTAL : params[2]);
   408 
   409 		for (unsigned int i=0; i<num; i++)
   410 		{
   411 			flags[i] = (AdminFlag)addr[i];
   412 		}
   413 		return g_Admins.FlagArrayToBits(flags, num);
   414 	}
   415 }
   416 
   417 static cell_t FlagBitsToArray(IPluginContext *pContext, const cell_t *params)
   418 {
   419 	cell_t *addr;
   420 	pContext->LocalToPhysAddr(params[2], &addr);
   421 
   422 	if (sizeof(AdminFlag) == sizeof(cell_t))
   423 	{
   424 		return g_Admins.FlagBitsToArray(params[1], (AdminFlag *)addr, params[3]);
   425 	} else {
   426 		AdminFlag flags[AdminFlags_TOTAL];
   427 		unsigned int num = ((unsigned)params[2] > AdminFlags_TOTAL ? AdminFlags_TOTAL : params[2]);
   428 		num = g_Admins.FlagBitsToArray(params[1], flags, num);
   429 
   430 		for (unsigned int i=0; i<num; i++)
   431 		{
   432 			addr[i] = flags[i];
   433 		}
   434 
   435 		return num;
   436 	}
   437 }
   438 
   439 static cell_t CanAdminTarget(IPluginContext *pContext, const cell_t *params)
   440 {
   441 	return g_Admins.CanAdminTarget(params[1], params[2]) ? 1 : 0;
   442 }
   443 
   444 static cell_t CreateAuthMethod(IPluginContext *pContext, const cell_t *params)
   445 {
   446 	char *name;
   447 	pContext->LocalToString(params[1], &name);
   448 	g_Admins.RegisterAuthIdentType(name);
   449 
   450 	return 1;
   451 }
   452 
   453 static cell_t SetAdmGroupImmunityLevel(IPluginContext *pContext, const cell_t *params)
   454 {
   455 	return g_Admins.SetGroupImmunityLevel(params[1], params[2]);
   456 }
   457 
   458 static cell_t GetAdmGroupImmunityLevel(IPluginContext *pContext, const cell_t *params)
   459 {
   460 	return g_Admins.GetGroupImmunityLevel(params[1]);
   461 }
   462 
   463 static cell_t SetAdminImmunityLevel(IPluginContext *pContext, const cell_t *params)
   464 {
   465 	return g_Admins.SetAdminImmunityLevel(params[1], params[2]);
   466 }
   467 
   468 static cell_t GetAdminImmunityLevel(IPluginContext *pContext, const cell_t *params)
   469 {
   470 	return g_Admins.GetAdminImmunityLevel(params[1]);
   471 }
   472 
   473 static cell_t FindFlagByName(IPluginContext *pContext, const cell_t *params)
   474 {
   475 	char *flag;
   476 	pContext->LocalToString(params[1], &flag);
   477 
   478 	cell_t *addr;
   479 	pContext->LocalToPhysAddr(params[2], &addr);
   480 
   481 	AdminFlag admflag;
   482 	if (!g_Admins.FindFlag(flag, &admflag))
   483 	{
   484 		return 0;
   485 	}
   486 
   487 	*addr = (cell_t)admflag;
   488 
   489 	return 1;
   490 }
   491 
   492 static cell_t FindFlagByChar(IPluginContext *pContext, const cell_t *params)
   493 {
   494 	cell_t *addr;
   495 	pContext->LocalToPhysAddr(params[2], &addr);
   496 
   497 	AdminFlag admflag;
   498 	if (!g_Admins.FindFlag((char)params[1], &admflag))
   499 	{
   500 		return 0;
   501 	}
   502 
   503 	*addr = (cell_t)admflag;
   504 
   505 	return 1;
   506 }
   507 
   508 static cell_t ReadFlagString(IPluginContext *pContext, const cell_t *params)
   509 {
   510 	char *flag;
   511 	pContext->LocalToString(params[1], &flag);
   512 
   513 	cell_t *addr;
   514 	pContext->LocalToPhysAddr(params[2], &addr);
   515 
   516 	const char *end = flag;
   517 	FlagBits bits = g_Admins.ReadFlagString(flag, &end);
   518 
   519 	*addr = end - flag;
   520 
   521 	return bits;
   522 }
   523 
   524 REGISTER_NATIVES(adminNatives)
   525 {
   526 	{"DumpAdminCache",			DumpAdminCache},
   527 	{"AddCommandOverride",		AddCommandOverride},
   528 	{"GetCommandOverride",		GetCommandOverride},
   529 	{"UnsetCommandOverride",	UnsetCommandOverride},
   530 	{"CreateAdmGroup",			CreateAdmGroup},
   531 	{"FindAdmGroup",			FindAdmGroup},
   532 	{"SetAdmGroupAddFlag",		SetAdmGroupAddFlag},
   533 	{"GetAdmGroupAddFlag",		GetAdmGroupAddFlag},
   534 	{"SetAdmGroupImmunity",		SetAdmGroupImmunity},
   535 	{"GetAdmGroupImmunity",		GetAdmGroupImmunity},
   536 	{"SetAdmGroupImmuneFrom",	SetAdmGroupImmuneFrom},
   537 	{"GetAdmGroupImmuneFrom",	GetAdmGroupImmuneFrom},
   538 	{"GetAdmGroupImmuneCount",	GetAdmGroupImmuneCount},
   539 	{"AddAdmGroupCmdOverride",	AddAdmGroupCmdOverride},
   540 	{"GetAdmGroupCmdOverride",	GetAdmGroupCmdOverride},
   541 	{"GetAdmGroupAddFlags",		GetAdmGroupAddFlags},
   542 	{"RegisterAuthIdentType",	RegisterAuthIdentType},
   543 	{"CreateAdmin",				CreateAdmin},
   544 	{"GetAdminUsername",		GetAdminUsername},
   545 	{"BindAdminIdentity",		BindAdminIdentity},
   546 	{"SetAdminFlag",			SetAdminFlag},
   547 	{"GetAdminFlag",			GetAdminFlag},
   548 	{"GetAdminFlags",			GetAdminFlags},
   549 	{"AdminInheritGroup",		AdminInheritGroup},
   550 	{"GetAdminGroupCount",		GetAdminGroupCount},
   551 	{"GetAdminGroup",			GetAdminGroup},
   552 	{"SetAdminPassword",		SetAdminPassword},
   553 	{"GetAdminPassword",		GetAdminPassword},
   554 	{"FindAdminByIdentity",		FindAdminByIdentity},
   555 	{"RemoveAdmin",				RemoveAdmin},
   556 	{"FlagBitsToBitArray",		FlagBitsToBitArray},
   557 	{"FlagBitArrayToBits",		FlagBitArrayToBits},
   558 	{"FlagArrayToBits",			FlagArrayToBits},
   559 	{"FlagBitsToArray",			FlagBitsToArray},
   560 	{"CanAdminTarget",			CanAdminTarget},
   561 	{"CreateAuthMethod",		CreateAuthMethod},
   562 	{"FindFlagByName",			FindFlagByName},
   563 	{"FindFlagByChar",			FindFlagByChar},
   564 	{"ReadFlagString",			ReadFlagString},
   565 	{"GetAdmGroupImmunityLevel",GetAdmGroupImmunityLevel},
   566 	{"SetAdmGroupImmunityLevel",SetAdmGroupImmunityLevel},
   567 	{"GetAdminImmunityLevel",	GetAdminImmunityLevel},
   568 	{"SetAdminImmunityLevel",	SetAdminImmunityLevel},
   569 	/* -------------------------------------------------- */
   570 	{NULL,						NULL},
   571 };
   572
sourcemod-central
Feed