sourcemm/CSmmAPI.cpp
author Scott Ehlert <ds@alliedmods.net>
Tue Feb 27 03:25:36 2007 +0000 (2007-02-27)
changeset 291 267d4bc27469
parent 288 ec7c7bfbcbae
child 292 1a828b239258
permissions -rw-r--r--
Fixed some issues with getting the user messages when mod was compiled with frame pointer.
Added support for Dystopia through an ugly hack until more information known.
Code has been further uglified.
     1 /* ======== SourceMM ========
     2  * Copyright (C) 2004-2007 Metamod:Source Development Team
     3  * No warranties of any kind
     4  *
     5  * License: zlib/libpng
     6  *
     7  * Author(s): David "BAILOPAN" Anderson
     8  * ============================
     9  */
    10 
    11 #include "convar_smm.h"
    12 #include "CSmmAPI.h"
    13 #include "sourcemm.h"
    14 #include "concommands.h"
    15 #include "CPlugin.h"
    16 #include "vsp_listener.h"
    17 
    18 /**
    19  * @brief Implementation of main API interface
    20  * @file CSmmAPI.cpp
    21  */
    22 
    23 using namespace SourceMM;
    24 
    25 CSmmAPI g_SmmAPI;
    26 
    27 CSmmAPI::CSmmAPI()
    28 {
    29 	m_ConPrintf = NULL;
    30 	m_CmdCache = false;
    31 	m_MsgCount = -1;
    32 	m_VSP = false;
    33 }
    34 
    35 CSmmAPI::~CSmmAPI()
    36 {
    37 	m_UserMessages.RemoveAll();
    38 }
    39 
    40 void CSmmAPI::LogMsg(ISmmPlugin *pl, const char *msg, ...)
    41 {
    42 	va_list ap;
    43 	static char buffer[2048];
    44 
    45 	buffer[0] = '\0';
    46 
    47 	va_start(ap, msg);
    48 	vsnprintf(buffer, sizeof(buffer)-1, msg, ap);
    49 	va_end(ap);
    50 
    51 	LogMessage("[%s] %s", pl->GetLogTag(), buffer);
    52 }
    53 
    54 CreateInterfaceFn CSmmAPI::engineFactory(bool syn)
    55 {
    56 	if (syn)
    57 		return EngineFactory;
    58 	return g_Engine.engineFactory;
    59 }
    60 
    61 CreateInterfaceFn CSmmAPI::physicsFactory(bool syn)
    62 {
    63 	if (syn)
    64 		return PhysicsFactory;
    65 	return g_Engine.physicsFactory;
    66 }
    67 
    68 CreateInterfaceFn CSmmAPI::fileSystemFactory(bool syn)
    69 {
    70 	if (syn)
    71 		return FileSystemFactory;
    72 	return g_Engine.fileSystemFactory;
    73 }
    74 
    75 CreateInterfaceFn CSmmAPI::serverFactory(bool syn)
    76 {
    77 	if (syn)
    78 		return CreateInterface;
    79 	return g_GameDll.factory;
    80 }
    81 
    82 CGlobalVars *CSmmAPI::pGlobals()
    83 {
    84 	return g_Engine.pGlobals;
    85 }
    86 
    87 void CSmmAPI::SetLastMetaReturn(META_RES res)
    88 {
    89 	m_Res = res;
    90 }
    91 
    92 META_RES CSmmAPI::GetLastMetaReturn()
    93 {
    94 	return m_Res;
    95 }
    96 
    97 IConCommandBaseAccessor *CSmmAPI::GetCvarBaseAccessor()
    98 {
    99 	return static_cast<IConCommandBaseAccessor *>(&g_SMConVarAccessor);
   100 }
   101 
   102 bool CSmmAPI::RegisterConCmdBase(ISmmPlugin *plugin, ConCommandBase *pCommand)
   103 {
   104 	if (pCommand->IsCommand())
   105 	{
   106 		g_PluginMngr.AddPluginCmd(plugin, pCommand);
   107 	} else {
   108 		g_PluginMngr.AddPluginCvar(plugin, pCommand);
   109 	}
   110 
   111 	return g_SMConVarAccessor.Register(pCommand);
   112 }
   113 
   114 void CSmmAPI::UnregisterConCmdBase(ISmmPlugin *plugin, ConCommandBase *pCommand)
   115 {
   116 	if (pCommand->IsCommand())
   117 	{
   118 		g_PluginMngr.RemovePluginCmd(plugin, pCommand);
   119 	} else {
   120 		g_PluginMngr.RemovePluginCvar(plugin, pCommand);
   121 	}
   122 
   123 	g_SMConVarAccessor.Unregister(pCommand);
   124 }
   125 
   126 void CSmmAPI::ConPrint(const char *fmt)
   127 {
   128 	(m_ConPrintf)("%s", fmt);
   129 }
   130 
   131 void CSmmAPI::ConPrintf(const char *fmt, ...)
   132 {
   133 	va_list ap;
   134 	static char buf[4096];
   135 	va_start(ap, fmt);
   136 	vsnprintf(buf, sizeof(buf)-1, fmt, ap);
   137 	ConPrint(buf);
   138 	va_end(ap);
   139 }
   140 
   141 void CSmmAPI::AddListener(ISmmPlugin *plugin, IMetamodListener *pListener)
   142 {
   143 	CPluginManager::CPlugin *pl = g_PluginMngr.FindByAPI(plugin);
   144 
   145 	pl->m_Events.push_back(pListener);
   146 }
   147 
   148 void *CSmmAPI::MetaFactory(const char *iface, int *_ret, PluginId *id)
   149 {
   150 	if (id)
   151 	{
   152 		*id = 0;
   153 	}
   154 
   155 	if (!iface)
   156 	{
   157 		return NULL;
   158 	}
   159 
   160 	//first check ours... we get first chance!
   161 	if (strcmp(iface, MMIFACE_SOURCEHOOK) == 0)
   162 	{
   163 		if (_ret)
   164 		{
   165 			*_ret = IFACE_OK;
   166 		}
   167 		return static_cast<void *>(static_cast<SourceHook::ISourceHook *>(&g_SourceHook));
   168 	} else if (strcmp(iface, MMIFACE_PLMANAGER) == 0) {
   169 		if (_ret)
   170 		{
   171 			*_ret = IFACE_OK;
   172 		}
   173 		return static_cast<void *>(static_cast<ISmmPluginManager *>(&g_PluginMngr));
   174 	}
   175 
   176 	CPluginManager::CPlugin *pl;
   177 	SourceHook::List<IMetamodListener *>::iterator event;
   178 	IMetamodListener *api;
   179 	int ret = 0;
   180 	void *val = NULL;
   181 
   182 	for (PluginIter iter = g_PluginMngr._begin(); iter != g_PluginMngr._end(); iter++)
   183 	{
   184 		pl = (*iter);
   185 		for (event=pl->m_Events.begin(); event!=pl->m_Events.end(); event++)
   186 		{
   187 			api = (*event);
   188 			ret = IFACE_FAILED;
   189 			if ( (val=api->OnMetamodQuery(iface, &ret)) != NULL )
   190 			{
   191 				if (_ret)
   192 					*_ret = ret;
   193 				if (id)
   194 					*id = pl->m_Id;
   195 				return val;
   196 			}
   197 		}
   198 	}
   199 
   200 	if (_ret)
   201 		*_ret = IFACE_FAILED;
   202 
   203 	return NULL;
   204 }
   205 
   206 //////////////////////////////////////////////////////////////////////////
   207 //THERE BE HAX HERE!!!! DON'T TELL ALFRED, BUT GABE WANTED IT THAT WAY. //
   208 // (note: you can find the offset by looking for the text               //
   209 //   "Echo text to console", you'll find the callback cmd pushed on the //
   210 //   stack.)                                                            //
   211 //////////////////////////////////////////////////////////////////////////
   212 
   213 #define SIGLEN			8
   214 #define ENGINE486_SIG	"\x55\x89\xE5\x53\x83\xEC\x14\xBB"
   215 #define ENGINE486_OFFS	40
   216 #define ENGINE686_SIG	"\x53\x83\xEC\x08\xBB\x01\x00\x00"
   217 #define ENGINE686_OFFS	50
   218 #define	ENGINEAMD_SIG	"\x53\x51\xBB\x01\x00\x00\x00\x51"
   219 #define	ENGINEAMD_OFFS	47
   220 #define ENGINEW32_SIG	"\xA1\x2A\x2A\x2A\x2A\x56\xBE\x01"
   221 #define ENGINEW32_OFFS	38
   222 #define IA32_CALL		0xE8
   223 
   224 bool vcmp(const void *_addr1, const void *_addr2, size_t len)
   225 {
   226 	unsigned char *addr1 = (unsigned char *)_addr1;
   227 	unsigned char *addr2 = (unsigned char *)_addr2;
   228 
   229 	for (size_t i=0; i<len; i++)
   230 	{
   231 		if (addr2[i] == '*')
   232 			continue;
   233 		if (addr1[i] != addr2[i])
   234 			return false;
   235 	}
   236 
   237 	return true;
   238 }
   239 
   240 //Thanks to fysh for the idea of extracting info from "echo" and for
   241 // having the original offsets at hand!
   242 bool CSmmAPI::CacheCmds()
   243 {
   244 	ICvar *pCvar = g_Engine.icvar;
   245 
   246 	ConCommandBase *pBase = pCvar->GetCommands();
   247 	unsigned char *ptr = NULL;
   248 	FnCommandCallback callback = NULL;
   249 	int offs = 0;
   250 
   251 	while (pBase)
   252 	{
   253 		if ( strcmp(pBase->GetName(), "echo") == 0 )
   254 		{
   255 			//callback = //*((FnCommandCallback *)((char *)pBase + offsetof(ConCommand, m_fnCommandCallback)));
   256 			callback = ((ConCommand *)pBase)->GetCallback();
   257 			ptr = (unsigned char *)callback;
   258 		#ifdef OS_LINUX
   259 			if (vcmp(ptr, ENGINE486_SIG, SIGLEN))
   260 			{
   261 				offs = ENGINE486_OFFS;
   262 			}
   263 			else if (vcmp(ptr, ENGINE686_SIG, SIGLEN))
   264 			{
   265 				offs = ENGINE686_OFFS;
   266 			}
   267 			else if (vcmp(ptr, ENGINEAMD_SIG, SIGLEN))
   268 			{
   269 				offs = ENGINEAMD_OFFS;
   270 			}
   271 		#elif defined OS_WIN32 // Only one Windows engine binary so far...
   272 			if (vcmp(ptr, ENGINEW32_SIG, SIGLEN))
   273 			{
   274 				offs = ENGINEW32_OFFS;
   275 			}
   276 		#endif
   277 
   278 			if (!offs || ptr[offs-1] != IA32_CALL)
   279 			{
   280 				m_ConPrintf = (CONPRINTF_FUNC)Msg;
   281 				return false;
   282 			}
   283 			//get the relative offset
   284 			m_ConPrintf = *((CONPRINTF_FUNC *)(ptr + offs));
   285 			//add the base offset, to the ip (which is the address+offset + 4 bytes for next instruction)
   286 			m_ConPrintf = (CONPRINTF_FUNC)((unsigned long)m_ConPrintf + (unsigned long)(ptr + offs) + 4);
   287 
   288 			m_CmdCache = true;
   289 
   290 			return true;
   291 		}
   292 		pBase = const_cast<ConCommandBase *>(pBase->GetNext());
   293 	}
   294 
   295 	m_ConPrintf = (CONPRINTF_FUNC)Msg;
   296 
   297 	return false;
   298 }
   299 
   300 bool CSmmAPI::CmdCacheSuccessful()
   301 {
   302 	return m_CmdCache;
   303 }
   304 
   305 void CSmmAPI::GetApiVersions(int &major, int &minor, int &plvers, int &plmin)
   306 {
   307 	major = SM_VERS_API_MAJOR;
   308 	minor = SM_VERS_API_MINOR;
   309 	plvers = PLAPI_VERSION;
   310 	plmin = PLAPI_MIN_VERSION;
   311 }
   312 
   313 void CSmmAPI::GetShVersions(int &shvers, int &shimpl)
   314 {
   315 	shvers = SH_IFACE_VERSION;
   316 	shimpl = SH_IMPL_VERSION;
   317 }
   318 
   319 int CSmmAPI::FormatIface(char iface[], unsigned int maxlength)
   320 {
   321 	int length = (int)strlen(iface);
   322 	int i;
   323 	int num = 0;
   324 
   325 	for (i=length-1; i>=0; i--)
   326 	{
   327 		if (!isdigit(iface[i]))
   328 		{
   329 			if (i != length-1)
   330 			{
   331 				num = 1;
   332 			}
   333 			break;
   334 		}
   335 	}
   336 
   337 	if ( (num && ((int)maxlength <= length)) || (!num && ((int)maxlength <= length+3)) )
   338 	{
   339 		return -1;
   340 	}
   341 
   342 	if (i != length-1)
   343 		num = atoi(&(iface[++i]));
   344 
   345 	num++;
   346 
   347 	snprintf(&(iface[i]), 4, "%03d", num);
   348 
   349 	return num;
   350 }
   351 
   352 void *CSmmAPI::InterfaceSearch(CreateInterfaceFn fn, const char *iface, int max, int *ret)
   353 {
   354 	char _if[256];	/* assume no interface goes beyond this */
   355 	size_t len = strlen(iface);
   356 	int num = 0;
   357 	void *pf = NULL;
   358 
   359 	if (max > 999)
   360 		max = 999;
   361 
   362 	if (len + 4 > sizeof(_if))
   363 	{
   364 		if (ret)
   365 		{
   366 			*ret = IFACE_FAILED;
   367 		}
   368 		return NULL;
   369 	}
   370 
   371 	strcpy(_if, iface);
   372 
   373 	do
   374 	{
   375 		if ( (pf = (fn)(_if, ret)) != NULL )
   376 			break;
   377 		if (num > max)
   378 			break;
   379 	} while (( num = FormatIface(_if, len+1) ));
   380 
   381 	return pf;
   382 }
   383 
   384 void *CSmmAPI::VInterfaceMatch(CreateInterfaceFn fn, const char *iface, int min)
   385 {
   386 	char buffer[256];	/* assume no interface will go beyond this */
   387 	int len = static_cast<int>(strlen(iface));
   388 	int ret;			/* just in case something doesn't handle NULL properly */
   389 
   390 	if (len > static_cast<int>(sizeof(buffer) - 4))
   391 	{
   392 		return NULL;
   393 	}
   394 
   395 	strcpy(buffer, iface);
   396 
   397 	if (min != -1)
   398 	{
   399 		char *ptr = &buffer[len-1];
   400 		int digits = 0;
   401 		while (isdigit(*ptr) && digits <=3)
   402 		{
   403 			*ptr = '\0';
   404 			digits++;
   405 			ptr--;
   406 		}
   407 		if (digits != 3)
   408 		{
   409 			/* for now, assume this is an error */
   410 			strcpy(buffer, iface);
   411 		} else {
   412 			char num[4];
   413 			min = (min == 0) ? 1 : min;
   414 			snprintf(num, sizeof(num), "%03d", min);
   415 			strcat(buffer, num);
   416 		}
   417 	}
   418 
   419 	return InterfaceSearch(fn, buffer, IFACE_MAXNUM, &ret);
   420 }
   421 
   422 const char *CSmmAPI::GetBaseDir()
   423 {
   424 	return g_ModPath.c_str();
   425 }
   426 
   427 void CSmmAPI::PathFormat(char *buffer, size_t len, const char *fmt, ...)
   428 {
   429 	va_list ap;
   430 	va_start(ap,fmt);
   431 	size_t mylen = vsnprintf(buffer, len, fmt, ap);
   432 	va_end(ap);
   433 
   434 	if (mylen == 0xFFFFFFFF || mylen >= len)
   435 	{
   436 		mylen = len - 1;
   437 	}
   438 
   439 	for (size_t i=0; i<mylen; i++)
   440 	{
   441 		if (buffer[i] == ALT_SEP_CHAR)
   442 			buffer[i] = PATH_SEP_CHAR;
   443 	}
   444 }
   445 
   446 void CSmmAPI::ClientConPrintf(edict_t *client, const char *fmt, ...)
   447 {
   448 	va_list ap;
   449 	static char buf[4096];
   450 	va_start(ap, fmt);
   451 	vsnprintf(buf, sizeof(buf) - 1, fmt, ap);
   452 	g_Engine.engine->ClientPrintf(client, buf);
   453 	va_end(ap);
   454 }
   455 
   456 void CSmmAPI::LoadAsVSP()
   457 {
   458 	g_Engine.engine->ServerCommand("plugin_load \n");
   459 	g_Engine.engine->ServerExecute();
   460 
   461 	IServerPluginCallbacks *iface = NULL;
   462 	if (g_VspListener.IsLoaded())
   463 	{
   464 		iface = &g_VspListener;
   465 	}
   466 
   467 	PluginIter iter;
   468 	CPluginManager::CPlugin *pPlugin;
   469 	SourceHook::List<IMetamodListener *>::iterator event;
   470 	IMetamodListener *pML;
   471 	for (iter=g_PluginMngr._begin(); iter!=g_PluginMngr._end(); iter++)
   472 	{
   473 		pPlugin = (*iter);
   474 		if (pPlugin->m_Status < Pl_Paused)
   475 		{
   476 			continue;
   477 		}
   478 		/* Only valid for plugins >= 10 (v1:5, SourceMM 1.4) */
   479 		if (pPlugin->m_API->GetApiVersion() < 10)
   480 		{
   481 			continue;
   482 		}
   483 		for (event=pPlugin->m_Events.begin();
   484 			 event!=pPlugin->m_Events.end();
   485 			 event++)
   486 		{
   487 			pML = (*event);
   488 			pML->OnVSPListening(iface);
   489 		}
   490 	}
   491 }
   492 
   493 void CSmmAPI::EnableVSPListener()
   494 {
   495 	/* If GameInit already passed and we're not already enabled or loaded, go ahead and LoadAsVSP load */
   496 	if (bGameInit && !m_VSP && !g_VspListener.IsLoaded())
   497 	{
   498 		LoadAsVSP();
   499 	}
   500 	m_VSP = true;
   501 }
   502 
   503 int CSmmAPI::GetGameDLLVersion()
   504 {
   505 	return g_GameDllVersion;
   506 }
   507 
   508 //////////////////////////////////////////////////////////////////////
   509 // EVEN MORE HACKS HERE! YOU HAVE BEEN WARNED!                      //
   510 // Signatures necessary in finding the pointer to the CUtlDict that //
   511 //   stores user message information.                               //
   512 // IServerGameDLL::GetUserMessageInfo() normally crashes with bad   //
   513 //   message indices. This is our answer to it. Yuck! <:-(          //
   514 //////////////////////////////////////////////////////////////////////
   515 #ifdef OS_WIN32
   516 	#define MSGCLASS_SIGLEN		7
   517 	#define MSGCLASS_SIG		"\x8B\x0D\x2A\x2A\x2A\x2A\x56"
   518 	#define MSGCLASS_OFFS		2
   519 
   520 	#define MSGCLASS2_SIGLEN	16
   521 	#define MSGCLASS2_SIG		"\x56\x8B\x74\x24\x2A\x85\xF6\x7C\x2A\x3B\x35\x2A\x2A\x2A\x2A\x7D"
   522 	#define MSGCLASS2_OFFS		11
   523 #elif defined OS_LINUX
   524 	#define MSGCLASS_SIGLEN		14
   525 	#define MSGCLASS_SIG		"\x53\x83\xEC\x2A\x8B\x2A\x2A\x2A\xA1\x2A\x2A\x2A\x2A\x89"
   526 	#define MSGCLASS_OFFS		9
   527 
   528 	#define MSGCLASS2_SIGLEN	16
   529 	#define MSGCLASS2_SIG		"\x55\x89\xE5\x53\x83\xEC\x2A\x8B\x2A\x2A\xA1\x2A\x2A\x2A\x2A\x89"
   530 	#define MSGCLASS2_OFFS		11
   531 #endif
   532 
   533 /* This is the ugliest function in all of SourceMM */
   534 /* :TODO: Make this prettier */
   535 bool CSmmAPI::CacheUserMessages()
   536 {
   537 	SourceHook::MemFuncInfo info = {true, -1, 0, 0};
   538 	SourceHook::GetFuncInfo(&IServerGameDLL::GetUserMessageInfo, info);
   539 
   540 	// Get address of original GetUserMessageInfo()
   541 	char *vfunc = reinterpret_cast<char *>(g_GameDllPatch->GetOrigFunc(info.vtbloffs, info.vtblindex));
   542 
   543 	// If we can't get original function (GetOrigFunc bug?)
   544 	if (vfunc == NULL)
   545 	{
   546 		// This means there's no hook, so we must get it manually - Lovely code <:-(
   547 		char *adjustedptr = reinterpret_cast<char *>(g_GameDll.pGameDLL) + info.thisptroffs + info.vtbloffs;
   548 		char **vtable = *reinterpret_cast<char ***>(adjustedptr);
   549 
   550 		vfunc = vtable[info.vtblindex];
   551 	}
   552 
   553 	UserMsgDict *dict = NULL;
   554 
   555 	if (vcmp(vfunc, MSGCLASS_SIG, MSGCLASS_SIGLEN))
   556 	{
   557 		// Get address of CUserMessages instance
   558 		char **userMsgClass = *reinterpret_cast<char ***>(vfunc + MSGCLASS_OFFS);
   559 
   560 		// Get address of CUserMessages::m_UserMessages
   561 		dict = reinterpret_cast<UserMsgDict *>(*userMsgClass);
   562 	} else if (vcmp(vfunc, MSGCLASS2_SIG, MSGCLASS2_SIGLEN)) {
   563 	#ifdef OS_WIN32
   564 		/* If we get here, the code is possibly inlined like in Dystopia */
   565 
   566 		// Get the address of the CUtlRBTree
   567 		char *rbtree = *reinterpret_cast<char **>(vfunc + MSGCLASS2_OFFS);
   568 
   569 		// The CUtlDict should be 8 bytes before the CUtlRBTree (yeah I know this is hacky)
   570 		dict = reinterpret_cast<UserMsgDict *>(rbtree - 8);
   571 	#elif defined OS_LINUX
   572 		// Get address of CUserMessages instance
   573 		char **userMsgClass = *reinterpret_cast<char ***>(vfunc + MSGCLASS2_OFFS);
   574 
   575 		// Get address of CUserMessages::m_UserMessages
   576 		dict = reinterpret_cast<UserMsgDict *>(*userMsgClass);
   577 	#endif
   578 	}
   579 
   580 	if (dict)
   581 	{
   582 		m_MsgCount = dict->Count();
   583 
   584 		// Make sure count falls within bounds of an unsigned byte (engine sends message types as such)
   585 		if (m_MsgCount < 0 || m_MsgCount > 255)
   586 		{
   587 			m_MsgCount = -1;
   588 			return false;
   589 		}
   590 
   591 		UserMessage *msg;
   592 
   593 		// Cache messages in our CUtlDict
   594 		for (int i = 0; i < m_MsgCount; i++)
   595 		{
   596 			msg = dict->Element(i);
   597 			m_UserMessages.Insert(msg->name, msg);
   598 		}
   599 
   600 		return true;
   601 	}
   602 
   603 	return false;
   604 }
   605 
   606 bool CSmmAPI::MsgCacheSuccessful()
   607 {
   608 	return m_MsgCount > -1;
   609 }
   610 
   611 int CSmmAPI::GetUserMessageCount()
   612 {
   613 	return m_MsgCount;
   614 }
   615 
   616 int CSmmAPI::FindUserMessage(const char *name, int *size)
   617 {
   618 	int index = m_UserMessages.Find(name);
   619 
   620 	if (size && index > -1)
   621 	{
   622 		UserMessage *msg = m_UserMessages.Element(index);
   623 		*size = msg->size;
   624 	}
   625 
   626 	return index;
   627 }
   628 
   629 const char *CSmmAPI::GetUserMessage(int index, int *size)
   630 {
   631 	if (m_MsgCount <= 0 || index < 0 || index >= m_MsgCount)
   632 	{
   633 		return NULL;
   634 	}
   635 
   636 	UserMessage *msg = m_UserMessages.Element(index);
   637 
   638 	if (size)
   639 	{
   640 		*size = msg->size;
   641 	}
   642 
   643 	return msg->name;
   644 }