sourcemod-central: core/PluginSys.cpp@2fe3c4c0eb76

     1 /**

     2  * vim: set ts=4 :

     3  * =============================================================================

     4  * SourceMod

     5  * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.

     6  * =============================================================================

     7  *

     8  * This program is free software; you can redistribute it and/or modify it under

     9  * the terms of the GNU General Public License, version 3.0, as published by the

    10  * Free Software Foundation.

    11  *

    12  * This program is distributed in the hope that it will be useful, but WITHOUT

    13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

    14  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more

    15  * details.

    16  *

    17  * You should have received a copy of the GNU General Public License along with

    18  * this program.  If not, see <http://www.gnu.org/licenses/>.

    19  *

    20  * As a special exception, AlliedModders LLC gives you permission to link the

    21  * code of this program (as well as its derivative works) to "Half-Life 2," the

    22  * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software

    23  * by the Valve Corporation.  You must obey the GNU General Public License in

    24  * all respects for all other code used.  Additionally, AlliedModders LLC grants

    25  * this exception to all derivative works.  AlliedModders LLC defines further

    26  * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),

    27  * or <http://www.sourcemod.net/license.php>.

    28  *

    29  * Version: $Id$

    30  */

    32 #include <stdio.h>

    33 #include "PluginSys.h"

    34 #include "ShareSys.h"

    35 #include "LibrarySys.h"

    36 #include "HandleSys.h"

    37 #include "ForwardSys.h"

    38 #include "sourcemm_api.h"

    39 #include "sourcemod.h"

    40 #include "Logger.h"

    41 #include "ExtensionSys.h"

    42 #include "sm_srvcmds.h"

    43 #include "sm_stringutil.h"

    44 #include "ConCmdManager.h"

    45 #include "PlayerManager.h"

    46 #include "CoreConfig.h"

    47 #include "logic_bridge.h"

    49 CPluginManager g_PluginSys;

    50 HandleType_t g_PluginType = 0;

    51 IdentityType_t g_PluginIdent = 0;

    53 CPlugin::CPlugin(const char *file)

    54 {

    55 	static int MySerial = 0;

    57 	m_type = PluginType_Private;

    58 	m_status = Plugin_Uncompiled;

    59 	m_bSilentlyFailed = false;

    60 	m_serial = ++MySerial;

    61 	m_pRuntime = NULL;

    62 	m_errormsg[sizeof(m_errormsg) - 1] = '\0';

    63 	UTIL_Format(m_filename, sizeof(m_filename), "%s", file);

    64 	m_handle = 0;

    65 	m_ident = NULL;

    66 	m_pProps = sm_trie_create();

    67 	m_FakeNativesMissing = false;

    68 	m_LibraryMissing = false;

    69 	m_bGotAllLoaded = false;

    70 	m_pPhrases = translator->CreatePhraseCollection();

    71 	m_MaxClientsVar = NULL;

    72 }

    74 CPlugin::~CPlugin()

    75 {

    76 	if (m_handle)

    77 	{

    78 		HandleSecurity sec;

    79 		sec.pOwner = g_PluginSys.GetIdentity();

    80 		sec.pIdentity = sec.pOwner;

    82 		g_HandleSys.FreeHandle(m_handle, &sec);

    83 		g_ShareSys.DestroyIdentity(m_ident);

    84 	}

    86 	if (m_pRuntime != NULL)

    87 	{

    88 		delete m_pRuntime;

    89 		m_pRuntime = NULL;

    90 	}

    92 	if (m_pProps)

    93 	{

    94 		sm_trie_destroy(m_pProps);

    95 	}

    96 	for (size_t i=0; i<m_configs.size(); i++)

    97 	{

    98 		delete m_configs[i];

    99 	}

   100 	m_configs.clear();

   101 	if (m_pPhrases != NULL)

   102 	{

   103 		m_pPhrases->Destroy();

   104 		m_pPhrases = NULL;

   105 	}

   106 }

   108 void CPlugin::InitIdentity()

   109 {

   110 	if (!m_handle)

   111 	{

   112 		m_ident = g_ShareSys.CreateIdentity(g_PluginIdent, this);

   113 		m_handle = g_HandleSys.CreateHandle(g_PluginType, this, g_PluginSys.GetIdentity(), g_PluginSys.GetIdentity(), NULL);

   114 		m_pRuntime->GetDefaultContext()->SetKey(1, m_ident);

   115 		m_pRuntime->GetDefaultContext()->SetKey(2, (IPlugin *)this);

   116 	}

   117 }

   119 unsigned int CPlugin::CalcMemUsage()

   120 {

   121 	unsigned int base_size =

   122 		sizeof(CPlugin)

   123 		+ sizeof(IdentityToken_t)

   124 		+ (m_configs.size() * (sizeof(AutoConfig *) + sizeof(AutoConfig)))

   125 		+ sm_trie_mem_usage(m_pProps);

   127 	for (unsigned int i = 0; i < m_configs.size(); i++)

   128 	{

   129 		base_size += m_configs[i]->autocfg.size();

   130 		base_size += m_configs[i]->folder.size();

   131 	}

   133 	for (List<String>::iterator i = m_Libraries.begin();

   134 		 i != m_Libraries.end();

   135 		 i++)

   136 	{

   137 		base_size += (*i).size();

   138 	}

   140 	for (List<String>::iterator i = m_RequiredLibs.begin();

   141 		 i != m_RequiredLibs.end();

   142 		 i++)

   143 	{

   144 		base_size += (*i).size();

   145 	}

   147 	return base_size;

   148 }

   150 Handle_t CPlugin::GetMyHandle()

   151 {

   152 	return m_handle;

   153 }

   155 CPlugin *CPlugin::CreatePlugin(const char *file, char *error, size_t maxlength)

   156 {

   157 	char fullpath[PLATFORM_MAX_PATH];

   158 	g_SourceMod.BuildPath(Path_SM, fullpath, sizeof(fullpath), "plugins/%s", file);

   159 	FILE *fp = fopen(fullpath, "rb");

   161 	CPlugin *pPlugin = new CPlugin(file);

   163 	if (!fp)

   164 	{

   165 		if (error)

   166 		{

   167 			UTIL_Format(error, maxlength, "Unable to open file");

   168 		}

   169 		pPlugin->m_status = Plugin_BadLoad;

   170 		return pPlugin;

   171 	}

   173 	fclose(fp);

   175 	return pPlugin;

   176 }

   178 bool CPlugin::GetProperty(const char *prop, void **ptr, bool remove/* =false */)

   179 {

   180 	bool exists = sm_trie_retrieve(m_pProps, prop, ptr);

   182 	if (exists && remove)

   183 	{

   184 		sm_trie_delete(m_pProps, prop);

   185 	}

   187 	return exists;

   188 }

   190 bool CPlugin::SetProperty(const char *prop, void *ptr)

   191 {

   192 	return sm_trie_insert(m_pProps, prop, ptr);

   193 }

   195 IPluginRuntime *CPlugin::GetRuntime()

   196 {

   197 	return m_pRuntime;

   198 }

   200 void CPlugin::SetErrorState(PluginStatus status, const char *error_fmt, ...)

   201 {

   202 	PluginStatus old_status = m_status;

   203 	m_status = status;

   205 	if (old_status == Plugin_Running)

   206 	{

   207 		/* Tell everyone we're now paused */

   208 		g_PluginSys._SetPauseState(this, true);

   209 	}

   211 	va_list ap;

   212 	va_start(ap, error_fmt);

   213 	UTIL_FormatArgs(m_errormsg, sizeof(m_errormsg), error_fmt, ap);

   214 	va_end(ap);

   216 	if (m_pRuntime != NULL)

   217 	{

   218 		m_pRuntime->SetPauseState(true);

   219 	}

   220 }

   222 bool CPlugin::UpdateInfo()

   223 {

   224 	/* Now grab the info */

   225 	uint32_t idx;

   226 	IPluginContext *base = GetBaseContext();

   227 	int err = base->FindPubvarByName("myinfo", &idx);

   229 	memset(&m_info, 0, sizeof(m_info));

   231 	if (err == SP_ERROR_NONE)

   232 	{

   233 		struct sm_plugininfo_c_t

   234 		{

   235 			cell_t name;

   236 			cell_t description;

   237 			cell_t author;

   238 			cell_t version;

   239 			cell_t url;

   240 		};

   241 		sm_plugininfo_c_t *cinfo;

   242 		cell_t local_addr;

   244 		base->GetPubvarAddrs(idx, &local_addr, (cell_t **)&cinfo);

   245 		base->LocalToString(cinfo->name, (char **)&m_info.name);

   246 		base->LocalToString(cinfo->description, (char **)&m_info.description);

   247 		base->LocalToString(cinfo->author, (char **)&m_info.author);

   248 		base->LocalToString(cinfo->url, (char **)&m_info.url);

   249 		base->LocalToString(cinfo->version, (char **)&m_info.version);

   250 	}

   252 	m_info.author = m_info.author ? m_info.author : "";

   253 	m_info.description = m_info.description ? m_info.description : "";

   254 	m_info.name = m_info.name ? m_info.name : "";

   255 	m_info.url = m_info.url ? m_info.url : "";

   256 	m_info.version = m_info.version ? m_info.version : "";

   258 	if ((err = base->FindPubvarByName("__version", &idx)) == SP_ERROR_NONE)

   259 	{

   260 		struct __version_info

   261 		{

   262 			cell_t version;

   263 			cell_t filevers;

   264 			cell_t date;

   265 			cell_t time;

   266 		};

   267 		__version_info *info;

   268 		cell_t local_addr;

   269 		const char *pDate, *pTime, *pFileVers;

   271 		pDate = "";

   272 		pTime = "";

   274 		base->GetPubvarAddrs(idx, &local_addr, (cell_t **)&info);

   275 		m_FileVersion = info->version;

   276 		if (m_FileVersion >= 4)

   277 		{

   278 			base->LocalToString(info->date, (char **)&pDate);

   279 			base->LocalToString(info->time, (char **)&pTime);

   280 			UTIL_Format(m_DateTime, sizeof(m_DateTime), "%s %s", pDate, pTime);

   281 		}

   282 		if (m_FileVersion > 5)

   283 		{

   284 			base->LocalToString(info->filevers, (char **)&pFileVers);

   285 			SetErrorState(Plugin_Failed, "Newer SourceMod required (%s or higher)", pFileVers);

   286 			return false;

   287 		}

   288 	}

   289 	else

   290 	{

   291 		m_FileVersion = 0;

   292 	}

   294 	if ((err = base->FindPubvarByName("MaxClients", &idx)) == SP_ERROR_NONE)

   295 	{

   296 		base->GetPubvarByIndex(idx, &m_MaxClientsVar);

   297 	}

   299 	return true;

   300 }

   302 void CPlugin::SyncMaxClients(int max_clients)

   303 {

   304 	if (m_MaxClientsVar == NULL)

   305 	{

   306 		return;

   307 	}

   309 	*m_MaxClientsVar->offs = max_clients;

   310 }

   312 void CPlugin::Call_OnPluginStart()

   313 {

   314 	if (m_status != Plugin_Loaded)

   315 	{

   316 		return;

   317 	}

   319 	m_status = Plugin_Running;

   321 	SyncMaxClients(g_Players.MaxClients());

   323 	cell_t result;

   324 	IPluginFunction *pFunction = m_pRuntime->GetFunctionByName("OnPluginStart");

   325 	if (!pFunction)

   326 	{

   327 		return;

   328 	}

   330 	int err;

   331 	if ((err=pFunction->Execute(&result)) != SP_ERROR_NONE)

   332 	{

   333 		SetErrorState(Plugin_Error, "Error detected in plugin startup (see error logs)");

   334 	}

   335 }

   337 void CPlugin::Call_OnPluginEnd()

   338 {

   339 	if (m_status > Plugin_Paused)

   340 	{

   341 		return;

   342 	}

   344 	cell_t result;

   345 	IPluginFunction *pFunction = m_pRuntime->GetFunctionByName("OnPluginEnd");

   346 	if (!pFunction)

   347 	{

   348 		return;

   349 	}

   351 	pFunction->Execute(&result);

   352 }

   354 void CPlugin::Call_OnAllPluginsLoaded()

   355 {

   356 	if (m_status > Plugin_Paused)

   357 	{

   358 		return;

   359 	}

   361 	if (m_bGotAllLoaded)

   362 	{

   363 		return;

   364 	}

   366 	m_bGotAllLoaded = true;

   368 	cell_t result;

   369 	IPluginFunction *pFunction = m_pRuntime->GetFunctionByName("OnAllPluginsLoaded");

   370 	if (pFunction != NULL)

   371 	{

   372 		pFunction->Execute(&result);

   373 	}

   375 	if (g_SourceMod.IsMapRunning())

   376 	{

   377 		if ((pFunction = m_pRuntime->GetFunctionByName("OnMapStart")) != NULL)

   378 		{

   379 			pFunction->Execute(NULL);

   380 		}

   381 	}

   383 	if (SM_AreConfigsExecuted())

   384 	{

   385 		SM_ExecuteForPlugin(GetBaseContext());

   386 	}

   387 }

   389 APLRes CPlugin::Call_AskPluginLoad(char *error, size_t maxlength)

   390 {

   391 	if (m_status != Plugin_Created)

   392 	{

   393 		return APLRes_Failure;

   394 	}

   396 	m_status = Plugin_Loaded;

   398 	int err;

   399 	cell_t result;

   400 	bool haveNewAPL = false;

   401 	IPluginFunction *pFunction = m_pRuntime->GetFunctionByName("AskPluginLoad2");

   403 	if (pFunction)

   404 	{

   405 		haveNewAPL = true;

   406 	}

   407 	else if (!(pFunction = m_pRuntime->GetFunctionByName("AskPluginLoad")))

   408 	{

   409 		return APLRes_Success;

   410 	}

   412 	pFunction->PushCell(m_handle);

   413 	pFunction->PushCell(g_PluginSys.IsLateLoadTime() ? 1 : 0);

   414 	pFunction->PushStringEx(error, maxlength, 0, SM_PARAM_COPYBACK);

   415 	pFunction->PushCell(maxlength);

   416 	if ((err=pFunction->Execute(&result)) != SP_ERROR_NONE)

   417 	{

   418 		return APLRes_Failure;

   419 	}

   421 	if (haveNewAPL)

   422 	{

   423 		return (APLRes)result;

   424 	}

   425 	else if (result)

   426 	{

   427 		return APLRes_Success;

   428 	}

   429 	else

   430 	{

   431 		return APLRes_Failure;

   432 	}

   433 }

   435 void *CPlugin::GetPluginStructure()

   436 {

   437 	return NULL;

   438 }

   440 IPluginContext *CPlugin::GetBaseContext()

   441 {

   442 	if (m_pRuntime == NULL)

   443 	{

   444 		return NULL;

   445 	}

   447 	return m_pRuntime->GetDefaultContext();

   448 }

   450 sp_context_t *CPlugin::GetContext()

   451 {

   452 	return NULL;

   453 }

   455 const char *CPlugin::GetFilename()

   456 {

   457 	return m_filename;

   458 }

   460 PluginType CPlugin::GetType()

   461 {

   462 	return m_type;

   463 }

   465 const sm_plugininfo_t *CPlugin::GetPublicInfo()

   466 {

   467 	if (GetStatus() >= Plugin_Created)

   468 	{

   469 		return NULL;

   470 	}

   471 	return &m_info;

   472 }

   474 unsigned int CPlugin::GetSerial()

   475 {

   476 	return m_serial;

   477 }

   479 PluginStatus CPlugin::GetStatus()

   480 {

   481 	return m_status;

   482 }

   484 bool CPlugin::IsSilentlyFailed()

   485 {

   486 	return m_bSilentlyFailed;

   487 }

   489 bool CPlugin::IsDebugging()

   490 {

   491 	if (m_pRuntime == NULL)

   492 	{

   493 		return false;

   494 	}

   496 	return true;

   497 }

   499 void CPlugin::SetSilentlyFailed(bool sf)

   500 {

   501 	m_bSilentlyFailed = sf;

   502 }

   504 void CPlugin::LibraryActions(bool dropping)

   505 {

   506 	List<String>::iterator iter;

   507 	for (iter = m_Libraries.begin();

   508 		iter != m_Libraries.end();

   509 		iter++)

   510 	{

   511 		g_PluginSys.OnLibraryAction((*iter).c_str(), true, dropping);

   512 	}

   513 }

   515 bool CPlugin::SetPauseState(bool paused)

   516 {

   517 	if (paused && GetStatus() != Plugin_Running)

   518 	{

   519 		return false;

   520 	} else if (!paused && GetStatus() != Plugin_Paused) {

   521 		return false;

   522 	}

   524 	if (paused)

   525 	{

   526 		LibraryActions(true);

   527 	}

   529 	IPluginFunction *pFunction = m_pRuntime->GetFunctionByName("OnPluginPauseChange");

   530 	if (pFunction)

   531 	{

   532 		cell_t result;

   533 		pFunction->PushCell(paused ? 1 : 0);

   534 		pFunction->Execute(&result);

   535 	}

   537 	if (paused)

   538 	{

   539 		m_status = Plugin_Paused;

   540 		m_pRuntime->SetPauseState(true);

   541 	} else {

   542 		m_status = Plugin_Running;

   543 		m_pRuntime->SetPauseState(false);

   544 	}

   546 	g_PluginSys._SetPauseState(this, paused);

   548 	if (!paused)

   549 	{

   550 		LibraryActions(false);

   551 	}

   553 	return true;

   554 }

   556 IdentityToken_t *CPlugin::GetIdentity()

   557 {

   558 	return m_ident;

   559 }

   561 bool CPlugin::IsRunnable()

   562 {

   563 	return (m_status <= Plugin_Paused) ? true : false;

   564 }

   566 time_t CPlugin::GetFileTimeStamp()

   567 {

   568 	char path[PLATFORM_MAX_PATH];

   569 	g_SourceMod.BuildPath(Path_SM, path, sizeof(path), "plugins/%s", m_filename);

   570 #ifdef PLATFORM_WINDOWS

   571 	struct _stat s;

   572 	if (_stat(path, &s) != 0)

   573 #elif defined PLATFORM_POSIX

   574 	struct stat s;

   575 	if (stat(path, &s) != 0)

   576 #endif

   577 	{

   578 		return 0;

   579 	}

   580 	else

   581 	{

   582 		return s.st_mtime;

   583 	}

   584 }

   586 time_t CPlugin::GetTimeStamp()

   587 {

   588 	return m_LastAccess;

   589 }

   591 void CPlugin::SetTimeStamp(time_t t)

   592 {

   593 	m_LastAccess = t;

   594 }

   596 IPhraseCollection *CPlugin::GetPhrases()

   597 {

   598 	return m_pPhrases;

   599 }

   601 void CPlugin::DependencyDropped(CPlugin *pOwner)

   602 {

   603 	if (!m_pRuntime)

   604 	{

   605 		return;

   606 	}

   608 	List<String>::iterator reqlib_iter;

   609 	List<String>::iterator lib_iter;

   610 	for (lib_iter=pOwner->m_Libraries.begin(); lib_iter!=pOwner->m_Libraries.end(); lib_iter++)

   611 	{

   612 		for (reqlib_iter=m_RequiredLibs.begin(); reqlib_iter!=m_RequiredLibs.end(); reqlib_iter++)

   613 		{

   614 			if ((*reqlib_iter) == (*lib_iter))

   615 			{

   616 				m_LibraryMissing = true;

   617 			}

   618 		}

   619 	}

   621 	List<NativeEntry *>::iterator iter;

   622 	NativeEntry *pNative;

   623 	sp_native_t *native;

   624 	uint32_t idx;

   625 	unsigned int unbound = 0;

   627 	for (iter = pOwner->m_Natives.begin();

   628 		 iter != pOwner->m_Natives.end();

   629 		 iter++)

   630 	{

   631 		pNative = (*iter);

   632 		/* Find this native! */

   633 		if (m_pRuntime->FindNativeByName(pNative->name, &idx) != SP_ERROR_NONE)

   634 		{

   635 			continue;

   636 		}

   637 		/* Unbind it */

   638 		m_pRuntime->GetNativeByIndex(idx, &native);

   639 		native->pfn = NULL;

   640 		native->status = SP_NATIVE_UNBOUND;

   641 		unbound++;

   642 	}

   644 	if (unbound)

   645 	{

   646 		m_FakeNativesMissing = true;

   647 	}

   649 	/* :IDEA: in the future, add native trapping? */

   650 	if (m_FakeNativesMissing || m_LibraryMissing)

   651 	{

   652 		SetErrorState(Plugin_Error, "Depends on plugin: %s", pOwner->GetFilename());

   653 	}

   654 }

   656 unsigned int CPlugin::GetConfigCount()

   657 {

   658 	return (unsigned int)m_configs.size();

   659 }

   661 AutoConfig *CPlugin::GetConfig(unsigned int i)

   662 {

   663 	if (i >= GetConfigCount())

   664 	{

   665 		return NULL;

   666 	}

   668 	return m_configs[i];

   669 }

   671 void CPlugin::AddConfig(bool autoCreate, const char *cfg, const char *folder)

   672 {

   673 	/* Do a check for duplicates to prevent double-execution */

   674 	for (size_t i = 0; i < m_configs.size(); i++)

   675 	{

   676 		if (m_configs[i]->autocfg.compare(cfg) == 0

   677 			&& m_configs[i]->folder.compare(folder) == 0

   678 			&& m_configs[i]->create == autoCreate)

   679 		{

   680 			return;

   681 		}

   682 	}

   684 	AutoConfig *c = new AutoConfig;

   686 	c->autocfg = cfg;

   687 	c->folder = folder;

   688 	c->create = autoCreate;

   690 	m_configs.push_back(c);

   691 }

   693 void CPlugin::DropEverything()

   694 {

   695 	CPlugin *pOther;

   696 	List<CPlugin *>::iterator iter;

   697 	List<WeakNative>::iterator wk_iter;

   699 	/* Tell everyone that depends on us that we're about to drop */

   700 	for (iter = m_Dependents.begin();

   701 		 iter != m_Dependents.end();

   702 		 iter++)

   703 	{

   704 		pOther = (*iter);

   705 		pOther->DependencyDropped(this);

   706 	}

   708 	/* Note: we don't care about things we depend on.

   709 	 * The reason is that extensions have their own cleanup

   710 	 * code for plugins.  Although the "right" design would be

   711 	 * to centralize that here, i'm omitting it for now.  Thus,

   712 	 * the code below to walk the plugins list will suffice.

   713 	 */

   715 	/* Other plugins could be holding weak references that were

   716 	 * added by us.  We need to clean all of those up now.

   717 	 */

   718 	for (iter = g_PluginSys.m_plugins.begin();

   719 		 iter != g_PluginSys.m_plugins.end();

   720 		 iter++)

   721 	{

   722 		(*iter)->DropRefsTo(this);

   723 	}

   725 	/* Proceed with the rest of the necessities. */

   726 	CNativeOwner::DropEverything();

   727 }

   729 bool CPlugin::AddFakeNative(IPluginFunction *pFunc, const char *name, SPVM_FAKENATIVE_FUNC func)

   730 {

   731 	NativeEntry *pEntry;

   733 	if ((pEntry = g_ShareSys.AddFakeNative(pFunc, name, func)) == NULL)

   734 	{

   735 		return false;

   736 	}

   738 	m_Natives.push_back(pEntry);

   740 	return true;

   741 }

   743 /*******************

   744  * PLUGIN ITERATOR *

   745  *******************/

   747 CPluginManager::CPluginIterator::CPluginIterator(List<CPlugin *> *_mylist)

   748 {

   749 	mylist = _mylist;

   750 	Reset();

   751 }

   753 IPlugin *CPluginManager::CPluginIterator::GetPlugin()

   754 {

   755 	return (*current);

   756 }

   758 bool CPluginManager::CPluginIterator::MorePlugins()

   759 {

   760 	return (current != mylist->end());

   761 }

   763 void CPluginManager::CPluginIterator::NextPlugin()

   764 {

   765 	current++;

   766 }

   768 void CPluginManager::CPluginIterator::Release()

   769 {

   770 	g_PluginSys.ReleaseIterator(this);

   771 }

   773 CPluginManager::CPluginIterator::~CPluginIterator()

   774 {

   775 }

   777 void CPluginManager::CPluginIterator::Reset()

   778 {

   779 	current = mylist->begin();

   780 }

   782 /******************

   783  * PLUGIN MANAGER *

   784  ******************/

   786 CPluginManager::CPluginManager()

   787 {

   788 	m_LoadLookup = sm_trie_create();

   789 	m_AllPluginsLoaded = false;

   790 	m_MyIdent = NULL;

   791 	m_LoadingLocked = false;

   793 	m_bBlockBadPlugins = true;

   794 }

   796 CPluginManager::~CPluginManager()

   797 {

   798 	/* :NOTICE:

   799 	 * Ignore the fact that there might be plugins in the cache.

   800 	 * This usually means that Core is not being unloaded properly, and everything

   801 	 * will crash anyway.  YAY

   802 	 */

   803 	sm_trie_destroy(m_LoadLookup);

   805 	CStack<CPluginManager::CPluginIterator *>::iterator iter;

   806 	for (iter=m_iters.begin(); iter!=m_iters.end(); iter++)

   807 	{

   808 		delete (*iter);

   809 	}

   810 	m_iters.popall();

   811 }

   813 void CPluginManager::Shutdown()

   814 {

   815 	List<CPlugin *>::iterator iter;

   817 	while ((iter = m_plugins.begin()) != m_plugins.end())

   818 	{

   819 		UnloadPlugin(*iter);

   820 	}

   821 }

   823 void CPluginManager::LoadAll_FirstPass(const char *config, const char *basedir)

   824 {

   825 	/* First read in the database of plugin settings */

   826 	SMCError err;

   827 	SMCStates states;

   828 	m_AllPluginsLoaded = false;

   829 	if ((err=textparsers->ParseFile_SMC(config, &m_PluginInfo, &states)) != SMCError_Okay)

   830 	{

   831 		g_Logger.LogError("[SM] Encountered fatal error parsing file \"%s\"", config);

   832 		const char *err_msg = textparsers->GetSMCErrorString(err);

   833 		if (err_msg)

   834 		{

   835 			g_Logger.LogError("[SM] Parse error encountered: \"%s\"", err_msg);

   836 		}

   837 	}

   839 	LoadPluginsFromDir(basedir, NULL);

   840 }

   842 void CPluginManager::LoadPluginsFromDir(const char *basedir, const char *localpath)

   843 {

   844 	char base_path[PLATFORM_MAX_PATH];

   846 	/* Form the current path to start reading from */

   847 	if (localpath == NULL)

   848 	{

   849 		g_LibSys.PathFormat(base_path, sizeof(base_path), "%s", basedir);

   850 	} else {

   851 		g_LibSys.PathFormat(base_path, sizeof(base_path), "%s/%s", basedir, localpath);

   852 	}

   854 	IDirectory *dir = g_LibSys.OpenDirectory(base_path);

   856 	if (!dir)

   857 	{

   858 		char error[256];

   859 		g_LibSys.GetPlatformError(error, sizeof(error));

   860 		g_Logger.LogError("[SM] Failure reading from plugins path: %s", localpath);

   861 		g_Logger.LogError("[SM] Platform returned error: %s", error);

   862 		return;

   863 	}

   865 	while (dir->MoreFiles())

   866 	{

   867 		if (dir->IsEntryDirectory()

   868 			&& (strcmp(dir->GetEntryName(), ".") != 0)

   869 			&& (strcmp(dir->GetEntryName(), "..") != 0)

   870 			&& (strcmp(dir->GetEntryName(), "disabled") != 0)

   871 			&& (strcmp(dir->GetEntryName(), "optional") != 0))

   872 		{

   873 			char new_local[PLATFORM_MAX_PATH];

   874 			if (localpath == NULL)

   875 			{

   876 				/* If no path yet, don't add a former slash */

   877 				UTIL_Format(new_local, sizeof(new_local), "%s", dir->GetEntryName());

   878 			} else {

   879 				g_LibSys.PathFormat(new_local, sizeof(new_local), "%s/%s", localpath, dir->GetEntryName());

   880 			}

   881 			LoadPluginsFromDir(basedir, new_local);

   882 		} else if (dir->IsEntryFile()) {

   883 			const char *name = dir->GetEntryName();

   884 			size_t len = strlen(name);

   885 			if (len >= 4

   886 				&& strcmp(&name[len-4], ".smx") == 0)

   887 			{

   888 				/* If the filename matches, load the plugin */

   889 				char plugin[PLATFORM_MAX_PATH];

   890 				if (localpath == NULL)

   891 				{

   892 					UTIL_Format(plugin, sizeof(plugin), "%s", name);

   893 				} else {

   894 					g_LibSys.PathFormat(plugin, sizeof(plugin), "%s/%s", localpath, name);

   895 				}

   896 				LoadAutoPlugin(plugin);

   897 			}

   898 		}

   899 		dir->NextEntry();

   900 	}

   901 	g_LibSys.CloseDirectory(dir);

   902 }

   904 LoadRes CPluginManager::_LoadPlugin(CPlugin **_plugin, const char *path, bool debug, PluginType type, char error[], size_t maxlength)

   905 {

   906 	if (m_LoadingLocked)

   907 	{

   908 		return LoadRes_NeverLoad;

   909 	}

   911 	int err;

   912 	bool no_load = false;

   913 	PluginSettings *pset;

   914 	unsigned int setcount = m_PluginInfo.GetSettingsNum();

   915 	for (unsigned int i=0; i<setcount; i++)

   916 	{

   917 		if ((pset = m_PluginInfo.GetSettingsIfMatch(i, path)) == NULL)

   918 		{

   919 			continue;

   920 		}

   921 		if (pset->blockload_val)

   922 		{

   923 			no_load = true;

   924 			break;

   925 		}

   926 	}

   928 	/**

   929 	 * Does this plugin already exist?

   930 	 */

   931 	CPlugin *pPlugin;

   932 	if (sm_trie_retrieve(m_LoadLookup, path, (void **)&pPlugin))

   933 	{

   934 		/* Check to see if we should try reloading it */

   935 		if (pPlugin->GetStatus() == Plugin_BadLoad

   936 			|| pPlugin->GetStatus() == Plugin_Error

   937 			|| pPlugin->GetStatus() == Plugin_Failed

   938 			|| no_load)

   939 		{

   940 			UnloadPlugin(pPlugin);

   941 		}

   942 		else

   943 		{

   944 			if (_plugin)

   945 			{

   946 				*_plugin = pPlugin;

   947 			}

   948 			return LoadRes_AlreadyLoaded;

   949 		}

   950 	}

   952 	if (no_load)

   953 	{

   954 		return LoadRes_NeverLoad;

   955 	}

   957 	pPlugin = CPlugin::CreatePlugin(path, error, maxlength);

   959 	assert(pPlugin != NULL);

   961 	pPlugin->m_type = PluginType_MapUpdated;

   963 	ICompilation *co = NULL;

   965 	if (pPlugin->m_status == Plugin_Uncompiled)

   966 	{

   967 		co = g_pSourcePawn2->StartCompilation();

   968 	}

   970 	for (unsigned int i=0; i<setcount; i++)

   971 	{

   972 		if ((pset=m_PluginInfo.GetSettingsIfMatch(i, path)) == NULL)

   973 		{

   974 			continue;

   975 		}

   976 		pPlugin->m_type = pset->type_val;

   977 		if (co)

   978 		{

   979 			for (unsigned int j=0; j<pset->opts_num; j++)

   980 			{

   981 				const char *key, *val;

   982 				m_PluginInfo.GetOptionsForPlugin(pset, j, &key, &val);

   983 				if (!key || !val)

   984 				{

   985 					continue;

   986 				}

   987 				if ((err = co->SetOption(key, val)) == SP_ERROR_NONE)

   988 				{

   989 					if (error)

   990 					{

   991 						UTIL_Format(error, maxlength, "Unable to set JIT option (key \"%s\") (value \"%s\")", key, val);

   992 					}

   993 					co->Abort();

   994 					co = NULL;

   995 					break;

   996 				}

   997 			}

   998 		}

   999 	}

  1001 	/* Do the actual compiling */

  1002 	if (co != NULL)

  1003 	{

  1004 		char fullpath[PLATFORM_MAX_PATH];

  1005 		g_SourceMod.BuildPath(Path_SM, fullpath, sizeof(fullpath), "plugins/%s", pPlugin->m_filename);

  1007 		pPlugin->m_pRuntime = g_pSourcePawn2->LoadPlugin(co, fullpath, &err);

  1008 		if (pPlugin->m_pRuntime == NULL)

  1009 		{

  1010 			if (error)

  1011 			{

  1012 				UTIL_Format(error,

  1013 					maxlength,

  1014 					"Unable to load plugin (error %d: %s)",

  1015 					err,

  1016 					g_pSourcePawn2->GetErrorString(err));

  1017 			}

  1018 			pPlugin->m_status = Plugin_BadLoad;

  1019 		}

  1020 		else

  1021 		{

  1022 			if (pPlugin->UpdateInfo())

  1023 			{

  1024 				pPlugin->m_status = Plugin_Created;

  1025 			}

  1026 			else

  1027 			{

  1028 				if (error)

  1029 				{

  1030 					UTIL_Format(error, maxlength, "%s", pPlugin->m_errormsg);

  1031 				}

  1032 			}

  1033 		}

  1034 	}

  1036 	if (pPlugin->GetStatus() == Plugin_Created)

  1037 	{

  1038 		unsigned char *pCodeHash = pPlugin->m_pRuntime->GetCodeHash();

  1040 		char codeHashBuf[40];

  1041 		UTIL_Format(codeHashBuf, 40, "plugin_");

  1042 		for (int i = 0; i < 16; i++)

  1043 			UTIL_Format(codeHashBuf + 7 + (i * 2), 3, "%02x", pCodeHash[i]);

  1045 		const char *bulletinUrl = g_pGameConf->GetKeyValue(codeHashBuf);

  1046 		if (bulletinUrl != NULL)

  1047 		{

  1048 			if (m_bBlockBadPlugins)

  1049 			{

  1050 				if (error)

  1051 				{

  1052 					if (bulletinUrl[0] != '\0')

  1053 					{

  1054 						UTIL_Format(error, maxlength, "Known malware detected and blocked. See %s for more info", bulletinUrl);

  1055 					} else {

  1056 						UTIL_Format(error, maxlength, "Possible malware or illegal plugin detected and blocked");

  1057 					}

  1058 				}

  1059 				pPlugin->m_status = Plugin_BadLoad;

  1060 			} else {

  1061 				if (bulletinUrl[0] != '\0')

  1062 				{

  1063 					g_Logger.LogMessage("%s: Known malware detected. See %s for more info, blocking disabled in core.cfg", pPlugin->GetFilename(), bulletinUrl);

  1064 				} else {

  1065 					g_Logger.LogMessage("%s: Possible malware or illegal plugin detected, blocking disabled in core.cfg", pPlugin->GetFilename());

  1066 				}

  1067 			}

  1068 		}

  1069 	}

  1071 	LoadRes loadFailure = LoadRes_Failure;

  1072 	/* Get the status */

  1073 	if (pPlugin->GetStatus() == Plugin_Created)

  1074 	{

  1075 		/* First native pass - add anything from Core */

  1076 		g_ShareSys.BindNativesToPlugin(pPlugin, true);

  1077 		pPlugin->InitIdentity();

  1078 		APLRes result = pPlugin->Call_AskPluginLoad(error, maxlength);

  1079 		switch (result)

  1080 		{

  1081 		case APLRes_Success:

  1082 			/* Autoload any modules */

  1083 			LoadOrRequireExtensions(pPlugin, 1, error, maxlength);

  1084 			break;

  1085 		case APLRes_Failure:

  1086 			pPlugin->SetErrorState(Plugin_Failed, "%s", error);

  1087 			loadFailure = LoadRes_Failure;

  1088 			break;

  1089 		case APLRes_SilentFailure:

  1090 			pPlugin->SetErrorState(Plugin_Failed, "%s", error);

  1091 			loadFailure = LoadRes_SilentFailure;

  1092 			pPlugin->SetSilentlyFailed(true);

  1093 			break;

  1094 		default:

  1095 			assert(false);

  1096 		}

  1097 	}

  1099 	/* Save the time stamp */

  1100 	time_t t = pPlugin->GetFileTimeStamp();

  1101 	pPlugin->SetTimeStamp(t);

  1103 	if (_plugin)

  1104 	{

  1105 		*_plugin = pPlugin;

  1106 	}

  1108 	return (pPlugin->GetStatus() == Plugin_Loaded) ? LoadRes_Successful : loadFailure;

  1109 }

  1111 IPlugin *CPluginManager::LoadPlugin(const char *path, bool debug, PluginType type, char error[], size_t maxlength, bool *wasloaded)

  1112 {

  1113 	CPlugin *pl;

  1114 	LoadRes res;

  1116 	*wasloaded = false;

  1117 	if ((res=_LoadPlugin(&pl, path, true, type, error, maxlength)) == LoadRes_Failure)

  1118 	{

  1119 		delete pl;

  1120 		return NULL;

  1121 	}

  1123 	if (res == LoadRes_AlreadyLoaded)

  1124 	{

  1125 		*wasloaded = true;

  1126 		return pl;

  1127 	}

  1129 	if (res == LoadRes_NeverLoad)

  1130 	{

  1131 		if (error)

  1132 		{

  1133 			if (m_LoadingLocked)

  1134 			{

  1135 				UTIL_Format(error, maxlength, "There is a global plugin loading lock in effect");

  1136 			}

  1137 			else

  1138 			{

  1139 				UTIL_Format(error, maxlength, "This plugin is blocked from loading (see plugin_settings.cfg)");

  1140 			}

  1141 		}

  1142 		return NULL;

  1143 	}

  1145 	AddPlugin(pl);

  1147 	/* Run second pass if we need to */

  1148 	if (IsLateLoadTime() && pl->GetStatus() == Plugin_Loaded)

  1149 	{

  1150 		if (!RunSecondPass(pl, error, maxlength))

  1151 		{

  1152 			UnloadPlugin(pl);

  1153 			return NULL;

  1154 		}

  1155 		pl->Call_OnAllPluginsLoaded();

  1156 	}

  1158 	return pl;

  1159 }

  1161 void CPluginManager::LoadAutoPlugin(const char *plugin)

  1162 {

  1163 	CPlugin *pl = NULL;

  1164 	LoadRes res;

  1165 	char error[255] = "Unknown error";

  1167 	if ((res=_LoadPlugin(&pl, plugin, false, PluginType_MapUpdated, error, sizeof(error))) == LoadRes_Failure)

  1168 	{

  1169 		g_Logger.LogError("[SM] Failed to load plugin \"%s\": %s.", plugin, error);

  1170 		pl->SetErrorState(

  1171 			pl->GetStatus() <= Plugin_Created ? Plugin_BadLoad : pl->GetStatus(),

  1172 			"%s",

  1173 			error);

  1174 	}

  1176 	if (res == LoadRes_Successful || res == LoadRes_Failure || res == LoadRes_SilentFailure)

  1177 	{

  1178 		AddPlugin(pl);

  1179 	}

  1180 }

  1182 void CPluginManager::AddPlugin(CPlugin *pPlugin)

  1183 {

  1184 	List<IPluginsListener *>::iterator iter;

  1185 	IPluginsListener *pListener;

  1187 	for (iter=m_listeners.begin(); iter!=m_listeners.end(); iter++)

  1188 	{

  1189 		pListener = (*iter);

  1190 		pListener->OnPluginCreated(pPlugin);

  1191 	}

  1193 	m_plugins.push_back(pPlugin);

  1194 	sm_trie_insert(m_LoadLookup, pPlugin->m_filename, pPlugin);

  1195 }

  1197 void CPluginManager::LoadAll_SecondPass()

  1198 {

  1199 	List<CPlugin *>::iterator iter;

  1200 	CPlugin *pPlugin;

  1202 	char error[256];

  1203 	for (iter=m_plugins.begin(); iter!=m_plugins.end(); iter++)

  1204 	{

  1205 		pPlugin = (*iter);

  1206 		if (pPlugin->GetStatus() == Plugin_Loaded)

  1207 		{

  1208 			error[0] = '\0';

  1209 			if (!RunSecondPass(pPlugin, error, sizeof(error)))

  1210 			{

  1211 				g_Logger.LogError("[SM] Unable to load plugin \"%s\": %s", pPlugin->GetFilename(), error);

  1212 				pPlugin->SetErrorState(Plugin_Failed, "%s", error);

  1213 			}

  1214 		}

  1215 	}

  1217 	m_AllPluginsLoaded = true;

  1218 }

  1220 bool CPluginManager::FindOrRequirePluginDeps(CPlugin *pPlugin, char *error, size_t maxlength)

  1221 {

  1222 	struct _pl

  1223 	{

  1224 		cell_t name;

  1225 		cell_t file;

  1226 		cell_t required;

  1227 	} *pl;

  1229 	IPluginContext *pBase = pPlugin->GetBaseContext();

  1230 	uint32_t num = pBase->GetPubVarsNum();

  1231 	sp_pubvar_t *pubvar;

  1232 	char *name, *file;

  1233 	char pathfile[PLATFORM_MAX_PATH];

  1235 	for (uint32_t i=0; i<num; i++)

  1236 	{

  1237 		if (pBase->GetPubvarByIndex(i, &pubvar) != SP_ERROR_NONE)

  1238 		{

  1239 			continue;

  1240 		}

  1241 		if (strncmp(pubvar->name, "__pl_", 5) == 0)

  1242 		{

  1243 			pl = (_pl *)pubvar->offs;

  1244 			if (pBase->LocalToString(pl->file, &file) != SP_ERROR_NONE)

  1245 			{

  1246 				continue;

  1247 			}

  1248 			if (pBase->LocalToString(pl->name, &name) != SP_ERROR_NONE)

  1249 			{

  1250 				continue;

  1251 			}

  1252 			g_LibSys.GetFileFromPath(pathfile, sizeof(pathfile), pPlugin->GetFilename());

  1253 			if (strcmp(pathfile, file) == 0)

  1254 			{

  1255 				continue;

  1256 			}

  1257 			if (pl->required == false)

  1258 			{

  1259 				IPluginFunction *pFunc;

  1260 				char buffer[64];

  1261 				UTIL_Format(buffer, sizeof(buffer), "__pl_%s_SetNTVOptional", &pubvar->name[5]);

  1262 				if ((pFunc=pBase->GetFunctionByName(buffer)))

  1263 				{

  1264 					cell_t res;

  1265 					pFunc->Execute(&res);

  1266 					if (pPlugin->GetBaseContext()->GetLastNativeError() != SP_ERROR_NONE)

  1267 					{

  1268 						if (error)

  1269 						{

  1270 							UTIL_Format(error, maxlength, "Fatal error during initializing plugin load");

  1271 						}

  1272 						return false;

  1273 					}

  1274 				}

  1275 			}

  1276 			else

  1277 			{

  1278 				/* Check that we aren't registering the same library twice */

  1279 				if (pPlugin->m_RequiredLibs.find(name) == pPlugin->m_RequiredLibs.end())

  1280 				{

  1281 					pPlugin->m_RequiredLibs.push_back(name);

  1282 				}

  1283 				else

  1284 				{

  1285 					continue;

  1286 				}

  1287 				List<CPlugin *>::iterator iter;

  1288 				CPlugin *pl;

  1289 				bool found = false;

  1290 				for (iter=m_plugins.begin(); iter!=m_plugins.end(); iter++)

  1291 				{

  1292 					pl = (*iter);

  1293 					if (pl->m_Libraries.find(name) != pl->m_Libraries.end())

  1294 					{

  1295 						found = true;

  1296 						break;

  1297 					}

  1298 				}

  1299 				if (!found)

  1300 				{

  1301 					if (error)

  1302 					{

  1303 						UTIL_Format(error, maxlength, "Could not find required plugin \"%s\"", name);

  1304 					}

  1305 					return false;

  1306 				}

  1307 			}

  1308 		}

  1309 	}

  1311 	return true;

  1312 }

  1314 bool CPluginManager::LoadOrRequireExtensions(CPlugin *pPlugin, unsigned int pass, char *error, size_t maxlength)

  1315 {

  1316 	/* Find any extensions this plugin needs */

  1317 	struct _ext

  1318 	{

  1319 		cell_t name;

  1320 		cell_t file;

  1321 		cell_t autoload;

  1322 		cell_t required;

  1323 	} *ext;

  1325 	IPluginContext *pBase = pPlugin->GetBaseContext();

  1326 	uint32_t num = pBase->GetPubVarsNum();

  1327 	sp_pubvar_t *pubvar;

  1328 	IExtension *pExt;

  1329 	char path[PLATFORM_MAX_PATH];

  1330 	char *file, *name;

  1331 	for (uint32_t i=0; i<num; i++)

  1332 	{

  1333 		if (pBase->GetPubvarByIndex(i, &pubvar) != SP_ERROR_NONE)

  1334 		{

  1335 			continue;

  1336 		}

  1337 		if (strncmp(pubvar->name, "__ext_", 6) == 0)

  1338 		{

  1339 			ext = (_ext *)pubvar->offs;

  1340 			if (pBase->LocalToString(ext->file, &file) != SP_ERROR_NONE)

  1341 			{

  1342 				continue;

  1343 			}

  1344 			if (pBase->LocalToString(ext->name, &name) != SP_ERROR_NONE)

  1345 			{

  1346 				continue;

  1347 			}

  1348 			if (pass == 1)

  1349 			{

  1350 				/* Attempt to auto-load if necessary */

  1351 				if (ext->autoload)

  1352 				{

  1353 					g_LibSys.PathFormat(path, PLATFORM_MAX_PATH, "%s", file);

  1354 					bool bErrorOnMissing = ext->required ? true : false;

  1355 					g_Extensions.LoadAutoExtension(path, bErrorOnMissing);

  1356 				}

  1357 			}

  1358 			else if (pass == 2)

  1359 			{

  1360 				/* Is this required? */

  1361 				if (ext->required)

  1362 				{

  1363 					g_LibSys.PathFormat(path, PLATFORM_MAX_PATH, "%s", file);

  1364 					if ((pExt = g_Extensions.FindExtensionByFile(path)) == NULL)

  1365 					{

  1366 						pExt = g_Extensions.FindExtensionByName(name);

  1367 					}

  1368 					/* :TODO: should we bind to unloaded extensions?

  1369 					 * Currently the extension manager will ignore this.

  1370 					 */

  1371 					if (!pExt || !pExt->IsRunning(NULL, 0))

  1372 					{

  1373 						if (error)

  1374 						{

  1375 							UTIL_Format(error, maxlength, "Required extension \"%s\" file(\"%s\") not running", name, file);

  1376 						}

  1377 						return false;

  1378 					}

  1379 					else

  1380 					{

  1381 						g_Extensions.BindChildPlugin(pExt, pPlugin);

  1382 					}

  1383 				}

  1384 				else

  1385 				{

  1386 					IPluginFunction *pFunc;

  1387 					char buffer[64];

  1388 					UTIL_Format(buffer, sizeof(buffer), "__ext_%s_SetNTVOptional", &pubvar->name[6]);

  1390 					if ((pFunc = pBase->GetFunctionByName(buffer)) != NULL)

  1391 					{

  1392 						cell_t res;

  1393 						pFunc->Execute(&res);

  1394 						if (pPlugin->GetBaseContext()->GetLastNativeError() != SP_ERROR_NONE)

  1395 						{

  1396 							if (error)

  1397 							{

  1398 								UTIL_Format(error, maxlength, "Fatal error during plugin initialization (ext req)");

  1399 							}

  1400 							return false;

  1401 						}

  1402 					}

  1403 				}

  1404 			}

  1405 		}

  1406 	}

  1408 	return true;

  1409 }

  1411 bool CPluginManager::RunSecondPass(CPlugin *pPlugin, char *error, size_t maxlength)

  1412 {

  1413 	/* Second pass for extension requirements */

  1414 	if (!LoadOrRequireExtensions(pPlugin, 2, error, maxlength))

  1415 	{

  1416 		return false;

  1417 	}

  1419 	if (!FindOrRequirePluginDeps(pPlugin, error, maxlength))

  1420 	{

  1421 		return false;

  1422 	}

  1424 	/* Run another binding pass */

  1425 	g_ShareSys.BindNativesToPlugin(pPlugin, false);

  1427 	/* Find any unbound natives. Right now, these are not allowed. */

  1428 	IPluginContext *pContext = pPlugin->GetBaseContext();

  1429 	uint32_t num = pContext->GetNativesNum();

  1430 	sp_native_t *native;

  1431 	for (unsigned int i=0; i<num; i++)

  1432 	{

  1433 		if (pContext->GetNativeByIndex(i, &native) != SP_ERROR_NONE)

  1434 		{

  1435 			break;

  1436 		}

  1437 		if (native->status == SP_NATIVE_UNBOUND

  1438 			&& native->name[0] != '@'

  1439 			&& !(native->flags & SP_NTVFLAG_OPTIONAL))

  1440 		{

  1441 			if (error)

  1442 			{

  1443 				UTIL_Format(error, maxlength, "Native \"%s\" was not found", native->name);

  1444 			}

  1445 			return false;

  1446 		}

  1447 	}

  1449 	/* Finish by telling all listeners */

  1450 	List<IPluginsListener *>::iterator iter;

  1451 	IPluginsListener *pListener;

  1452 	for (iter=m_listeners.begin(); iter!=m_listeners.end(); iter++)

  1453 	{

  1454 		pListener = (*iter);

  1455 		pListener->OnPluginLoaded(pPlugin);

  1456 	}

  1458 	/* Tell this plugin to finish initializing itself */

  1459 	pPlugin->Call_OnPluginStart();

  1461 	/* Now, if we have fake natives, go through all plugins that might need rebinding */

  1462 	if (pPlugin->GetStatus() <= Plugin_Paused && pPlugin->m_Natives.size())

  1463 	{

  1464 		List<CPlugin *>::iterator pl_iter;

  1465 		CPlugin *pOther;

  1466 		for (pl_iter = m_plugins.begin();

  1467 			 pl_iter != m_plugins.end();

  1468 			 pl_iter++)

  1469 		{

  1470 			pOther = (*pl_iter);

  1471 			if ((pOther->GetStatus() == Plugin_Error

  1472 				&& (pOther->m_FakeNativesMissing || pOther->m_LibraryMissing))

  1473 				|| pOther->m_FakeNativesMissing)

  1474 			{

  1475 				TryRefreshDependencies(pOther);

  1476 			}

  1477 			else if ((pOther->GetStatus() == Plugin_Running

  1478 					  || pOther->GetStatus() == Plugin_Paused)

  1479 					 && pOther != pPlugin)

  1480 			{

  1481 				List<NativeEntry *>::iterator nv_iter;

  1482 				for (nv_iter = pPlugin->m_Natives.begin();

  1483 					 nv_iter != pPlugin->m_Natives.end();

  1484 					 nv_iter++)

  1485 				{

  1486 					g_ShareSys.BindNativeToPlugin(pOther, (*nv_iter));

  1487 				}

  1488 			}

  1489 		}

  1490 	}

  1492 	/* Go through our libraries and tell other plugins they're added */

  1493 	List<String>::iterator s_iter;

  1494 	for (s_iter = pPlugin->m_Libraries.begin();

  1495 		s_iter != pPlugin->m_Libraries.end();

  1496 		s_iter++)

  1497 	{

  1498 		OnLibraryAction((*s_iter).c_str(), true, false);

  1499 	}

  1501 	/* :TODO: optimize? does this even matter? */

  1502 	pPlugin->GetPhrases()->AddPhraseFile("core.phrases");

  1504 	return true;

  1505 }

  1507 void CPluginManager::TryRefreshDependencies(CPlugin *pPlugin)

  1508 {

  1509 	assert(pPlugin->GetBaseContext() != NULL);

  1511 	g_ShareSys.BindNativesToPlugin(pPlugin, false);

  1513 	List<String>::iterator lib_iter;

  1514 	List<String>::iterator req_iter;

  1515 	List<CPlugin *>::iterator pl_iter;

  1516 	CPlugin *pl;

  1517 	for (req_iter=pPlugin->m_RequiredLibs.begin(); req_iter!=pPlugin->m_RequiredLibs.end(); req_iter++)

  1518 	{

  1519 		bool found = false;

  1520 		for (pl_iter=m_plugins.begin(); pl_iter!=m_plugins.end(); pl_iter++)

  1521 		{

  1522 			pl = (*pl_iter);

  1523 			for (lib_iter=pl->m_Libraries.begin(); lib_iter!=pl->m_Libraries.end(); lib_iter++)

  1524 			{

  1525 				if ((*req_iter) == (*lib_iter))

  1526 				{

  1527 					found = true;

  1528 				}

  1529 			}

  1530 		}

  1531 		if (!found)

  1532 		{

  1533 			pPlugin->SetErrorState(Plugin_Error, "Library not found: %s", (*req_iter).c_str());

  1534 			return;

  1535 		}

  1536 	}

  1538 	/* Find any unbound natives

  1539 	 * Right now, these are not allowed

  1540 	 */

  1541 	IPluginContext *pContext = pPlugin->GetBaseContext();

  1542 	uint32_t num = pContext->GetNativesNum();

  1543 	sp_native_t *native;

  1544 	for (unsigned int i=0; i<num; i++)

  1545 	{

  1546 		if (pContext->GetNativeByIndex(i, &native) != SP_ERROR_NONE)

  1547 		{

  1548 			break;

  1549 		}

  1550 		if (native->status == SP_NATIVE_UNBOUND

  1551 			&& native->name[0] != '@'

  1552 			&& !(native->flags & SP_NTVFLAG_OPTIONAL))

  1553 		{

  1554 			pPlugin->SetErrorState(Plugin_Error, "Native not found: %s", native->name);

  1555 			return;

  1556 		}

  1557 	}

  1559 	if (pPlugin->GetStatus() == Plugin_Error)

  1560 	{

  1561 		/* If we got here, all natives are okay again! */

  1562 		pPlugin->m_status = Plugin_Running;

  1563 		if (pPlugin->m_pRuntime->IsPaused())

  1564 		{

  1565 			pPlugin->m_pRuntime->SetPauseState(false);

  1566 			_SetPauseState(pPlugin, false);

  1567 		}

  1568 	}

  1569 }

  1571 bool CPluginManager::UnloadPlugin(IPlugin *plugin)

  1572 {

  1573 	CPlugin *pPlugin = (CPlugin *)plugin;

  1575 	/* This prevents removal during insertion or anything else weird */

  1576 	if (m_plugins.find(pPlugin) == m_plugins.end())

  1577 	{

  1578 		return false;

  1579 	}

  1581 	IPluginContext *pContext = plugin->GetBaseContext();

  1582 	if (pContext != NULL && pContext->IsInExec())

  1583 	{

  1584 		char buffer[255];

  1585 		UTIL_Format(buffer, sizeof(buffer), "sm plugins unload %s\n", plugin->GetFilename());

  1586 		engine->ServerCommand(buffer);

  1587 		return false;

  1588 	}

  1590 	/* Remove us from the lookup table and linked list */

  1591 	m_plugins.remove(pPlugin);

  1592 	sm_trie_delete(m_LoadLookup, pPlugin->m_filename);

  1594 	/* Go through our libraries and tell other plugins they're gone */

  1595 	List<String>::iterator s_iter;

  1596 	for (s_iter = pPlugin->m_Libraries.begin();

  1597 		 s_iter != pPlugin->m_Libraries.end();

  1598 		 s_iter++)

  1599 	{

  1600 		OnLibraryAction((*s_iter).c_str(), true, true);

  1601 	}

  1603 	List<IPluginsListener *>::iterator iter;

  1604 	IPluginsListener *pListener;

  1606 	if (pPlugin->GetStatus() <= Plugin_Error)

  1607 	{

  1608 		/* Notify listeners of unloading */

  1609 		for (iter=m_listeners.begin(); iter!=m_listeners.end(); iter++)

  1610 		{

  1611 			pListener = (*iter);

  1612 			pListener->OnPluginUnloaded(pPlugin);

  1613 		}

  1614 		/* Notify plugin */

  1615 		pPlugin->Call_OnPluginEnd();

  1616 	}

  1618 	pPlugin->DropEverything();

  1620 	for (iter=m_listeners.begin(); iter!=m_listeners.end(); iter++)

  1621 	{

  1622 		/* Notify listeners of destruction */

  1623 		pListener = (*iter);

  1624 		pListener->OnPluginDestroyed(pPlugin);

  1625 	}

  1627 	/* Tell the plugin to delete itself */

  1628 	delete pPlugin;

  1630 	return true;

  1631 }

  1633 IPlugin *CPluginManager::FindPluginByContext(const sp_context_t *ctx)

  1634 {

  1635 	IPlugin *pPlugin;

  1636 	IPluginContext *pContext;

  1638 	pContext = reinterpret_cast<IPluginContext *>(const_cast<sp_context_t *>(ctx));

  1640 	if (pContext->GetKey(2, (void **)&pPlugin))

  1641 	{

  1642 		return pPlugin;

  1643 	}

  1645 	return NULL;

  1646 }

  1648 CPlugin *CPluginManager::GetPluginByCtx(const sp_context_t *ctx)

  1649 {

  1650 	return (CPlugin *)FindPluginByContext(ctx);

  1651 }

  1653 unsigned int CPluginManager::GetPluginCount()

  1654 {

  1655 	return m_plugins.size();

  1656 }

  1658 void CPluginManager::AddPluginsListener(IPluginsListener *listener)

  1659 {

  1660 	m_listeners.push_back(listener);

  1661 }

  1663 void CPluginManager::RemovePluginsListener(IPluginsListener *listener)

  1664 {

  1665 	m_listeners.remove(listener);

  1666 }

  1668 IPluginIterator *CPluginManager::GetPluginIterator()

  1669 {

  1670 	if (m_iters.empty())

  1671 	{

  1672 		return new CPluginIterator(&m_plugins);

  1673 	} else {

  1674 		CPluginIterator *iter = m_iters.front();

  1675 		m_iters.pop();

  1676 		iter->Reset();

  1677 		return iter;

  1678 	}

  1679 }

  1681 void CPluginManager::ReleaseIterator(CPluginIterator *iter)

  1682 {

  1683 	m_iters.push(iter);

  1684 }

  1686 bool CPluginManager::TestAliasMatch(const char *alias, const char *localpath)

  1687 {

  1688 	/* As an optimization, we do not call strlen, but compute the length in the first pass */

  1689 	size_t alias_len = 0;

  1690 	size_t local_len = 0;

  1692 	const char *ptr = alias;

  1693 	unsigned int alias_explicit_paths = 0;

  1694 	unsigned int alias_path_end = 0;

  1695 	while (*ptr != '\0')

  1696 	{

  1697 		if (*ptr == '\\' || *ptr == '/')

  1698 		{

  1699 			alias_explicit_paths++;

  1700 			alias_path_end = alias_len;

  1701 		}

  1702 		alias_len++;

  1703 		ptr++;

  1704 	}

  1706 	if (alias_explicit_paths && alias_path_end == alias_len - 1)

  1707 	{

  1708 		/* Trailing slash is totally invalid here */

  1709 		return false;

  1710 	}

  1712 	ptr = localpath;

  1713 	unsigned int local_explicit_paths = 0;

  1714 	unsigned int local_path_end = 0;

  1715 	while (*ptr != '\0')

  1716 	{

  1717 		if (*ptr == '\\' || *ptr == '/')

  1718 		{

  1719 			local_explicit_paths++;

  1720 			local_path_end = local_len;

  1721 		}

  1722 		local_len++;

  1723 		ptr++;

  1724 	}

  1726 	/* If the alias has more explicit paths than the real path,

  1727 	 * no match will be possible.

  1728 	 */

  1729 	if (alias_explicit_paths > local_explicit_paths)

  1730 	{

  1731 		return false;

  1732 	}

  1734 	if (alias_explicit_paths)

  1735 	{

  1736 		/* We need to find if the paths match now.  For example, these should all match:

  1737 		 * csdm     csdm

  1738 		 * csdm     optional/csdm

  1739 		 * csdm/ban optional/crab/csdm/ban

  1740 		*/

  1741 		const char *aliasptr = alias;

  1742 		const char *localptr = localpath;

  1743 		bool match = true;

  1744 		do

  1745 		{

  1746 			if (*aliasptr != *localptr)

  1747 			{

  1748 				/* We have to knock one path off */

  1749 				local_explicit_paths--;

  1750 				if (alias_explicit_paths > local_explicit_paths)

  1751 				{

  1752 					/* Skip out if we're gonna have an impossible match */

  1753 					return false;

  1754 				}

  1755 				/* Eat up localptr tokens until we get a result */

  1756 				while (((localptr - localpath) < (int)local_path_end)

  1757 					&& *localptr != '/'

  1758 					&& *localptr != '\\')

  1759 				{

  1760 					localptr++;

  1761 				}

  1762 				/* Check if we hit the end of our searchable area.

  1763 				 * This probably isn't possible because of the path

  1764 				 * count check, but it's a good idea anyway.

  1765 				 */

  1766 				if ((localptr - localpath) >= (int)local_path_end)

  1767 				{

  1768 					return false;

  1769 				} else {

  1770 					/* Consume the slash token */

  1771 					localptr++;

  1772 				}

  1773 				/* Reset the alias pointer so we can continue consuming */

  1774 				aliasptr = alias;

  1775 				match = false;

  1776 				continue;

  1777 			}

  1778 			/* Note:

  1779 			 * This is safe because if localptr terminates early, aliasptr will too

  1780 			 */

  1781 			do

  1782 			{

  1783 				/* We should never reach the end of the string because of this check. */

  1784 				bool aliasend = (aliasptr - alias) > (int)alias_path_end;

  1785 				bool localend = (localptr - localpath) > (int)local_path_end;

  1786 				if (aliasend || localend)

  1787 				{

  1788 					if (aliasend && localend)

  1789 					{

  1790 						/* we matched, and we can break out now */

  1791 						match = true;

  1792 						break;

  1793 					}

  1794 					/* Otherwise, we've hit the end somehow and rest won't match up.  Break out. */

  1795 					match = false;

  1796 					break;

  1797 				}

  1799 				/* If we got here, it's safe to compare the next two tokens */

  1800 				if (*localptr != *aliasptr)

  1801 				{

  1802 					match = false;

  1803 					break;

  1804 				}

  1805 				localptr++;

  1806 				aliasptr++;

  1807 			} while (true);

  1808 		} while (!match);

  1809 	}

  1811 	/* If we got here, it's time to compare filenames */

  1812 	const char *aliasptr = alias;

  1813 	const char *localptr = localpath;

  1815 	if (alias_explicit_paths)

  1816 	{

  1817 		aliasptr = &alias[alias_path_end + 1];

  1818 	}

  1820 	if (local_explicit_paths)

  1821 	{

  1822 		localptr = &localpath[local_path_end + 1];

  1823 	}

  1825 	while (true)

  1826 	{

  1827 		if (*aliasptr == '*')

  1828 		{

  1829 			/* First, see if this is the last character */

  1830 			if ((unsigned)(aliasptr - alias) == alias_len - 1)

  1831 			{

  1832 				/* If so, there's no need to match anything else */

  1833 				return true;

  1834 			}

  1835 			/* Otherwise, we need to search for an appropriate matching sequence in local.

  1836 			 * Note that we only need to search up to the next asterisk.

  1837 			 */

  1838 			aliasptr++;

  1839 			bool match = true;

  1840 			const char *local_orig = localptr;

  1841 			do

  1842 			{

  1843 				match = true;

  1844 				while (*aliasptr != '\0' && *aliasptr != '*')

  1845 				{

  1846 					/* Since aliasptr is never '\0', localptr hitting the end will fail */

  1847 					if (*aliasptr != *localptr)

  1848 					{

  1849 						match = false;

  1850 						break;

  1851 					}

  1852 					aliasptr++;

  1853 					localptr++;

  1854 				}

  1855 				if (!match)

  1856 				{

  1857 					/* If we didn't get a match, we need to advance the search stream.

  1858 					 * This will let us skip tokens while still searching for another match.

  1859 					 */

  1860 					localptr = ++local_orig;

  1861 					/* Make sure we don't go out of bounds */

  1862 					if (*localptr == '\0')

  1863 					{

  1864 						break;

  1865 					}

  1866 				}

  1867 			} while (!match);

  1869 			if (!match)

  1870 			{

  1871 				return false;

  1872 			} else {

  1873 				/* If we got a match, move on to the next token */

  1874 				continue;

  1875 			}

  1876 		} else if (*aliasptr == '\0') {

  1877 			if (*localptr == '\0'

  1878 				||

  1879 				strcmp(localptr, ".smx") == 0)

  1880 			{

  1881 				return true;

  1882 			} else {

  1883 				return false;

  1884 			}

  1885 		} else if (*aliasptr != *localptr) {

  1886 			return false;

  1887 		}

  1888 		aliasptr++;

  1889 		localptr++;

  1890 	}

  1892 	return true;

  1893 }

  1895 bool CPluginManager::IsLateLoadTime() const

  1896 {

  1897 	return (m_AllPluginsLoaded || !g_SourceMod.IsMapLoading());

  1898 }

  1900 void CPluginManager::OnSourceModAllInitialized()

  1901 {

  1902 	m_MyIdent = g_ShareSys.CreateCoreIdentity();

  1904 	HandleAccess sec;

  1905 	g_HandleSys.InitAccessDefaults(NULL, &sec);

  1907 	sec.access[HandleAccess_Delete] = HANDLE_RESTRICT_IDENTITY;

  1908 	sec.access[HandleAccess_Clone] = HANDLE_RESTRICT_IDENTITY;

  1910 	g_PluginType = g_HandleSys.CreateType("Plugin", this, 0, NULL, &sec, m_MyIdent, NULL);

  1911 	g_PluginIdent = g_ShareSys.CreateIdentType("PLUGIN");

  1913 	g_RootMenu.AddRootConsoleCommand("plugins", "Manage Plugins", this);

  1915 	g_ShareSys.AddInterface(NULL, this);

  1916 }

  1918 void CPluginManager::OnSourceModShutdown()

  1919 {

  1920 	g_RootMenu.RemoveRootConsoleCommand("plugins", this);

  1922 	UnloadAll();

  1924 	g_HandleSys.RemoveType(g_PluginType, m_MyIdent);

  1925 	g_ShareSys.DestroyIdentType(g_PluginIdent);

  1926 	g_ShareSys.DestroyIdentity(m_MyIdent);

  1927 }

  1929 ConfigResult CPluginManager::OnSourceModConfigChanged(const char *key,

  1930 												 const char *value,

  1931 												 ConfigSource source,

  1932 												 char *error,

  1933 												 size_t maxlength)

  1934 {

  1935 	if (strcmp(key, "BlockBadPlugins") == 0) {

  1936 		if (strcasecmp(value, "yes") == 0)

  1937 		{

  1938 			m_bBlockBadPlugins = true;

  1939 		} else if (strcasecmp(value, "no") == 0) {

  1940 			m_bBlockBadPlugins = false;

  1941 		} else {

  1942 			UTIL_Format(error, maxlength, "Invalid value: must be \"yes\" or \"no\"");

  1943 			return ConfigResult_Reject;

  1944 		}

  1945 		return ConfigResult_Accept;

  1946 	}

  1947 	return ConfigResult_Ignore;

  1948 }

  1950 void CPluginManager::OnHandleDestroy(HandleType_t type, void *object)

  1951 {

  1952 	/* We don't care about the internal object, actually */

  1953 }

  1955 bool CPluginManager::GetHandleApproxSize(HandleType_t type, void *object, unsigned int *pSize)

  1956 {

  1957 	*pSize = ((CPlugin *)object)->CalcMemUsage();

  1958 	return true;

  1959 }

  1961 IPlugin *CPluginManager::PluginFromHandle(Handle_t handle, HandleError *err)

  1962 {

  1963 	IPlugin *pPlugin;

  1964 	HandleError _err;

  1966 	HandleSecurity sec;

  1968 	sec.pOwner = NULL;

  1969 	sec.pIdentity = m_MyIdent;

  1971 	if ((_err=g_HandleSys.ReadHandle(handle, g_PluginType, &sec, (void **)&pPlugin)) != HandleError_None)

  1972 	{

  1973 		pPlugin = NULL;

  1974 	}

  1976 	if (err)

  1977 	{

  1978 		*err = _err;

  1979 	}

  1981 	return pPlugin;

  1982 }

  1984 CPlugin *CPluginManager::GetPluginByOrder(int num)

  1985 {

  1986 	if (num < 1 || num > (int)GetPluginCount())

  1987 	{

  1988 		return NULL;

  1989 	}

  1991 	CPlugin *pl;

  1992 	int id = 1;

  1994 	SourceHook::List<CPlugin *>::iterator iter;

  1995 	for (iter = m_plugins.begin(); iter != m_plugins.end() && id < num; iter++, id++) {}

  1997 	pl = *iter;

  1999 	return pl;

  2000 }

  2002 const char *CPluginManager::GetStatusText(PluginStatus st)

  2003 {

  2004 	switch (st)

  2005 	{

  2006 	case Plugin_Running:

  2007 		return "Running";

  2008 	case Plugin_Paused:

  2009 		return "Paused";

  2010 	case Plugin_Error:

  2011 		return "Error";

  2012 	case Plugin_Uncompiled:

  2013 		return "Uncompiled";

  2014 	case Plugin_BadLoad:

  2015 		return "Bad Load";

  2016 	case Plugin_Failed:

  2017 		return "Failed";

  2018 	default:

  2019 		assert(false);

  2020 		return "-";

  2021 	}

  2022 }

  2024 void CPluginManager::OnRootConsoleCommand(const char *cmdname, const CCommand &command)

  2025 {

  2026 	int argcount = command.ArgC();

  2027 	if (argcount >= 3)

  2028 	{

  2029 		const char *cmd = command.Arg(2);

  2030 		if (strcmp(cmd, "list") == 0)

  2031 		{

  2032 			char buffer[256];

  2033 			unsigned int id = 1;

  2034 			int plnum = GetPluginCount();

  2036 			if (!plnum)

  2037 			{

  2038 				g_RootMenu.ConsolePrint("[SM] No plugins loaded");

  2039 				return;

  2040 			}

  2041 			else

  2042 			{

  2043 				g_RootMenu.ConsolePrint("[SM] Listing %d plugin%s:", GetPluginCount(), (plnum > 1) ? "s" : "");

  2044 			}

  2046 			CPlugin *pl;

  2047 			SourceHook::List<CPlugin *>::iterator iter;

  2048 			SourceHook::List<CPlugin *> m_FailList;

  2050 			for (iter = m_plugins.begin(); iter != m_plugins.end(); iter++, id++)

  2051 			{

  2052 				pl = (*iter);

  2053 				assert(pl->GetStatus() != Plugin_Created);

  2054 				int len = 0;

  2055 				const sm_plugininfo_t *info = pl->GetPublicInfo();

  2056 				if (pl->GetStatus() != Plugin_Running && !pl->IsSilentlyFailed())

  2057 				{

  2058 					len += UTIL_Format(buffer, sizeof(buffer), "  %02d <%s>", id, GetStatusText(pl->GetStatus()));

  2060 					if (pl->GetStatus() <= Plugin_Error)

  2061 					{

  2062 						/* Plugin has failed to load. */

  2063 						m_FailList.push_back(pl);

  2064 					}

  2065 				}

  2066 				else

  2067 				{

  2068 					len += UTIL_Format(buffer, sizeof(buffer), "  %02d", id);

  2069 				}

  2070 				if (pl->GetStatus() < Plugin_Created)

  2071 				{

  2072 					if (pl->IsSilentlyFailed())

  2073 						len += UTIL_Format(&buffer[len], sizeof(buffer)-len, " Disabled:");

  2074 					len += UTIL_Format(&buffer[len], sizeof(buffer)-len, " \"%s\"", (IS_STR_FILLED(info->name)) ? info->name : pl->GetFilename());

  2075 					if (IS_STR_FILLED(info->version))

  2076 					{

  2077 						len += UTIL_Format(&buffer[len], sizeof(buffer)-len, " (%s)", info->version);

  2078 					}

  2079 					if (IS_STR_FILLED(info->author))

  2080 					{

  2081 						UTIL_Format(&buffer[len], sizeof(buffer)-len, " by %s", info->author);

  2082 					}

  2083 				}

  2084 				else

  2085 				{

  2086 					UTIL_Format(&buffer[len], sizeof(buffer)-len, " %s", pl->m_filename);

  2087 				}

  2088 				g_RootMenu.ConsolePrint("%s", buffer);

  2089 			}

  2091 			if (!m_FailList.empty())

  2092 			{

  2093 				g_RootMenu.ConsolePrint("Load Errors:");

  2095 				SourceHook::List<CPlugin *>::iterator _iter;

  2097 				CPlugin *pl;

  2099 				for (_iter=m_FailList.begin(); _iter!=m_FailList.end(); _iter++)

  2100 				{

  2101 					pl = (CPlugin *)*_iter;

  2102 					g_RootMenu.ConsolePrint("%s: %s",(IS_STR_FILLED(pl->GetPublicInfo()->name)) ? pl->GetPublicInfo()->name : pl->GetFilename(), pl->m_errormsg);

  2103 				}

  2104 			}

  2106 			return;

  2107 		}

  2108 		else if (strcmp(cmd, "load") == 0)

  2109 		{

  2110 			if (argcount < 4)

  2111 			{

  2112 				g_RootMenu.ConsolePrint("[SM] Usage: sm plugins load <file>");

  2113 				return;

  2114 			}

  2116 			char error[128];

  2117 			bool wasloaded;

  2118 			const char *filename = command.Arg(3);

  2120 			char pluginfile[256];

  2121 			const char *ext = g_LibSys.GetFileExtension(filename) ? "" : ".smx";

  2122 			g_SourceMod.BuildPath(Path_None, pluginfile, sizeof(pluginfile), "%s%s", filename, ext);

  2124 			IPlugin *pl = LoadPlugin(pluginfile, false, PluginType_MapUpdated, error, sizeof(error), &wasloaded);

  2126 			if (wasloaded)

  2127 			{

  2128 				g_RootMenu.ConsolePrint("[SM] Plugin %s is already loaded.", pluginfile);

  2129 				return;

  2130 			}

  2132 			if (pl)

  2133 			{

  2134 				g_RootMenu.ConsolePrint("[SM] Loaded plugin %s successfully.", pluginfile);

  2135 			}

  2136 			else

  2137 			{

  2138 				g_RootMenu.ConsolePrint("[SM] Plugin %s failed to load: %s.", pluginfile, error);

  2139 			}

  2141 			return;

  2142 		}

  2143 		else if (strcmp(cmd, "unload") == 0)

  2144 		{

  2145 			if (argcount < 4)

  2146 			{

  2147 				g_RootMenu.ConsolePrint("[SM] Usage: sm plugins unload <#|file>");

  2148 				return;

  2149 			}

  2151 			CPlugin *pl;

  2152 			char *end;

  2153 			const char *arg = command.Arg(3);

  2154 			int id = strtol(arg, &end, 10);

  2156 			if (*end == '\0')

  2157 			{

  2158 				pl = GetPluginByOrder(id);

  2159 				if (!pl)

  2160 				{

  2161 					g_RootMenu.ConsolePrint("[SM] Plugin index %d not found.", id);

  2162 					return;

  2163 				}

  2164 			}

  2165 			else

  2166 			{

  2167 				char pluginfile[256];

  2168 				const char *ext = g_LibSys.GetFileExtension(arg) ? "" : ".smx";

  2169 				g_SourceMod.BuildPath(Path_None, pluginfile, sizeof(pluginfile), "%s%s", arg, ext);

  2171 				if (!sm_trie_retrieve(m_LoadLookup, pluginfile, (void **)&pl))

  2172 				{

  2173 					g_RootMenu.ConsolePrint("[SM] Plugin %s is not loaded.", pluginfile);

  2174 					return;

  2175 				}

  2176 			}

  2178 			char name[PLATFORM_MAX_PATH];

  2180 			if (pl->GetStatus() < Plugin_Created)

  2181 			{

  2182 				const sm_plugininfo_t *info = pl->GetPublicInfo();

  2183 				UTIL_Format(name, sizeof(name), (IS_STR_FILLED(info->name)) ? info->name : pl->GetFilename());

  2184 			}

  2185 			else

  2186 			{

  2187 				UTIL_Format(name, sizeof(name), "%s", pl->GetFilename());

  2188 			}

  2190 			if (UnloadPlugin(pl))

  2191 			{

  2192 				g_RootMenu.ConsolePrint("[SM] Plugin %s unloaded successfully.", name);

  2193 			}

  2194 			else

  2195 			{

  2196 				g_RootMenu.ConsolePrint("[SM] Failed to unload plugin %s.", name);

  2197 			}

  2199 			return;

  2200 		}

  2201 		else if (strcmp(cmd, "unload_all") == 0)

  2202 		{

  2203 			g_PluginSys.UnloadAll();

  2204 			g_RootMenu.ConsolePrint("[SM] All plugins have been unloaded.");

  2205 			return;

  2206 		}

  2207 		else if (strcmp(cmd, "load_lock") == 0)

  2208 		{

  2209 			if (m_LoadingLocked)

  2210 			{

  2211 				g_RootMenu.ConsolePrint("[SM] There is already a loading lock in effect.");

  2212 			}

  2213 			else

  2214 			{

  2215 				m_LoadingLocked = true;

  2216 				g_RootMenu.ConsolePrint("[SM] Loading is now locked; no plugins will be loaded or re-loaded.");

  2217 			}

  2218 			return;

  2219 		}

  2220 		else if (strcmp(cmd, "load_unlock") == 0)

  2221 		{

  2222 			if (m_LoadingLocked)

  2223 			{

  2224 				m_LoadingLocked = false;

  2225 				g_RootMenu.ConsolePrint("[SM] The loading lock is no longer in effect.");

  2226 			}

  2227 			else

  2228 			{

  2229 				g_RootMenu.ConsolePrint("[SM] There was no loading lock in effect.");

  2230 			}

  2231 			return;

  2232 		}

  2233 		else if (strcmp(cmd, "info") == 0)

  2234 		{

  2235 			if (argcount < 4)

  2236 			{

  2237 				g_RootMenu.ConsolePrint("[SM] Usage: sm plugins info <#>");

  2238 				return;

  2239 			}

  2241 			CPlugin *pl;

  2242 			char *end;

  2243 			const char *arg = command.Arg(3);

  2244 			int id = strtol(arg, &end, 10);

  2246 			if (*end == '\0')

  2247 			{

  2248 				pl = GetPluginByOrder(id);

  2249 				if (!pl)

  2250 				{

  2251 					g_RootMenu.ConsolePrint("[SM] Plugin index %d not found.", id);

  2252 					return;

  2253 				}

  2254 			}

  2255 			else

  2256 			{

  2257 				char pluginfile[256];

  2258 				const char *ext = g_LibSys.GetFileExtension(arg) ? "" : ".smx";

  2259 				g_SourceMod.BuildPath(Path_None, pluginfile, sizeof(pluginfile), "%s%s", arg, ext);

  2261 				if (!sm_trie_retrieve(m_LoadLookup, pluginfile, (void **)&pl))

  2262 				{

  2263 					g_RootMenu.ConsolePrint("[SM] Plugin %s is not loaded.", pluginfile);

  2264 					return;

  2265 				}

  2266 			}

  2268 			const sm_plugininfo_t *info = pl->GetPublicInfo();

  2270 			g_RootMenu.ConsolePrint("  Filename: %s", pl->GetFilename());

  2271 			if (pl->GetStatus() <= Plugin_Error)

  2272 			{

  2273 				if (IS_STR_FILLED(info->name))

  2274 				{

  2275 					if (IS_STR_FILLED(info->description))

  2276 					{

  2277 						g_RootMenu.ConsolePrint("  Title: %s (%s)", info->name, info->description);

  2278 					} else {

  2279 						g_RootMenu.ConsolePrint("  Title: %s", info->name);

  2280 					}

  2281 				}

  2282 				if (IS_STR_FILLED(info->author))

  2283 				{

  2284 					g_RootMenu.ConsolePrint("  Author: %s", info->author);

  2285 				}

  2286 				if (IS_STR_FILLED(info->version))

  2287 				{

  2288 					g_RootMenu.ConsolePrint("  Version: %s", info->version);

  2289 				}

  2290 				if (IS_STR_FILLED(info->url))

  2291 				{

  2292 					g_RootMenu.ConsolePrint("  URL: %s", info->url);

  2293 				}

  2294 				if (pl->GetStatus() == Plugin_Error)

  2295 				{

  2296 					g_RootMenu.ConsolePrint("  Error: %s", pl->m_errormsg);

  2297 				}

  2298 				else

  2299 				{

  2300 					if (pl->GetStatus() == Plugin_Running)

  2301 					{

  2302 						g_RootMenu.ConsolePrint("  Status: running");

  2303 					}

  2304 					else

  2305 					{

  2306 						g_RootMenu.ConsolePrint("  Status: not running");

  2307 					}

  2309 					const char *typestr = "";

  2310 					switch (pl->GetType())

  2311 					{

  2312 					case PluginType_MapUpdated:

  2313 						typestr = "Map Change if Updated";

  2314 						break;

  2315 					case PluginType_MapOnly:

  2316 						typestr = "Map Change";

  2317 						break;

  2318 					case PluginType_Private:

  2319 					case PluginType_Global:

  2320 						typestr = "Never";

  2321 						break;

  2322 					}

  2324 					g_RootMenu.ConsolePrint("  Reloads: %s", typestr);

  2325 				}

  2326 				if (pl->m_FileVersion >= 3)

  2327 				{

  2328 					g_RootMenu.ConsolePrint("  Timestamp: %s", pl->m_DateTime);

  2329 				}

  2331 				unsigned char *pCodeHash = pl->m_pRuntime->GetCodeHash();

  2332 				unsigned char *pDataHash = pl->m_pRuntime->GetDataHash();

  2334 				char combinedHash[33];

  2335 				for (int i = 0; i < 16; i++)

  2336 					UTIL_Format(combinedHash + (i * 2), 3, "%02x", pCodeHash[i] ^ pDataHash[i]);

  2338 				g_RootMenu.ConsolePrint("  Hash: %s", combinedHash);

  2339 			}

  2340 			else

  2341 			{

  2342 				g_RootMenu.ConsolePrint("  Load error: %s", pl->m_errormsg);

  2343 				if (pl->GetStatus() < Plugin_Created)

  2344 				{

  2345 					g_RootMenu.ConsolePrint("  File info: (title \"%s\") (version \"%s\")",

  2346 											info->name ? info->name : "<none>",

  2347 											info->version ? info->version : "<none>");

  2348 					if (IS_STR_FILLED(info->url))

  2349 					{

  2350 						g_RootMenu.ConsolePrint("  File URL: %s", info->url);

  2351 					}

  2352 				}

  2353 			}

  2355 			return;

  2356 		}

  2357 		else if (strcmp(cmd, "refresh") == 0)

  2358 		{

  2359 			g_SourceMod.DoGlobalPluginLoads();

  2360 			g_RootMenu.ConsolePrint("[SM] The plugin list has been refreshed and reloaded.");

  2361 			return;

  2362 		}

  2363 		else if (strcmp(cmd, "reload") == 0)

  2364 		{

  2365 			if (argcount < 4)

  2366 			{

  2367 				g_RootMenu.ConsolePrint("[SM] Usage: sm plugins reload <#|file>");

  2368 				return;

  2369 			}

  2371 			CPlugin *pl;

  2372 			char *end;

  2373 			const char *arg = command.Arg(3);

  2374 			int id = strtol(arg, &end, 10);

  2376 			if (*end == '\0')

  2377 			{

  2378 				pl = GetPluginByOrder(id);

  2379 				if (!pl)

  2380 				{

  2381 					g_RootMenu.ConsolePrint("[SM] Plugin index %d not found.", id);

  2382 					return;

  2383 				}

  2384 			}

  2385 			else

  2386 			{

  2387 				char pluginfile[256];

  2388 				const char *ext = g_LibSys.GetFileExtension(arg) ? "" : ".smx";

  2389 				g_SourceMod.BuildPath(Path_None, pluginfile, sizeof(pluginfile), "%s%s", arg, ext);

  2391 				if (!sm_trie_retrieve(m_LoadLookup, pluginfile, (void **)&pl))

  2392 				{

  2393 					g_RootMenu.ConsolePrint("[SM] Plugin %s is not loaded.", pluginfile);

  2394 					return;

  2395 				}

  2396 			}

  2398 			char name[PLATFORM_MAX_PATH];

  2399 			const sm_plugininfo_t *info = pl->GetPublicInfo();

  2400 			if (pl->GetStatus() <= Plugin_Paused)

  2401 				strcpy(name, (IS_STR_FILLED(info->name)) ? info->name : pl->GetFilename());

  2402 			else

  2403 				strcpy(name, pl->GetFilename());

  2405 			if (ReloadPlugin(pl))

  2406 			{

  2407 				g_RootMenu.ConsolePrint("[SM] Plugin %s reloaded successfully.", name);

  2408 			}

  2409 			else

  2410 			{

  2411 				g_RootMenu.ConsolePrint("[SM] Failed to reload plugin %s.", name);

  2412 			}

  2414 			return;

  2415 		}

  2416 	}

  2418 	/* Draw the main menu */

  2419 	g_RootMenu.ConsolePrint("SourceMod Plugins Menu:");

  2420 	g_RootMenu.DrawGenericOption("info", "Information about a plugin");

  2421 	g_RootMenu.DrawGenericOption("list", "Show loaded plugins");

  2422 	g_RootMenu.DrawGenericOption("load", "Load a plugin");

  2423 	g_RootMenu.DrawGenericOption("load_lock", "Prevents any more plugins from being loaded");

  2424 	g_RootMenu.DrawGenericOption("load_unlock", "Re-enables plugin loading");

  2425 	g_RootMenu.DrawGenericOption("refresh", "Reloads/refreshes all plugins in the plugins folder");

  2426 	g_RootMenu.DrawGenericOption("reload", "Reloads a plugin");

  2427 	g_RootMenu.DrawGenericOption("unload", "Unload a plugin");

  2428 	g_RootMenu.DrawGenericOption("unload_all", "Unloads all plugins");

  2429 }

  2431 bool CPluginManager::ReloadPlugin(CPlugin *pl)

  2432 {

  2433 	List<CPlugin *>::iterator iter;

  2434 	char filename[PLATFORM_MAX_PATH];

  2435 	bool wasloaded;

  2436 	PluginType ptype;

  2437 	IPlugin *newpl;

  2438 	int id = 1;

  2440 	strcpy(filename, pl->m_filename);

  2441 	ptype = pl->GetType();

  2443 	for (iter=m_plugins.begin(); iter!=m_plugins.end(); iter++, id++)

  2444 	{

  2445 		if ((*iter) == pl)

  2446 		{

  2447 			break;

  2448 		}

  2449 	}

  2451 	if (!UnloadPlugin(pl))

  2452 	{

  2453 		return false;

  2454 	}

  2455 	if (!(newpl=LoadPlugin(filename, true, ptype, NULL, 0, &wasloaded)))

  2456 	{

  2457 		return false;

  2458 	}

  2460 	for (iter=m_plugins.begin(); iter!=m_plugins.end(); iter++)

  2461 	{

  2462 		if ((*iter) == (CPlugin *)newpl)

  2463 		{

  2464 			m_plugins.erase(iter);

  2465 			break;

  2466 		}

  2467 	}

  2469 	int i;

  2470 	for (i=1, iter=m_plugins.begin(); iter!=m_plugins.end() && i<id; iter++, i++)

  2471 	{

  2472 	}

  2473 	m_plugins.insert(iter, (CPlugin *)newpl);

  2475 	return true;

  2476 }

  2478 void CPluginManager::ReloadOrUnloadPlugins()

  2479 {

  2480 	/* If we're in a load lock, just skip this whole bit. */

  2481 	if (m_LoadingLocked)

  2482 	{

  2483 		return;

  2484 	}

  2486 	List<CPlugin *>::iterator iter;

  2487 	List<CPlugin *> tmp_list = m_plugins;

  2488 	CPlugin *pl;

  2489 	time_t t;

  2491 	for (iter=tmp_list.begin(); iter!=tmp_list.end(); iter++)

  2492 	{

  2493 		pl = (*iter);

  2494 		if (pl->GetType() ==  PluginType_MapOnly)

  2495 		{

  2496 			UnloadPlugin((IPlugin *)pl);

  2497 		}

  2498 		else if (pl->GetType() == PluginType_MapUpdated)

  2499 		{

  2500 			t = pl->GetFileTimeStamp();

  2501 			if (!t || t > pl->GetTimeStamp())

  2502 			{

  2503 				pl->SetTimeStamp(t);

  2504 				UnloadPlugin((IPlugin *)pl);

  2505 			}

  2506 		}

  2507 	}

  2508 }

  2510 void CPluginManager::_SetPauseState(CPlugin *pl, bool paused)

  2511 {

  2512 	List<IPluginsListener *>::iterator iter;

  2513 	IPluginsListener *pListener;

  2514 	for (iter=m_listeners.begin(); iter!=m_listeners.end(); iter++)

  2515 	{

  2516 		pListener = (*iter);

  2517 		pListener->OnPluginPauseChange(pl, paused);

  2518 	}

  2519 }

  2521 void CPluginManager::AddFunctionsToForward(const char *name, IChangeableForward *pForward)

  2522 {

  2523 	List<CPlugin *>::iterator iter;

  2524 	CPlugin *pPlugin;

  2525 	IPluginFunction *pFunction;

  2527 	for (iter = m_plugins.begin(); iter != m_plugins.end(); iter++)

  2528 	{

  2529 		pPlugin = (*iter);

  2531 		if (pPlugin->GetStatus() <= Plugin_Paused)

  2532 		{

  2533 			pFunction = pPlugin->GetBaseContext()->GetFunctionByName(name);

  2535 			if (pFunction)

  2536 			{

  2537 				pForward->AddFunction(pFunction);

  2538 			}

  2539 		}

  2540 	}

  2541 }

  2543 CPlugin *CPluginManager::GetPluginFromIdentity(IdentityToken_t *pToken)

  2544 {

  2545 	if (pToken->type != g_PluginIdent)

  2546 	{

  2547 		return NULL;

  2548 	}

  2550 	return (CPlugin *)(pToken->ptr);

  2551 }

  2553 void CPluginManager::OnLibraryAction(const char *lib, bool is_a_plugin, bool drop)

  2554 {

  2555 	List<CPlugin *>::iterator iter;

  2557 	struct _pl

  2558 	{

  2559 		cell_t name;

  2560 		cell_t file;

  2561 		cell_t required;

  2562 	} *plc;

  2564 	struct _ext

  2565 	{

  2566 		cell_t name;

  2567 		cell_t file;

  2568 		cell_t autoload;

  2569 		cell_t required;

  2570 	} *ext;

  2572 	const char *name = drop ? "OnLibraryRemoved" : "OnLibraryAdded";

  2574 	for (iter=m_plugins.begin();

  2575 		 iter!=m_plugins.end();

  2576 		 iter++)

  2577 	{

  2578 		CPlugin *pl = (*iter);

  2579 		if (pl->GetStatus() != Plugin_Running)

  2580 		{

  2581 			continue;

  2582 		}

  2583 		IPluginContext *pContext = pl->GetBaseContext();

  2584 		IPluginFunction *pf = pContext->GetFunctionByName(name);

  2585 		if (!pf)

  2586 		{

  2587 			continue;

  2588 		}

  2589 		uint32_t num_vars = pContext->GetPubVarsNum();

  2590 		for (uint32_t i=0; i<num_vars; i++)

  2591 		{

  2592 			sp_pubvar_t *pubvar;

  2593 			if (pContext->GetPubvarByIndex(i, &pubvar) != SP_ERROR_NONE)

  2594 			{

  2595 				continue;

  2596 			}

  2597 			if (is_a_plugin && strncmp(pubvar->name, "__pl_", 5) == 0)

  2598 			{

  2599 				plc = (_pl *)pubvar->offs;

  2600 				if (plc->required)

  2601 				{

  2602 					continue;

  2603 				}

  2604 				char *str;

  2605 				pContext->LocalToString(plc->name, &str);

  2606 				if (strcmp(str, lib) != 0)

  2607 				{

  2608 					continue;

  2609 				}

  2610 				pf->PushString(lib);

  2611 				pf->Execute(NULL);

  2612 			}

  2613 			else if (!is_a_plugin && strncmp(pubvar->name, "__ext_", 6) == 0)

  2614 			{

  2615 				ext = (_ext *)pubvar->offs;

  2616 				if (ext->required)

  2617 				{

  2618 					continue;

  2619 				}

  2620 				char *str;

  2621 				pContext->LocalToString(ext->name, &str);

  2622 				if (strcmp(str, lib) != 0)

  2623 				{

  2624 					continue;

  2625 				}

  2626 				pf->PushString(lib);

  2627 				pf->Execute(NULL);

  2628 			}

  2629 		}

  2630 	}

  2631 }

  2633 bool CPluginManager::LibraryExists(const char *lib)

  2634 {

  2635 	List<CPlugin *>::iterator iter;

  2637 	for (iter=m_plugins.begin();

  2638 		 iter!=m_plugins.end();

  2639 		 iter++)

  2640 	{

  2641 		CPlugin *pl = (*iter);

  2642 		if (pl->GetStatus() != Plugin_Running)

  2643 		{

  2644 			continue;

  2645 		}

  2646 		List<String>::iterator s_iter;

  2647 		for (s_iter = pl->m_Libraries.begin();

  2648 			 s_iter != pl->m_Libraries.end();

  2649 			 s_iter++)

  2650 		{

  2651 			if ((*s_iter).compare(lib) == 0)

  2652 			{

  2653 				return true;

  2654 			}

  2655 		}

  2656 	}

  2658 	return false;

  2659 }

  2661 void CPluginManager::AllPluginsLoaded()

  2662 {

  2663 	List<CPlugin *>::iterator iter;

  2664 	CPlugin *pl;

  2666 	for (iter=m_plugins.begin(); iter!=m_plugins.end(); iter++)

  2667 	{

  2668 		pl = (*iter);

  2669 		pl->Call_OnAllPluginsLoaded();

  2670 	}

  2671 }

  2673 void CPluginManager::UnloadAll()

  2674 {

  2675 	List<CPlugin *>::iterator iter;

  2676 	while ( (iter = m_plugins.begin()) != m_plugins.end() )

  2677 	{

  2678 		UnloadPlugin((*iter));

  2679 	}

  2680 }

  2682 int CPluginManager::GetOrderOfPlugin(IPlugin *pl)

  2683 {

  2684 	int id = 1;

  2685 	List<CPlugin *>::iterator iter;

  2687 	for (iter = m_plugins.begin(); iter != m_plugins.end(); iter++, id++)

  2688 	{

  2689 		if ((*iter) == pl)

  2690 		{

  2691 			return id;

  2692 		}

  2693 	}

  2695 	return -1;

  2696 }

  2698 CPlugin *CPluginManager::FindPluginByConsoleArg(const char *arg)

  2699 {

  2700 	int id;

  2701 	char *end;

  2702 	CPlugin *pl;

  2704 	id = strtol(arg, &end, 10);

  2706 	if (*end == '\0')

  2707 	{

  2708 		pl = GetPluginByOrder(id);

  2709 		if (!pl)

  2710 		{

  2711 			return NULL;

  2712 		}

  2713 	}

  2714 	else

  2715 	{

  2716 		char pluginfile[256];

  2717 		const char *ext = g_LibSys.GetFileExtension(arg) ? "" : ".smx";

  2718 		UTIL_Format(pluginfile, sizeof(pluginfile), "%s%s", arg, ext);

  2720 		if (!sm_trie_retrieve(m_LoadLookup, pluginfile, (void **)&pl))

  2721 		{

  2722 			return NULL;

  2723 		}

  2724 	}

  2726 	return pl;

  2727 }

  2729 void CPluginManager::OnSourceModMaxPlayersChanged(int newvalue)

  2730 {

  2731 	SyncMaxClients(newvalue);

  2732 }

  2734 void CPluginManager::SyncMaxClients(int max_clients)

  2735 {

  2736 	List<CPlugin *>::iterator iter;

  2738 	for (iter = m_plugins.begin(); iter != m_plugins.end(); iter++)

  2739 	{

  2740 		(*iter)->SyncMaxClients(max_clients);

  2741 	}

  2742 }

  2744 void CPluginManager::ListPluginsToClient(CPlayer *player, const CCommand &args)

  2745 {

  2746 	char buffer[256];

  2747 	unsigned int id = 0;

  2748 	int plnum = GetPluginCount();

  2749 	edict_t *e = player->GetEdict();

  2750 	unsigned int start = 0;

  2752 	if (!plnum)

  2753 	{

  2754 		ClientConsolePrint(e, "[SM] No plugins found.");

  2755 		return;

  2756 	}

  2758 	if (args.ArgC() > 2)

  2759 	{

  2760 		start = atoi(args.Arg(2));

  2761 	}

  2763 	CPlugin *pl;

  2764 	SourceHook::List<CPlugin *>::iterator iter;

  2765 	SourceHook::List<CPlugin *> m_FailList;

  2767 	for (iter = m_plugins.begin();

  2768 		 iter != m_plugins.end();

  2769 		 iter++)

  2770 	{

  2771 		pl = (*iter);

  2773 		if (pl->GetStatus() != Plugin_Running)

  2774 		{

  2775 			continue;

  2776 		}

  2778 		/* Count valid plugins */

  2779 		id++;

  2780 		if (id < start)

  2781 		{

  2782 			continue;

  2783 		}

  2785 		if (id - start > 10)

  2786 		{

  2787 			break;

  2788 		}

  2790 		size_t len;

  2791 		const sm_plugininfo_t *info = pl->GetPublicInfo();

  2792 		len = UTIL_Format(buffer, sizeof(buffer), " \"%s\"", (IS_STR_FILLED(info->name)) ? info->name : pl->GetFilename());

  2793 		if (IS_STR_FILLED(info->version))

  2794 		{

  2795 			len += UTIL_Format(&buffer[len], sizeof(buffer)-len, " (%s)", info->version);

  2796 		}

  2797 		if (IS_STR_FILLED(info->author))

  2798 		{

  2799 			UTIL_Format(&buffer[len], sizeof(buffer)-len, " by %s", info->author);

  2800 		}

  2801 		else

  2802 		{

  2803 			UTIL_Format(&buffer[len], sizeof(buffer)-len, " %s", pl->m_filename);

  2804 		}

  2805 		ClientConsolePrint(e, "%s", buffer);

  2806 	}

  2808 	/* See if we can get more plugins */

  2809 	while (iter != m_plugins.end())

  2810 	{

  2811 		if ((*iter)->GetStatus() == Plugin_Running)

  2812 		{

  2813 			break;

  2814 		}

  2815 	}

  2817 	/* Do we actually have more plugins? */

  2818 	if (iter != m_plugins.end())

  2819 	{

  2820 		ClientConsolePrint(e, "To see more, type \"sm plugins %d\"", id);

  2821 	}

  2822 }

author	Anthony Iacono <anthonyiacono@gmail.com>
	Sun Aug 26 23:33:04 2012 -0400 (2012-08-26)
changeset 3632	2fe3c4c0eb76
parent 3601	d3a2fb7b3a1e
child 3700	d2194fab1dd5
permissions	-rw-r--r--