Home - sourcemod-central - file revision - core/smn_fakenatives.cpp@2e8046793bc9 Mercurial
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
core/smn_fakenatives.cpp
author Phong Dang <teame06@gmail.com>
Wed Aug 01 07:29:40 2007 +0000 (2007-08-01)
changeset 1241 2e8046793bc9
parent 1231 17badaf66ce4
child 1330 ab94316bb52b
permissions -rw-r--r--
Added check to make sure player are alive to perform sm_slap, sm_burn, sm_slay. 
     1 /**
     2  * vim: set ts=4 :
     3  * ================================================================
     4  * SourceMod
     5  * Copyright (C) 2004-2007 AlliedModders LLC.  All rights reserved.
     6  * ================================================================
     7  *
     8  * This program is free software; you can redistribute it and/or 
     9  * modify it under the terms of the GNU General Public License, 
    10  * version 3.0, as published by the Free Software Foundation.
    11  * 
    12  * This program is distributed in the hope that it will be useful,
    13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    15  * GNU General Public License for more details.
    16  *
    17  * You should have received a copy of the GNU General Public License
    18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
    19  *
    20  * As a special exception, AlliedModders LLC gives you permission to 
    21  * link the code of this program (as well as its derivative works) to 
    22  * "Half-Life 2," the "Source Engine," the "SourcePawn JIT," and any 
    23  * Game MODs that run on software by the Valve Corporation.  You must 
    24  * obey the GNU General Public License in all respects for all other 
    25  * code used. Additionally, AlliedModders LLC grants this exception 
    26  * to all derivative works. AlliedModders LLC defines further 
    27  * exceptions, found in LICENSE.txt (as of this writing, version 
    28  * JULY-31-2007), or <http://www.sourcemod.net/license.php>.
    29  *
    30  * Version: $Id$
    31  */
    32 
    33 #include <sh_list.h>
    34 #include <sh_string.h>
    35 #include "sm_trie.h"
    36 #include "sm_globals.h"
    37 #include "PluginSys.h"
    38 #include "sourcemod.h"
    39 #include "sm_stringutil.h"
    40 
    41 using namespace SourceHook;
    42 
    43 static cell_t s_curparams[SP_MAX_EXEC_PARAMS+1];
    44 static FakeNative *s_curnative = NULL;
    45 static IPluginContext *s_curcaller = NULL;
    46 
    47 cell_t FakeNativeRouter(IPluginContext *pContext, const cell_t *params, void *pData)
    48 {
    49 	FakeNative *native = (FakeNative *)pData;
    50 
    51 	/* Check if too many parameters were passed */
    52 	if (params[0] > SP_MAX_EXEC_PARAMS)
    53 	{
    54 		return pContext->ThrowNativeError("Called native with too many parameters (%d>%d)", params[9], SP_MAX_EXEC_PARAMS);
    55 	}
    56 
    57 	/* Check if the native is paused */
    58 	sp_context_t *pNativeCtx = native->ctx->GetContext();
    59 	if ((pNativeCtx->flags & SPFLAG_PLUGIN_PAUSED) == SPFLAG_PLUGIN_PAUSED)
    60 	{
    61 		return pContext->ThrowNativeError("Plugin owning this native is currently paused.");
    62 	}
    63 
    64 	CPlugin *pCaller = g_PluginSys.GetPluginByCtx(pContext->GetContext());
    65 
    66 	/* Save any old data on the stack */
    67 	FakeNative *pSaveNative = s_curnative;
    68 	IPluginContext *pSaveCaller = s_curcaller;
    69 	cell_t save_params[SP_MAX_EXEC_PARAMS+1];
    70 	if (pSaveNative != NULL)
    71 	{
    72 		/* Copy all old parameters */
    73 		for (cell_t i=0; i<=s_curparams[0]; i++)
    74 		{
    75 			save_params[i] = s_curparams[i];
    76 		}
    77 	}
    78 
    79 	/* Save the current parameters */
    80 	s_curnative = native;
    81 	s_curcaller = pContext;
    82 	for (cell_t i=0; i<=params[0]; i++)
    83 	{
    84 		s_curparams[i] = params[i];
    85 	}
    86 
    87 	/* Push info and execute. */
    88 	cell_t result = 0;
    89 	native->call->PushCell(pCaller->GetMyHandle());
    90 	native->call->PushCell(params[0]);
    91 	int error;
    92 	if ((error=native->call->Execute(&result)) != SP_ERROR_NONE)
    93 	{
    94 		if (pContext->GetContext()->n_err == SP_ERROR_NONE)
    95 		{
    96 			pContext->ThrowNativeErrorEx(error, "Error encountered while processing a dynamic native");
    97 		}
    98 	}
    99 
   100 	/* Restore everything from the stack if necessary */
   101 	s_curnative = pSaveNative;
   102 	s_curcaller = pSaveCaller;
   103 	if (pSaveNative != NULL)
   104 	{
   105 		for (cell_t i=0; i<=save_params[0]; i++)
   106 		{
   107 			s_curparams[i] = save_params[i];
   108 		}
   109 	}
   110 
   111 	return result;
   112 }
   113 
   114 static cell_t CreateNative(IPluginContext *pContext, const cell_t *params)
   115 {
   116 	char *name;
   117 	pContext->LocalToString(params[1], &name);
   118 
   119 	IPluginFunction *pFunction = pContext->GetFunctionById(params[2]);
   120 	if (!pFunction)
   121 	{
   122 		return pContext->ThrowNativeError("Function %x is not a valid function", params[2]);
   123 	}
   124 
   125 	if (!g_PluginSys.AddFakeNative(pFunction, name, FakeNativeRouter))
   126 	{
   127 		return pContext->ThrowNativeError("Fatal error creating dynamic native!");
   128 	}
   129 
   130 	return 1;
   131 }
   132 
   133 static cell_t ThrowNativeError(IPluginContext *pContext, const cell_t *params)
   134 {
   135 	if (!s_curnative || (s_curnative->ctx != pContext))
   136 	{
   137 		return pContext->ThrowNativeError("Not called from inside a native function");
   138 	}
   139 
   140 	g_SourceMod.SetGlobalTarget(LANG_SERVER);
   141 
   142 	char buffer[512];
   143 
   144 	g_SourceMod.FormatString(buffer, sizeof(buffer), pContext, params, 2);
   145 
   146 	if (pContext->GetContext()->n_err != SP_ERROR_NONE)
   147 	{
   148 		s_curcaller->ThrowNativeError("Error encountered while processing a dynamic native");
   149 	} else {
   150 		s_curcaller->ThrowNativeErrorEx(params[1], "%s", buffer);
   151 	}
   152 
   153 	return 0;
   154 }
   155 
   156 static cell_t GetNativeStringLength(IPluginContext *pContext, const cell_t *params)
   157 {
   158 	if (!s_curnative || (s_curnative->ctx != pContext))
   159 	{
   160 		return pContext->ThrowNativeError("Not called from inside a native function");
   161 	}
   162 
   163 	cell_t param = params[1];
   164 	if (param < 1 || param > s_curparams[0])
   165 	{
   166 		return pContext->ThrowNativeErrorEx(SP_ERROR_PARAM, "Invalid parameter number: %d", param);
   167 	}
   168 
   169 	int err;
   170 	char *str;
   171 	if ((err=s_curcaller->LocalToString(s_curparams[param], &str)) != SP_ERROR_NONE)
   172 	{
   173 		return err;
   174 	}
   175 
   176 	cell_t *addr;
   177 	pContext->LocalToPhysAddr(params[2], &addr);
   178 	*addr = (cell_t)strlen(str);
   179 
   180 	return SP_ERROR_NONE;
   181 }
   182 
   183 static cell_t GetNativeString(IPluginContext *pContext, const cell_t *params)
   184 {
   185 	if (!s_curnative || (s_curnative->ctx != pContext))
   186 	{
   187 		return pContext->ThrowNativeError("Not called from inside a native function");
   188 	}
   189 
   190 	cell_t param = params[1];
   191 	if (param < 1 || param > s_curparams[0])
   192 	{
   193 		return pContext->ThrowNativeErrorEx(SP_ERROR_PARAM, "Invalid parameter number: %d", param);
   194 	}
   195 
   196 	int err;
   197 	char *str;
   198 	if ((err=s_curcaller->LocalToString(s_curparams[param], &str)) != SP_ERROR_NONE)
   199 	{
   200 		return err;
   201 	}
   202 
   203 	size_t bytes = 0;
   204 	pContext->StringToLocalUTF8(params[2], params[3], str, &bytes);
   205 
   206 	cell_t *addr;
   207 	pContext->LocalToPhysAddr(params[4], &addr);
   208 	*addr = (cell_t)bytes;
   209 
   210 	return SP_ERROR_NONE;
   211 }
   212 
   213 static cell_t SetNativeString(IPluginContext *pContext, const cell_t *params)
   214 {
   215 	if (!s_curnative || (s_curnative->ctx != pContext))
   216 	{
   217 		return pContext->ThrowNativeError("Not called from inside a native function");
   218 	}
   219 
   220 	cell_t param = params[1];
   221 	if (param < 1 || param > s_curparams[0])
   222 	{
   223 		return pContext->ThrowNativeErrorEx(SP_ERROR_PARAM, "Invalid parameter number: %d", param);
   224 	}
   225 
   226 	char *str;
   227 	pContext->LocalToString(params[2], &str);
   228 
   229 	int err;
   230 	size_t bytes = 0;
   231 	if (params[4])
   232 	{
   233 		err = s_curcaller->StringToLocalUTF8(s_curparams[param], params[3], str, &bytes);
   234 	} else {
   235 		err = s_curcaller->StringToLocal(s_curparams[param], params[3], str);
   236 		/* Eww */
   237 		bytes = strlen(str);
   238 		if (bytes >= (size_t)params[3])
   239 		{
   240 			bytes = params[3] - 1;
   241 		}
   242 	}
   243 
   244 	if (err != SP_ERROR_NONE)
   245 	{
   246 		return err;
   247 	}
   248 
   249 	cell_t *addr;
   250 	pContext->LocalToPhysAddr(params[5], &addr);
   251 	*addr = (cell_t)bytes;
   252 
   253 	return SP_ERROR_NONE;
   254 }
   255 
   256 static cell_t GetNativeCell(IPluginContext *pContext, const cell_t *params)
   257 {
   258 	if (!s_curnative || (s_curnative->ctx != pContext))
   259 	{
   260 		return pContext->ThrowNativeError("Not called from inside a native function");
   261 	}
   262 
   263 	cell_t param = params[1];
   264 	if (param < 1 || param > s_curparams[0])
   265 	{
   266 		return pContext->ThrowNativeErrorEx(SP_ERROR_PARAM, "Invalid parameter number: %d", param);
   267 	}
   268 
   269 	return s_curparams[param];
   270 }
   271 
   272 static cell_t GetNativeCellRef(IPluginContext *pContext, const cell_t *params)
   273 {
   274 	if (!s_curnative || (s_curnative->ctx != pContext))
   275 	{
   276 		return pContext->ThrowNativeError("Not called from inside a native function");
   277 	}
   278 
   279 	cell_t param = params[1];
   280 	if (param < 1 || param > s_curparams[0])
   281 	{
   282 		return pContext->ThrowNativeErrorEx(SP_ERROR_PARAM, "Invalid parameter number: %d", param);
   283 	}
   284 
   285 	cell_t *addr;
   286 	if (s_curcaller->LocalToPhysAddr(s_curparams[param], &addr) != SP_ERROR_NONE)
   287 	{
   288 		return s_curcaller->ThrowNativeErrorEx(SP_ERROR_INVALID_ADDRESS, "Invalid address value");
   289 	}
   290 
   291 	return *addr;
   292 }
   293 
   294 static cell_t SetNativeCellRef(IPluginContext *pContext, const cell_t *params)
   295 {
   296 	if (!s_curnative || (s_curnative->ctx != pContext))
   297 	{
   298 		return pContext->ThrowNativeError("Not called from inside a native function");
   299 	}
   300 
   301 	cell_t param = params[1];
   302 	if (param < 1 || param > s_curparams[0])
   303 	{
   304 		return pContext->ThrowNativeErrorEx(SP_ERROR_PARAM, "Invalid parameter number: %d", param);
   305 	}
   306 
   307 	cell_t *addr;
   308 	if (s_curcaller->LocalToPhysAddr(s_curparams[param], &addr) != SP_ERROR_NONE)
   309 	{
   310 		return s_curcaller->ThrowNativeErrorEx(SP_ERROR_INVALID_ADDRESS, "Invalid address value");
   311 	}
   312 
   313 	*addr = params[2];
   314 
   315 	return 1;
   316 }
   317 
   318 static cell_t GetNativeArray(IPluginContext *pContext, const cell_t *params)
   319 {
   320 	if (!s_curnative || (s_curnative->ctx != pContext))
   321 	{
   322 		return pContext->ThrowNativeError("Not called from inside a native function");
   323 	}
   324 
   325 	cell_t param = params[1];
   326 	if (param < 1 || param > s_curparams[0])
   327 	{
   328 		return pContext->ThrowNativeErrorEx(SP_ERROR_PARAM, "Invalid parameter number: %d", param);
   329 	}
   330 
   331 	int err;
   332 	cell_t *addr;
   333 	if ((err=s_curcaller->LocalToPhysAddr(s_curparams[param], &addr)) != SP_ERROR_NONE)
   334 	{
   335 		return err;
   336 	}
   337 
   338 	cell_t *src;
   339 	pContext->LocalToPhysAddr(params[2], &src);
   340 
   341 	memcpy(src, addr, sizeof(cell_t) * params[3]);
   342 
   343 	return SP_ERROR_NONE;
   344 }
   345 
   346 static cell_t SetNativeArray(IPluginContext *pContext, const cell_t *params)
   347 {
   348 	if (!s_curnative || (s_curnative->ctx != pContext))
   349 	{
   350 		return pContext->ThrowNativeError("Not called from inside a native function");
   351 	}
   352 
   353 	cell_t param = params[1];
   354 	if (param < 1 || param > s_curparams[0])
   355 	{
   356 		return pContext->ThrowNativeErrorEx(SP_ERROR_PARAM, "Invalid parameter number: %d", param);
   357 	}
   358 
   359 	int err;
   360 	cell_t *addr;
   361 	if ((err=s_curcaller->LocalToPhysAddr(s_curparams[param], &addr)) != SP_ERROR_NONE)
   362 	{
   363 		return err;
   364 	}
   365 
   366 	cell_t *src;
   367 	pContext->LocalToPhysAddr(params[2], &src);
   368 
   369 	memcpy(addr, src, sizeof(cell_t) * params[3]);
   370 
   371 	return SP_ERROR_NONE;
   372 }
   373 
   374 static cell_t FormatNativeString(IPluginContext *pContext, const cell_t *params)
   375 {
   376 	if (!s_curnative || (s_curnative->ctx != pContext))
   377 	{
   378 		return pContext->ThrowNativeError("Not called from inside a native function");
   379 	}
   380 
   381 	int out_param = params[1];
   382 	int fmt_param = params[2];
   383 	int var_param = params[3];
   384 
   385 	/* Validate input */
   386 	if (out_param && (out_param < 1 || out_param > s_curparams[0]))
   387 	{
   388 		return pContext->ThrowNativeErrorEx(SP_ERROR_PARAM, "Invalid parameter number: %d", out_param);
   389 	}
   390 	if (fmt_param && (fmt_param < 1 || fmt_param > s_curparams[0]))
   391 	{
   392 		return pContext->ThrowNativeErrorEx(SP_ERROR_PARAM, "Invalid parameter number: %d", fmt_param);
   393 	}
   394 	if (var_param && (var_param < 1 || var_param > s_curparams[0] + 1))
   395 	{
   396 		return pContext->ThrowNativeErrorEx(SP_ERROR_PARAM, "Invalid parameter number: %d", fmt_param);
   397 	}
   398 
   399 	/* Get buffer information */
   400 	int err;
   401 	char *output_buffer;
   402 	char *format_buffer;
   403 
   404 	if (out_param)
   405 	{
   406 		if ((err=s_curcaller->LocalToString(s_curparams[out_param], &output_buffer)) != SP_ERROR_NONE)
   407 		{
   408 			return err;
   409 		}
   410 	} else {
   411 		pContext->LocalToString(params[6], &output_buffer);
   412 	}
   413 
   414 	if (fmt_param)
   415 	{
   416 		if ((err=s_curcaller->LocalToString(s_curparams[fmt_param], &format_buffer)) != SP_ERROR_NONE)
   417 		{
   418 			return err;
   419 		}
   420 	} else {
   421 		pContext->LocalToString(params[7], &format_buffer);
   422 	}
   423 
   424 	/* Get maximum length */
   425 	size_t maxlen = (size_t)params[4];
   426 
   427 	/* Do the format */
   428 	size_t written = atcprintf(output_buffer, maxlen, format_buffer, s_curcaller, s_curparams, &var_param);
   429 
   430 	cell_t *addr;
   431 	pContext->LocalToPhysAddr(params[5], &addr);
   432 	*addr = (cell_t)written;
   433 
   434 	return s_curcaller->GetContext()->n_err;
   435 }
   436 
   437 //tee hee
   438 REGISTER_NATIVES(nativeNatives)
   439 {
   440 	{"CreateNative",			CreateNative},
   441 	{"GetNativeArray",			GetNativeArray},
   442 	{"GetNativeCell",			GetNativeCell},
   443 	{"GetNativeCellRef",		GetNativeCellRef},
   444 	{"GetNativeString",			GetNativeString},
   445 	{"GetNativeStringLength",	GetNativeStringLength},
   446 	{"FormatNativeString",		FormatNativeString},
   447 	{"ThrowNativeError",		ThrowNativeError},
   448 	{"SetNativeArray",			SetNativeArray},
   449 	{"SetNativeCellRef",		SetNativeCellRef},
   450 	{"SetNativeString",			SetNativeString},
   451 	{NULL,						NULL},
   452 };
sourcemod-central
Feed