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