sourcemm/CPlugin.cpp
author David Anderson <dvander@alliedmods.net>
Thu Dec 22 13:04:08 2005 +0000 (2005-12-22)
changeset 160 ab0cf7cd2e8a
parent 141 84488512ee3a
child 161 264cecd7a0a8
permissions -rw-r--r--
Fixed crash bug in plugin retry/reloading
     1 /* ======== SourceMM ========
     2 * Copyright (C) 2004-2005 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 	/*if (m_Plugins.size())
    48 	{
    49 		UnloadAll();
    50 		m_Plugins.clear();
    51 	}*/
    52 }
    53 
    54 CPluginManager::CPlugin::CPlugin() : m_Lib(NULL), m_API(NULL), m_Id(0), m_Source(0)
    55 {
    56 
    57 }
    58 
    59 PluginId CPluginManager::Load(const char *file, PluginId source, bool &already, char *error, size_t maxlen)
    60 {
    61 	PluginIter i;
    62 
    63 	already = false;
    64 	//Check if we're about to reload an old plugin
    65 	PluginIter iter = m_Plugins.begin();
    66 	PluginIter end = m_Plugins.end();
    67 	while (iter != end)
    68 	{
    69 		if ( (*i) && (*i)->m_File.compare(file)==0 )
    70 		{
    71 			if ( (*i)->m_Status < Pl_Paused )
    72 			{
    73 				//Attempt to load the plugin again
    74 				already = true;
    75 				i = m_Plugins.erase(i);
    76 				continue;
    77 			} else {
    78 				//No need to load it
    79 				already = true;
    80 				return (*i)->m_Id;
    81 			}
    82 		}
    83 		iter++;
    84 	}
    85 
    86 	CPlugin *pl = _Load(file, source, error, maxlen);
    87 
    88 	if (!pl)
    89 		return Pl_BadLoad;
    90 
    91 	ITER_PLEVENT(OnPluginLoad, pl->m_Id);
    92 
    93 	return pl->m_Id;
    94 }
    95 
    96 CPluginManager::CPlugin *CPluginManager::FindById(PluginId id)
    97 {
    98 	PluginIter i;
    99 
   100 	for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
   101 	{
   102 		if ( (*i)->m_Id == id )
   103 			return (*i);
   104 	}
   105 
   106 	return NULL;
   107 }
   108 
   109 void CPluginManager::SetAllLoaded()
   110 {
   111 	m_AllLoaded = true;
   112 	PluginIter i;
   113 
   114 	for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
   115 	{
   116 		if ( (*i) && (*i)->m_Status == Pl_Running && (*i)->m_API )
   117 		{
   118 			//API 4 is when we added this callback
   119 			//Min version is now 5, so we ignore this check
   120 			//if ( (*i)->m_API->GetApiVersion() >= 004 )
   121 			(*i)->m_API->AllPluginsLoaded();
   122 		}
   123 	}
   124 }
   125 
   126 bool CPluginManager::Pause(PluginId id, char *error, size_t maxlen)
   127 {
   128 	CPlugin *pl = FindById(id);
   129 	
   130 	if (!pl)
   131 	{
   132 		snprintf(error, maxlen, "Plugin id not found");
   133 		return false;
   134 	}
   135 
   136 	bool ret;
   137 	
   138 	if ( (ret=_Pause(pl, error, maxlen)) == true )
   139 	{
   140 		ITER_PLEVENT(OnPluginPause, pl->m_Id);
   141 	}
   142 
   143 	return ret;
   144 }
   145 
   146 bool CPluginManager::Unpause(PluginId id, char *error, size_t maxlen)
   147 {
   148 	CPlugin *pl = FindById(id);
   149 	
   150 	if (!pl)
   151 	{
   152 		snprintf(error, maxlen, "Plugin id not found");
   153 		return false;
   154 	}
   155 
   156 	bool ret;
   157 	
   158 	if ( (ret=_Unpause(pl, error, maxlen)) == true )
   159 	{
   160 		ITER_PLEVENT(OnPluginUnpause, pl->m_Id);
   161 	}
   162 
   163 	return ret;
   164 }
   165 
   166 bool CPluginManager::Unload(PluginId id, bool force, char *error, size_t maxlen)
   167 {
   168 	CPlugin *pl = FindById(id);
   169 	
   170 	if (!pl)
   171 	{
   172 		snprintf(error, maxlen, "Plugin %d not found", id);
   173 		return false;
   174 	}
   175 
   176 	bool ret;
   177 	PluginId old_id = pl->m_Id;
   178 	if ( (ret=_Unload(pl, force, error, maxlen)) == true )
   179 	{
   180 		ITER_PLEVENT(OnPluginUnload, old_id);
   181 	}
   182 
   183 	return ret;
   184 }
   185 
   186 bool CPluginManager::Retry(PluginId id, char *error, size_t len)
   187 {
   188 	PluginIter i;
   189 	char buffer[64];
   190 	for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
   191 	{
   192 		if ( (*i) && (*i)->m_Id == id )
   193 		{
   194 			if ( (*i)->m_Status >= Pl_Paused)
   195 			{
   196 				snprintf(error, len, "Plugin %d is already running.", id);
   197 				return false;
   198 			}
   199 			CPlugin *pl = _Load((*i)->m_File.c_str(), Pl_Console, error, len);
   200 			if (!pl)
   201 				return false;
   202 			if (pl->m_Status >= Pl_Paused)
   203 			{
   204 				//Now it gets crazy... unload the original copy.
   205 				_Unload( (*i), true, buffer, sizeof(buffer)-1 );
   206 				
   207 				//Set the new copy's id
   208 				pl->m_Id = id;
   209 
   210 				//We just wasted an id... reclaim it
   211 				m_LastId--;
   212 				
   213 				return true;
   214 			} else {
   215 				//don't really care about the buffer here
   216 				_Unload(pl, true, buffer, sizeof(buffer)-1);
   217 
   218 				//We just wasted an id... reclaim it
   219 				m_LastId--;
   220 				return false;
   221 			}
   222 		}
   223 	}
   224 
   225 	snprintf(error, len, "Plugin %d not found,", id);
   226 	return false;
   227 }
   228 
   229 CPluginManager::CPlugin *CPluginManager::FindByAPI(ISmmPlugin *api)
   230 {
   231 	PluginIter i;
   232 
   233 	//don't find bad plugins!
   234 	if (!api)
   235 		return NULL;
   236 
   237 	for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
   238 	{
   239 		if ( (*i)->m_API == api )
   240 			return (*i);
   241 	}
   242 
   243 	return NULL;
   244 }
   245 
   246 CPluginManager::CPlugin *CPluginManager::_Load(const char *file, PluginId source, char *error, size_t maxlen)
   247 {
   248 	FILE *fp;
   249 	CPlugin *pl;
   250 
   251 	pl = new CPlugin();
   252 	*error = '\0';
   253 	
   254 	//Add plugin to list
   255 	pl->m_Id = m_LastId;
   256 	pl->m_File.assign(file);
   257 	m_Plugins.push_back(pl);
   258 	m_LastId++;
   259 
   260 	//Check if the file even exists
   261 	fp = fopen(file, "r");
   262 	if (!fp)
   263 	{
   264 		if (error)
   265 			snprintf(error, maxlen, "File not found: %s", file);
   266 		pl->m_Status = Pl_NotFound;
   267 	} else {
   268 		fclose(fp);
   269 		fp = NULL;
   270 		
   271 		//Load the file
   272 		pl->m_Lib = dlmount(file);
   273 		if (!pl->m_Lib)
   274 		{
   275 			if (error)
   276 				snprintf(error, maxlen, "%s", dlerror());
   277 			pl->m_Status = Pl_Error;
   278 		} else {
   279 			CreateInterfaceFn pfn = reinterpret_cast<CreateInterfaceFn>(dlsym(pl->m_Lib, PL_EXPOSURE_C));
   280 			if (!pfn)
   281 			{
   282 				if (error)
   283 					snprintf(error, maxlen, "Function %s not found", PL_EXPOSURE_C);
   284 				pl->m_Status = Pl_Error;
   285 			} else {
   286 				pl->m_API = static_cast<ISmmPlugin *>((pfn)(PLAPI_NAME, NULL));
   287 				if (!pl->m_API)
   288 				{
   289 					if (error)
   290 						snprintf(error, maxlen, "Failed to get API");
   291 					pl->m_Status = Pl_Error;
   292 				} else {
   293 					int api = pl->m_API->GetApiVersion();
   294 					if (api < PLAPI_MIN_VERSION)
   295 					{
   296 						if (error)
   297 							snprintf(error, maxlen, "Plugin API %d is out of date with required minimum (%d)", api, PLAPI_MIN_VERSION);
   298 						pl->m_Status = Pl_Error;
   299 					} else if (api > PLAPI_VERSION) {
   300 						if (error)
   301 							snprintf(error, maxlen, "Plugin API %d is newer than internal version (%d)", api, PLAPI_VERSION);
   302 						pl->m_Status = Pl_Error;
   303 					} else {
   304 						if (pl->m_API->Load(pl->m_Id, static_cast<ISmmAPI *>(&g_SmmAPI), error, maxlen, m_AllLoaded))
   305 						{
   306 							pl->m_Status = Pl_Running;
   307 							if (m_AllLoaded)
   308 							{
   309 								//API 4 is when we added this callback
   310 								//Removing this code as the min version is now 5
   311 								//if (pl->m_API->GetApiVersion() >= 4)
   312 								pl->m_API->AllPluginsLoaded();
   313 							}
   314 						} else {
   315 							pl->m_Status = Pl_Refused;
   316 						}
   317 					}
   318 				}
   319 			}
   320 		}
   321 	}
   322 
   323 	if (pl->m_Lib && (pl->m_Status < Pl_Paused))
   324 	{
   325 		dlclose(pl->m_Lib);
   326 		pl->m_Lib = NULL;
   327 		pl->m_API = NULL;
   328 	}
   329 
   330 	return pl;
   331 }
   332 
   333 bool CPluginManager::_Unload(CPluginManager::CPlugin *pl, bool force, char *error, size_t maxlen)
   334 {
   335 	if (error)
   336 		*error = '\0';
   337 	if (pl->m_API && pl->m_Lib)
   338 	{
   339 		//Note, we'll always tell the plugin it will be unloading...
   340 		if (pl->m_API->Unload(error, maxlen) || force)
   341 		{
   342 			//Make sure to detach it from sourcehook!
   343 			g_SourceHook.UnloadPlugin(pl->m_Id);
   344 
   345 			UnregAllConCmds(pl);
   346 
   347 			//Clean up the DLL
   348 			dlclose(pl->m_Lib);
   349 			pl->m_Lib = NULL;
   350 			pl->m_API = NULL;
   351 
   352 			//Remove the plugin from the list
   353 			PluginIter i;
   354 			for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
   355 			{
   356 				if ( (*i)->m_Id == pl->m_Id )
   357 				{
   358 					i = m_Plugins.erase(i);
   359 					break;
   360 				}
   361 			}
   362 			//Free its memory
   363 			delete pl;
   364 
   365 			return true;
   366 		}
   367 	} else {
   368 		//The plugin is not valid, and let's just remove it from the list anyway
   369 		PluginIter i;
   370 		for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
   371 		{
   372 			if ( (*i)->m_Id == pl->m_Id )
   373 			{
   374 				i = m_Plugins.erase(i);
   375 				break;
   376 			}
   377 		}
   378 		delete pl;
   379 
   380 		return true;
   381 	}
   382 
   383 	return false;
   384 }
   385 
   386 bool CPluginManager::_Pause(CPluginManager::CPlugin *pl, char *error, size_t maxlen)
   387 {
   388 	if (error)
   389 		*error = '\0';
   390 	if (pl->m_Status != Pl_Running || !pl->m_API)
   391 	{
   392 		if (error)
   393 			snprintf(error, maxlen, "Plugin cannot be paused");
   394 	} else {
   395 		if (pl->m_API->Pause(error, maxlen))
   396 		{
   397 			g_SourceHook.PausePlugin(pl->m_Id);
   398 			pl->m_Status = Pl_Paused;
   399 
   400 			return true;
   401 		}
   402 	}
   403 
   404 	return false;
   405 }
   406 
   407 bool CPluginManager::_Unpause(CPluginManager::CPlugin *pl, char *error, size_t maxlen)
   408 {
   409 	if (error)
   410 		*error = '\0';
   411 
   412 	if (pl->m_Status != Pl_Paused || !pl->m_API)
   413 	{
   414 		if (error)
   415 			snprintf(error, maxlen, "Plugin cannot be unpaused");
   416 	} else {
   417 		if (pl->m_API->Unpause(error, maxlen))
   418 		{
   419 			g_SourceHook.UnpausePlugin(pl->m_Id);
   420 			pl->m_Status = Pl_Running;
   421 
   422 			return true;
   423 		}
   424 	}
   425 
   426 	return false;
   427 }
   428 
   429 bool CPluginManager::UnloadAll()
   430 {
   431 	PluginIter i;
   432 
   433 	SourceHook::List<SourceMM::CPluginManager::CPlugin *> remqueue;
   434 
   435 	for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
   436 		remqueue.push_back( (*i) );
   437 
   438 	char error[128];
   439 	bool status = true;
   440 
   441 	for (i=remqueue.begin(); i!=remqueue.end(); i++)
   442 	{
   443 		if ( !_Unload( (*i), true, error, sizeof(error)-1) )
   444 			status = false;
   445 	}
   446 
   447 	m_Plugins.clear();
   448 	remqueue.clear();
   449 
   450 	return status;
   451 }
   452 
   453 bool CPluginManager::Query(PluginId id, const char *&file, Pl_Status &status, PluginId &source)
   454 {
   455 	CPlugin *pl = FindById(id);
   456 
   457 	if (!pl)
   458 		return false;
   459 
   460 	file = pl->m_File.c_str();
   461 	status = pl->m_Status;
   462 	source = pl->m_Source;
   463 
   464 	return true;
   465 }
   466 
   467 bool CPluginManager::QueryRunning(PluginId id, char *error, size_t maxlength)
   468 {
   469 	CPlugin *pl = FindById(id);
   470 
   471 	if (!pl || !pl->m_API)
   472 	{
   473 		if (error)
   474 			snprintf(error, maxlength, "Plugin not valid");
   475 		return false;
   476 	}
   477 
   478 	return pl->m_API->QueryRunning(error, maxlength);
   479 }
   480 
   481 PluginIter CPluginManager::_begin()
   482 {
   483 	return m_Plugins.begin();
   484 }
   485 
   486 PluginIter CPluginManager::_end()
   487 {
   488 	return m_Plugins.end();
   489 }
   490 
   491 void CPluginManager::AddPluginCvar(ISmmPlugin *api, ConCommandBase *pCvar)
   492 {
   493 	CPlugin *pl = FindByAPI(api);
   494 
   495 	if (!pl)
   496 		return;
   497 
   498 	pl->m_Cvars.push_back(pCvar);
   499 }
   500 
   501 void CPluginManager::AddPluginCmd(ISmmPlugin *api, ConCommandBase *pCmd)
   502 {
   503 	CPlugin *pl = FindByAPI(api);
   504 
   505 	if (!pl)
   506 		return;
   507 
   508 	pl->m_Cmds.push_back(pCmd);
   509 }
   510 
   511 void CPluginManager::RemovePluginCvar(ISmmPlugin *api, ConCommandBase *pCvar)
   512 {
   513 	CPlugin *pl = FindByAPI(api);
   514 
   515 	if (!pl)
   516 		return;
   517 
   518 	pl->m_Cvars.remove(pCvar);
   519 }
   520 
   521 void CPluginManager::RemovePluginCmd(ISmmPlugin *api, ConCommandBase *pCmd)
   522 {
   523 	CPlugin *pl = FindByAPI(api);
   524 
   525 	if (!pl)
   526 		return;
   527 
   528 	pl->m_Cmds.remove(pCmd);
   529 }
   530 
   531 void CPluginManager::UnregAllConCmds(CPlugin *pl)
   532 {
   533 	SourceHook::List<ConCommandBase *>::iterator i;
   534 
   535 	for (i=pl->m_Cvars.begin(); i!=pl->m_Cvars.end(); i++)
   536 		g_SMConVarAccessor.Unregister( (*i) );
   537 
   538 	pl->m_Cvars.clear();
   539 
   540 	for (i=pl->m_Cmds.begin(); i!=pl->m_Cmds.end(); i++)
   541 		g_SMConVarAccessor.Unregister( (*i) );
   542 
   543 	pl->m_Cmds.clear();
   544 }