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