Home - sourcemod-central - file revision - core/smn_core.cpp@d6f1e42f0263 Mercurial
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
core/smn_core.cpp
author Nicholas Hastings <skamonkey@gmail.com>
Wed Aug 14 13:14:59 2013 -0400 (2013-08-14)
changeset 4007 d6f1e42f0263
parent 3872 4c93f74cae51
child 4073 56283c919b7b
permissions -rw-r--r--
Fixed typo in Nuclear Dawn gamedata backcompat fix. 
     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 <time.h>
    33 #include <string.h>
    34 #include <stdlib.h>
    35 #include "sm_stringutil.h"
    36 #include "sm_globals.h"
    37 #include "sourcemod.h"
    38 #include "LibrarySys.h"
    39 #include "TimerSys.h"
    40 #include "ForwardSys.h"
    41 #include "Logger.h"
    42 #include <sm_trie_tpl.h>
    43 #include <sh_memory.h>
    44 #include "logic_bridge.h"
    45 
    46 #if defined PLATFORM_WINDOWS
    47 #include <windows.h>
    48 #elif defined PLATFORM_POSIX
    49 #include <limits.h>
    50 #include <unistd.h>
    51 #include <sys/times.h>
    52 #endif
    53 
    54 HandleType_t g_PlIter;
    55 ConVar sm_datetime_format("sm_datetime_format", "%m/%d/%Y - %H:%M:%S", 0, "Default formatting time rules");
    56 IForward *g_OnLogAction = NULL;
    57 
    58 class CoreNativeHelpers : 
    59 	public SMGlobalClass,
    60 	public IHandleTypeDispatch
    61 {
    62 public:
    63 	void OnSourceModAllInitialized()
    64 	{
    65 		HandleAccess hacc;
    66 		handlesys->InitAccessDefaults(NULL,  &hacc);
    67 		hacc.access[HandleAccess_Clone] = HANDLE_RESTRICT_IDENTITY|HANDLE_RESTRICT_OWNER;
    68 
    69 		g_PlIter = handlesys->CreateType("PluginIterator", this, 0, NULL, NULL, g_pCoreIdent, NULL);
    70 
    71 		g_OnLogAction = g_Forwards.CreateForward("OnLogAction", 
    72 			ET_Hook, 
    73 			5, 
    74 			NULL,
    75 			Param_Cell,
    76 			Param_Cell,
    77 			Param_Cell,
    78 			Param_Cell,
    79 			Param_String);
    80 	}
    81 	void OnHandleDestroy(HandleType_t type, void *object)
    82 	{
    83 		IPluginIterator *iter = (IPluginIterator *)object;
    84 		iter->Release();
    85 	}
    86 	void OnSourceModShutdown()
    87 	{
    88 		g_Forwards.ReleaseForward(g_OnLogAction);
    89 		handlesys->RemoveType(g_PlIter, g_pCoreIdent);
    90 	}
    91 } g_CoreNativeHelpers;
    92 
    93 void LogAction(Handle_t hndl, int type, int client, int target, const char *message)
    94 {
    95 	if (g_OnLogAction->GetFunctionCount())
    96 	{
    97 		cell_t result = 0;
    98 		g_OnLogAction->PushCell(hndl);
    99 		g_OnLogAction->PushCell(type);
   100 		g_OnLogAction->PushCell(client);
   101 		g_OnLogAction->PushCell(target);
   102 		g_OnLogAction->PushString(message);
   103 		g_OnLogAction->Execute(&result);
   104 
   105 		if (result >= (ResultType)Pl_Handled)
   106 		{
   107 			return;
   108 		}
   109 	}
   110 
   111 	const char *logtag = "SM";
   112 	if (type == 2)
   113 	{
   114 		HandleError err;
   115 		IPlugin *pPlugin = scripts->FindPluginByHandle(hndl, &err);
   116 		if (pPlugin)
   117 		{
   118 			logtag = pPlugin->GetFilename();
   119 		}
   120 	}
   121 
   122 	g_Logger.LogMessage("[%s] %s", logtag, message);
   123 }
   124 
   125 static cell_t ThrowError(IPluginContext *pContext, const cell_t *params)
   126 {
   127 	char buffer[512];
   128 
   129 	g_SourceMod.SetGlobalTarget(SOURCEMOD_SERVER_LANGUAGE);
   130 
   131 	g_SourceMod.FormatString(buffer, sizeof(buffer), pContext, params, 1);
   132 
   133 	if (pContext->GetLastNativeError() == SP_ERROR_NONE)
   134 	{
   135 		pContext->ThrowNativeErrorEx(SP_ERROR_ABORTED, "%s", buffer);
   136 	}
   137 
   138 	return 0;
   139 }
   140 
   141 static cell_t GetTime(IPluginContext *pContext, const cell_t *params)
   142 {
   143 	time_t t = GetAdjustedTime();
   144 	cell_t *addr;
   145 	pContext->LocalToPhysAddr(params[1], &addr);
   146 
   147 	*(time_t *)addr = t;
   148 
   149 	return static_cast<cell_t>(t);
   150 }
   151 
   152 #if defined SUBPLATFORM_SECURECRT
   153 void _ignore_invalid_parameter(
   154 						const wchar_t * expression,
   155 						const wchar_t * function, 
   156 						const wchar_t * file, 
   157 						unsigned int line,
   158 						uintptr_t pReserved
   159 						)
   160 {
   161 	/* Wow we don't care, thanks Microsoft. */
   162 }
   163 #endif
   164 
   165 static cell_t FormatTime(IPluginContext *pContext, const cell_t *params)
   166 {
   167 	char *format, *buffer;
   168 	pContext->LocalToString(params[1], &buffer);
   169 	pContext->LocalToStringNULL(params[3], &format);
   170 
   171 	if (format == NULL)
   172 	{
   173 		format = const_cast<char *>(sm_datetime_format.GetString());
   174 	}
   175 
   176 #if defined SUBPLATFORM_SECURECRT
   177 	_invalid_parameter_handler handler = _set_invalid_parameter_handler(_ignore_invalid_parameter);
   178 #endif
   179 
   180 	time_t t = (params[4] == -1) ? GetAdjustedTime() : (time_t)params[4];
   181 	size_t written = strftime(buffer, params[2], format, localtime(&t));
   182 
   183 #if defined SUBPLATFORM_SECURECRT
   184 	_set_invalid_parameter_handler(handler);
   185 #endif
   186 
   187 	if (params[2] && format[0] != '\0' && !written)
   188 	{
   189 		pContext->ThrowNativeError("Invalid time format or buffer too small");
   190 		return 0;
   191 	}
   192 
   193 	return 1;
   194 }
   195 
   196 static cell_t GetPluginIterator(IPluginContext *pContext, const cell_t *params)
   197 {
   198 	IPluginIterator *iter = scripts->GetPluginIterator();
   199 
   200 	Handle_t hndl = handlesys->CreateHandle(g_PlIter, iter, pContext->GetIdentity(), g_pCoreIdent, NULL);
   201 
   202 	if (hndl == BAD_HANDLE)
   203 	{
   204 		iter->Release();
   205 	}
   206 
   207 	return hndl;
   208 }
   209 
   210 static cell_t MorePlugins(IPluginContext *pContext, const cell_t *params)
   211 {
   212 	Handle_t hndl = (Handle_t)params[1];
   213 	HandleError err;
   214 	IPluginIterator *pIter;
   215 
   216 	HandleSecurity sec;
   217 	sec.pIdentity = g_pCoreIdent;
   218 	sec.pOwner = pContext->GetIdentity();
   219 
   220 	if ((err=handlesys->ReadHandle(hndl, g_PlIter, &sec, (void **)&pIter)) != HandleError_None)
   221 	{
   222 		return pContext->ThrowNativeError("Could not read Handle %x (error %d)", hndl, err);
   223 	}
   224 
   225 	return pIter->MorePlugins() ? 1 : 0;
   226 }
   227 
   228 static cell_t ReadPlugin(IPluginContext *pContext, const cell_t *params)
   229 {
   230 	Handle_t hndl = (Handle_t)params[1];
   231 	HandleError err;
   232 	IPluginIterator *pIter;
   233 
   234 	HandleSecurity sec;
   235 	sec.pIdentity = g_pCoreIdent;
   236 	sec.pOwner = pContext->GetIdentity();
   237 
   238 	if ((err=handlesys->ReadHandle(hndl, g_PlIter, &sec, (void **)&pIter)) != HandleError_None)
   239 	{
   240 		return pContext->ThrowNativeError("Could not read Handle %x (error %d)", hndl, err);
   241 	}
   242 
   243 	IPlugin *pPlugin = pIter->GetPlugin();
   244 	if (!pPlugin)
   245 	{
   246 		return BAD_HANDLE;
   247 	}
   248 
   249 	pIter->NextPlugin();
   250 
   251 	return pPlugin->GetMyHandle();
   252 }
   253 
   254 IPlugin *GetPluginFromHandle(IPluginContext *pContext, Handle_t hndl)
   255 {
   256 	if (hndl == BAD_HANDLE)
   257 	{
   258 		return scripts->FindPluginByContext(pContext->GetContext());
   259 	} else {
   260 		HandleError err;
   261 		IPlugin *pPlugin = scripts->FindPluginByHandle(hndl, &err);
   262 		if (!pPlugin)
   263 		{
   264 			pContext->ThrowNativeError("Could not read Handle %x (error %d)", hndl, err);
   265 		}
   266 		return pPlugin;
   267 	}
   268 }
   269 
   270 static cell_t GetPluginStatus(IPluginContext *pContext, const cell_t *params)
   271 {
   272 	IPlugin *pPlugin = GetPluginFromHandle(pContext, params[1]);
   273 	if (!pPlugin)
   274 	{
   275 		return 0;
   276 	}
   277 
   278 	return pPlugin->GetStatus();
   279 }
   280 
   281 static cell_t GetPluginFilename(IPluginContext *pContext, const cell_t *params)
   282 {
   283 	IPlugin *pPlugin = GetPluginFromHandle(pContext, params[1]);
   284 	if (!pPlugin)
   285 	{
   286 		return 0;
   287 	}
   288 
   289 	pContext->StringToLocalUTF8(params[2], params[3], pPlugin->GetFilename(), NULL);
   290 
   291 	return 1;
   292 }
   293 
   294 static cell_t IsPluginDebugging(IPluginContext *pContext, const cell_t *params)
   295 {
   296 	IPlugin *pPlugin = GetPluginFromHandle(pContext, params[1]);
   297 	if (!pPlugin)
   298 	{
   299 		return 0;
   300 	}
   301 
   302 	return pPlugin->IsDebugging() ? 1 : 0;
   303 }
   304 
   305 /* Local to plugins only */
   306 enum PluginInfo
   307 {
   308 	PlInfo_Name,			/**< Plugin name */
   309 	PlInfo_Author,			/**< Plugin author */
   310 	PlInfo_Description,		/**< Plugin description */
   311 	PlInfo_Version,			/**< Plugin verison */
   312 	PlInfo_URL,				/**< Plugin URL */
   313 };
   314 
   315 static cell_t GetPluginInfo(IPluginContext *pContext, const cell_t *params)
   316 {
   317 	IPlugin *pPlugin = GetPluginFromHandle(pContext, params[1]);
   318 	if (!pPlugin)
   319 	{
   320 		return 0;
   321 	}
   322 
   323 	const sm_plugininfo_t *info = pPlugin->GetPublicInfo();
   324 
   325 	if (!info)
   326 	{
   327 		return 0;
   328 	}
   329 
   330 	const char *str = NULL;
   331 
   332 	switch ((PluginInfo)params[2])
   333 	{
   334 	case PlInfo_Name:
   335 		{
   336 			str = info->name;
   337 			break;
   338 		}
   339 	case PlInfo_Author:
   340 		{
   341 			str = info->author;
   342 			break;
   343 		}
   344 	case PlInfo_Description:
   345 		{
   346 			str = info->description;
   347 			break;
   348 		}
   349 	case PlInfo_Version:
   350 		{
   351 			str = info->version;
   352 			break;
   353 		}
   354 	case PlInfo_URL:
   355 		{
   356 			str = info->url;
   357 			break;
   358 		}
   359 	}
   360 
   361 	if (!str || str[0] == '\0')
   362 	{
   363 		return 0;
   364 	}
   365 
   366 	pContext->StringToLocalUTF8(params[3], params[4], str, NULL);
   367 
   368 	return 1;
   369 }
   370 
   371 static cell_t SetFailState(IPluginContext *pContext, const cell_t *params)
   372 {
   373 	char *str;
   374 	SMPlugin *pPlugin;
   375 
   376 	pContext->LocalToString(params[1], &str);
   377 	pPlugin = scripts->FindPluginByContext(pContext->GetContext());
   378 
   379 	if (params[0] == 1)
   380 	{
   381 		pPlugin->SetErrorState(Plugin_Error, "%s", str);
   382 
   383 		return pContext->ThrowNativeErrorEx(SP_ERROR_ABORTED, "%s", str);
   384 	}
   385 	else
   386 	{
   387 		char buffer[2048];
   388 
   389 		g_SourceMod.FormatString(buffer, sizeof(buffer), pContext, params, 1);
   390 		if (pContext->GetLastNativeError() != SP_ERROR_NONE)
   391 		{
   392 			pPlugin->SetErrorState(Plugin_Error, "%s", str);
   393 			return pContext->ThrowNativeErrorEx(SP_ERROR_ABORTED, "Formatting error (%s)", str);
   394 		}
   395 		else
   396 		{
   397 			pPlugin->SetErrorState(Plugin_Error, "%s", buffer);
   398 			return pContext->ThrowNativeErrorEx(SP_ERROR_ABORTED, "%s", buffer);
   399 		}
   400 	}
   401 
   402 	return 0;
   403 }
   404 
   405 static cell_t GetSysTickCount(IPluginContext *pContext, const cell_t *params)
   406 {
   407 #if defined PLATFORM_WINDOWS
   408 	return (cell_t)GetTickCount();
   409 #elif defined PLATFORM_POSIX
   410 	tms tm;
   411 	clock_t ticks = times(&tm);
   412 	long ticks_per_sec = sysconf(_SC_CLK_TCK);
   413 	double fticks = (double)ticks / (double)ticks_per_sec;
   414 	fticks *= 1000.0f;
   415 	if (fticks > INT_MAX)
   416 	{
   417 		double r = (int)(fticks / INT_MAX) * (double)INT_MAX;
   418 		fticks -= r;
   419 	}
   420 	return (cell_t)fticks;
   421 #endif
   422 }
   423 
   424 static cell_t AutoExecConfig(IPluginContext *pContext, const cell_t *params)
   425 {
   426 	SMPlugin *plugin = scripts->FindPluginByContext(pContext->GetContext());
   427 
   428 	char *cfg, *folder;
   429 	pContext->LocalToString(params[2], &cfg);
   430 	pContext->LocalToString(params[3], &folder);
   431 
   432 	if (cfg[0] == '\0')
   433 	{
   434 		static char temp_str[255];
   435 		static char temp_file[PLATFORM_MAX_PATH];
   436 		char *ptr;
   437 
   438 		g_LibSys.GetFileFromPath(temp_str, sizeof(temp_str), plugin->GetFilename());
   439 		if ((ptr = strstr(temp_str, ".smx")) != NULL)
   440 		{
   441 			*ptr = '\0';
   442 		}
   443 
   444 		/* We have the raw filename! */
   445 		UTIL_Format(temp_file, sizeof(temp_file), "plugin.%s", temp_str);
   446 		cfg = temp_file;
   447 	}
   448 
   449 	plugin->AddConfig(params[1] ? true : false, cfg, folder);
   450 
   451 	return 1;
   452 }
   453 
   454 static cell_t MarkNativeAsOptional(IPluginContext *pContext, const cell_t *params)
   455 {
   456 	char *name;
   457 	uint32_t idx;
   458 	sp_native_t *native;
   459 
   460 	pContext->LocalToString(params[1], &name);
   461 	if (pContext->FindNativeByName(name, &idx) != SP_ERROR_NONE)
   462 	{
   463 		/* Oops! This HAS to silently fail! */
   464 		return 0;
   465 	}
   466 
   467 	pContext->GetNativeByIndex(idx, &native);
   468 
   469 	native->flags |= SP_NTVFLAG_OPTIONAL;
   470 
   471 	return 1;
   472 }
   473 
   474 static cell_t RegPluginLibrary(IPluginContext *pContext, const cell_t *params)
   475 {
   476 	char *name;
   477 	SMPlugin *pl = scripts->FindPluginByContext(pContext->GetContext());
   478 
   479 	pContext->LocalToString(params[1], &name);
   480 
   481 	pl->AddLibrary(name);
   482 	return 1;
   483 }
   484 
   485 static cell_t LibraryExists(IPluginContext *pContext, const cell_t *params)
   486 {
   487 	char *str;
   488 	pContext->LocalToString(params[1], &str);
   489 
   490 	if (strcmp(str, "__CanTestFeatures__") == 0)
   491 	{
   492 		return 1;
   493 	}
   494 
   495 	if (scripts->LibraryExists(str))
   496 	{
   497 		return 1;
   498 	}
   499 
   500 	if (extsys->LibraryExists(str))
   501 	{
   502 		return 1;
   503 	}
   504 
   505 	return 0;
   506 }
   507 
   508 static cell_t sm_LogAction(IPluginContext *pContext, const cell_t *params)
   509 {
   510 	char buffer[2048];
   511 	g_SourceMod.SetGlobalTarget(SOURCEMOD_SERVER_LANGUAGE);
   512 	g_SourceMod.FormatString(buffer, sizeof(buffer), pContext, params, 3);
   513 
   514 	if (pContext->GetLastNativeError() != SP_ERROR_NONE)
   515 	{
   516 		return 0;
   517 	}
   518 
   519 	IPlugin *pPlugin = scripts->FindPluginByContext(pContext->GetContext());
   520 
   521 	LogAction(pPlugin->GetMyHandle(), 2, params[1], params[2], buffer);
   522 
   523 	return 1;
   524 }
   525 
   526 static cell_t LogToFile(IPluginContext *pContext, const cell_t *params)
   527 {
   528 	char *file;
   529 	pContext->LocalToString(params[1], &file);
   530 
   531 	char path[PLATFORM_MAX_PATH];
   532 	g_SourceMod.BuildPath(Path_Game, path, sizeof(path), "%s", file);
   533 
   534 	FILE *fp = fopen(path, "at");
   535 	if (!fp)
   536 	{
   537 		return pContext->ThrowNativeError("Could not open file \"%s\"", path);
   538 	}
   539 
   540 	char buffer[2048];
   541 	g_SourceMod.SetGlobalTarget(SOURCEMOD_SERVER_LANGUAGE);
   542 	g_SourceMod.FormatString(buffer, sizeof(buffer), pContext, params, 2);
   543 
   544 	if (pContext->GetLastNativeError() != SP_ERROR_NONE)
   545 	{
   546 		fclose(fp);
   547 		return 0;
   548 	}
   549 
   550 	IPlugin *pPlugin = scripts->FindPluginByContext(pContext->GetContext());
   551 
   552 	g_Logger.LogToOpenFile(fp, "[%s] %s", pPlugin->GetFilename(), buffer);
   553 
   554 	fclose(fp);
   555 
   556 	return 1;
   557 }
   558 
   559 static cell_t LogToFileEx(IPluginContext *pContext, const cell_t *params)
   560 {
   561 	char *file;
   562 	pContext->LocalToString(params[1], &file);
   563 
   564 	char path[PLATFORM_MAX_PATH];
   565 	g_SourceMod.BuildPath(Path_Game, path, sizeof(path), "%s", file);
   566 
   567 	FILE *fp = fopen(path, "at");
   568 	if (!fp)
   569 	{
   570 		return pContext->ThrowNativeError("Could not open file \"%s\"", path);
   571 	}
   572 
   573 	char buffer[2048];
   574 	g_SourceMod.SetGlobalTarget(SOURCEMOD_SERVER_LANGUAGE);
   575 	g_SourceMod.FormatString(buffer, sizeof(buffer), pContext, params, 2);
   576 
   577 	if (pContext->GetLastNativeError() != SP_ERROR_NONE)
   578 	{
   579 		fclose(fp);
   580 		return 0;
   581 	}
   582 
   583 	g_Logger.LogToOpenFile(fp, "%s", buffer);
   584 
   585 	fclose(fp);
   586 
   587 	return 1;
   588 }
   589 
   590 static cell_t GetExtensionFileStatus(IPluginContext *pContext, const cell_t *params)
   591 {
   592 	char *str;
   593 	pContext->LocalToString(params[1], &str);
   594 
   595 	IExtension *pExtension = extsys->FindExtensionByFile(str);
   596 	
   597 	if (!pExtension)
   598 	{
   599 		return -2;
   600 	}
   601 	
   602 	if (!pExtension->IsLoaded())
   603 	{
   604 		return -1;
   605 	}
   606 
   607 	char *error;
   608 	pContext->LocalToString(params[2], &error);
   609 	if (!pExtension->IsRunning(error, params[3]))
   610 	{
   611 		return 0;
   612 	}
   613 
   614 	return 1;
   615 }
   616 
   617 static cell_t FindPluginByNumber(IPluginContext *pContext, const cell_t *params)
   618 {
   619 	IPlugin *pPlugin = scripts->FindPluginByOrder(params[1]);
   620 	
   621 	if (pPlugin == NULL)
   622 	{
   623 		return BAD_HANDLE;
   624 	}
   625 
   626 	return pPlugin->GetMyHandle();
   627 }
   628 
   629 static cell_t VerifyCoreVersion(IPluginContext *pContext, const cell_t *params)
   630 {
   631 	return 4;
   632 }
   633 
   634 static cell_t GetFeatureStatus(IPluginContext *pContext, const cell_t *params)
   635 {
   636 	FeatureType type = (FeatureType)params[1];
   637 	char *name;
   638 
   639 	pContext->LocalToString(params[2], &name);
   640 
   641 	return sharesys->TestFeature(pContext->GetRuntime(), type, name);
   642 }
   643 
   644 static cell_t RequireFeature(IPluginContext *pContext, const cell_t *params)
   645 {
   646 	FeatureType type = (FeatureType)params[1];
   647 	char *name;
   648 
   649 	pContext->LocalToString(params[2], &name);
   650 
   651 	if (sharesys->TestFeature(pContext->GetRuntime(), type, name) != FeatureStatus_Available)
   652 	{
   653 		char buffer[255];
   654 		char *msg = buffer;
   655 		char default_message[255];
   656 		SMPlugin *pPlugin = scripts->FindPluginByContext(pContext->GetContext());
   657 
   658 		g_SourceMod.FormatString(buffer, sizeof(buffer), pContext, params, 3);
   659 		if (pContext->GetLastNativeError() != SP_ERROR_NONE || buffer[0] == '\0')
   660 		{
   661 			UTIL_Format(default_message, sizeof(default_message), "Feature \"%s\" not available", name);
   662 			msg = default_message;
   663 		}
   664 		pPlugin->SetErrorState(Plugin_Error, "%s", msg);
   665 		return pContext->ThrowNativeErrorEx(SP_ERROR_ABORTED, "%s", msg);
   666 	}
   667 
   668 	return 1;
   669 }
   670 
   671 enum NumberType
   672 {
   673 	NumberType_Int8,
   674 	NumberType_Int16,
   675 	NumberType_Int32
   676 };
   677 
   678 //memory addresses below 0x10000 are automatically considered invalid for dereferencing
   679 #define VALID_MINIMUM_MEMORY_ADDRESS 0x10000
   680 
   681 static cell_t LoadFromAddress(IPluginContext *pContext, const cell_t *params)
   682 {
   683 	void *addr = reinterpret_cast<void*>(params[1]);
   684 
   685 	if (addr == NULL)
   686 	{
   687 		pContext->ThrowNativeError("Address cannot be null");
   688 	}
   689 	else if (reinterpret_cast<uintptr_t>(addr) < VALID_MINIMUM_MEMORY_ADDRESS)
   690 	{
   691 		pContext->ThrowNativeError("Invalid address 0x%x is pointing to reserved memory.", addr);
   692 	}
   693 	NumberType size = static_cast<NumberType>(params[2]);
   694 
   695 	switch(size)
   696 	{
   697 	case NumberType_Int8:
   698 		return *reinterpret_cast<uint8_t*>(addr);
   699 	case NumberType_Int16:
   700 		return *reinterpret_cast<uint16_t*>(addr);
   701 	case NumberType_Int32:
   702 		return *reinterpret_cast<uint32_t*>(addr);
   703 	default:
   704 		pContext->ThrowNativeError("Invalid number types %d", size);
   705 	}
   706 
   707 	return 1;
   708 }
   709 
   710 
   711 static cell_t StoreToAddress(IPluginContext *pContext, const cell_t *params)
   712 {
   713 	void *addr = reinterpret_cast<void*>(params[1]);
   714 
   715 	if (addr == NULL)
   716 	{
   717 		pContext->ThrowNativeError("Address cannot be null");
   718 	}
   719 	else if (reinterpret_cast<uintptr_t>(addr) < VALID_MINIMUM_MEMORY_ADDRESS)
   720 	{
   721 		pContext->ThrowNativeError("Invalid address 0x%x is pointing to reserved memory.", addr);
   722 	}
   723 	cell_t data = params[2];
   724 
   725 	NumberType size = static_cast<NumberType>(params[3]);
   726 
   727 	switch(size)
   728 	{
   729 	case NumberType_Int8:
   730 		SourceHook::SetMemAccess(addr, sizeof(uint8_t), SH_MEM_READ|SH_MEM_WRITE|SH_MEM_EXEC);
   731 		*reinterpret_cast<uint8_t*>(addr) = data;
   732 		break;
   733 	case NumberType_Int16:
   734 		SourceHook::SetMemAccess(addr, sizeof(uint16_t), SH_MEM_READ|SH_MEM_WRITE|SH_MEM_EXEC);
   735 		*reinterpret_cast<uint16_t*>(addr) = data;
   736 		break;
   737 	case NumberType_Int32:
   738 		SourceHook::SetMemAccess(addr, sizeof(uint32_t), SH_MEM_READ|SH_MEM_WRITE|SH_MEM_EXEC);
   739 		*reinterpret_cast<uint32_t*>(addr) = data;
   740 		break;
   741 	default:
   742 		pContext->ThrowNativeError("Invalid number types %d", size);
   743 	}
   744 
   745 	return 1;
   746 }
   747 
   748 REGISTER_NATIVES(coreNatives)
   749 {
   750 	{"AutoExecConfig",			AutoExecConfig},
   751 	{"GetPluginFilename",		GetPluginFilename},
   752 	{"GetPluginInfo",			GetPluginInfo},
   753 	{"GetPluginIterator",		GetPluginIterator},
   754 	{"GetPluginStatus",			GetPluginStatus},
   755 	{"GetSysTickCount",			GetSysTickCount},
   756 	{"GetTime",					GetTime},
   757 	{"IsPluginDebugging",		IsPluginDebugging},
   758 	{"MorePlugins",				MorePlugins},
   759 	{"ReadPlugin",				ReadPlugin},
   760 	{"ThrowError",				ThrowError},
   761 	{"SetFailState",			SetFailState},
   762 	{"FormatTime",				FormatTime},
   763 	{"MarkNativeAsOptional",	MarkNativeAsOptional},
   764 	{"RegPluginLibrary",		RegPluginLibrary},
   765 	{"LibraryExists",			LibraryExists},
   766 	{"LogAction",				sm_LogAction},
   767 	{"LogToFile",				LogToFile},
   768 	{"LogToFileEx",				LogToFileEx},
   769 	{"GetExtensionFileStatus",	GetExtensionFileStatus},
   770 	{"FindPluginByNumber",		FindPluginByNumber},
   771 	{"VerifyCoreVersion",		VerifyCoreVersion},
   772 	{"GetFeatureStatus",        GetFeatureStatus},
   773 	{"RequireFeature",          RequireFeature},
   774 	{"LoadFromAddress",         LoadFromAddress},
   775 	{"StoreToAddress",          StoreToAddress},
   776 	{NULL,						NULL},
   777 };
   778
sourcemod-central
Feed