Home - sourcemod-central - file revision - core/smn_core.cpp@a30528e5cb8a Mercurial
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
core/smn_core.cpp
author Scott Ehlert <ds@alliedmods.net>
Thu Aug 19 22:51:42 2010 -0500 (2010-08-19)
changeset 3114 a30528e5cb8a
parent 3027 0f90dd9754ca
child 3469 7c5adf8e29eb
permissions -rw-r--r--
Fixed alignment on a couple of SourcePawn debugging structures on OS X (bug 4578, r=dvander).

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