sourcemm/metamod_plugins.cpp
author David Anderson <dvander@alliedmods.net>
Sat Sep 29 15:01:32 2007 +0000 (2007-09-29)
branchsourcemm-1.6.0
changeset 365 afdf36dee1a6
parent 363 b3db5c1dd016
child 367 fc76472b980f
permissions -rw-r--r--
- fixed shutdown crash
- fixed makefile for linux
     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 			pl->m_Events.clear();
   493 
   494 			UnregAllConCmds(pl);
   495 
   496 			//Clean up the DLL
   497 			dlclose(pl->m_Lib);
   498 			pl->m_Lib = NULL;
   499 			pl->m_API = NULL;
   500 
   501 			//Remove the plugin from the list
   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 			//Free its memory
   512 			delete pl;
   513 
   514 			return true;
   515 		}
   516 	} else {
   517 		//The plugin is not valid, and let's just remove it from the list anyway
   518 		PluginIter i;
   519 		for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
   520 		{
   521 			if ( (*i)->m_Id == pl->m_Id )
   522 			{
   523 				i = m_Plugins.erase(i);
   524 				break;
   525 			}
   526 		}
   527 		delete pl;
   528 
   529 		return true;
   530 	}
   531 
   532 	return false;
   533 }
   534 
   535 bool CPluginManager::_Pause(CPluginManager::CPlugin *pl, char *error, size_t maxlen)
   536 {
   537 	if (error)
   538 	{
   539 		*error = '\0';
   540 	}
   541 
   542 	if (pl->m_Status != Pl_Running || !pl->m_API)
   543 	{
   544 		if (error)
   545 		{
   546 			UTIL_Format(error, maxlen, "Plugin cannot be paused");
   547 		}
   548 	}
   549 	else
   550 	{
   551 		if (pl->m_API->Pause(error, maxlen))
   552 		{
   553 			g_SourceHook.PausePlugin(pl->m_Id);
   554 			pl->m_Status = Pl_Paused;
   555 
   556 			return true;
   557 		}
   558 	}
   559 
   560 	return false;
   561 }
   562 
   563 bool CPluginManager::_Unpause(CPluginManager::CPlugin *pl, char *error, size_t maxlen)
   564 {
   565 	if (error)
   566 	{
   567 		*error = '\0';
   568 	}
   569 
   570 	if (pl->m_Status != Pl_Paused || !pl->m_API)
   571 	{
   572 		if (error)
   573 		{
   574 			UTIL_Format(error, maxlen, "Plugin cannot be unpaused");
   575 		}
   576 	}
   577 	else
   578 	{
   579 		if (pl->m_API->Unpause(error, maxlen))
   580 		{
   581 			g_SourceHook.UnpausePlugin(pl->m_Id);
   582 			pl->m_Status = Pl_Running;
   583 
   584 			return true;
   585 		}
   586 	}
   587 
   588 	return false;
   589 }
   590 
   591 bool CPluginManager::UnloadAll()
   592 {
   593 	PluginIter i;
   594 
   595 	char error[128];
   596 	bool status = true;
   597 
   598 	while ((i = m_Plugins.begin()) != m_Plugins.end())
   599 	{
   600 		if ( !_Unload( (*i), true, error, sizeof(error)) )
   601 		{
   602 			status = false;
   603 		}
   604 	}
   605 
   606 	return status;
   607 }
   608 
   609 bool CPluginManager::Query(PluginId id, const char *&file, Pl_Status &status, PluginId &source)
   610 {
   611 	CPlugin *pl = FindById(id);
   612 
   613 	if (!pl)
   614 	{
   615 		return false;
   616 	}
   617 
   618 	file = pl->m_File.c_str();
   619 	status = pl->m_Status;
   620 	source = pl->m_Source;
   621 
   622 	return true;
   623 }
   624 
   625 bool CPluginManager::QueryRunning(PluginId id, char *error, size_t maxlength)
   626 {
   627 	CPlugin *pl = FindById(id);
   628 
   629 	if (!pl || !pl->m_API)
   630 	{
   631 		if (error)
   632 		{
   633 			UTIL_Format(error, maxlength, "Plugin not valid");
   634 		}
   635 		return false;
   636 	}
   637 
   638 	return pl->m_API->QueryRunning(error, maxlength);
   639 }
   640 
   641 bool CPluginManager::QueryHandle(PluginId id, void *&handle)
   642 {
   643 	CPlugin *pl = FindById(id);
   644 
   645 	if (!pl)
   646 	{
   647 		return false;
   648 	}
   649 
   650 	handle = static_cast<void *>(pl->m_Lib);
   651 
   652 	return true;
   653 }
   654 
   655 PluginIter CPluginManager::_begin()
   656 {
   657 	return m_Plugins.begin();
   658 }
   659 
   660 PluginIter CPluginManager::_end()
   661 {
   662 	return m_Plugins.end();
   663 }
   664 
   665 void CPluginManager::AddPluginCvar(ISmmPlugin *api, ConCommandBase *pCvar)
   666 {
   667 	CPlugin *pl = FindByAPI(api);
   668 
   669 	if (!pl)
   670 	{
   671 		return;
   672 	}
   673 
   674 	pl->m_Cvars.push_back(pCvar);
   675 }
   676 
   677 void CPluginManager::AddPluginCmd(ISmmPlugin *api, ConCommandBase *pCmd)
   678 {
   679 	CPlugin *pl = FindByAPI(api);
   680 
   681 	if (!pl)
   682 	{
   683 		return;
   684 	}
   685 
   686 	pl->m_Cmds.push_back(pCmd);
   687 }
   688 
   689 void CPluginManager::RemovePluginCvar(ISmmPlugin *api, ConCommandBase *pCvar)
   690 {
   691 	CPlugin *pl = FindByAPI(api);
   692 
   693 	if (!pl)
   694 	{
   695 		return;
   696 	}
   697 
   698 	pl->m_Cvars.remove(pCvar);
   699 }
   700 
   701 void CPluginManager::RemovePluginCmd(ISmmPlugin *api, ConCommandBase *pCmd)
   702 {
   703 	CPlugin *pl = FindByAPI(api);
   704 
   705 	if (!pl)
   706 	{
   707 		return;
   708 	}
   709 
   710 	pl->m_Cmds.remove(pCmd);
   711 }
   712 
   713 void CPluginManager::UnregAllConCmds(CPlugin *pl)
   714 {
   715 	SourceHook::List<ConCommandBase *>::iterator i;
   716 
   717 	/* :TODO: */
   718 	for (i=pl->m_Cvars.begin(); i!=pl->m_Cvars.end(); i++)
   719 	{
   720 		g_Metamod.UnregisterConCommandBase(pl->m_Id, (*i) );
   721 	}
   722 	pl->m_Cvars.clear();
   723 
   724 	for (i=pl->m_Cmds.begin(); i!=pl->m_Cmds.end(); i++)
   725 	{
   726 		g_Metamod.UnregisterConCommandBase(pl->m_Id, (*i) );
   727 	}
   728 	pl->m_Cmds.clear();
   729 }
   730