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