/addons/sourcemod/scripting/admin-sql-threaded.sp

https://bitbucket.org/kimoto/sushi · Unknown · 857 lines · 735 code · 122 blank · 0 comment · 0 complexity · 4e8ad4dacfbf1fa505f906ee6cc1e7e5 MD5 · raw file 

    

  1. /**

    2. 

  2.  * vim: set ts=4 :

    3. 

  3.  * =============================================================================

    4. 

  4.  * SourceMod SQL Admins Plugin (Threaded)

    5. 

  5.  * Fetches admins from an SQL database dynamically.

    6. 

  6.  *

    7. 

  7.  * SourceMod (C)2004-2008 AlliedModders LLC.  All rights reserved.

    8. 

  8.  * =============================================================================

    9. 

  9.  *

    10. 

  10.  * This program is free software; you can redistribute it and/or modify it under

    11. 

  11.  * the terms of the GNU General Public License, version 3.0, as published by the

    12. 

  12.  * Free Software Foundation.

    13. 

  13.  * 

    14. 

  14.  * This program is distributed in the hope that it will be useful, but WITHOUT

    15. 

  15.  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

    16. 

  16.  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more

    17. 

  17.  * details.

    18. 

  18.  *

    19. 

  19.  * You should have received a copy of the GNU General Public License along with

    20. 

  20.  * this program.  If not, see <http://www.gnu.org/licenses/>.

    21. 

  21.  *

    22. 

  22.  * As a special exception, AlliedModders LLC gives you permission to link the

    23. 

  23.  * code of this program (as well as its derivative works) to "Half-Life 2," the

    24. 

  24.  * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software

    25. 

  25.  * by the Valve Corporation.  You must obey the GNU General Public License in

    26. 

  26.  * all respects for all other code used.  Additionally, AlliedModders LLC grants

    27. 

  27.  * this exception to all derivative works.  AlliedModders LLC defines further

    28. 

  28.  * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),

    29. 

  29.  * or <http://www.sourcemod.net/license.php>.

    30. 

  30.  *

    31. 

  31.  * Version: $Id$

    32. 

  32.  */

    33. 

  33. 

    34. 

  34. /* We like semicolons */

    35. 

  35. #pragma semicolon 1

    36. 

  36. 

    37. 

  37. #include <sourcemod>

    38. 

  38. 

    39. 

  39. public Plugin:myinfo = 

    40. 

  40. {

    41. 

  41. 	name = "SQL Admins (Threaded)",

    42. 

  42. 	author = "AlliedModders LLC",

    43. 

  43. 	description = "Reads admins from SQL dynamically",

    44. 

  44. 	version = SOURCEMOD_VERSION,

    45. 

  45. 	url = "http://www.sourcemod.net/"

    46. 

  46. };

    47. 

  47. 

    48. 

  48. /**

    49. 

  49.  * Notes:

    50. 

  50.  *

    51. 

  51.  * 1) All queries in here are high priority.  This is because the admin stuff 

    52. 

  52.  *    is very important.  Do not take this to mean that in your script, 

    53. 

  53.  *    everything should be high priority.  

    54. 

  54.  *

    55. 

  55.  * 2) All callbacks are locked with "sequence numbers."  This is to make sure 

    56. 

  56.  *    that multiple calls to sm_reloadadmins and the like do not make us 

    57. 

  57.  *    store the results from two or more callbacks accidentally.  Instead, we 

    58. 

  58.  *    check the sequence number in each callback with the current "allowed" 

    59. 

  59.  *    sequence number, and if it doesn't match, the callback is cancelled.

    60. 

  60.  *

    61. 

  61.  * 3) Sequence numbers for groups and overrides are not cleared unless there 

    62. 

  62.  *    was a 100% success in the fetch.  This is so we can potentially implement 

    63. 

  63.  *    connection retries in the future.

    64. 

  64.  *

    65. 

  65.  * 4) Sequence numbers for the user cache are ignored except for being 

    66. 

  66.  *    non-zero, which means players in-game should be re-checked for admin 

    67. 

  67.  *    powers.

    68. 

  68.  */

    69. 

  69. 

    70. 

  70. new Handle:hDatabase = INVALID_HANDLE;			/** Database connection */

    71. 

  71. new g_sequence = 0;								/** Global unique sequence number */

    72. 

  72. new ConnectLock = 0;							/** Connect sequence number */

    73. 

  73. new RebuildCachePart[3] = {0};					/** Cache part sequence numbers */

    74. 

  74. new PlayerSeq[MAXPLAYERS+1];					/** Player-specific sequence numbers */

    75. 

  75. new bool:PlayerAuth[MAXPLAYERS+1];				/** Whether a player has been "pre-authed" */

    76. 

  76. 

    77. 

  77. //#define _DEBUG

    78. 

  78. 

    79. 

  79. public OnMapEnd()

    80. 

  80. {

    81. 

  81. 	/**

    82. 

  82. 	 * Clean up on map end just so we can start a fresh connection when we need it later.

    83. 

  83. 	 */

    84. 

  84. 	if (hDatabase != INVALID_HANDLE)

    85. 

  85. 	{

    86. 

  86. 		CloseHandle(hDatabase);

    87. 

  87. 		hDatabase = INVALID_HANDLE;

    88. 

  88. 	}

    89. 

  89. }

    90. 

  90. 

    91. 

  91. public bool:OnClientConnect(client, String:rejectmsg[], maxlen)

    92. 

  92. {

    93. 

  93. 	PlayerSeq[client] = 0;

    94. 

  94. 	PlayerAuth[client] = false;

    95. 

  95. 	return true;

    96. 

  96. }

    97. 

  97. 

    98. 

  98. public OnClientDisconnect(client)

    99. 

  99. {

    100. 

  100. 	PlayerSeq[client] = 0;

    101. 

  101. 	PlayerAuth[client] = false;

    102. 

  102. }

    103. 

  103. 

    104. 

  104. public OnDatabaseConnect(Handle:owner, Handle:hndl, const String:error[], any:data)

    105. 

  105. {

    106. 

  106. #if defined _DEBUG

    107. 

  107. 	PrintToServer("OnDatabaseConnect(%x,%x,%d) ConnectLock=%d", owner, hndl, data, ConnectLock);

    108. 

  108. #endif

    109. 

  109. 

    110. 

  110. 	/**

    111. 

  111. 	 * If this happens to be an old connection request, ignore it.

    112. 

  112. 	 */

    113. 

  113. 	if (data != ConnectLock || hDatabase != INVALID_HANDLE)

    114. 

  114. 	{

    115. 

  115. 		if (hndl != INVALID_HANDLE)

    116. 

  116. 		{

    117. 

  117. 			CloseHandle(hndl);

    118. 

  118. 		}

    119. 

  119. 		return;

    120. 

  120. 	}

    121. 

  121. 	

    122. 

  122. 	ConnectLock = 0;

    123. 

  123. 	hDatabase = hndl;

    124. 

  124. 	

    125. 

  125. 	/**

    126. 

  126. 	 * See if the connection is valid.  If not, don't un-mark the caches

    127. 

  127. 	 * as needing rebuilding, in case the next connection request works.

    128. 

  128. 	 */

    129. 

  129. 	if (hDatabase == INVALID_HANDLE)

    130. 

  130. 	{

    131. 

  131. 		LogError("Failed to connect to database: %s", error);

    132. 

  132. 		return;

    133. 

  133. 	}

    134. 

  134. 	

    135. 

  135. 	/**

    136. 

  136. 	 * See if we need to get any of the cache stuff now.

    137. 

  137. 	 */

    138. 

  138. 	new sequence;

    139. 

  139. 	if ((sequence = RebuildCachePart[_:AdminCache_Overrides]) != 0)

    140. 

  140. 	{

    141. 

  141. 		FetchOverrides(hDatabase, sequence);

    142. 

  142. 	}

    143. 

  143. 	if ((sequence = RebuildCachePart[_:AdminCache_Groups]) != 0)

    144. 

  144. 	{

    145. 

  145. 		FetchGroups(hDatabase, sequence);

    146. 

  146. 	}

    147. 

  147. 	if ((sequence = RebuildCachePart[_:AdminCache_Admins]) != 0)

    148. 

  148. 	{

    149. 

  149. 		FetchUsersWeCan(hDatabase);

    150. 

  150. 	}

    151. 

  151. }

    152. 

  152. 

    153. 

  153. RequestDatabaseConnection()

    154. 

  154. {

    155. 

  155. 	ConnectLock = ++g_sequence;

    156. 

  156. 	if (SQL_CheckConfig("admins"))

    157. 

  157. 	{

    158. 

  158. 		SQL_TConnect(OnDatabaseConnect, "admins", ConnectLock);

    159. 

  159. 	} else {

    160. 

  160. 		SQL_TConnect(OnDatabaseConnect, "default", ConnectLock);

    161. 

  161. 	}

    162. 

  162. }

    163. 

  163. 

    164. 

  164. public OnRebuildAdminCache(AdminCachePart:part)

    165. 

  165. {

    166. 

  166. 	/**

    167. 

  167. 	 * Mark this part of the cache as being rebuilt.  This is used by the 

    168. 

  168. 	 * callback system to determine whether the results should still be 

    169. 

  169. 	 * used.

    170. 

  170. 	 */

    171. 

  171. 	new sequence = ++g_sequence;

    172. 

  172. 	RebuildCachePart[_:part] = sequence;

    173. 

  173. 	

    174. 

  174. 	/**

    175. 

  175. 	 * If we don't have a database connection, we can't do any lookups just yet.

    176. 

  176. 	 */

    177. 

  177. 	if (!hDatabase)

    178. 

  178. 	{

    179. 

  179. 		/**

    180. 

  180. 		 * Ask for a new connection if we need it.

    181. 

  181. 		 */

    182. 

  182. 		if (!ConnectLock)

    183. 

  183. 		{

    184. 

  184. 			RequestDatabaseConnection();

    185. 

  185. 		}

    186. 

  186. 		return;

    187. 

  187. 	}

    188. 

  188. 	

    189. 

  189. 	if (part == AdminCache_Overrides)

    190. 

  190. 	{

    191. 

  191. 		FetchOverrides(hDatabase, sequence);

    192. 

  192. 	} else if (part == AdminCache_Groups) {

    193. 

  193. 		FetchGroups(hDatabase, sequence);

    194. 

  194. 	} else if (part == AdminCache_Admins) {

    195. 

  195. 		FetchUsersWeCan(hDatabase);

    196. 

  196. 	}

    197. 

  197. }

    198. 

  198. 

    199. 

  199. public Action:OnClientPreAdminCheck(client)

    200. 

  200. {

    201. 

  201. 	PlayerAuth[client] = true;

    202. 

  202. 	

    203. 

  203. 	/**

    204. 

  204. 	 * Play nice with other plugins.  If there's no database, don't delay the 

    205. 

  205. 	 * connection process.  Unfortunately, we can't attempt anything else and 

    206. 

  206. 	 * we just have to hope either the database is waiting or someone will type 

    207. 

  207. 	 * sm_reloadadmins.

    208. 

  208. 	 */

    209. 

  209. 	if (hDatabase == INVALID_HANDLE)

    210. 

  210. 	{

    211. 

  211. 		return Plugin_Continue;

    212. 

  212. 	}

    213. 

  213. 	

    214. 

  214. 	/**

    215. 

  215. 	 * Similarly, if the cache is in the process of being rebuilt, don't delay 

    216. 

  216. 	 * the user's normal connection flow.  The database will soon auth the user 

    217. 

  217. 	 * normally.

    218. 

  218. 	 */

    219. 

  219. 	if (RebuildCachePart[_:AdminCache_Admins] != 0)

    220. 

  220. 	{

    221. 

  221. 		return Plugin_Continue;

    222. 

  222. 	}

    223. 

  223. 	

    224. 

  224. 	/**

    225. 

  225. 	 * If someone has already assigned an admin ID (bad bad bad), don't 

    226. 

  226. 	 * bother waiting.

    227. 

  227. 	 */

    228. 

  228. 	if (GetUserAdmin(client) != INVALID_ADMIN_ID)

    229. 

  229. 	{

    230. 

  230. 		return Plugin_Continue;

    231. 

  231. 	}

    232. 

  232. 	

    233. 

  233. 	FetchUser(hDatabase, client);

    234. 

  234. 	

    235. 

  235. 	return Plugin_Handled;

    236. 

  236. }

    237. 

  237. 

    238. 

  238. public OnReceiveUserGroups(Handle:owner, Handle:hndl, const String:error[], any:data)

    239. 

  239. {

    240. 

  240. 	new Handle:pk = Handle:data;

    241. 

  241. 	ResetPack(pk);

    242. 

  242. 	

    243. 

  243. 	new client = ReadPackCell(pk);

    244. 

  244. 	new sequence = ReadPackCell(pk);

    245. 

  245. 	

    246. 

  246. 	/**

    247. 

  247. 	 * Make sure it's the same client.

    248. 

  248. 	 */

    249. 

  249. 	if (PlayerSeq[client] != sequence)

    250. 

  250. 	{

    251. 

  251. 		CloseHandle(pk);

    252. 

  252. 		return;

    253. 

  253. 	}

    254. 

  254. 	

    255. 

  255. 	new AdminId:adm = AdminId:ReadPackCell(pk);

    256. 

  256. 	

    257. 

  257. 	/**

    258. 

  258. 	 * Someone could have sneakily changed the admin id while we waited.

    259. 

  259. 	 */

    260. 

  260. 	if (GetUserAdmin(client) != adm)

    261. 

  261. 	{

    262. 

  262. 		NotifyPostAdminCheck(client);

    263. 

  263. 		CloseHandle(pk);

    264. 

  264. 		return;

    265. 

  265. 	}

    266. 

  266. 	

    267. 

  267. 	/**

    268. 

  268. 	 * See if we got results.

    269. 

  269. 	 */

    270. 

  270. 	if (hndl == INVALID_HANDLE)

    271. 

  271. 	{

    272. 

  272. 		decl String:query[255];

    273. 

  273. 		ReadPackString(pk, query, sizeof(query));

    274. 

  274. 		LogError("SQL error receiving user: %s", error);

    275. 

  275. 		LogError("Query dump: %s", query);

    276. 

  276. 		NotifyPostAdminCheck(client);

    277. 

  277. 		CloseHandle(pk);

    278. 

  278. 		return;

    279. 

  279. 	}

    280. 

  280. 	

    281. 

  281. 	decl String:name[80];

    282. 

  282. 	new GroupId:gid;

    283. 

  283. 	

    284. 

  284. 	while (SQL_FetchRow(hndl))

    285. 

  285. 	{

    286. 

  286. 		SQL_FetchString(hndl, 0, name, sizeof(name));

    287. 

  287. 		

    288. 

  288. 		if ((gid = FindAdmGroup(name)) == INVALID_GROUP_ID)

    289. 

  289. 		{

    290. 

  290. 			continue;

    291. 

  291. 		}

    292. 

  292. 		

    293. 

  293. #if defined _DEBUG

    294. 

  294. 		PrintToServer("Binding user group (%d, %d, %d, %s, %d)", client, sequence, adm, name, gid);

    295. 

  295. #endif

    296. 

  296. 		

    297. 

  297. 		AdminInheritGroup(adm, gid);

    298. 

  298. 	}

    299. 

  299. 	

    300. 

  300. 	/**

    301. 

  301. 	 * We're DONE! Omg.

    302. 

  302. 	 */

    303. 

  303. 	NotifyPostAdminCheck(client);

    304. 

  304. 	CloseHandle(pk);

    305. 

  305. }

    306. 

  306. 

    307. 

  307. public OnReceiveUser(Handle:owner, Handle:hndl, const String:error[], any:data)

    308. 

  308. {

    309. 

  309. 	new Handle:pk = Handle:data;

    310. 

  310. 	ResetPack(pk);

    311. 

  311. 	

    312. 

  312. 	new client = ReadPackCell(pk);

    313. 

  313. 	

    314. 

  314. 	/**

    315. 

  315. 	 * Check if this is the latest result request.

    316. 

  316. 	 */

    317. 

  317. 	new sequence = ReadPackCell(pk);

    318. 

  318. 	if (PlayerSeq[client] != sequence)

    319. 

  319. 	{

    320. 

  320. 		/* Discard everything, since we're out of sequence. */

    321. 

  321. 		CloseHandle(pk);

    322. 

  322. 		return;

    323. 

  323. 	}

    324. 

  324. 	

    325. 

  325. 	/**

    326. 

  326. 	 * If we need to use the results, make sure they succeeded.

    327. 

  327. 	 */

    328. 

  328. 	if (hndl == INVALID_HANDLE)

    329. 

  329. 	{

    330. 

  330. 		decl String:query[255];

    331. 

  331. 		ReadPackString(pk, query, sizeof(query));

    332. 

  332. 		LogError("SQL error receiving user: %s", error);

    333. 

  333. 		LogError("Query dump: %s", query);

    334. 

  334. 		RunAdminCacheChecks(client);

    335. 

  335. 		NotifyPostAdminCheck(client);

    336. 

  336. 		CloseHandle(pk);

    337. 

  337. 		return;

    338. 

  338. 	}

    339. 

  339. 	

    340. 

  340. 	new num_accounts = SQL_GetRowCount(hndl);

    341. 

  341. 	if (num_accounts == 0)

    342. 

  342. 	{

    343. 

  343. 		RunAdminCacheChecks(client);

    344. 

  344. 		NotifyPostAdminCheck(client);

    345. 

  345. 		CloseHandle(pk);

    346. 

  346. 		return;

    347. 

  347. 	}

    348. 

  348. 	

    349. 

  349. 	decl String:authtype[16];

    350. 

  350. 	decl String:identity[80];

    351. 

  351. 	decl String:password[80];

    352. 

  352. 	decl String:flags[32];

    353. 

  353. 	decl String:name[80];

    354. 

  354. 	new AdminId:adm, id;

    355. 

  355. 	new immunity;

    356. 

  356. 	

    357. 

  357. 	/**

    358. 

  358. 	 * Cache user info -- [0] = db id, [1] = cache id, [2] = groups

    359. 

  359. 	 */

    360. 

  360. 	decl user_lookup[num_accounts][3];

    361. 

  361. 	new total_users = 0;

    362. 

  362. 	

    363. 

  363. 	while (SQL_FetchRow(hndl))

    364. 

  364. 	{

    365. 

  365. 		id = SQL_FetchInt(hndl, 0);

    366. 

  366. 		SQL_FetchString(hndl, 1, authtype, sizeof(authtype));

    367. 

  367. 		SQL_FetchString(hndl, 2, identity, sizeof(identity));

    368. 

  368. 		SQL_FetchString(hndl, 3, password, sizeof(password));

    369. 

  369. 		SQL_FetchString(hndl, 4, flags, sizeof(flags));

    370. 

  370. 		SQL_FetchString(hndl, 5, name, sizeof(name));

    371. 

  371. 		immunity = SQL_FetchInt(hndl, 7);

    372. 

  372. 		

    373. 

  373. 		/* For dynamic admins we clear anything already in the cache. */

    374. 

  374. 		if ((adm = FindAdminByIdentity(authtype, identity)) != INVALID_ADMIN_ID)

    375. 

  375. 		{

    376. 

  376. 			RemoveAdmin(adm);

    377. 

  377. 		}

    378. 

  378. 		

    379. 

  379. 		adm = CreateAdmin(name);

    380. 

  380. 		if (!BindAdminIdentity(adm, authtype, identity))

    381. 

  381. 		{

    382. 

  382. 			LogError("Could not bind prefetched SQL admin (authtype \"%s\") (identity \"%s\")", authtype, identity);

    383. 

  383. 			continue;

    384. 

  384. 		}

    385. 

  385. 		

    386. 

  386. 		user_lookup[total_users][0] = id;

    387. 

  387. 		user_lookup[total_users][1] = _:adm;

    388. 

  388. 		user_lookup[total_users][2] = SQL_FetchInt(hndl, 6);

    389. 

  389. 		total_users++;

    390. 

  390. 		

    391. 

  391. #if defined _DEBUG

    392. 

  392. 		PrintToServer("Found SQL admin (%d,%s,%s,%s,%s,%s,%d):%d:%d", id, authtype, identity, password, flags, name, immunity, adm, user_lookup[total_users-1][2]);

    393. 

  393. #endif

    394. 

  394. 		

    395. 

  395. 		/* See if this admin wants a password */

    396. 

  396. 		if (password[0] != '\0')

    397. 

  397. 		{

    398. 

  398. 			SetAdminPassword(adm, password);

    399. 

  399. 		}

    400. 

  400. 

    401. 

  401. 		SetAdminImmunityLevel(adm, immunity);

    402. 

  402. 		

    403. 

  403. 		/* Apply each flag */

    404. 

  404. 		new len = strlen(flags);

    405. 

  405. 		new AdminFlag:flag;

    406. 

  406. 		for (new i=0; i<len; i++)

    407. 

  407. 		{

    408. 

  408. 			if (!FindFlagByChar(flags[i], flag))

    409. 

  409. 			{

    410. 

  410. 				continue;

    411. 

  411. 			}

    412. 

  412. 			SetAdminFlag(adm, flag, true);

    413. 

  413. 		}

    414. 

  414. 	}

    415. 

  415. 	

    416. 

  416. 	/**

    417. 

  417. 	 * Try binding the user.

    418. 

  418. 	 */	

    419. 

  419. 	new group_count = 0;

    420. 

  420. 	RunAdminCacheChecks(client);

    421. 

  421. 	adm = GetUserAdmin(client);

    422. 

  422. 	id = 0;

    423. 

  423. 	

    424. 

  424. 	

    425. 

  425. 	for (new i=0; i<total_users; i++)

    426. 

  426. 	{

    427. 

  427. 		if (user_lookup[i][1] == _:adm)

    428. 

  428. 		{

    429. 

  429. 			id = user_lookup[i][0];

    430. 

  430. 			group_count = user_lookup[i][2];

    431. 

  431. 			break;

    432. 

  432. 		}

    433. 

  433. 	}

    434. 

  434. 	

    435. 

  435. #if defined _DEBUG

    436. 

  436. 	PrintToServer("Binding client (%d, %d) resulted in: (%d, %d, %d)", client, sequence, id, adm, group_count);

    437. 

  437. #endif

    438. 

  438. 	

    439. 

  439. 	/**

    440. 

  440. 	 * If we can't verify that we assigned a database admin, or the user has no 

    441. 

  441. 	 * groups, don't bother doing anything.

    442. 

  442. 	 */

    443. 

  443. 	if (!id || !group_count)

    444. 

  444. 	{

    445. 

  445. 		NotifyPostAdminCheck(client);

    446. 

  446. 		CloseHandle(pk);

    447. 

  447. 		return;

    448. 

  448. 	}

    449. 

  449. 	

    450. 

  450. 	/**

    451. 

  451. 	 * The user has groups -- we need to fetch them!

    452. 

  452. 	 */

    453. 

  453. 	decl String:query[255];

    454. 

  454. 	Format(query, sizeof(query), "SELECT g.name FROM sm_admins_groups ag JOIN sm_groups g ON ag.group_id = g.id WHERE ag.admin_id = %d", id);

    455. 

  455. 	 

    456. 

  456. 	ResetPack(pk);

    457. 

  457. 	WritePackCell(pk, client);

    458. 

  458. 	WritePackCell(pk, sequence);

    459. 

  459. 	WritePackCell(pk, _:adm);

    460. 

  460. 	WritePackString(pk, query);

    461. 

  461. 	

    462. 

  462. 	SQL_TQuery(owner, OnReceiveUserGroups, query, pk, DBPrio_High);

    463. 

  463. }

    464. 

  464. 

    465. 

  465. FetchUser(Handle:db, client)

    466. 

  466. {

    467. 

  467. 	decl String:name[65];

    468. 

  468. 	decl String:safe_name[140];

    469. 

  469. 	decl String:steamid[32];

    470. 

  470. 	decl String:steamidalt[32];

    471. 

  471. 	decl String:ipaddr[24];

    472. 

  472. 	

    473. 

  473. 	/**

    474. 

  474. 	 * Get authentication information from the client.

    475. 

  475. 	 */

    476. 

  476. 	GetClientName(client, name, sizeof(name));

    477. 

  477. 	GetClientIP(client, ipaddr, sizeof(ipaddr));

    478. 

  478. 	

    479. 

  479. 	steamid[0] = '\0';

    480. 

  480. 	if (GetClientAuthString(client, steamid, sizeof(steamid)))

    481. 

  481. 	{

    482. 

  482. 		if (StrEqual(steamid, "STEAM_ID_LAN"))

    483. 

  483. 		{

    484. 

  484. 			steamid[0] = '\0';

    485. 

  485. 		}

    486. 

  486. 	}

    487. 

  487. 	

    488. 

  488. 	SQL_EscapeString(db, name, safe_name, sizeof(safe_name));

    489. 

  489. 	

    490. 

  490. 	/**

    491. 

  491. 	 * Construct the query using the information the user gave us.

    492. 

  492. 	 */

    493. 

  493. 	decl String:query[512];

    494. 

  494. 	new len = 0;

    495. 

  495. 	

    496. 

  496. 	len += Format(query[len], sizeof(query)-len, "SELECT a.id, a.authtype, a.identity, a.password, a.flags, a.name, COUNT(ag.group_id), immunity");

    497. 

  497. 	len += Format(query[len], sizeof(query)-len, " FROM sm_admins a LEFT JOIN sm_admins_groups ag ON a.id = ag.admin_id WHERE ");

    498. 

  498. 	len += Format(query[len], sizeof(query)-len, " (a.authtype = 'ip' AND a.identity = '%s')", ipaddr);

    499. 

  499. 	len += Format(query[len], sizeof(query)-len, " OR (a.authtype = 'name' AND a.identity = '%s')", safe_name);

    500. 

  500. 	if (steamid[0] != '\0')

    501. 

  501. 	{

    502. 

  502. 		strcopy(steamidalt, sizeof(steamidalt), steamid);

    503. 

  503. 		steamidalt[6] = (steamid[6] == '0') ? '1' : '0';

    504. 

  504. 

    505. 

  505. 		len += Format(query[len], sizeof(query)-len, " OR (a.authtype = 'steam' AND (a.identity = '%s' OR a.identity = '%s'))", steamid, steamidalt);

    506. 

  506. 	}

    507. 

  507. 	len += Format(query[len], sizeof(query)-len, " GROUP BY a.id");

    508. 

  508. 	

    509. 

  509. 	/**

    510. 

  510. 	 * Send the actual query.

    511. 

  511. 	 */	

    512. 

  512. 	PlayerSeq[client] = ++g_sequence;

    513. 

  513. 	

    514. 

  514. 	new Handle:pk;

    515. 

  515. 	pk = CreateDataPack();

    516. 

  516. 	WritePackCell(pk, client);

    517. 

  517. 	WritePackCell(pk, PlayerSeq[client]);

    518. 

  518. 	WritePackString(pk, query);

    519. 

  519. 	

    520. 

  520. #if defined _DEBUG

    521. 

  521. 	PrintToServer("Sending user query: %s", query);

    522. 

  522. #endif

    523. 

  523. 	

    524. 

  524. 	SQL_TQuery(db, OnReceiveUser, query, pk, DBPrio_High);

    525. 

  525. }

    526. 

  526. 

    527. 

  527. FetchUsersWeCan(Handle:db)

    528. 

  528. {

    529. 

  529. 	for (new i=1; i<=MaxClients; i++)

    530. 

  530. 	{

    531. 

  531. 		if (PlayerAuth[i] && GetUserAdmin(i) == INVALID_ADMIN_ID)

    532. 

  532. 		{

    533. 

  533. 			FetchUser(db, i);

    534. 

  534. 		}

    535. 

  535. 	}

    536. 

  536. 	

    537. 

  537. 	/**

    538. 

  538. 	 * This round of updates is done.  Go in peace.

    539. 

  539. 	 */

    540. 

  540. 	RebuildCachePart[_:AdminCache_Admins] = 0;

    541. 

  541. }

    542. 

  542. 

    543. 

  543. 

    544. 

  544. public OnReceiveGroupImmunity(Handle:owner, Handle:hndl, const String:error[], any:data)

    545. 

  545. {

    546. 

  546. 	new Handle:pk = Handle:data;

    547. 

  547. 	ResetPack(pk);

    548. 

  548. 	

    549. 

  549. 	/**

    550. 

  550. 	 * Check if this is the latest result request.

    551. 

  551. 	 */

    552. 

  552. 	new sequence = ReadPackCell(pk);

    553. 

  553. 	if (RebuildCachePart[_:AdminCache_Groups] != sequence)

    554. 

  554. 	{

    555. 

  555. 		/* Discard everything, since we're out of sequence. */

    556. 

  556. 		CloseHandle(pk);

    557. 

  557. 		return;

    558. 

  558. 	}

    559. 

  559. 	

    560. 

  560. 	/**

    561. 

  561. 	 * If we need to use the results, make sure they succeeded.

    562. 

  562. 	 */

    563. 

  563. 	if (hndl == INVALID_HANDLE)

    564. 

  564. 	{

    565. 

  565. 		decl String:query[255];

    566. 

  566. 		ReadPackString(pk, query, sizeof(query));		

    567. 

  567. 		LogError("SQL error receiving group immunity: %s", error);

    568. 

  568. 		LogError("Query dump: %s", query);

    569. 

  569. 		CloseHandle(pk);	

    570. 

  570. 		return;

    571. 

  571. 	}

    572. 

  572. 	

    573. 

  573. 	/* We're done with the pack forever. */

    574. 

  574. 	CloseHandle(pk);

    575. 

  575. 	

    576. 

  576. 	while (SQL_FetchRow(hndl))

    577. 

  577. 	{

    578. 

  578. 		decl String:group1[80];

    579. 

  579. 		decl String:group2[80];

    580. 

  580. 		new GroupId:gid1, GroupId:gid2;

    581. 

  581. 		

    582. 

  582. 		SQL_FetchString(hndl, 0, group1, sizeof(group1));

    583. 

  583. 		SQL_FetchString(hndl, 1, group2, sizeof(group2));

    584. 

  584. 		

    585. 

  585. 		if (((gid1 = FindAdmGroup(group1)) == INVALID_GROUP_ID)

    586. 

  586. 			|| (gid2 = FindAdmGroup(group2)) == INVALID_GROUP_ID)

    587. 

  587. 		{

    588. 

  588. 			continue;

    589. 

  589. 		}

    590. 

  590. 		

    591. 

  591. 		SetAdmGroupImmuneFrom(gid1, gid2);

    592. 

  592. #if defined _DEBUG

    593. 

  593. 		PrintToServer("SetAdmGroupImmuneFrom(%d, %d)", gid1, gid2);

    594. 

  594. #endif

    595. 

  595. 	}

    596. 

  596. 	

    597. 

  597. 	/* Clear the sequence so another connect doesn't refetch */

    598. 

  598. 	RebuildCachePart[_:AdminCache_Groups] = 0;

    599. 

  599. }

    600. 

  600. 

    601. 

  601. public OnReceiveGroupOverrides(Handle:owner, Handle:hndl, const String:error[], any:data)

    602. 

  602. {

    603. 

  603. 	new Handle:pk = Handle:data;

    604. 

  604. 	ResetPack(pk);

    605. 

  605. 	

    606. 

  606. 	/**

    607. 

  607. 	 * Check if this is the latest result request.

    608. 

  608. 	 */

    609. 

  609. 	new sequence = ReadPackCell(pk);

    610. 

  610. 	if (RebuildCachePart[_:AdminCache_Groups] != sequence)

    611. 

  611. 	{

    612. 

  612. 		/* Discard everything, since we're out of sequence. */

    613. 

  613. 		CloseHandle(pk);

    614. 

  614. 		return;

    615. 

  615. 	}

    616. 

  616. 	

    617. 

  617. 	/**

    618. 

  618. 	 * If we need to use the results, make sure they succeeded.

    619. 

  619. 	 */

    620. 

  620. 	if (hndl == INVALID_HANDLE)

    621. 

  621. 	{

    622. 

  622. 		decl String:query[255];

    623. 

  623. 		ReadPackString(pk, query, sizeof(query));		

    624. 

  624. 		LogError("SQL error receiving group overrides: %s", error);

    625. 

  625. 		LogError("Query dump: %s", query);

    626. 

  626. 		CloseHandle(pk);	

    627. 

  627. 		return;

    628. 

  628. 	}

    629. 

  629. 	

    630. 

  630. 	/**

    631. 

  631. 	 * Fetch the overrides.

    632. 

  632. 	 */

    633. 

  633. 	decl String:name[80];

    634. 

  634. 	decl String:type[16];

    635. 

  635. 	decl String:command[64];

    636. 

  636. 	decl String:access[16];

    637. 

  637. 	new GroupId:gid;

    638. 

  638. 	while (SQL_FetchRow(hndl))

    639. 

  639. 	{

    640. 

  640. 		SQL_FetchString(hndl, 0, name, sizeof(name));

    641. 

  641. 		SQL_FetchString(hndl, 1, type, sizeof(type));

    642. 

  642. 		SQL_FetchString(hndl, 2, command, sizeof(command));

    643. 

  643. 		SQL_FetchString(hndl, 3, access, sizeof(access));

    644. 

  644. 		

    645. 

  645. 		/* Find the group.  This is actually faster than doing the ID lookup. */

    646. 

  646. 		if ((gid = FindAdmGroup(name)) == INVALID_GROUP_ID)

    647. 

  647. 		{

    648. 

  648. 			/* Oh well, just ignore it. */

    649. 

  649. 			continue;

    650. 

  650. 		}

    651. 

  651. 		

    652. 

  652. 		new OverrideType:o_type = Override_Command;

    653. 

  653. 		if (StrEqual(type, "group"))

    654. 

  654. 		{

    655. 

  655. 			o_type = Override_CommandGroup;

    656. 

  656. 		}

    657. 

  657. 				

    658. 

  658. 		new OverrideRule:o_rule = Command_Deny;

    659. 

  659. 		if (StrEqual(access, "allow"))

    660. 

  660. 		{

    661. 

  661. 			o_rule = Command_Allow;

    662. 

  662. 		}

    663. 

  663. 				

    664. 

  664. #if defined _DEBUG

    665. 

  665. 		PrintToServer("AddAdmGroupCmdOverride(%d, %s, %d, %d)", gid, command, o_type, o_rule);

    666. 

  666. #endif

    667. 

  667. 				

    668. 

  668. 		AddAdmGroupCmdOverride(gid, command, o_type, o_rule);

    669. 

  669. 	}

    670. 

  670. 	

    671. 

  671. 	/**

    672. 

  672. 	 * It's time to get the group immunity list.

    673. 

  673. 	 */

    674. 

  674. 	new len = 0;

    675. 

  675. 	decl String:query[256];

    676. 

  676. 	len += Format(query[len], sizeof(query)-len, "SELECT g1.name, g2.name FROM sm_group_immunity gi");

    677. 

  677. 	len += Format(query[len], sizeof(query)-len, " LEFT JOIN sm_groups g1 ON g1.id = gi.group_id ");

    678. 

  678. 	len += Format(query[len], sizeof(query)-len, " LEFT JOIN sm_groups g2 ON g2.id = gi.other_id");

    679. 

  679. 

    680. 

  680. 	ResetPack(pk);

    681. 

  681. 	WritePackCell(pk, sequence);

    682. 

  682. 	WritePackString(pk, query);

    683. 

  683. 	

    684. 

  684. 	SQL_TQuery(owner, OnReceiveGroupImmunity, query, pk, DBPrio_High);

    685. 

  685. }

    686. 

  686. 

    687. 

  687. public OnReceiveGroups(Handle:owner, Handle:hndl, const String:error[], any:data)

    688. 

  688. {

    689. 

  689. 	new Handle:pk = Handle:data;

    690. 

  690. 	ResetPack(pk);

    691. 

  691. 	

    692. 

  692. 	/**

    693. 

  693. 	 * Check if this is the latest result request.

    694. 

  694. 	 */

    695. 

  695. 	new sequence = ReadPackCell(pk);

    696. 

  696. 	if (RebuildCachePart[_:AdminCache_Groups] != sequence)

    697. 

  697. 	{

    698. 

  698. 		/* Discard everything, since we're out of sequence. */

    699. 

  699. 		CloseHandle(pk);

    700. 

  700. 		return;

    701. 

  701. 	}

    702. 

  702. 	

    703. 

  703. 	/**

    704. 

  704. 	 * If we need to use the results, make sure they succeeded.

    705. 

  705. 	 */

    706. 

  706. 	if (hndl == INVALID_HANDLE)

    707. 

  707. 	{

    708. 

  708. 		decl String:query[255];

    709. 

  709. 		ReadPackString(pk, query, sizeof(query));

    710. 

  710. 		LogError("SQL error receiving groups: %s", error);

    711. 

  711. 		LogError("Query dump: %s", query);

    712. 

  712. 		CloseHandle(pk);

    713. 

  713. 		return;

    714. 

  714. 	}

    715. 

  715. 	

    716. 

  716. 	/**

    717. 

  717. 	 * Now start fetching groups.

    718. 

  718. 	 */

    719. 

  719. 	decl String:flags[32];

    720. 

  720. 	decl String:name[128];

    721. 

  721. 	new immunity;

    722. 

  722. 	while (SQL_FetchRow(hndl))

    723. 

  723. 	{

    724. 

  724. 		SQL_FetchString(hndl, 0, flags, sizeof(flags));

    725. 

  725. 		SQL_FetchString(hndl, 1, name, sizeof(name));

    726. 

  726. 		immunity = SQL_FetchInt(hndl, 2);

    727. 

  727. 		

    728. 

  728. #if defined _DEBUG

    729. 

  729. 		PrintToServer("Adding group (%d, %s, %s)", immunity, flags, name);

    730. 

  730. #endif

    731. 

  731. 		

    732. 

  732. 		/* Find or create the group */

    733. 

  733. 		new GroupId:gid;

    734. 

  734. 		if ((gid = FindAdmGroup(name)) == INVALID_GROUP_ID)

    735. 

  735. 		{

    736. 

  736. 			gid = CreateAdmGroup(name);

    737. 

  737. 		}

    738. 

  738. 

    739. 

  739. 		/* Add flags from the database to the group */

    740. 

  740. 		new num_flag_chars = strlen(flags);

    741. 

  741. 		for (new i=0; i<num_flag_chars; i++)

    742. 

  742. 		{

    743. 

  743. 			decl AdminFlag:flag;

    744. 

  744. 			if (!FindFlagByChar(flags[i], flag))

    745. 

  745. 			{

    746. 

  746. 				continue;

    747. 

  747. 			}

    748. 

  748. 			SetAdmGroupAddFlag(gid, flag, true);

    749. 

  749. 		}

    750. 

  750. 		

    751. 

  751. 		SetAdmGroupImmunityLevel(gid, immunity);

    752. 

  752. 	}

    753. 

  753. 	

    754. 

  754. 	/**

    755. 

  755. 	 * It's time to get the group override list.

    756. 

  756. 	 */

    757. 

  757. 	decl String:query[255];

    758. 

  758. 	Format(query, 

    759. 

  759. 		sizeof(query), 

    760. 

  760. 		"SELECT g.name, og.type, og.name, og.access FROM sm_group_overrides og JOIN sm_groups g ON og.group_id = g.id ORDER BY g.id DESC");

    761. 

  761. 

    762. 

  762. 	ResetPack(pk);

    763. 

  763. 	WritePackCell(pk, sequence);

    764. 

  764. 	WritePackString(pk, query);

    765. 

  765. 	

    766. 

  766. 	SQL_TQuery(owner, OnReceiveGroupOverrides, query, pk, DBPrio_High);

    767. 

  767. }

    768. 

  768. 

    769. 

  769. FetchGroups(Handle:db, sequence)

    770. 

  770. {

    771. 

  771. 	decl String:query[255];

    772. 

  772. 	new Handle:pk;

    773. 

  773. 	

    774. 

  774. 	Format(query, sizeof(query), "SELECT flags, name, immunity_level FROM sm_groups");

    775. 

  775. 

    776. 

  776. 	pk = CreateDataPack();

    777. 

  777. 	WritePackCell(pk, sequence);

    778. 

  778. 	WritePackString(pk, query);

    779. 

  779. 	

    780. 

  780. 	SQL_TQuery(db, OnReceiveGroups, query, pk, DBPrio_High);

    781. 

  781. }

    782. 

  782. 

    783. 

  783. public OnReceiveOverrides(Handle:owner, Handle:hndl, const String:error[], any:data)

    784. 

  784. {

    785. 

  785. 	new Handle:pk = Handle:data;

    786. 

  786. 	ResetPack(pk);

    787. 

  787. 	

    788. 

  788. 	/**

    789. 

  789. 	 * Check if this is the latest result request.

    790. 

  790. 	 */

    791. 

  791. 	new sequence = ReadPackCell(pk);

    792. 

  792. 	if (RebuildCachePart[_:AdminCache_Overrides] != sequence)

    793. 

  793. 	{

    794. 

  794. 		/* Discard everything, since we're out of sequence. */

    795. 

  795. 		CloseHandle(pk);

    796. 

  796. 		return;

    797. 

  797. 	}

    798. 

  798. 	

    799. 

  799. 	/**

    800. 

  800. 	 * If we need to use the results, make sure they succeeded.

    801. 

  801. 	 */

    802. 

  802. 	if (hndl == INVALID_HANDLE)

    803. 

  803. 	{

    804. 

  804. 		decl String:query[255];

    805. 

  805. 		ReadPackString(pk, query, sizeof(query));

    806. 

  806. 		LogError("SQL error receiving overrides: %s", error);

    807. 

  807. 		LogError("Query dump: %s", query);

    808. 

  808. 		CloseHandle(pk);

    809. 

  809. 		return;

    810. 

  810. 	}

    811. 

  811. 	

    812. 

  812. 	/**

    813. 

  813. 	 * We're done with you, now.

    814. 

  814. 	 */

    815. 

  815. 	CloseHandle(pk);

    816. 

  816. 	

    817. 

  817. 	decl String:type[64];

    818. 

  818. 	decl String:name[64];

    819. 

  819. 	decl String:flags[32];

    820. 

  820. 	new flag_bits;

    821. 

  821. 	while (SQL_FetchRow(hndl))

    822. 

  822. 	{

    823. 

  823. 		SQL_FetchString(hndl, 0, type, sizeof(type));

    824. 

  824. 		SQL_FetchString(hndl, 1, name, sizeof(name));

    825. 

  825. 		SQL_FetchString(hndl, 2, flags, sizeof(flags));

    826. 

  826. 		

    827. 

  827. #if defined _DEBUG

    828. 

  828. 		PrintToServer("Adding override (%s, %s, %s)", type, name, flags);

    829. 

  829. #endif

    830. 

  830. 		

    831. 

  831. 		flag_bits = ReadFlagString(flags);

    832. 

  832. 		if (StrEqual(type, "command"))

    833. 

  833. 		{

    834. 

  834. 			AddCommandOverride(name, Override_Command, flag_bits);

    835. 

  835. 		} else if (StrEqual(type, "group")) {

    836. 

  836. 			AddCommandOverride(name, Override_CommandGroup, flag_bits);

    837. 

  837. 		}

    838. 

  838. 	}

    839. 

  839. 	

    840. 

  840. 	/* Clear the sequence so another connect doesn't refetch */

    841. 

  841. 	RebuildCachePart[_:AdminCache_Overrides] = 0;

    842. 

  842. }

    843. 

  843. 

    844. 

  844. FetchOverrides(Handle:db, sequence)

    845. 

  845. {

    846. 

  846. 	decl String:query[255];

    847. 

  847. 	new Handle:pk;

    848. 

  848. 	

    849. 

  849. 	Format(query, sizeof(query), "SELECT type, name, flags FROM sm_overrides");

    850. 

  850. 

    851. 

  851. 	pk = CreateDataPack();

    852. 

  852. 	WritePackCell(pk, sequence);

    853. 

  853. 	WritePackString(pk, query);

    854. 

  854. 	

    855. 

  855. 	SQL_TQuery(db, OnReceiveOverrides, query, pk, DBPrio_High);

    856. 

  856. }
    857.