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