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