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