core-legacy/CPlugin.cpp
author David Anderson <dvander@alliedmods.net>
Thu Oct 29 02:37:52 2009 -0400 (2009-10-29)
changeset 663 e07fd1dc5290
parent 548 dd85920ecaaf
child 665 c2ed9ba7f74c
permissions -rw-r--r--
Fixed circular dependency between sourcemm.h/util.h (build bustage).
     1 /* ======== SourceMM ========
     2  * Copyright (C) 2004-2008 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 #include "vsp_listener.h"
    16 #include "util.h"
    17 
    18 /** 
    19  * @brief Implements functions from CPlugin.h
    20  * @file CPlugin.cpp
    21  */
    22 
    23 using namespace SourceMM;
    24 
    25 #define ITER_PLEVENT(evn, plid) \
    26 	CPluginManager::CPlugin *_Xpl; \
    27 	SourceHook::List<CPluginEventHandler>::iterator event; \
    28 	IMetamodListener *api; \
    29 	for (PluginIter iter = g_PluginMngr._begin(); iter != g_PluginMngr._end(); iter++) { \
    30 		_Xpl = (*iter); \
    31 		if (_Xpl->m_Id == plid) \
    32 			continue; \
    33 		for (event=_Xpl->m_Events.begin(); event!=_Xpl->m_Events.end(); event++) { \
    34 			api = (*event).event; \
    35 			api->evn(plid); \
    36 		} \
    37 	}
    38 
    39 CPluginManager g_PluginMngr;
    40 
    41 CPluginManager::CPluginManager()
    42 {
    43 	m_LastId = Pl_MinId;
    44 	m_AllLoaded = false;
    45 }
    46 
    47 CPluginManager::~CPluginManager()
    48 {
    49 	SourceHook::List<CNameAlias *>::iterator iter;
    50 
    51 	for (iter=m_Aliases.begin(); iter!=m_Aliases.end(); iter++)
    52 	{
    53 		delete (*iter);
    54 	}
    55 
    56 	m_Aliases.clear();
    57 }
    58 
    59 const char *CPluginManager::LookupAlias(const char *alias)
    60 {
    61 	SourceHook::List<CNameAlias *>::iterator iter;
    62 	CNameAlias *p;
    63 
    64 	for (iter=m_Aliases.begin(); iter!=m_Aliases.end(); iter++)
    65 	{
    66 		p = (*iter);
    67 		if (p->alias.compare(alias) == 0)
    68 		{
    69 			return p->value.c_str();
    70 		}
    71 	}
    72 
    73 	return NULL;
    74 }
    75 
    76 SourceHook::List<SourceMM::CNameAlias *>::iterator CPluginManager::_alias_begin()
    77 {
    78 	return m_Aliases.begin();
    79 }
    80 
    81 SourceHook::List<SourceMM::CNameAlias *>::iterator CPluginManager::_alias_end()
    82 {
    83 	return m_Aliases.end();
    84 }
    85 
    86 void CPluginManager::SetAlias(const char *alias, const char *value)
    87 {
    88 	SourceHook::List<CNameAlias *>::iterator iter;
    89 	CNameAlias *p;
    90 
    91 	for (iter=m_Aliases.begin(); iter!=m_Aliases.end(); iter++)
    92 	{
    93 		p = (*iter);
    94 		if (p->alias.compare(alias) == 0)
    95 		{
    96 			if (value[0] == '\0')
    97 			{
    98 				iter = m_Aliases.erase(iter);
    99 				return;
   100 			} else {
   101 				p->value.assign(value);
   102 				return;
   103 			}
   104 		}
   105 	}
   106 
   107 	if (value[0] != '\0')
   108 	{
   109 		p = new CNameAlias;
   110 	
   111 		p->alias.assign(alias);
   112 		p->value.assign(value);
   113 	
   114 		m_Aliases.push_back(p);
   115 	}
   116 }
   117 
   118 CPluginManager::CPlugin::CPlugin() : m_Id(0), m_Source(0), m_API(NULL), m_Lib(NULL)
   119 {
   120 
   121 }
   122 
   123 PluginId CPluginManager::Load(const char *file, PluginId source, bool &already, char *error, size_t maxlen)
   124 {
   125 	already = false;
   126 	//Check if we're about to reload an old plugin
   127 	PluginIter i = m_Plugins.begin();
   128 	while (i != m_Plugins.end())
   129 	{
   130 		if ( (*i) && UTIL_PathCmp(file, (*i)->m_File.c_str()) )
   131 		{
   132 			if ( (*i)->m_Status < Pl_Paused )
   133 			{
   134 				//Attempt to load the plugin again
   135 				already = true;
   136 				i = m_Plugins.erase(i);
   137 				continue;
   138 			} else {
   139 				//No need to load it
   140 				already = true;
   141 				return (*i)->m_Id;
   142 			}
   143 		}
   144 		i++;
   145 	}
   146 
   147 	CPlugin *pl = _Load(file, source, error, maxlen);
   148 
   149 	if (!pl)
   150 		return Pl_BadLoad;
   151 
   152 	ITER_PLEVENT(OnPluginLoad, pl->m_Id);
   153 
   154 	return pl->m_Id;
   155 }
   156 
   157 CPluginManager::CPlugin *CPluginManager::FindById(PluginId id)
   158 {
   159 	PluginIter i;
   160 
   161 	for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
   162 	{
   163 		if ( (*i)->m_Id == id )
   164 			return (*i);
   165 	}
   166 
   167 	return NULL;
   168 }
   169 
   170 void CPluginManager::SetAllLoaded()
   171 {
   172 	m_AllLoaded = true;
   173 	PluginIter i;
   174 
   175 	for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
   176 	{
   177 		if ( (*i) && (*i)->m_Status == Pl_Running && (*i)->m_API )
   178 		{
   179 			//API 4 is when we added this callback
   180 			//Min version is now 5, so we ignore this check
   181 			//if ( (*i)->m_API->GetApiVersion() >= 004 )
   182 			(*i)->m_API->AllPluginsLoaded();
   183 		}
   184 	}
   185 }
   186 
   187 void CPluginManager::SetVSPAsLoaded()
   188 {
   189 	PluginIter i;
   190 	CPlugin *pPlugin;
   191 	SourceHook::List<CPluginEventHandler>::iterator event;
   192 
   193 	for (i = m_Plugins.begin(); i != m_Plugins.end(); i++)
   194 	{
   195 		pPlugin = (*i);
   196 		if (pPlugin->m_Status < Pl_Paused)
   197 		{
   198 			continue;
   199 		}
   200 		/* Only valid for plugins >= 10 (v1:5, SourceMM 1.4) */
   201 		if (pPlugin->m_API->GetApiVersion() < 10)
   202 		{
   203 			continue;
   204 		}
   205 		for (event = pPlugin->m_Events.begin();
   206 			 event != pPlugin->m_Events.end();
   207 			 event++)
   208 		{
   209 			if ((*event).got_vsp)
   210 			{
   211 				continue;
   212 			}
   213 			(*event).got_vsp = true;
   214 			(*event).event->OnVSPListening(g_pRealVspCallbacks);
   215 		}
   216 	}
   217 }
   218 
   219 bool CPluginManager::Pause(PluginId id, char *error, size_t maxlen)
   220 {
   221 	CPlugin *pl = FindById(id);
   222 	
   223 	if (!pl)
   224 	{
   225 		UTIL_Format(error, maxlen, "Plugin id not found");
   226 		return false;
   227 	}
   228 
   229 	bool ret;
   230 	
   231 	if ( (ret=_Pause(pl, error, maxlen)) == true )
   232 	{
   233 		ITER_PLEVENT(OnPluginPause, pl->m_Id);
   234 	}
   235 
   236 	return ret;
   237 }
   238 
   239 bool CPluginManager::Unpause(PluginId id, char *error, size_t maxlen)
   240 {
   241 	CPlugin *pl = FindById(id);
   242 	
   243 	if (!pl)
   244 	{
   245 		UTIL_Format(error, maxlen, "Plugin id not found");
   246 		return false;
   247 	}
   248 
   249 	bool ret;
   250 	
   251 	if ( (ret=_Unpause(pl, error, maxlen)) == true )
   252 	{
   253 		ITER_PLEVENT(OnPluginUnpause, pl->m_Id);
   254 	}
   255 
   256 	return ret;
   257 }
   258 
   259 bool CPluginManager::Unload(PluginId id, bool force, char *error, size_t maxlen)
   260 {
   261 	CPlugin *pl = FindById(id);
   262 	
   263 	if (!pl)
   264 	{
   265 		UTIL_Format(error, maxlen, "Plugin %d not found", id);
   266 		return false;
   267 	}
   268 
   269 	bool ret;
   270 	PluginId old_id = pl->m_Id;
   271 	if ( (ret=_Unload(pl, force, error, maxlen)) == true )
   272 	{
   273 		ITER_PLEVENT(OnPluginUnload, old_id);
   274 	}
   275 
   276 	return ret;
   277 }
   278 
   279 bool CPluginManager::Retry(PluginId id, char *error, size_t len)
   280 {
   281 	PluginIter i;
   282 	char buffer[64];
   283 	for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
   284 	{
   285 		if ( (*i) && (*i)->m_Id == id )
   286 		{
   287 			if ( (*i)->m_Status >= Pl_Paused)
   288 			{
   289 				UTIL_Format(error, len, "Plugin %d is already running.", id);
   290 				return false;
   291 			}
   292 			CPlugin *pl = _Load((*i)->m_File.c_str(), Pl_Console, error, len);
   293 			if (!pl)
   294 				return false;
   295 			if (pl->m_Status >= Pl_Paused)
   296 			{
   297 				//Now it gets crazy... unload the original copy.
   298 				_Unload( (*i), true, buffer, sizeof(buffer)-1 );
   299 				
   300 				//Set the new copy's id
   301 				pl->m_Id = id;
   302 
   303 				//We just wasted an id... reclaim it
   304 				m_LastId--;
   305 				
   306 				return true;
   307 			} else {
   308 				//don't really care about the buffer here
   309 				_Unload(pl, true, buffer, sizeof(buffer)-1);
   310 
   311 				//We just wasted an id... reclaim it
   312 				m_LastId--;
   313 				return false;
   314 			}
   315 		}
   316 	}
   317 
   318 	UTIL_Format(error, len, "Plugin %d not found,", id);
   319 	return false;
   320 }
   321 
   322 CPluginManager::CPlugin *CPluginManager::FindByAPI(ISmmPlugin *api)
   323 {
   324 	PluginIter i;
   325 
   326 	//don't find bad plugins!
   327 	if (!api)
   328 		return NULL;
   329 
   330 	for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
   331 	{
   332 		if ( (*i)->m_API == api )
   333 			return (*i);
   334 	}
   335 
   336 	return NULL;
   337 }
   338 
   339 CPluginManager::CPlugin *CPluginManager::_Load(const char *file, PluginId source, char *error, size_t maxlen)
   340 {
   341 	FILE *fp;
   342 	CPlugin *pl;
   343 
   344 	pl = new CPlugin();
   345 	*error = '\0';
   346 	
   347 	//Add plugin to list
   348 	pl->m_Id = m_LastId;
   349 	pl->m_File.assign(file);
   350 	m_Plugins.push_back(pl);
   351 	m_LastId++;
   352 
   353 	//Check if the file even exists
   354 	fp = fopen(file, "r");
   355 	if (!fp)
   356 	{
   357 		if (error)
   358 			UTIL_Format(error, maxlen, "File not found: %s", file);
   359 		pl->m_Status = Pl_NotFound;
   360 	}
   361 
   362 	if (fp)
   363 	{
   364 		fclose(fp);
   365 		fp = NULL;
   366 		
   367 		//Load the file
   368 		pl->m_Lib = dlmount(file);
   369 		if (!pl->m_Lib)
   370 		{
   371 			if (error)
   372 				UTIL_Format(error, maxlen, "[%d]", GetLastError());
   373 			pl->m_Status = Pl_Error;
   374 		} else {
   375 			CreateInterfaceFn pfn = (CreateInterfaceFn)(dlsym(pl->m_Lib, PL_EXPOSURE_C));
   376 			if (!pfn)
   377 			{
   378 				if (error)
   379 					UTIL_Format(error, maxlen, "Function %s not found", PL_EXPOSURE_C);
   380 				pl->m_Status = Pl_Error;
   381 			} else {
   382 				pl->m_API = static_cast<ISmmPlugin *>((pfn)(PLAPI_NAME, NULL));
   383 				if (!pl->m_API)
   384 				{
   385 					if (error)
   386 						UTIL_Format(error, maxlen, "Failed to get API");
   387 					pl->m_Status = Pl_Error;
   388 				} else {
   389 					int api = pl->m_API->GetApiVersion();
   390 					if (api < PLAPI_MIN_VERSION)
   391 					{
   392 						if (error)
   393 							UTIL_Format(error, maxlen, "Plugin API %d is out of date with required minimum (%d)", api, PLAPI_MIN_VERSION);
   394 						pl->m_Status = Pl_Error;
   395 					} else if (api > PLAPI_VERSION) {
   396 						if (error)
   397 							UTIL_Format(error, maxlen, "Plugin API %d is newer than internal version (%d)", api, PLAPI_VERSION);
   398 						pl->m_Status = Pl_Error;
   399 					} else {
   400 						if (pl->m_API->Load(pl->m_Id, static_cast<ISmmAPI *>(&g_SmmAPI), error, maxlen, m_AllLoaded))
   401 						{
   402 							pl->m_Status = Pl_Running;
   403 							if (m_AllLoaded)
   404 							{
   405 								//API 4 is when we added this callback
   406 								//Removing this code as the min version is now 5
   407 								//if (pl->m_API->GetApiVersion() >= 4)
   408 								pl->m_API->AllPluginsLoaded();
   409 							}
   410 							if (g_bIsBridgedAsVsp ||
   411 								(g_VspListener.IsLoaded() && g_SmmAPI.VSPEnabled()))
   412 							{
   413 								SourceHook::List<CPluginEventHandler>::iterator event;
   414 								for (event = pl->m_Events.begin();
   415 									 event != pl->m_Events.end(); 
   416 									 event++)
   417 								{
   418 									if (pl->m_API->GetApiVersion() < 10 || (*event).got_vsp)
   419 										continue;
   420 									(*event).got_vsp = true;
   421 									(*event).event->OnVSPListening(g_pRealVspCallbacks);
   422 								}
   423 							}
   424 						} else {
   425 							pl->m_Status = Pl_Refused;
   426 						}
   427 					}
   428 				}
   429 			}
   430 		}
   431 	}
   432 
   433 	if (pl->m_Lib && (pl->m_Status < Pl_Paused))
   434 	{
   435 		pl->m_Events.clear();
   436 		g_SourceHook.UnloadPlugin(pl->m_Id);
   437 		UnregAllConCmds(pl);
   438 
   439 		dlclose(pl->m_Lib);
   440 		pl->m_Lib = NULL;
   441 		pl->m_API = NULL;
   442 	}
   443 
   444 	return pl;
   445 }
   446 
   447 bool CPluginManager::_Unload(CPluginManager::CPlugin *pl, bool force, char *error, size_t maxlen)
   448 {
   449 	if (error)
   450 		*error = '\0';
   451 	if (pl->m_API && pl->m_Lib)
   452 	{
   453 		//Note, we'll always tell the plugin it will be unloading...
   454 		if (pl->m_API->Unload(error, maxlen) || force)
   455 		{
   456 			//Make sure to detach it from sourcehook!
   457 			g_SourceHook.UnloadPlugin(pl->m_Id);
   458 
   459 			UnregAllConCmds(pl);
   460 
   461 			//Clean up the DLL
   462 			dlclose(pl->m_Lib);
   463 			pl->m_Lib = NULL;
   464 			pl->m_API = NULL;
   465 
   466 			//Remove the plugin from the list
   467 			PluginIter i;
   468 			for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
   469 			{
   470 				if ( (*i)->m_Id == pl->m_Id )
   471 				{
   472 					i = m_Plugins.erase(i);
   473 					break;
   474 				}
   475 			}
   476 			//Free its memory
   477 			delete pl;
   478 
   479 			return true;
   480 		}
   481 	} else {
   482 		//The plugin is not valid, and let's just remove it from the list anyway
   483 		PluginIter i;
   484 		for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
   485 		{
   486 			if ( (*i)->m_Id == pl->m_Id )
   487 			{
   488 				i = m_Plugins.erase(i);
   489 				break;
   490 			}
   491 		}
   492 		delete pl;
   493 
   494 		return true;
   495 	}
   496 
   497 	return false;
   498 }
   499 
   500 bool CPluginManager::_Pause(CPluginManager::CPlugin *pl, char *error, size_t maxlen)
   501 {
   502 	if (error)
   503 		*error = '\0';
   504 	if (pl->m_Status != Pl_Running || !pl->m_API)
   505 	{
   506 		if (error)
   507 			UTIL_Format(error, maxlen, "Plugin cannot be paused");
   508 	} else {
   509 		if (pl->m_API->Pause(error, maxlen))
   510 		{
   511 			g_SourceHook.PausePlugin(pl->m_Id);
   512 			pl->m_Status = Pl_Paused;
   513 
   514 			return true;
   515 		}
   516 	}
   517 
   518 	return false;
   519 }
   520 
   521 bool CPluginManager::_Unpause(CPluginManager::CPlugin *pl, char *error, size_t maxlen)
   522 {
   523 	if (error)
   524 		*error = '\0';
   525 
   526 	if (pl->m_Status != Pl_Paused || !pl->m_API)
   527 	{
   528 		if (error)
   529 			UTIL_Format(error, maxlen, "Plugin cannot be unpaused");
   530 	} else {
   531 		if (pl->m_API->Unpause(error, maxlen))
   532 		{
   533 			g_SourceHook.UnpausePlugin(pl->m_Id);
   534 			pl->m_Status = Pl_Running;
   535 
   536 			return true;
   537 		}
   538 	}
   539 
   540 	return false;
   541 }
   542 
   543 bool CPluginManager::UnloadAll()
   544 {
   545 	PluginIter i;
   546 
   547 	char error[128];
   548 	bool status = true;
   549 
   550 	while ((i = m_Plugins.begin()) != m_Plugins.end())
   551 	{
   552 		if ( !_Unload( (*i), true, error, sizeof(error)) )
   553 		{
   554 			status = false;
   555 		}
   556 	}
   557 
   558 	return status;
   559 }
   560 
   561 bool CPluginManager::Query(PluginId id, const char *&file, Pl_Status &status, PluginId &source)
   562 {
   563 	CPlugin *pl = FindById(id);
   564 
   565 	if (!pl)
   566 		return false;
   567 
   568 	file = pl->m_File.c_str();
   569 	status = pl->m_Status;
   570 	source = pl->m_Source;
   571 
   572 	return true;
   573 }
   574 
   575 bool CPluginManager::QueryRunning(PluginId id, char *error, size_t maxlength)
   576 {
   577 	CPlugin *pl = FindById(id);
   578 
   579 	if (!pl || !pl->m_API)
   580 	{
   581 		if (error)
   582 			UTIL_Format(error, maxlength, "Plugin not valid");
   583 		return false;
   584 	}
   585 
   586 	return pl->m_API->QueryRunning(error, maxlength);
   587 }
   588 
   589 bool CPluginManager::QueryHandle(PluginId id, void *&handle)
   590 {
   591 	CPlugin *pl = FindById(id);
   592 
   593 	if (!pl)
   594 	{
   595 		return false;
   596 	}
   597 
   598 	handle = static_cast<void *>(pl->m_Lib);
   599 
   600 	return true;
   601 }
   602 
   603 PluginIter CPluginManager::_begin()
   604 {
   605 	return m_Plugins.begin();
   606 }
   607 
   608 PluginIter CPluginManager::_end()
   609 {
   610 	return m_Plugins.end();
   611 }
   612 
   613 void CPluginManager::AddPluginCvar(ISmmPlugin *api, ConCommandBase *pCvar)
   614 {
   615 	CPlugin *pl = FindByAPI(api);
   616 
   617 	if (!pl)
   618 		return;
   619 
   620 	pl->m_Cvars.push_back(pCvar);
   621 }
   622 
   623 void CPluginManager::AddPluginCmd(ISmmPlugin *api, ConCommandBase *pCmd)
   624 {
   625 	CPlugin *pl = FindByAPI(api);
   626 
   627 	if (!pl)
   628 		return;
   629 
   630 	pl->m_Cmds.push_back(pCmd);
   631 }
   632 
   633 void CPluginManager::RemovePluginCvar(ISmmPlugin *api, ConCommandBase *pCvar)
   634 {
   635 	CPlugin *pl = FindByAPI(api);
   636 
   637 	if (!pl)
   638 		return;
   639 
   640 	pl->m_Cvars.remove(pCvar);
   641 }
   642 
   643 void CPluginManager::RemovePluginCmd(ISmmPlugin *api, ConCommandBase *pCmd)
   644 {
   645 	CPlugin *pl = FindByAPI(api);
   646 
   647 	if (!pl)
   648 		return;
   649 
   650 	pl->m_Cmds.remove(pCmd);
   651 }
   652 
   653 void CPluginManager::UnregAllConCmds(CPlugin *pl)
   654 {
   655 	SourceHook::List<ConCommandBase *>::iterator i;
   656 
   657 	for (i=pl->m_Cvars.begin(); i!=pl->m_Cvars.end(); i++)
   658 		g_SMConVarAccessor.Unregister( (*i) );
   659 
   660 	pl->m_Cvars.clear();
   661 
   662 	for (i=pl->m_Cmds.begin(); i!=pl->m_Cmds.end(); i++)
   663 		g_SMConVarAccessor.Unregister( (*i) );
   664 
   665 	pl->m_Cmds.clear();
   666 }
   667 
   668 const char *CPluginManager::GetStatusText(CPlugin *pl)
   669 {
   670 	switch (pl->m_Status)
   671 	{
   672 	case Pl_NotFound:
   673 		return "NOFILE";
   674 	case Pl_Error:
   675 		return "ERROR";
   676 	case Pl_Refused:
   677 		return "FAILED";
   678 	case Pl_Paused:
   679 		return "PAUSED";
   680 	case Pl_Running:
   681 		{
   682 			if (pl->m_API && pl->m_API->QueryRunning(NULL, 0))
   683 			{
   684 				return "STOPPED";
   685 			} else {
   686 				return "RUNNING";
   687 			}
   688 		}
   689 	default:
   690 		return "-";
   691 	}
   692 }
   693 
   694 unsigned int CPluginManager::GetPluginCount()
   695 {
   696 	return (unsigned int)m_Plugins.size();
   697 }