sourcemm/CPlugin.cpp
author David Anderson <dvander@alliedmods.net>
Tue Dec 06 08:18:49 2005 +0000 (2005-12-06)
changeset 153 36cb532609ed
parent 141 84488512ee3a
child 160 ab0cf7cd2e8a
permissions -rw-r--r--
Bumped version #
     1 /* ======== SourceMM ========
     2 * Copyright (C) 2004-2005 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 "CPlugin.h"
    12 #include "CSmmAPI.h"
    13 #include "sourcemm.h"
    14 #include "concommands.h"
    15 
    16 /** 
    17  * @brief Implements functions from CPlugin.h
    18  * @file CPlugin.cpp
    19  */
    20 
    21 using namespace SourceMM;
    22 
    23 #define ITER_PLEVENT(evn, plid) \
    24 	CPluginManager::CPlugin *_Xpl; \
    25 	SourceHook::List<IMetamodListener *>::iterator event; \
    26 	IMetamodListener *api; \
    27 	for (PluginIter iter = g_PluginMngr._begin(); iter != g_PluginMngr._end(); iter++) { \
    28 		_Xpl = (*iter); \
    29 		if (_Xpl->m_Id == plid) \
    30 			continue; \
    31 		for (event=_Xpl->m_Events.begin(); event!=_Xpl->m_Events.end(); event++) { \
    32 			api = (*event); \
    33 			api->evn(plid); \
    34 		} \
    35 	}
    36 
    37 CPluginManager g_PluginMngr;
    38 
    39 CPluginManager::CPluginManager()
    40 {
    41 	m_LastId = Pl_MinId;
    42 	m_AllLoaded = false;
    43 }
    44 
    45 CPluginManager::~CPluginManager()
    46 {
    47 	/*if (m_Plugins.size())
    48 	{
    49 		UnloadAll();
    50 		m_Plugins.clear();
    51 	}*/
    52 }
    53 
    54 CPluginManager::CPlugin::CPlugin() : m_Lib(NULL), m_API(NULL), m_Id(0), m_Source(0)
    55 {
    56 
    57 }
    58 
    59 PluginId CPluginManager::Load(const char *file, PluginId source, bool &already, char *error, size_t maxlen)
    60 {
    61 	PluginIter i;
    62 
    63 	already = false;
    64 	//Check if we're about to reload an old plugin
    65 	for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
    66 	{
    67 		if ( (*i) && (*i)->m_File.compare(file)==0 )
    68 		{
    69 			if ( (*i)->m_Status < Pl_Paused )
    70 			{
    71 				//Attempt to load the plugin again
    72 				already = true;
    73 				i = m_Plugins.erase(i);
    74 			} else {
    75 				//No need to load it
    76 				already = true;
    77 				return (*i)->m_Id;
    78 			}
    79 		}
    80 	}
    81 
    82 	CPlugin *pl = _Load(file, source, error, maxlen);
    83 
    84 	if (!pl)
    85 		return Pl_BadLoad;
    86 
    87 	ITER_PLEVENT(OnPluginLoad, pl->m_Id);
    88 
    89 	return pl->m_Id;
    90 }
    91 
    92 CPluginManager::CPlugin *CPluginManager::FindById(PluginId id)
    93 {
    94 	PluginIter i;
    95 
    96 	for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
    97 	{
    98 		if ( (*i)->m_Id == id )
    99 			return (*i);
   100 	}
   101 
   102 	return NULL;
   103 }
   104 
   105 void CPluginManager::SetAllLoaded()
   106 {
   107 	m_AllLoaded = true;
   108 	PluginIter i;
   109 
   110 	for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
   111 	{
   112 		if ( (*i) && (*i)->m_Status == Pl_Running && (*i)->m_API )
   113 		{
   114 			//API 4 is when we added this callback
   115 			//Min version is now 5, so we ignore this check
   116 			//if ( (*i)->m_API->GetApiVersion() >= 004 )
   117 			(*i)->m_API->AllPluginsLoaded();
   118 		}
   119 	}
   120 }
   121 
   122 bool CPluginManager::Pause(PluginId id, char *error, size_t maxlen)
   123 {
   124 	CPlugin *pl = FindById(id);
   125 	
   126 	if (!pl)
   127 	{
   128 		snprintf(error, maxlen, "Plugin id not found");
   129 		return false;
   130 	}
   131 
   132 	bool ret;
   133 	
   134 	if ( (ret=_Pause(pl, error, maxlen)) == true )
   135 	{
   136 		ITER_PLEVENT(OnPluginPause, pl->m_Id);
   137 	}
   138 
   139 	return ret;
   140 }
   141 
   142 bool CPluginManager::Unpause(PluginId id, char *error, size_t maxlen)
   143 {
   144 	CPlugin *pl = FindById(id);
   145 	
   146 	if (!pl)
   147 	{
   148 		snprintf(error, maxlen, "Plugin id not found");
   149 		return false;
   150 	}
   151 
   152 	bool ret;
   153 	
   154 	if ( (ret=_Unpause(pl, error, maxlen)) == true )
   155 	{
   156 		ITER_PLEVENT(OnPluginUnpause, pl->m_Id);
   157 	}
   158 
   159 	return ret;
   160 }
   161 
   162 bool CPluginManager::Unload(PluginId id, bool force, char *error, size_t maxlen)
   163 {
   164 	CPlugin *pl = FindById(id);
   165 	
   166 	if (!pl)
   167 	{
   168 		snprintf(error, maxlen, "Plugin %d not found", id);
   169 		return false;
   170 	}
   171 
   172 	bool ret;
   173 	PluginId old_id = pl->m_Id;
   174 	if ( (ret=_Unload(pl, force, error, maxlen)) == true )
   175 	{
   176 		ITER_PLEVENT(OnPluginUnload, old_id);
   177 	}
   178 
   179 	return ret;
   180 }
   181 
   182 bool CPluginManager::Retry(PluginId id, char *error, size_t len)
   183 {
   184 	PluginIter i;
   185 	char buffer[64];
   186 	for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
   187 	{
   188 		if ( (*i) && (*i)->m_Id == id )
   189 		{
   190 			if ( (*i)->m_Status >= Pl_Paused)
   191 			{
   192 				snprintf(error, len, "Plugin %d is already running.", id);
   193 				return false;
   194 			}
   195 			CPlugin *pl = _Load((*i)->m_File.c_str(), Pl_Console, error, len);
   196 			if (!pl)
   197 				return false;
   198 			if (pl->m_Status >= Pl_Paused)
   199 			{
   200 				//Now it gets crazy... unload the original copy.
   201 				_Unload( (*i), true, buffer, sizeof(buffer)-1 );
   202 				
   203 				//Set the new copy's id
   204 				pl->m_Id = id;
   205 
   206 				//We just wasted an id... reclaim it
   207 				m_LastId--;
   208 				
   209 				return true;
   210 			} else {
   211 				//don't really care about the buffer here
   212 				_Unload(pl, true, buffer, sizeof(buffer)-1);
   213 
   214 				//We just wasted an id... reclaim it
   215 				m_LastId--;
   216 				return false;
   217 			}
   218 		}
   219 	}
   220 
   221 	snprintf(error, len, "Plugin %d not found,", id);
   222 	return false;
   223 }
   224 
   225 CPluginManager::CPlugin *CPluginManager::FindByAPI(ISmmPlugin *api)
   226 {
   227 	PluginIter i;
   228 
   229 	//don't find bad plugins!
   230 	if (!api)
   231 		return NULL;
   232 
   233 	for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
   234 	{
   235 		if ( (*i)->m_API == api )
   236 			return (*i);
   237 	}
   238 
   239 	return NULL;
   240 }
   241 
   242 CPluginManager::CPlugin *CPluginManager::_Load(const char *file, PluginId source, char *error, size_t maxlen)
   243 {
   244 	FILE *fp;
   245 	CPlugin *pl;
   246 
   247 	pl = new CPlugin();
   248 	*error = '\0';
   249 	
   250 	//Add plugin to list
   251 	pl->m_Id = m_LastId;
   252 	pl->m_File.assign(file);
   253 	m_Plugins.push_back(pl);
   254 	m_LastId++;
   255 
   256 	//Check if the file even exists
   257 	fp = fopen(file, "r");
   258 	if (!fp)
   259 	{
   260 		if (error)
   261 			snprintf(error, maxlen, "File not found: %s", file);
   262 		pl->m_Status = Pl_NotFound;
   263 	} else {
   264 		fclose(fp);
   265 		fp = NULL;
   266 		
   267 		//Load the file
   268 		pl->m_Lib = dlmount(file);
   269 		if (!pl->m_Lib)
   270 		{
   271 			if (error)
   272 				snprintf(error, maxlen, "%s", dlerror());
   273 			pl->m_Status = Pl_Error;
   274 		} else {
   275 			CreateInterfaceFn pfn = reinterpret_cast<CreateInterfaceFn>(dlsym(pl->m_Lib, PL_EXPOSURE_C));
   276 			if (!pfn)
   277 			{
   278 				if (error)
   279 					snprintf(error, maxlen, "Function %s not found", PL_EXPOSURE_C);
   280 				pl->m_Status = Pl_Error;
   281 			} else {
   282 				pl->m_API = static_cast<ISmmPlugin *>((pfn)(PLAPI_NAME, NULL));
   283 				if (!pl->m_API)
   284 				{
   285 					if (error)
   286 						snprintf(error, maxlen, "Failed to get API");
   287 					pl->m_Status = Pl_Error;
   288 				} else {
   289 					int api = pl->m_API->GetApiVersion();
   290 					if (api < PLAPI_MIN_VERSION)
   291 					{
   292 						if (error)
   293 							snprintf(error, maxlen, "Plugin API %d is out of date with required minimum (%d)", api, PLAPI_MIN_VERSION);
   294 						pl->m_Status = Pl_Error;
   295 					} else if (api > PLAPI_VERSION) {
   296 						if (error)
   297 							snprintf(error, maxlen, "Plugin API %d is newer than internal version (%d)", api, PLAPI_VERSION);
   298 						pl->m_Status = Pl_Error;
   299 					} else {
   300 						if (pl->m_API->Load(pl->m_Id, static_cast<ISmmAPI *>(&g_SmmAPI), error, maxlen, m_AllLoaded))
   301 						{
   302 							pl->m_Status = Pl_Running;
   303 							if (m_AllLoaded)
   304 							{
   305 								//API 4 is when we added this callback
   306 								//Removing this code as the min version is now 5
   307 								//if (pl->m_API->GetApiVersion() >= 4)
   308 								pl->m_API->AllPluginsLoaded();
   309 							}
   310 						} else {
   311 							pl->m_Status = Pl_Refused;
   312 						}
   313 					}
   314 				}
   315 			}
   316 		}
   317 	}
   318 
   319 	if (pl->m_Lib && (pl->m_Status < Pl_Paused))
   320 	{
   321 		dlclose(pl->m_Lib);
   322 		pl->m_Lib = NULL;
   323 		pl->m_API = NULL;
   324 	}
   325 
   326 	return pl;
   327 }
   328 
   329 bool CPluginManager::_Unload(CPluginManager::CPlugin *pl, bool force, char *error, size_t maxlen)
   330 {
   331 	if (error)
   332 		*error = '\0';
   333 	if (pl->m_API && pl->m_Lib)
   334 	{
   335 		//Note, we'll always tell the plugin it will be unloading...
   336 		if (pl->m_API->Unload(error, maxlen) || force)
   337 		{
   338 			//Make sure to detach it from sourcehook!
   339 			g_SourceHook.UnloadPlugin(pl->m_Id);
   340 
   341 			UnregAllConCmds(pl);
   342 
   343 			//Clean up the DLL
   344 			dlclose(pl->m_Lib);
   345 			pl->m_Lib = NULL;
   346 			pl->m_API = NULL;
   347 
   348 			//Remove the plugin from the list
   349 			PluginIter i;
   350 			for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
   351 			{
   352 				if ( (*i)->m_Id == pl->m_Id )
   353 				{
   354 					i = m_Plugins.erase(i);
   355 					break;
   356 				}
   357 			}
   358 			//Free its memory
   359 			delete pl;
   360 
   361 			return true;
   362 		}
   363 	} else {
   364 		//The plugin is not valid, and let's just remove it from the list anyway
   365 		PluginIter i;
   366 		for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
   367 		{
   368 			if ( (*i)->m_Id == pl->m_Id )
   369 			{
   370 				i = m_Plugins.erase(i);
   371 				break;
   372 			}
   373 		}
   374 		delete pl;
   375 
   376 		return true;
   377 	}
   378 
   379 	return false;
   380 }
   381 
   382 bool CPluginManager::_Pause(CPluginManager::CPlugin *pl, char *error, size_t maxlen)
   383 {
   384 	if (error)
   385 		*error = '\0';
   386 	if (pl->m_Status != Pl_Running || !pl->m_API)
   387 	{
   388 		if (error)
   389 			snprintf(error, maxlen, "Plugin cannot be paused");
   390 	} else {
   391 		if (pl->m_API->Pause(error, maxlen))
   392 		{
   393 			g_SourceHook.PausePlugin(pl->m_Id);
   394 			pl->m_Status = Pl_Paused;
   395 
   396 			return true;
   397 		}
   398 	}
   399 
   400 	return false;
   401 }
   402 
   403 bool CPluginManager::_Unpause(CPluginManager::CPlugin *pl, char *error, size_t maxlen)
   404 {
   405 	if (error)
   406 		*error = '\0';
   407 
   408 	if (pl->m_Status != Pl_Paused || !pl->m_API)
   409 	{
   410 		if (error)
   411 			snprintf(error, maxlen, "Plugin cannot be unpaused");
   412 	} else {
   413 		if (pl->m_API->Unpause(error, maxlen))
   414 		{
   415 			g_SourceHook.UnpausePlugin(pl->m_Id);
   416 			pl->m_Status = Pl_Running;
   417 
   418 			return true;
   419 		}
   420 	}
   421 
   422 	return false;
   423 }
   424 
   425 bool CPluginManager::UnloadAll()
   426 {
   427 	PluginIter i;
   428 
   429 	SourceHook::List<SourceMM::CPluginManager::CPlugin *> remqueue;
   430 
   431 	for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
   432 		remqueue.push_back( (*i) );
   433 
   434 	char error[128];
   435 	bool status = true;
   436 
   437 	for (i=remqueue.begin(); i!=remqueue.end(); i++)
   438 	{
   439 		if ( !_Unload( (*i), true, error, sizeof(error)-1) )
   440 			status = false;
   441 	}
   442 
   443 	m_Plugins.clear();
   444 	remqueue.clear();
   445 
   446 	return status;
   447 }
   448 
   449 bool CPluginManager::Query(PluginId id, const char *&file, Pl_Status &status, PluginId &source)
   450 {
   451 	CPlugin *pl = FindById(id);
   452 
   453 	if (!pl)
   454 		return false;
   455 
   456 	file = pl->m_File.c_str();
   457 	status = pl->m_Status;
   458 	source = pl->m_Source;
   459 
   460 	return true;
   461 }
   462 
   463 bool CPluginManager::QueryRunning(PluginId id, char *error, size_t maxlength)
   464 {
   465 	CPlugin *pl = FindById(id);
   466 
   467 	if (!pl || !pl->m_API)
   468 	{
   469 		if (error)
   470 			snprintf(error, maxlength, "Plugin not valid");
   471 		return false;
   472 	}
   473 
   474 	return pl->m_API->QueryRunning(error, maxlength);
   475 }
   476 
   477 PluginIter CPluginManager::_begin()
   478 {
   479 	return m_Plugins.begin();
   480 }
   481 
   482 PluginIter CPluginManager::_end()
   483 {
   484 	return m_Plugins.end();
   485 }
   486 
   487 void CPluginManager::AddPluginCvar(ISmmPlugin *api, ConCommandBase *pCvar)
   488 {
   489 	CPlugin *pl = FindByAPI(api);
   490 
   491 	if (!pl)
   492 		return;
   493 
   494 	pl->m_Cvars.push_back(pCvar);
   495 }
   496 
   497 void CPluginManager::AddPluginCmd(ISmmPlugin *api, ConCommandBase *pCmd)
   498 {
   499 	CPlugin *pl = FindByAPI(api);
   500 
   501 	if (!pl)
   502 		return;
   503 
   504 	pl->m_Cmds.push_back(pCmd);
   505 }
   506 
   507 void CPluginManager::RemovePluginCvar(ISmmPlugin *api, ConCommandBase *pCvar)
   508 {
   509 	CPlugin *pl = FindByAPI(api);
   510 
   511 	if (!pl)
   512 		return;
   513 
   514 	pl->m_Cvars.remove(pCvar);
   515 }
   516 
   517 void CPluginManager::RemovePluginCmd(ISmmPlugin *api, ConCommandBase *pCmd)
   518 {
   519 	CPlugin *pl = FindByAPI(api);
   520 
   521 	if (!pl)
   522 		return;
   523 
   524 	pl->m_Cmds.remove(pCmd);
   525 }
   526 
   527 void CPluginManager::UnregAllConCmds(CPlugin *pl)
   528 {
   529 	SourceHook::List<ConCommandBase *>::iterator i;
   530 
   531 	for (i=pl->m_Cvars.begin(); i!=pl->m_Cvars.end(); i++)
   532 		g_SMConVarAccessor.Unregister( (*i) );
   533 
   534 	pl->m_Cvars.clear();
   535 
   536 	for (i=pl->m_Cmds.begin(); i!=pl->m_Cmds.end(); i++)
   537 		g_SMConVarAccessor.Unregister( (*i) );
   538 
   539 	pl->m_Cmds.clear();
   540 }