sourcemm/sourcemm.cpp
author David Anderson <dvander@alliedmods.net>
Fri Sep 21 18:03:57 2007 +0000 (2007-09-21)
branchsourcemm-1.6.0
changeset 351 7347be0355ae
parent 348 716af2e7be78
permissions -rw-r--r--
- added an api call for finding source engine build
- random markup/doc changes
     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  * Contributor(s): Scott "Damaged Soul" Ehlert
     9  *				: Pavol "PM OnoTo" Marko
    10  * ============================
    11  */
    12 
    13 #include <interface.h>
    14 #include <eiface.h>
    15 #include <tier0/icommandline.h>
    16 #include "sourcemm.h"
    17 #include "concommands.h"
    18 #include "CSmmAPI.h"
    19 #include "CPlugin.h"
    20 #include "util.h"
    21 #include "vsp_listener.h"
    22 
    23 using namespace SourceMM;
    24 
    25 /**
    26  * @brief Implementation of main SourceMM GameDLL functionality
    27  * @file sourcemm.cpp
    28  */
    29 
    30 #undef CommandLine
    31 DLL_IMPORT ICommandLine *CommandLine();
    32 
    33 SH_DECL_HOOK4(IServerGameDLL, DLLInit, SH_NOATTRIB, false, bool, CreateInterfaceFn, CreateInterfaceFn, CreateInterfaceFn, CGlobalVars *);
    34 SH_DECL_HOOK0_void(IServerGameDLL, DLLShutdown, SH_NOATTRIB, false);
    35 SH_DECL_HOOK0_void(IServerGameDLL, LevelShutdown, SH_NOATTRIB, false);
    36 SH_DECL_HOOK6(IServerGameDLL, LevelInit, SH_NOATTRIB, false, bool, const char *, const char *, const char *, const char *, bool, bool);
    37 SH_DECL_HOOK1_void(IServerGameClients, ClientCommand, SH_NOATTRIB, 0, edict_t *);
    38 SH_DECL_HOOK0(IServerGameDLL, GameInit, SH_NOATTRIB, false, bool);
    39 
    40 bool DLLInit(CreateInterfaceFn engineFactory, CreateInterfaceFn physicsFactory, CreateInterfaceFn filesystemFactory, CGlobalVars *pGlobals);
    41 bool DLLInit_Post(CreateInterfaceFn engineFactory, CreateInterfaceFn physicsFactory, CreateInterfaceFn filesystemFactory, CGlobalVars *pGlobals);
    42 void DLLShutdown_handler();
    43 void LevelShutdown_handler();
    44 bool LevelInit_handler(char const *pMapName, char const *pMapEntities, char const *pOldLevel, char const *pLandmarkName, bool loadGame, bool background);
    45 bool GameInit_handler();
    46 
    47 GameDllInfo g_GameDll = {false, NULL, NULL, NULL, NULL};
    48 EngineInfo g_Engine;
    49 SourceHook::CSourceHookImpl g_SourceHook;
    50 SourceHook::ISourceHook *g_SHPtr = &g_SourceHook;
    51 SourceHook::String g_ModPath;
    52 SourceHook::String g_BinPath;
    53 SourceHook::String g_SmmPath;
    54 PluginId g_PLID = Pl_Console;			/* Technically, SourceMM is the "Console" plugin... :p */
    55 bool bInFirstLevel = true;
    56 bool gParsedGameInfo = false;
    57 bool bGameInit = false;
    58 SourceHook::List<GameDllInfo *> gamedll_list;
    59 SourceHook::CallClass<IServerGameDLL> *g_GameDllPatch;
    60 int g_GameDllVersion = 0;
    61 int g_GameClientsVersion = 0;
    62 int g_VspVersion = 0;
    63 int g_SourceEngineVersion = SOURCE_ENGINE_ORIGINAL;
    64 const char VSPIFACE[] = "ISERVERPLUGINCALLBACKS";
    65 const char GAMEINFO_PATH[] = "|gameinfo_path|";
    66 
    67 void ClearGamedllList();
    68 
    69 /* Helper Macro */
    70 #define	IFACE_MACRO(orig,nam) \
    71 	CPluginManager::CPlugin *pl; \
    72 	SourceHook::List<IMetamodListener *>::iterator event; \
    73 	IMetamodListener *api; \
    74 	int mret = 0; \
    75 	void *val = NULL; \
    76 	for (PluginIter iter = g_PluginMngr._begin(); iter != g_PluginMngr._end(); iter++) { \
    77 		pl = (*iter); \
    78 		for (event=pl->m_Events.begin(); event!=pl->m_Events.end(); event++) { \
    79 			api = (*event); \
    80 			mret = IFACE_FAILED; \
    81 			if ( (val=api->On##nam##Query(iface, &mret)) != NULL ) { \
    82 				if (ret) *ret = mret; \
    83 				return val; \
    84 			} \
    85 		} \
    86 	} \
    87 	return (orig)(iface, ret);
    88 
    89 #define ITER_EVENT(evn, args) \
    90 	CPluginManager::CPlugin *pl; \
    91 	SourceHook::List<IMetamodListener *>::iterator event; \
    92 	IMetamodListener *api; \
    93 	for (PluginIter iter = g_PluginMngr._begin(); iter != g_PluginMngr._end(); iter++) { \
    94 		pl = (*iter); \
    95 		for (event=pl->m_Events.begin(); event!=pl->m_Events.end(); event++) { \
    96 			api = (*event); \
    97 			api->evn args; \
    98 		} \
    99 	}
   100 
   101 ///////////////////////////////////
   102 // Main code for HL2 Interaction //
   103 ///////////////////////////////////
   104 
   105 /* Initialize everything here */
   106 void InitMainStates()
   107 {
   108 	char full_path[PATH_SIZE] = {0};
   109 	GetFileOfAddress((void *)g_GameDll.factory, full_path, sizeof(full_path));
   110 	g_BinPath.assign(full_path);
   111 
   112 	/* Like Metamod, reload plugins at the end of the map.
   113 	 * This is so plugins can hook everything on load, BUT, new plugins will be reloaded
   114 	 * if the server is shut down (silly, but rare case).
   115 	 */
   116 	bInFirstLevel = true;
   117 
   118 	SH_ADD_HOOK_STATICFUNC(IServerGameDLL, DLLInit, g_GameDll.pGameDLL, DLLInit, false);
   119 	SH_ADD_HOOK_STATICFUNC(IServerGameDLL, DLLInit, g_GameDll.pGameDLL, DLLInit_Post, true);
   120 	SH_ADD_HOOK_STATICFUNC(IServerGameDLL, DLLShutdown, g_GameDll.pGameDLL, DLLShutdown_handler, false);
   121 	SH_ADD_HOOK_STATICFUNC(IServerGameDLL, LevelShutdown, g_GameDll.pGameDLL, LevelShutdown_handler, true);
   122 	SH_ADD_HOOK_STATICFUNC(IServerGameDLL, LevelInit, g_GameDll.pGameDLL, LevelInit_handler, true);
   123 	SH_ADD_HOOK_STATICFUNC(IServerGameDLL, GameInit, g_GameDll.pGameDLL, GameInit_handler, false);
   124 }
   125 
   126 bool DLLInit(CreateInterfaceFn engineFactory, CreateInterfaceFn physicsFactory, CreateInterfaceFn filesystemFactory, CGlobalVars *pGlobals)
   127 {
   128 	g_Engine.engineFactory = engineFactory;
   129 	g_Engine.fileSystemFactory = filesystemFactory;
   130 	g_Engine.physicsFactory = physicsFactory;
   131 	g_Engine.pGlobals = pGlobals;
   132 
   133 	g_Engine.engine = (IVEngineServer *)((engineFactory)(INTERFACEVERSION_VENGINESERVER, NULL));
   134 	if (!g_Engine.engine)
   135 	{
   136 		Error("Could not find IVEngineServer! Metamod cannot load.");
   137 		return false;
   138 	}
   139 	g_Engine.icvar = (ICvar *)((engineFactory)(VENGINE_CVAR_INTERFACE_VERSION , NULL));
   140 	if (!g_Engine.icvar)
   141 	{
   142 		Error("Could not find ICvar! Metamod cannot load.");
   143 		return false;
   144 	}
   145 
   146 	g_Engine.loaded = true;
   147 
   148 	/* Initialize our console hooks */
   149 	ConCommandBaseMgr::OneTimeInit(static_cast<IConCommandBaseAccessor *>(&g_SMConVarAccessor));
   150 
   151 	g_GameDllPatch = SH_GET_CALLCLASS(g_GameDll.pGameDLL);
   152 
   153 	if (g_GameDll.pGameClients)
   154 	{
   155 		SH_ADD_HOOK_STATICFUNC(IServerGameClients, ClientCommand, g_GameDll.pGameClients, ClientCommand_handler, false);
   156 	} else {
   157 		/* If IServerGameClients isn't found, this really isn't a fatal error so... */
   158 		LogMessage("[META] Warning: Could not find IServerGameClients!");
   159 		LogMessage("[META] Warning: The 'meta' command will not be available to clients.");
   160 	}
   161 
   162 	if (!g_SmmAPI.CacheCmds())
   163 	{
   164 		LogMessage("[META] Warning: Failed to initialize Con_Printf.  Defaulting to Msg().");
   165 		LogMessage("[META] Warning: Console messages will not be redirected to rcon console.");
   166 	}
   167 
   168 	if (!g_SmmAPI.CacheUserMessages())
   169 	{
   170 		/* Don't know of a mod that has stripped out user messages completely, 
   171 		 * but perhaps should do something different here?
   172 		 */
   173 		LogMessage("[META] Warning: Failed to get list of user messages.");
   174 		LogMessage("[META] Warning: The 'meta game' command will not display user messages.");
   175 	}
   176 
   177 	const char *pluginFile = g_Engine.icvar->GetCommandLineValue("mm_pluginsfile");
   178 	if (!pluginFile) 
   179 	{
   180 		pluginFile = GetPluginsFile();
   181 	}
   182 
   183 	char full_path[260];
   184 	g_SmmAPI.PathFormat(full_path, sizeof(full_path), "%s/%s", g_ModPath.c_str(), pluginFile);
   185 
   186 	LoadPluginsFromFile(full_path);
   187 
   188 	bInFirstLevel = true;
   189 
   190 	RETURN_META_VALUE(MRES_IGNORED, true);
   191 }
   192 
   193 bool GameInit_handler()
   194 {
   195 	if (bGameInit)
   196 	{
   197 		return true;
   198 	}
   199 
   200 	if (g_SmmAPI.VSPEnabled())
   201 	{
   202 		g_SmmAPI.LoadAsVSP();
   203 	}
   204 
   205 	bGameInit = true;
   206 
   207 	RETURN_META_VALUE(MRES_IGNORED, true);
   208 }
   209 
   210 bool DLLInit_Post(CreateInterfaceFn engineFactory, CreateInterfaceFn physicsFactory, CreateInterfaceFn filesystemFactory, CGlobalVars *pGlobals)
   211 {
   212 	g_PluginMngr.SetAllLoaded();
   213 	RETURN_META_VALUE(MRES_IGNORED, true);
   214 }
   215 
   216 /* This is where the magic happens */
   217 SMM_API void *CreateInterface(const char *iface, int *ret)
   218 {
   219 	/* Prevent loading of self as a SourceMM plugin or Valve server plugin :x */
   220 	if (strcmp(iface, PLAPI_NAME) == 0)
   221 	{
   222 		Warning("Do not try loading Metamod:Source as a plugin.\n");
   223 
   224 		if (ret)
   225 		{
   226 			*ret = IFACE_FAILED;
   227 		}
   228 
   229 		return NULL;
   230 	}
   231 
   232 	if (strncmp(iface, VSPIFACE, 22) == 0)
   233 	{
   234 		g_VspVersion = atoi(&(iface[22]));
   235 
   236 		if (g_VspVersion <= MAX_VSP_VERSION)
   237 		{
   238 			if (ret)
   239 			{
   240 				*ret = IFACE_OK;
   241 			}
   242 			return &g_VspListener;
   243 		}
   244 	}
   245 
   246 	if (!gParsedGameInfo)
   247 	{
   248 		gParsedGameInfo = true;
   249 		const char *gameDir = NULL;
   250 		char gamePath[PATH_SIZE];
   251 		char smmPath[PATH_SIZE];
   252 
   253 		/* Get path to SourceMM DLL */
   254 		if (!GetFileOfAddress((void *)CreateInterface, smmPath, sizeof(smmPath)))
   255 		{
   256 			Error("GetFileOfAddress() failed! Metamod cannot load.\n");
   257 			return NULL;
   258 		}
   259 
   260 		g_SmmPath.assign(smmPath);
   261 
   262 		/* Get value of -game from command line, defaulting to hl2 as engine seems to do */
   263 		gameDir = CommandLine()->ParmValue("-game", "hl2");
   264 
   265 		/* Get absolute path */
   266 		abspath(gamePath, gameDir);
   267 		g_ModPath.assign(gamePath);
   268 
   269 		char tempPath[PATH_SIZE];
   270 
   271 		/* Path to gameinfo.txt */
   272 		g_SmmAPI.PathFormat(tempPath, PATH_SIZE, "%s/%s", g_ModPath.c_str(), "gameinfo.txt");
   273 
   274 		FILE *fp = fopen(tempPath, "rt");
   275 
   276 		if (!fp)
   277 		{
   278 			Error("Unable to open gameinfo.txt!  Metamod cannot load.\n");
   279 			return NULL;
   280 		}
   281 
   282 		char buffer[255];
   283 		char key[128], val[128];
   284 		bool search = false;
   285 		bool gamebin = false;
   286 		char *ptr;
   287 		const char *lptr;
   288 		char curPath[PATH_SIZE];
   289 
   290 		getcwd(curPath, PATH_SIZE);
   291 
   292 		while (!feof(fp))
   293 		{
   294 			buffer[0] = '\0';
   295 			fgets(buffer, sizeof(buffer), fp);
   296 			UTIL_TrimComments(buffer);
   297 			UTIL_TrimLeft(buffer);
   298 			UTIL_TrimRight(buffer);
   299 			if (stricmp(buffer, "SearchPaths") == 0)
   300 				search = true;
   301 			if (!search)
   302 				continue;
   303 			UTIL_KeySplit(buffer, key, sizeof(key) - 1, val, sizeof(val) - 1);
   304 			if (stricmp(key, "Game") == 0 || stricmp(key, "GameBin") == 0)
   305 			{
   306 				if (stricmp(key, "Game") == 0)
   307 					gamebin = false;
   308 				else
   309 					gamebin = true;
   310 
   311 				if (strncmp(val, GAMEINFO_PATH, sizeof(GAMEINFO_PATH) - 1) == 0)
   312 				{
   313 					ptr = &(val[sizeof(GAMEINFO_PATH) - 1]);
   314 					if (ptr[0] == '.')
   315 						ptr++;
   316 					lptr = g_ModPath.c_str();
   317 				} else {
   318 					ptr = val;
   319 					lptr = curPath;
   320 				}
   321 
   322 				size_t ptr_len = strlen(ptr);
   323 				if (ptr[ptr_len] == '/' || ptr[ptr_len] == '\\')
   324 					ptr[--ptr_len] = '\0';
   325 
   326 				/* No need to append "bin" if key is GameBin */
   327 				if (gamebin)
   328 				{
   329 					g_SmmAPI.PathFormat(tempPath, PATH_SIZE, "%s/%s/%s", lptr, ptr, SERVER_DLL);
   330 				} else if (!ptr[0]) {
   331 					g_SmmAPI.PathFormat(tempPath, PATH_SIZE, "%s/%s/%s", lptr, "bin", SERVER_DLL);
   332 				} else {
   333 					g_SmmAPI.PathFormat(tempPath, PATH_SIZE, "%s/%s/%s/%s", lptr, ptr, "bin", SERVER_DLL);
   334 				}
   335 
   336 				/* If not path to SourceMM... */
   337 				if (!UTIL_PathCmp(smmPath, tempPath))
   338 				{
   339 					FILE *fp = fopen(tempPath, "rb");
   340 					if (!fp)
   341 						continue;
   342 					//:TODO: Optimize this a bit!
   343 					SourceHook::List<GameDllInfo *>::iterator iter;
   344 					GameDllInfo *pCheck;
   345 					bool found = false;
   346 					for (iter=gamedll_list.begin(); iter!=gamedll_list.end(); iter++)
   347 					{
   348 						pCheck = (*iter);
   349 						if (GetFileOfAddress((void *)pCheck->factory, buffer, sizeof(buffer)))
   350 						{
   351 							if (UTIL_PathCmp(tempPath, buffer))
   352 							{
   353 								found = true;
   354 								break;
   355 							}
   356 						}
   357 					}
   358 					if (found)
   359 						continue;
   360 					fclose(fp);
   361 					HINSTANCE gamedll = dlmount(tempPath);
   362 					if (gamedll == NULL)
   363 						continue;
   364 					CreateInterfaceFn fn = (CreateInterfaceFn)dlsym(gamedll, "CreateInterface");
   365 					if (fn == NULL)
   366 					{
   367 						dlclose(gamedll);
   368 						continue;
   369 					}
   370 					GameDllInfo *pInfo = new GameDllInfo;
   371 					pInfo->factory = fn;
   372 					pInfo->lib = gamedll;
   373 					pInfo->loaded = true;
   374 					pInfo->pGameDLL = NULL;
   375 					gamedll_list.push_back(pInfo);
   376 					break;
   377 				}
   378 			}
   379 		}
   380 		fclose(fp);
   381 	}
   382 
   383 	if (!g_GameDll.loaded)
   384 	{
   385 		const char *str = "ServerGameDLL";
   386 		size_t len = strlen(str);
   387 
   388 		if (strncmp(iface, str, len) == 0)
   389 		{
   390 			/* This is the interface we want!  Right now we support versions 3 through 8 */
   391 			g_GameDllVersion = atoi(&(iface[len]));
   392 			if (g_GameDllVersion < MIN_GAMEDLL_VERSION)
   393 			{
   394 				if (ret)
   395 				{
   396 					*ret = IFACE_FAILED;
   397 				}
   398 			}
   399 			else if (g_GameDllVersion > 3)
   400 			{
   401 				/* The engine is at least episode 1 */
   402 				g_SourceEngineVersion = SOURCE_ENGINE_EPISODEONE;
   403 			}
   404 			SourceHook::List<GameDllInfo *>::iterator iter;
   405 			GameDllInfo *pInfo = NULL;
   406 			void *ptr;
   407 			for (iter=gamedll_list.begin(); iter!=gamedll_list.end(); iter++)
   408 			{
   409 				pInfo = (*iter);
   410 				ptr = (pInfo->factory)(iface, ret);
   411 				if (ptr)
   412 				{
   413 					/* This is our GameDLL. Unload the others. */
   414 					gamedll_list.erase(iter);
   415 					ClearGamedllList();
   416 					pInfo->pGameDLL = static_cast<IServerGameDLL *>(ptr);
   417 					g_GameDll = *pInfo;
   418 					delete pInfo;
   419 					break;
   420 				}
   421 			}
   422 			if (g_GameDll.loaded)
   423 			{
   424 				InitMainStates();
   425 			} else {
   426 				if (ret)
   427 				{
   428 					*ret = IFACE_FAILED;
   429 				}
   430 				return NULL;
   431 			}
   432 		} else {
   433 			/* wtf do we do... */
   434 			/* :TODO: .. something a bit more intelligent? */
   435 			Error("Engine requested unknown interface before GameDLL was known!\n");
   436 			return NULL;
   437 		}
   438 	}
   439 
   440 	/* We use this interface for responding to the meta client command */
   441 	if (strncmp(iface, "ServerGameClients", 17) == 0)
   442 	{
   443 		void *ptr = (g_GameDll.factory)(iface, ret);
   444 		g_GameDll.pGameClients = static_cast<IServerGameClients *>(ptr);
   445 		g_GameClientsVersion = atoi(&iface[17]);
   446 
   447 		return ptr;
   448 	}
   449 
   450 	/* If we got here, there's definitely a GameDLL */
   451 	IFACE_MACRO(g_GameDll.factory, GameDLL);
   452 }
   453 
   454 void ClearGamedllList()
   455 {
   456 	SourceHook::List<GameDllInfo *>::iterator iter;
   457 
   458 	GameDllInfo *pInfo;
   459 	for (iter=gamedll_list.begin(); iter!=gamedll_list.end(); iter++)
   460 	{
   461 		pInfo = (*iter);
   462 		dlclose(pInfo->lib);
   463 		delete pInfo;
   464 	}
   465 
   466 	gamedll_list.clear();
   467 }
   468 
   469 void DLLShutdown_handler()
   470 {
   471 	/* Unload plugins */
   472 	g_PluginMngr.UnloadAll();
   473 
   474 	/* Add the FCVAR_GAMEDLL flag to our cvars so the engine removes them properly */
   475 	g_SMConVarAccessor.MarkCommandsAsGameDLL();
   476 	g_SMConVarAccessor.UnregisterGameDLLCommands();
   477 
   478 	SH_CALL(g_GameDllPatch, &IServerGameDLL::DLLShutdown)();
   479 
   480 	SH_RELEASE_CALLCLASS(g_GameDllPatch);
   481 	g_GameDllPatch = NULL;
   482 
   483 	g_SourceHook.CompleteShutdown();
   484 
   485 	if (g_GameDll.lib && g_GameDll.loaded)
   486 		dlclose(g_GameDll.lib);
   487 	memset(&g_GameDll, 0, sizeof(GameDllInfo));
   488 
   489 	RETURN_META(MRES_SUPERCEDE);
   490 }
   491 
   492 int LoadPluginsFromFile(const char *_file)
   493 {
   494 	FILE *fp;
   495 	int total = 0, skipped=0;
   496 	PluginId id;
   497 	bool already;
   498 
   499 	fp = fopen(_file, "rt");
   500 	if (!fp)
   501 	{
   502 		LogMessage("[META] Could not open plugins file %s\n", _file);
   503 		return -1;
   504 	}
   505 
   506 	char buffer[255], error[255], full_path[255];
   507 	const char *ptr, *ext, *file;
   508 	size_t length;
   509 	while (!feof(fp))
   510 	{
   511 		buffer[0] = '\0';
   512 		fgets(buffer, sizeof(buffer), fp);
   513 		length = strlen(buffer);
   514 		if (!length)
   515 			continue;
   516 		if (buffer[length-1] == '\n')
   517 			buffer[--length] = '\0';
   518 
   519 		UTIL_TrimLeft(buffer);
   520 		UTIL_TrimRight(buffer);
   521 
   522 		if (buffer[0] == '\0' || buffer[0] == ';' || strncmp(buffer, "//", 2) == 0)
   523 			continue;
   524 		file = buffer;
   525 		if (buffer[0] == '"')
   526 		{
   527 			char *cptr = buffer;
   528 			file = ++cptr;
   529 
   530 			while (*cptr)
   531 			{
   532 				if (*cptr == '"')
   533 				{
   534 					*cptr = '\0';
   535 					break;
   536 				}
   537 				cptr++;
   538 			}
   539 		} else {
   540 			char *cptr = buffer;
   541 			while (*cptr)
   542 			{
   543 				if (isspace(*cptr))
   544 				{
   545 					char *optr = cptr;
   546 					while (*cptr && isspace(*cptr))
   547 						cptr++;
   548 					*optr = '\0';
   549 					UTIL_TrimRight(cptr);
   550 					if (*cptr && isalpha(*cptr))
   551 					{
   552 						g_PluginMngr.SetAlias(buffer, cptr);
   553 						file = cptr;
   554 					}
   555 					break;
   556 				}
   557 				cptr++;
   558 			}
   559 		}
   560 		if (!file[0])
   561 		{
   562 			continue;
   563 		}
   564 		/* First find if it's an absolute path or not... */
   565 		if (file[0] == '/' || strncmp(&(file[1]), ":\\", 2) == 0)
   566 		{
   567 			/* If we're in an absolute path, ignore our normal heuristics */
   568 			id = g_PluginMngr.Load(file, Pl_File, already, error, sizeof(error));
   569 			if (id < Pl_MinId || g_PluginMngr.FindById(id)->m_Status < Pl_Paused)
   570 			{
   571 				LogMessage("[META] Failed to load plugin %s.  %s", buffer, error);
   572 			} else {
   573 				if (already)
   574 					skipped++;
   575 				else
   576 					total++;
   577 			}
   578 		} else {
   579 			/* Attempt to find a file extension */
   580 			ptr = UTIL_GetExtension(file);
   581 			/* Add an extension if there's none there */
   582 			if (!ptr)
   583 			{
   584 #if defined WIN32 || defined _WIN32
   585 				ext = ".dll";
   586 #else
   587 				ext = "_i486.so";
   588 #endif
   589 			} else {
   590 				ext = "";
   591 			}
   592 			/* Format the new path */
   593 			g_SmmAPI.PathFormat(full_path, sizeof(full_path), "%s/%s%s", g_ModPath.c_str(), file, ext);
   594 			id = g_PluginMngr.Load(full_path, Pl_File, already, error, sizeof(error));
   595 			if (id < Pl_MinId || g_PluginMngr.FindById(id)->m_Status < Pl_Paused)
   596 			{
   597 				LogMessage("[META] Failed to load plugin %s.  %s", buffer, error);
   598 			} else {
   599 				if (already)
   600 					skipped++;
   601 				else
   602 					total++;
   603 			}
   604 		}
   605 	}
   606 	fclose(fp);
   607 
   608 	if (skipped)
   609 	{
   610 		LogMessage("[META] Loaded %d plugins from file (%d already loaded)", total, skipped);
   611 	} else {
   612 		LogMessage("[META] Loaded %d plugins from file.", total);
   613 	}
   614 	
   615 	return total;
   616 }
   617 
   618 /* Wrapper function.  This is called when the GameDLL thinks it's using
   619  * the engine's real engineFactory.
   620  */
   621 void *EngineFactory(const char *iface, int *ret)
   622 {
   623 	IFACE_MACRO(g_Engine.engineFactory, Engine);
   624 }
   625 
   626 /* Wrapper function.  This is called when the GameDLL thinks it's using
   627  * the engine's real physicsFactory.
   628  */
   629 void *PhysicsFactory(const char *iface, int *ret)
   630 {
   631 	IFACE_MACRO(g_Engine.physicsFactory, Physics);
   632 }
   633 
   634 /* Wrapper function.  This is called when the GameDLL thinks it's using
   635  * the engine's real fileSystemFactory.
   636  */
   637 void *FileSystemFactory(const char *iface, int *ret)
   638 {
   639 	IFACE_MACRO(g_Engine.fileSystemFactory, FileSystem);
   640 }
   641 
   642 void LogMessage(const char *msg, ...)
   643 {
   644 	va_list ap;
   645 	static char buffer[2048];
   646 
   647 	va_start(ap, msg);
   648 	size_t len = vsnprintf(buffer, sizeof(buffer) - 2, msg, ap);
   649 	va_end(ap);
   650 
   651 	buffer[len++] = '\n';
   652 	buffer[len] = '\0';
   653 
   654 	if (!g_Engine.engine)
   655 	{
   656 		fprintf(stdout, "%s", buffer);
   657 	} else {
   658 		g_Engine.engine->LogPrint(buffer);
   659 	}
   660 }
   661 
   662 void LevelShutdown_handler(void)
   663 {
   664 	if (!bInFirstLevel)
   665 	{
   666 		char full_path[255];
   667 		g_SmmAPI.PathFormat(full_path, sizeof(full_path), "%s/%s", g_ModPath.c_str(), GetPluginsFile());
   668 
   669 		LoadPluginsFromFile(full_path);
   670 	} else {
   671 		bInFirstLevel = false;
   672 	}
   673 
   674 	ITER_EVENT(OnLevelShutdown, ());
   675 
   676 	RETURN_META(MRES_IGNORED);
   677 }
   678 
   679 bool LevelInit_handler(char const *pMapName, char const *pMapEntities, char const *pOldLevel, char const *pLandmarkName, bool loadGame, bool background)
   680 {
   681 	if (!g_SmmAPI.CmdCacheSuccessful())
   682 	{
   683 		LogMessage("[META] Warning: Failed to initialize Con_Printf.  Defaulting to Msg().");
   684 		LogMessage("[META] Warning: Console messages will not be redirected to rcon console.");
   685 	}
   686 
   687 	ITER_EVENT(OnLevelInit, (pMapName, pMapEntities, pOldLevel, pLandmarkName, loadGame, background));
   688 
   689 	RETURN_META_VALUE(MRES_IGNORED, false);
   690 }
   691 
   692 #if defined __GNUC__ && (__GNUC__ == 3 || __GNUC__ == 4)
   693 void * operator new(size_t size) {
   694 	return(calloc(1, size)); 
   695 }
   696 
   697 void * operator new[](size_t size) {
   698 	return(calloc(1, size)); 
   699 }
   700 
   701 void operator delete(void * ptr) {
   702 	if(ptr)
   703 		free(ptr);
   704 }
   705 
   706 void operator delete[](void * ptr) {
   707 	if(ptr)
   708 		free(ptr);
   709 }
   710 #endif