sourcemm/CPlugin.cpp
author Scott Ehlert <ds@alliedmods.net>
Sun May 22 04:33:58 2005 +0000 (2005-05-22)
changeset 66 ddefc8bfb9fa
parent 51 7985801b5b42
child 67 1753f7a9b2f2
permissions -rw-r--r--
Added macro so that ConCommands created with the SDK's CON_COMMAND and CON_COMMAND_F macros can be properly registered and unregisterd
     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 
    15 /** 
    16  * @brief Implements functions from CPlugin.h
    17  * @file CPlugin.cpp
    18  */
    19 
    20 using namespace SourceMM;
    21 
    22 CPluginManager g_PluginMngr;
    23 
    24 CPluginManager::CPluginManager()
    25 {
    26 	m_LastId = Pl_MinId;
    27 	m_AllLoaded = false;
    28 }
    29 
    30 CPluginManager::~CPluginManager()
    31 {
    32 	if (m_Plugins.size())
    33 	{
    34 		UnloadAll();
    35 		m_Plugins.clear();
    36 	}
    37 }
    38 
    39 CPluginManager::CPlugin::CPlugin() : m_Lib(NULL), m_API(NULL), m_Id(0), m_Source(0)
    40 {
    41 	memset(&fac_list, 0, sizeof(factories));
    42 }
    43 
    44 PluginId CPluginManager::Load(const char *file, PluginId source, bool &already, char *error, size_t maxlen)
    45 {
    46 	PluginIter i;
    47 
    48 	already = false;
    49 	//Check if we're about to reload an old plugin
    50 	for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
    51 	{
    52 		if ( (*i) && (*i)->m_File.compare(file)==0 )
    53 		{
    54 			if ( (*i)->m_Status < Pl_Paused )
    55 			{
    56 				//Attempt to load the plugin again
    57 				already = true;
    58 				i = m_Plugins.erase(i);
    59 			} else {
    60 				//No need to load it
    61 				already = true;
    62 				return (*i)->m_Id;
    63 			}
    64 		}
    65 	}
    66 
    67 	CPlugin *pl = _Load(file, source, error, maxlen);
    68 
    69 	if (!pl)
    70 		return Pl_BadLoad;
    71 
    72 	return pl->m_Id;
    73 }
    74 
    75 CPluginManager::CPlugin *CPluginManager::FindById(PluginId id)
    76 {
    77 	PluginIter i;
    78 
    79 	for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
    80 	{
    81 		if ( (*i)->m_Id == id )
    82 			return (*i);
    83 	}
    84 
    85 	return NULL;
    86 }
    87 
    88 void CPluginManager::SetAllLoaded()
    89 {
    90 	m_AllLoaded = true;
    91 	PluginIter i;
    92 
    93 	for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
    94 	{
    95 		if ( (*i) && (*i)->m_Status == Pl_Running && (*i)->m_API )
    96 		{
    97 			//API 4 is when we added this callback
    98 			//Min version is now 5, so we ignore this check
    99 			//if ( (*i)->m_API->GetApiVersion() >= 004 )
   100 			(*i)->m_API->AllPluginsLoaded();
   101 		}
   102 	}
   103 }
   104 
   105 bool CPluginManager::Pause(PluginId id, char *error, size_t maxlen)
   106 {
   107 	CPlugin *pl = FindById(id);
   108 	
   109 	if (!pl)
   110 	{
   111 		snprintf(error, maxlen, "Plugin id not found");
   112 		return false;
   113 	}
   114 
   115 	return _Pause(pl, error, maxlen);
   116 }
   117 
   118 bool CPluginManager::Unpause(PluginId id, char *error, size_t maxlen)
   119 {
   120 	CPlugin *pl = FindById(id);
   121 	
   122 	if (!pl)
   123 	{
   124 		snprintf(error, maxlen, "Plugin id not found");
   125 		return false;
   126 	}
   127 
   128 	return _Unpause(pl, error, maxlen);
   129 }
   130 
   131 bool CPluginManager::Unload(PluginId id, bool force, char *error, size_t maxlen)
   132 {
   133 	CPlugin *pl = FindById(id);
   134 	
   135 	if (!pl)
   136 	{
   137 		snprintf(error, maxlen, "Plugin %d not found", id);
   138 		return false;
   139 	}
   140 
   141 	return _Unload(pl, force, error, maxlen);
   142 }
   143 
   144 bool CPluginManager::Retry(PluginId id, char *error, size_t len)
   145 {
   146 	PluginIter i;
   147 	char buffer[64];
   148 	for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
   149 	{
   150 		if ( (*i) && (*i)->m_Id == id )
   151 		{
   152 			if ( (*i)->m_Status >= Pl_Paused)
   153 			{
   154 				snprintf(error, len, "Plugin %d is already running.", id);
   155 				return false;
   156 			}
   157 			CPlugin *pl = _Load((*i)->m_File.c_str(), Pl_Console, error, len);
   158 			if (!pl)
   159 				return false;
   160 			if (pl->m_Status >= Pl_Paused)
   161 			{
   162 				//Now it gets crazy... unload the original copy.
   163 				_Unload( (*i), true, buffer, sizeof(buffer)-1 );
   164 				
   165 				//Set the new copy's id
   166 				pl->m_Id = id;
   167 
   168 				//We just wasted an id... reclaim it
   169 				m_LastId--;
   170 				
   171 				return true;
   172 			} else {
   173 				//don't really care about the buffer here
   174 				_Unload(pl, true, buffer, sizeof(buffer)-1);
   175 
   176 				//We just wasted an id... reclaim it
   177 				m_LastId--;
   178 				return false;
   179 			}
   180 		}
   181 	}
   182 
   183 	snprintf(error, len, "Plugin %d not found,", id);
   184 	return false;
   185 }
   186 
   187 CPluginManager::CPlugin *CPluginManager::_Load(const char *file, PluginId source, char *error, size_t maxlen)
   188 {
   189 	FILE *fp;
   190 	CPlugin *pl;
   191 
   192 	pl = new CPlugin();
   193 	*error = '\0';
   194 	
   195 	//Add plugin to list
   196 	pl->m_Id = m_LastId;
   197 	pl->m_File.assign(file);
   198 	m_Plugins.push_back(pl);
   199 	m_LastId++;
   200 
   201 	//Check if the file even exists
   202 	fp = fopen(file, "r");
   203 	if (!fp)
   204 	{
   205 		if (error)
   206 			snprintf(error, maxlen, "File not found: %s", file);
   207 		pl->m_Status = Pl_NotFound;
   208 	} else {
   209 		fclose(fp);
   210 		fp = NULL;
   211 		
   212 		//Load the file
   213 		pl->m_Lib = dlmount(file);
   214 		if (!pl->m_Lib)
   215 		{
   216 			if (error)
   217 				snprintf(error, maxlen, "%s", dlerror());
   218 			pl->m_Status = Pl_Error;
   219 		} else {
   220 			CreateInterfaceFn pfn = reinterpret_cast<CreateInterfaceFn>(dlsym(pl->m_Lib, PL_EXPOSURE_C));
   221 			if (!pfn)
   222 			{
   223 				if (error)
   224 					snprintf(error, maxlen, "Function %s not found", PL_EXPOSURE_C);
   225 				pl->m_Status = Pl_Error;
   226 			} else {
   227 				pl->m_API = static_cast<ISmmPlugin *>((pfn)(PLAPI_NAME, NULL));
   228 				if (!pl->m_API)
   229 				{
   230 					if (error)
   231 						snprintf(error, maxlen, "Failed to get API");
   232 					pl->m_Status = Pl_Error;
   233 				} else {
   234 					if (pl->m_API->GetApiVersion() < PLAPI_MIN_VERSION)
   235 					{
   236 						if (error)
   237 							snprintf(error, maxlen, "Plugin API %d is out of date with required minimum (%d)", pl->m_API->GetApiVersion(), PLAPI_MIN_VERSION);
   238 						pl->m_Status = Pl_Error;
   239 					} else {
   240 						if (pl->m_API->Load(pl->m_Id, static_cast<ISmmAPI *>(&g_SmmAPI), &(pl->fac_list), error, maxlen))
   241 						{
   242 							pl->m_Status = Pl_Running;
   243 							if (m_AllLoaded)
   244 							{
   245 								//API 4 is when we added this callback
   246 								//Removing this code as the min version is now 5
   247 								//if (pl->m_API->GetApiVersion() >= 4)
   248 								pl->m_API->AllPluginsLoaded();
   249 							}
   250 						} else {
   251 							pl->m_Status = Pl_Refused;
   252 						}
   253 					}
   254 				}
   255 			}
   256 		}
   257 	}
   258 
   259 	if (pl->m_Lib && (pl->m_Status < Pl_Paused))
   260 	{
   261 		dlclose(pl->m_Lib);
   262 		pl->m_Lib = NULL;
   263 		pl->m_API = NULL;
   264 	}
   265 
   266 	return pl;
   267 }
   268 
   269 bool CPluginManager::_Unload(CPluginManager::CPlugin *pl, bool force, char *error, size_t maxlen)
   270 {
   271 	if (error)
   272 		*error = '\0';
   273 	if (pl->m_API && pl->m_Lib)
   274 	{
   275 		//Note, we'll always tell the plugin it will be unloading...
   276 		if (pl->m_API->Unload(error, maxlen) || force)
   277 		{
   278 			//Make sure to detach it from sourcehook!
   279 			g_SourceHook.UnloadPlugin(pl->m_Id);
   280 
   281 			//Clean up the DLL
   282 			dlclose(pl->m_Lib);
   283 			pl->m_Lib = NULL;
   284 			pl->m_API = NULL;
   285 
   286 			//Remove the plugin from the list
   287 			PluginIter i;
   288 			for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
   289 			{
   290 				if ( (*i)->m_Id == pl->m_Id )
   291 				{
   292 					i = m_Plugins.erase(i);
   293 					break;
   294 				}
   295 			}
   296 			//Free its memory
   297 			delete pl;
   298 
   299 			return true;
   300 		}
   301 	} else {
   302 		//The plugin is not valid, and let's just remove it from the list anyway
   303 		PluginIter i;
   304 		for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
   305 		{
   306 			if ( (*i)->m_Id == pl->m_Id )
   307 			{
   308 				i = m_Plugins.erase(i);
   309 				break;
   310 			}
   311 		}
   312 		delete pl;
   313 
   314 		return true;
   315 	}
   316 
   317 	return false;
   318 }
   319 
   320 bool CPluginManager::_Pause(CPluginManager::CPlugin *pl, char *error, size_t maxlen)
   321 {
   322 	if (error)
   323 		*error = '\0';
   324 	if (pl->m_Status != Pl_Running || !pl->m_API)
   325 	{
   326 		if (error)
   327 			snprintf(error, maxlen, "Plugin cannot be paused");
   328 	} else {
   329 		if (pl->m_API->Pause(error, maxlen))
   330 		{
   331 			g_SourceHook.PausePlugin(pl->m_Id);
   332 			pl->m_Status = Pl_Paused;
   333 
   334 			return true;
   335 		}
   336 	}
   337 
   338 	return false;
   339 }
   340 
   341 bool CPluginManager::_Unpause(CPluginManager::CPlugin *pl, char *error, size_t maxlen)
   342 {
   343 	if (error)
   344 		*error = '\0';
   345 
   346 	if (pl->m_Status != Pl_Paused || !pl->m_API)
   347 	{
   348 		if (error)
   349 			snprintf(error, maxlen, "Plugin cannot be unpaused");
   350 	} else {
   351 		if (pl->m_API->Unpause(error, maxlen))
   352 		{
   353 			g_SourceHook.UnpausePlugin(pl->m_Id);
   354 			pl->m_Status = Pl_Running;
   355 
   356 			return true;
   357 		}
   358 	}
   359 
   360 	return false;
   361 }
   362 
   363 bool CPluginManager::UnloadAll()
   364 {
   365 	PluginIter i;
   366 	bool status = true;
   367 
   368 	for (i=m_Plugins.begin(); i!=m_Plugins.end(); i++)
   369 	{
   370 		if ( (*i) )
   371 		{
   372 			if ( (*i)->m_API )
   373 			{
   374 				if ( (*i)->m_API->Unload(NULL, 0) )
   375 					status = false;
   376 
   377 				//Unlink from SourceHook
   378 				g_SourceHook.UnloadPlugin( (*i)->m_Id );
   379 
   380 				//Free the DLL
   381 				dlclose( (*i)->m_Lib );
   382 			}
   383 			delete (*i);
   384 		}
   385 
   386 		i = m_Plugins.erase(i);
   387 	}
   388 
   389 	return status;
   390 }
   391 
   392 bool CPluginManager::Query(PluginId id, const char *&file, factories *&list, Pl_Status &status, PluginId &source)
   393 {
   394 	CPlugin *pl = FindById(id);
   395 
   396 	if (!pl)
   397 		return false;
   398 
   399 	file = pl->m_File.c_str();
   400 	list = &(pl->fac_list);
   401 	status = pl->m_Status;
   402 	source = pl->m_Source;
   403 
   404 	return true;
   405 }
   406 
   407 PluginIter CPluginManager::_begin()
   408 {
   409 	return m_Plugins.begin();
   410 }
   411 
   412 PluginIter CPluginManager::_end()
   413 {
   414 	return m_Plugins.end();
   415 }