开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
basehand.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：66k
源码类别：

Symbian

开发平台：

Visual C++

basehand.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: basehand.cpp,v 1.18.8.1 2004/07/09 02:07:27 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  50. #include "hxtypes.h"
  52. #ifdef _WINDOWS
  53. #if defined(_WINCE)
  54. #include <stdlib.h>
  55. #define itoa _itoa
  56. #endif
  57. #include <windows.h>
  58. #include <ctype.h>
  59. #endif
  60. #ifdef _MACINTOSH
  61. #include <ctype.h>
  62. #include "filespec.h"
  63. #include "filespecutils.h"
  64. #endif
  66. #if defined _UNIX
  67. #include <stdlib.h>
  68. #include <sys/param.h>
  69. #define _MAX_PATH MAXPATHLEN
  70. #elif defined (__MWERKS__)
  71. #include <stdlib.h>
  72. #include "fullpathname.h"
  73. #include "chxdataf.h"
  74. #include <stat.h>
  75. #include <fcntl.h>
  76. #else
  77. #include "hlxclib/sys/stat.h"
  78. #endif
  80. #include "hlxclib/stdio.h"
  82. #include "hxresult.h"
  83. #include "hxassert.h"
  84. #include "hxcom.h"
  85. #include "ihxpckts.h"
  86. #include "hxfiles.h"
  87. #include "hxformt.h"
  88. #include "hxfwrtr.h"
  89. #include "hxrendr.h"
  90. #include "hxprefs.h"
  91. #include "hxplugn.h"
  92. #include "hxdtcvt.h"
  93. #include "hxphand.h"
  94. #include "hxmeta.h"
  95. #include "hxsdesc.h"
  96. #include "hxauth.h"
  97. #include "hxallow.h"
  98. #include "hxerror.h"
  99. #include "hxcomm.h"
  100. #include "hxengin.h"
  101. #include "hxshtdn.h"
  102. #include "hxplgns.h"
  103. #include "hxmon.h"
  104. #include "chxpckts.h"
  105. #include "hxstring.h"
  106. #include "hxslist.h"
  107. #include "hxmap.h"
  108. #include "hxstrutl.h"
  109. #include "hxdir.h"
  110. #include "findfile.h"
  111. #include "dbcs.h"
  112. #include "hxbdwdth.h"
  113. #include "basehand.h"
  114. #include "chxuuid.h"
  115. #include "md5.h"
  117. #include "dllacces.h"
  118. #include "dllpath.h"
  120. #include "hxperf.h"
  121. #include "rtsputil.h"
  123. #include "hxver.h"
  125. #include "hxheap.h"
  126. #ifdef _DEBUG
  127. #undef HX_THIS_FILE
  128. static const char HX_THIS_FILE[] = __FILE__;
  129. #endif
  131. #ifdef _WINCE
  132. #include <wincestr.h>
  133. #endif
  135. #if defined(_STATICALLY_LINKED)
  136. #include "staticff.h"
  137. #endif
  139. /*
  140.  * XXXND These are also defined in geminc/gemplatformdata.h
  141.  */
  143. #define NAMESPACE_SEPARATOR ':'
  145. /*
  146.  *  Win98 does not allow reg keys that are larger than 16k a pop. we used this value to break up into more manageable bites
  147.  */
  149. #define PREF_CACHE_SIZE 10000
  151. /*
  152.     Load each plug-in, read info, store in memory and update prefs
  153.     This is only done if the plugin hash within the registery is not the same
  154.     as the plugin hash of the plugins directory.
  155. */
  157. const char* const BaseHandler::zm_pszValueSeperator = "|";
  158. const char* const BaseHandler::zm_pszListStart = "{";
  159. const char* const BaseHandler::zm_pszListEnd = "}";
  160. const char* const BaseHandler::zm_pszValueSeperator2= ",";
  162. const char* const BaseHandler::zm_pszKeyNameRegKey = "~KeyNames~";
  163. const char* const BaseHandler::zm_pszRegKeySeperator = "\";
  165. const char* const BaseHandler::zm_pszFileExtension = OS_DLL_PATTERN_STRING;
  166. const char* const BaseHandler::zm_pszDirectorySeperator = OS_SEPARATOR_STRING;
  167. const char BaseHandler::zm_cDirectorySeperator = OS_SEPARATOR_CHAR;
  169. IMPLEMENT_COM_CREATE_FUNCS( BaseHandler )
  171. BEGIN_INTERFACE_LIST_NOCREATE( BaseHandler )
  172.     INTERFACE_LIST_ENTRY_SIMPLE( IHXPluginEnumerator )
  173.     INTERFACE_LIST_ENTRY_SIMPLE( IHXPlugin2Handler )
  174.     INTERFACE_LIST_ENTRY_SIMPLE( IHXPluginHandler3 )
  175. END_INTERFACE_LIST
  177. BaseHandler::BaseHandler() :
  178.          m_pContext(NULL)
  179. {
  180. }
  182. BaseHandler::~BaseHandler()
  183. {
  184.     // Make sure Close() got called
  185.     if( m_pContext )
  186.     {
  187. Close();
  188.     }
  189. }
  191. STDMETHODIMP BaseHandler::Init(IUnknown* pContext)
  192. {
  193.     HX_RESULT result = HXR_FAIL;
  195.     if( SUCCEEDED( result = RegisterContext( pContext ) ) )
  196.     {
  197. result = ReadFromRegistry();
  198.     }
  200.     return result;
  201. }
  204. STDMETHODIMP_(ULONG32) BaseHandler::GetNumOfPlugins2()
  205. {
  206.     return m_PluginList.GetCount();
  207. }
  210. STDMETHODIMP
  211. BaseHandler::GetPluginInfo(UINT32 unIndex,
  212.    REF(IHXValues*) /*OUT*/ pValues)
  213. {
  214.     return HXR_NOTIMPL;
  215. }
  217. BaseHandler::Errors
  218. BaseHandler::LoadDLL(char* pszDllName,
  219.      PluginMountPoint* pMountPoint )
  220. {
  221.     Errors result     = NO_ERRORS;
  222.     UINT32 i     = 0;
  223.     struct stat stat_stuct;
  225.     // Make sure there is no path in the pszDllName
  226.     HX_ASSERT( !strrchr(pszDllName, BaseHandler::zm_cDirectorySeperator) );
  228.     BaseHandler::PluginDLL* pPluginDll  = NULL;
  229.     if( !( pPluginDll = new BaseHandler::PluginDLL( pszDllName, pMountPoint, this ) ) )
  230.     {
  231. return MEMORY_ERROR;
  232.     }
  234.     pPluginDll->AddRef();
  236.     CHXString sFileWithPath = pszDllName;
  237.     if (NO_ERRORS==Stat(sFileWithPath, &stat_stuct))
  238.     {
  239.         pPluginDll->SetFileSize((INT32)stat_stuct.st_size);
  240.     }
  242.     result = pPluginDll->Load(m_pContext);
  243.     if (NO_ERRORS != result )
  244.     {
  245. goto cleanup;
  246.     }
  248.     for(i=0;i<pPluginDll->GetNumPlugins();i++)
  249.     {
  250. Plugin* pPlugin = NULL;
  252.      // create a new plugin object
  253. if (!(pPlugin = new Plugin(m_pContext)))
  254. {
  255.     return MEMORY_ERROR;
  256. }
  258. // Setup plugin information
  259. pPlugin->AddRef();
  260. pPlugin->SetDLL(pPluginDll);
  261. pPlugin->SetIndex((UINT16)i);
  262. pPlugin->SetInfoNeedsRefresh(TRUE);
  264. IUnknown* pUnk = NULL;
  265. if( NO_ERRORS != pPlugin->GetPlugin( pUnk ) )
  266. {
  267.     // This plugin doesn't work.  Delete it.
  268.     HX_RELEASE( pPlugin );
  269. }
  270. else
  271. {
  272.     IHXPluginNamespace* pPluginNamespace = NULL;
  273.     if (SUCCEEDED(pUnk->QueryInterface(IID_IHXPluginNamespace, (void**) &pPluginNamespace)))
  274.     {
  275. /*
  276.  * Memory for the IHXBuffer is allocated in the plugin
  277.  */
  278. IHXBuffer* pBuffer = NULL;
  279. if (SUCCEEDED(pPluginNamespace->GetPluginNamespace(pBuffer)))
  280. {
  281.     pPluginDll->SetNamespace(pBuffer);
  282.     HX_RELEASE(pBuffer);
  283. }
  284. HX_RELEASE(pPluginNamespace);
  285.     }
  287.     IHXComponentPlugin* pIIterator = NULL;
  288.     if( SUCCEEDED( pUnk->QueryInterface( IID_IHXComponentPlugin, (void**) &pIIterator ) ) )
  289.     {
  290. // We don't need this.
  291. HX_RELEASE( pPlugin );
  293. LoadPluginsFromComponentDLL( pPluginDll, pIIterator );
  294. HX_RELEASE( pIIterator );
  295.     }
  296.     else
  297.     {
  298. IHXPlugin* pIHXPlugin;
  299. if( SUCCEEDED( pUnk->QueryInterface(IID_IHXPlugin, (void**)&pIHXPlugin ) ) )
  300. {
  301.     pPlugin->GetValuesFromDLL(pIHXPlugin);
  302.     m_PluginList.AddTail(pPlugin);
  303.     pIHXPlugin->Release();
  304. }
  305.     }
  306. }
  307. HX_RELEASE( pUnk );
  308.     }
  310. cleanup:
  312.     HX_RELEASE( pPluginDll );
  314.     return result;
  315. }
  318. void BaseHandler::LoadPluginsFromComponentDLL( BaseHandler::PluginDLL* pPluginDll,
  319.     IHXComponentPlugin* pIIterator )
  320. {
  321.     IHXPlugin* pIHXPlugin = NULL;
  322.     if( SUCCEEDED( pIIterator->QueryInterface(IID_IHXPlugin, (void**)&pIHXPlugin ) ) )
  323.     {
  324. for( UINT32 index = 0; index < pIIterator->GetNumComponents(); index++ )
  325. {
  326.     IHXValues* pIValues = NULL;
  327.     if( SUCCEEDED( pIIterator->GetComponentInfoAtIndex( index, pIValues ) ) )
  328.     {
  329. IHXBuffer* pBuffer = NULL;
  331. if (SUCCEEDED(pIValues->GetPropertyCString(PLUGIN_COMPONENT_NAME, pBuffer)))
  332. {
  333.     IHXBuffer* pNamespace = pPluginDll->GetNamespace();
  335.     if (pNamespace)
  336.     {
  337. CHXString TempNamespace = pNamespace->GetBuffer();
  338. TempNamespace += NAMESPACE_SEPARATOR;
  339. TempNamespace += pBuffer->GetBuffer();
  341. IHXBuffer* pTempBuffer = new CHXBuffer();
  342. pTempBuffer->AddRef();
  343. pTempBuffer->Set((BYTE*)(const char*)TempNamespace, TempNamespace.GetLength()+1);
  344. pIValues->SetPropertyCString(PLUGIN_COMPONENT_NAME, pTempBuffer);
  345. HX_RELEASE(pTempBuffer);
  346. HX_RELEASE(pNamespace);
  347.     }
  349.     HX_RELEASE(pBuffer);
  350. }
  352. // create a new plugin object
  353. Plugin* pPlugin = new Plugin( m_pContext );
  354. HX_ASSERT( pPlugin );
  356. // Setup plugin object
  357. pPlugin->AddRef();
  358. pPlugin->SetDLL( pPluginDll );
  360. pPlugin->SetInfoNeedsRefresh( TRUE );
  362. pPlugin->InitializeComponentPlugin( pIHXPlugin, pIValues );
  364. // Put in plugin list
  365. m_PluginList.AddTail(pPlugin);
  367. HX_RELEASE( pIValues );
  368.     }
  369. }
  371. HX_RELEASE (pIHXPlugin);
  372.     }
  373. }
  375. ///////////////////////////////////////////////////////////////////////////////
  376. //  These functions will find all plugins which are different
  377. //  then those loaded into the registry.
  378. //  It will then load them into memory, get their data, and unload them.
  379. //  It will return HXR_FAIL if some DLL has different values within the
  380. //  registry, and is presently in memory (how could this happen??)
  382. //  If anyone was keeping an index to a loaded DLL and assuming that it
  383. //  would remain constant ... that's not going to work!!!
  385. HX_RESULT BaseHandler::ReloadPluginsNoPropagate()
  386. {
  387.     HX_LOG_BLOCK( "BaseHandler::ReloadPluginsNoPropagate" );
  389.     HX_RESULT result = HXR_OK;
  391.     // Reload them all.
  392.     for(CHXMapStringToOb::Iterator mp = m_MountPoints.Begin(); mp!=m_MountPoints.End(); ++mp)
  393.     {
  394. PluginMountPoint* pMountPoint = (PluginMountPoint*) *mp;
  395. if( FAILED( ReloadPluginsNoPropagate( pMountPoint ) ) )
  396. {
  397.     result = HXR_FAIL;
  398. }
  399.     }
  401.     return result;
  402. }
  405. HX_RESULT BaseHandler::ReloadPluginsNoPropagateWithFindFile(
  406.                PluginMountPoint* pMountPoint, CFindFile* pFileFinder,
  407.                IHXBuffer* pPathBuffer, char* pszPluginDir)
  408. {
  409.     HX_LOG_BLOCK( "BaseHandler::ReloadPluginsNoPropagateWithFindFile" );
  410.     char*     pszDllName     = 0;
  411.     IHXBuffer*     pNewChecksum    = 0;
  413.     // if we have no context do not proceed.
  414.     if (!m_pContext)
  415.     {
  416. return INVALID_CONTEXT;
  417.     }
  419.     // If this is the 1st time, load everything into the registry.
  421.     pszDllName = pFileFinder->FindFirst();
  423.     while (pszDllName)
  424.     {
  425. BaseHandler::Errors loadResult;
  426. loadResult = LoadDLL( pszDllName, pMountPoint );
  428. if (loadResult!= NO_ERRORS)
  429. {
  430.     // The DLL had one of the following problems:
  431.     // (1) the DLL was unloadable
  432.     // (2) the DLL did not have an HXCreateInstance
  433.     // (3) an instance could not be created.
  434.     // (4) It did not implement the PLUGIN interface
  436.     // if it was case 2,3,4 then we can safely never attempt to
  437.     // load the DLL again. However if it was (1) then we must attempt
  438.     // to load the DLL ever time through since it was possibly unloadable due
  439.     // to an imp-lib that will be satisfied lated (without modifing the
  440.     // dll). Jeeze. That comment is UNREADABLE. I have to take effective written
  441.     // english again!
  443.     if (loadResult!=CANT_OPEN_DLL)
  444.     {
  445. BaseHandler::OtherDLL* pDLLData = new BaseHandler::OtherDLL;
  446. pDLLData->m_filename = pszDllName;
  447. pDLLData->m_pMountPoint = pMountPoint;
  449. pNewChecksum = ChecksumFile(pszDllName, pPathBuffer);
  450. if (pNewChecksum)
  451. {
  452.     pDLLData->m_fileChecksum = (char*)pNewChecksum->GetBuffer();
  453.     HX_RELEASE(pNewChecksum);
  454.     m_MiscDLLList.AddTail(pDLLData);
  455. }
  456. else
  457. {
  458.     HX_DELETE(pDLLData);
  459. }
  460.     }
  461. }
  463. pszDllName = pFileFinder->FindNext();
  464.     }
  466.     return HXR_OK;
  467. }
  469. HX_RESULT BaseHandler::ReloadPluginsNoPropagate( PluginMountPoint* pMountPoint )
  470. {
  471.     CFindFile* pFileFinder = NULL;
  472.     IHXBuffer* pPathBuffer = NULL;
  473.     char* pszPluginDir = NULL;
  474.     ULONG32 nPluginDirLen = NULL;
  476.     if (!m_pContext)
  477.     {
  478.         return INVALID_CONTEXT;
  479.     }
  481.     HX_RESULT retVal = HXR_FAIL;
  483. #if !defined(_STATICALLY_LINKED) || defined(HELIX_CONFIG_CONSOLIDATED_CORE)
  484.     pPathBuffer = pMountPoint->Path();
  485.     if (pPathBuffer)
  486.     {
  487.         pPathBuffer->Get((UCHAR*&)pszPluginDir, nPluginDirLen);
  489.         if (nPluginDirLen)
  490.         {
  491.             pFileFinder = CFindFile::CreateFindFile(pszPluginDir,
  492.                         0, BaseHandler::zm_pszFileExtension);
  493.             if (pFileFinder)
  494.             {
  495.                 retVal = ReloadPluginsNoPropagateWithFindFile(pMountPoint,
  496.                         pFileFinder, pPathBuffer, pszPluginDir);
  498.                 HX_DELETE(pFileFinder);
  499.             }
  500.         }
  501.     }
  502. #endif
  504. #if defined(_STATICALLY_LINKED)
  505. pszPluginDir="";
  506.         pFileFinder = CStaticFindFile::CreateFindFile(pszPluginDir,
  507.                 0, BaseHandler::zm_pszFileExtension);
  508.         if (pFileFinder)
  509.         {
  510.             retVal = ReloadPluginsNoPropagateWithFindFile(pMountPoint,
  511.                     pFileFinder, pPathBuffer, pszPluginDir);
  513.             HX_DELETE(pFileFinder);
  514.         }
  515. #endif
  517. #if !defined(_STATICALLY_LINKED) || defined(HELIX_CONFIG_CONSOLIDATED_CORE)
  518.     HX_RELEASE(pPathBuffer);
  519. #endif
  521.     return retVal;
  522. }
  524. STDMETHODIMP BaseHandler::FindIndexUsingValues (IHXValues* pValues,
  525. REF(UINT32) unIndex)
  526. {
  527.     return HXR_NOTIMPL;
  528. }
  530. STDMETHODIMP BaseHandler::GetInstance (UINT32 index, REF(IUnknown*) pUnknown)
  531. {
  532.     pUnknown = NULL;
  533.     LISTPOSITION pPos = m_PluginList.FindIndex(index);
  534.     if (pPos)
  535.     {
  536. BaseHandler::Plugin* pPlugin = (BaseHandler::Plugin*) m_PluginList.GetAt(pPos);
  537. if (pPlugin)
  538. {
  539.     Errors retVal = pPlugin->GetInstance(pUnknown);
  540.     if (retVal== NO_ERRORS)
  541.     {
  542. return HXR_OK;
  543.     }
  544. }
  545.     }
  546.     return HXR_FAIL;
  547. }
  549. STDMETHODIMP BaseHandler::FindIndexUsingStrings (char* PropName1,
  550.     char* PropVal1,
  551.     char* PropName2,
  552.     char* PropVal2,
  553.     char* PropName3,
  554.     char* PropVal3,
  555.     REF(UINT32) unIndex)
  556. {
  557.     return HXR_NOTIMPL;
  558. }
  561. STDMETHODIMP BaseHandler::FindPluginUsingValues (IHXValues* pValues,
  562. REF(IUnknown*) pUnk)
  563. {
  564.     return FindPluginUsingValues( pValues, pUnk, NULL );
  565. }
  567. HX_RESULT BaseHandler::FindGroupOfPluginsUsingStrings(char* PropName1,
  568.     char* PropVal1,
  569.     char* PropName2,
  570.     char* PropVal2,
  571.     char* PropName3,
  572.     char* PropVal3,
  573.     REF(CPluginEnumerator*) pEnumerator)
  574. {
  575.     // PropName and PropVal have to to valid tuple
  576.     if ((PropName1 && !PropVal1)    ||
  577. (PropName2 && !PropVal2)    ||
  578. (PropName3 && !PropVal3)    ||
  579. (!PropName1 && PropVal1)    ||
  580. (!PropName2 && PropVal2)    ||
  581. (!PropName3 && PropVal3))
  582. return HXR_FAIL;
  584.     IHXValues* pValues;
  585.     HX_RESULT   retVal = HXR_FAIL;
  587.     CHXHeader* pHeader = new CHXHeader;
  588.     pHeader->QueryInterface(IID_IHXValues,  (void**)&pValues);
  589.     AddToValues(pValues, PropName1, PropVal1, eString);
  590.     AddToValues(pValues, PropName2, PropVal2, eString);
  591.     AddToValues(pValues, PropName3, PropVal3, eString);
  592.     retVal = FindGroupOfPluginsUsingValues(pValues, pEnumerator);
  593.     pValues->Release();
  594.     return retVal;
  595. }
  597. HX_RESULT BaseHandler::FindGroupOfPluginsUsingValues(IHXValues* pValues,
  598. REF(CPluginEnumerator*) pEnumerator)
  599. {
  600.     CHXSimpleList::Iterator i = m_PluginList.Begin();
  601.     pEnumerator = NULL;
  603.     for(; i!= m_PluginList.End(); ++i)
  604.     {
  605. BaseHandler::Plugin* pPlugin = (BaseHandler::Plugin*) *i;
  606. if (pPlugin->DoesMatch(pValues))
  607. {
  608.     if (!pEnumerator)
  609.     {
  610. pEnumerator = new CPluginEnumerator();
  611.     }
  612.     pEnumerator->Add(pPlugin);
  613. }
  614.     }
  616.     if (!pEnumerator)
  617.     {
  618. return HXR_FAIL;
  619.     }
  621.     return HXR_OK;
  622. }
  624. /********************************************************************
  625. *
  626. * IHXPluginHandler3
  627. *
  628. ********************************************************************/
  630. STDMETHODIMP
  631. BaseHandler::RegisterContext( IUnknown* pContext )
  632. {
  633.     if( !pContext )
  634.     {
  635. return INVALID_CONTEXT;
  636.     }
  638.     if( m_pContext )
  639.     {
  640. return HXR_UNEXPECTED;
  641.     }
  643.     m_pContext = pContext;
  644.     m_pContext->AddRef();
  646.     return HXR_OK;
  647. }
  649. STDMETHODIMP
  650. BaseHandler::AddPluginMountPoint( const char* pName, UINT32 majorVersion, UINT32 minorVersion, IHXBuffer* pPath )
  651. {
  652.     HX_LOG_BLOCK( "BaseHandler::AddPluginMountPoint" );
  654.     const char* pMPKey = pName ? pName : (const char*) pPath->GetBuffer();
  656.     // Make sure this mount point is in the list
  657.     PluginMountPoint* pMountPoint = NULL;
  658.     if( !m_MountPoints.Lookup( pMPKey, (void*&) pMountPoint ) )
  659.     {
  660. // Create new mount point
  661. pMountPoint = new PluginMountPoint( this, pName, majorVersion, minorVersion, pPath );
  662. pMountPoint->AddRef();
  664. // Put new mount point in list
  665. m_MountPoints.SetAt( pMPKey, pMountPoint );
  666.     }
  668.     // Load information from registry, and sync DLLs that aren't up to date
  669.     return RefreshPluginInfo( pMountPoint );
  670. }
  673. STDMETHODIMP
  674. BaseHandler::RefreshPluginMountPoint( const char* pName )
  675. {
  676.     HX_RESULT result = HXR_FAIL;
  678.     // If this mount point is in the list, refresh it
  679.     PluginMountPoint* pMountPoint = NULL;
  680.     if( m_MountPoints.Lookup( pName, (void*&) pMountPoint ) )
  681.     {
  682. result = RefreshPluginInfo( pMountPoint );
  683.     }
  685.     return result;
  686. }
  689. STDMETHODIMP
  690. BaseHandler::RemovePluginMountPoint( const char* pName )
  691. {
  692.     HX_RESULT result = HXR_FAIL;
  694.     // Make sure this is a valid mount point
  695.     PluginMountPoint* pMountPoint = NULL;
  696.     if( m_MountPoints.Lookup( pName, (void*&) pMountPoint ) )
  697.     {
  698. // Clean up plugins
  699. if( m_PluginList.GetCount() )
  700. {
  701.     LISTPOSITION listPos = m_PluginList.GetHeadPosition();
  702.     while( listPos )
  703.     {
  704. // Save off current position for delete
  705. LISTPOSITION posAt = listPos;
  707. // Get current item, and increment position
  708. BaseHandler::Plugin* pPlugin = (BaseHandler::Plugin*) m_PluginList.GetNext( listPos );
  710. // If this plugin belongs to the mountpoint, remove it.
  711. if( pPlugin && ( pPlugin->GetDLL()->GetMountPoint() == pMountPoint ) )
  712. {
  713.     // Delete from the saved position
  714.     m_PluginList.RemoveAt( posAt );
  715.     HX_RELEASE( pPlugin );
  716. }
  717.     }
  718. }
  720. // Remove mount point from list
  721. m_MountPoints.RemoveKey( pName );
  722. HX_RELEASE( pMountPoint );
  723.     }
  725.     return result;
  726. }
  729. STDMETHODIMP
  730. BaseHandler::FindImplementationFromClassID( REFGUID GUIDClassID, REF(IUnknown*) pIUnknownInstance,
  731.     IUnknown* pIUnkOuter, IUnknown* pContext )
  732. {
  733.     HX_RESULT     rc = HXR_OK;
  734.     IUnknown*     pUnknown = NULL;
  735.     IHXPlugin*     pPlugin = NULL;
  736.     IHXCommonClassFactory*     pFactory = NULL;
  737.     IHXPluginSearchEnumerator*     pPluginEnumerator = NULL;
  739.     // a much simpler version than Plugin2Handler, it's not as efficient as Plugin2Handler but it
  740.     // should be good enough for static build.
  742.     // Initialize out params
  743.     pIUnknownInstance = NULL;
  745.     rc = FindGroupOfPluginsUsingStrings(PLUGIN_CLASS, PLUGIN_CLASS_FACTORY_TYPE,
  746. NULL, NULL, NULL, NULL, pPluginEnumerator);
  748.     if (HXR_OK != rc)
  749.     {
  750. rc = HXR_FAILED;
  751. goto cleanup;
  752.     }
  754.     while (HXR_OK == pPluginEnumerator->GetNextPlugin(pUnknown, NULL) && pUnknown)
  755.     {
  756. if (HXR_OK == pUnknown->QueryInterface(IID_IHXPlugin, (void**)&pPlugin))
  757. {
  758.     pPlugin->InitPlugin(pContext);
  760.     if (HXR_OK == pUnknown->QueryInterface(IID_IHXCommonClassFactory, (void**)&pFactory))
  761.     {
  762. if (HXR_OK == pFactory->CreateInstance(GUIDClassID, (void**)&pIUnknownInstance) &&
  763.     pIUnknownInstance)
  764. {
  765.     break;
  766. }
  767. HX_RELEASE(pIUnknownInstance);
  768.     }
  769.     HX_RELEASE(pFactory);
  770. }
  771. HX_RELEASE(pPlugin);
  772. HX_RELEASE(pUnknown);
  773.     }
  775.     if (!pIUnknownInstance)
  776.     {
  777. rc = HXR_FAILED;
  778.     }
  780. cleanup:
  782.     HX_RELEASE(pFactory);
  783.     HX_RELEASE(pPlugin);
  784.     HX_RELEASE(pUnknown);
  785.     HX_RELEASE(pPluginEnumerator);
  787.     return rc;
  788. }
  790. HX_RESULT
  791. BaseHandler::RefreshPluginInfo( PluginMountPoint* pMountPoint )
  792. {
  793.     return ReloadPluginsNoPropagate( pMountPoint );
  794. }
  796. STDMETHODIMP
  797. BaseHandler::FindCLSIDFromName( const char* pName, REF(IHXBuffer*) pCLSID )
  798. {
  799.     return HXR_NOTIMPL;
  800. }
  803. STDMETHODIMP
  804. BaseHandler::FindGroupOfPluginsUsingValues( IHXValues* pValues,
  805. REF(IHXPluginSearchEnumerator*) pIEnumerator)
  806. {
  807.     return HXR_NOTIMPL;
  808. }
  810. STDMETHODIMP
  811. BaseHandler::FindGroupOfPluginsUsingStrings( char* PropName1, char* PropVal1,
  812. char* PropName2, char* PropVal2,
  813. char* PropName3, char* PropVal3,
  814. REF(IHXPluginSearchEnumerator*) pIEnumerator)
  815. {
  816.     // Regardless of how the API can be used, the reality is that this function
  817.     // is essentially the highest level point of access for the core when
  818.     // starting playback of a new stream, so this is a great time to unload
  819.     // all our dead dlls.
  820.     // But the memory efficiency of DLL unloading comes at the expense of
  821.     // setup time, so we probably only want to do this on platforms where
  822.     // memory optimization is our highest priority.
  823. #if defined(HELIX_CONFIG_UNLOAD_DEAD_DLLS)
  824.     UnloadDeadDLLs();
  825. #endif
  827.     // Initialize out params
  828.     pIEnumerator = NULL;
  830.     // Use the internal function to build up an enumerator object
  831.     CPluginEnumerator* pEnumerator = NULL;
  832.     HX_RESULT result = FindGroupOfPluginsUsingStrings( PropName1, PropVal1,
  833.     PropName2, PropVal2, PropName3, PropVal3, pEnumerator );
  835.     // If we have our enumerator, get the appropriate interface
  836.     if( SUCCEEDED( result ) )
  837.     {
  838. result = pEnumerator->QueryInterface( IID_IHXPluginSearchEnumerator,
  839. (void**) &pIEnumerator );
  840.     }
  842.     return result;
  843. }
  845. void BaseHandler::ReportError( UINT8 severity, const char* pDLLName, const char* pDesc )
  846. {
  847. }
  850. STDMETHODIMP
  851. BaseHandler::FindPluginUsingValues( IHXValues* pCriteria,
  852. REF(IUnknown*) pIUnkResult,
  853. IUnknown* pIUnkOuter )
  854. {
  855.     HX_SETUP_CHECKPOINTLIST( "BaseHandler::FindPluginUsingValues()" );
  856.     HX_PRIME_ACCUMULATOR( 'fpuv', "Plugin lookup with IHXValues" );
  858.     // Initialize out params
  859.     pIUnkResult = NULL;
  861.     CHXSimpleList   PossibleValues;
  862.     IHXValues*     pPluginValues = NULL;
  863.     IHXBuffer*     pBuffer = NULL;
  864.     CHXSimpleList::Iterator i = m_PluginList.Begin();
  866.     for(; i!= m_PluginList.End(); ++i)
  867.     {
  868. BaseHandler::Plugin* pPlugin = (BaseHandler::Plugin*) *i;
  869. if (pPlugin->DoesMatch(pCriteria))
  870. {
  871.     PossibleValues.AddTail(pPlugin);
  872. }
  873.     }
  875.     HX_UPDATE_ACCUMULATOR( 'fpuv' );
  877.     if (PossibleValues.Begin() == PossibleValues.End())
  878.     {
  879. pIUnkResult = 0;
  880. return HXR_FAIL;
  881.     }
  883.     /****************************************************************
  884.     ** Presently when we arrive at this spot with more than one
  885.     ** plugin which matches the search criteria, we simply take
  886.     ** the first one found. If this is not satisfactory then
  887.     ** some method can be added which will process the list based
  888.     ** upon some criteria.
  889.     ****************************************************************/
  891.     // if there are multiple plugins found, we will pick the one whose
  892.     // plugin description contains "RealNetworks"
  893.     if (PossibleValues.GetCount() > 1)
  894.     {
  895. for(i = PossibleValues.Begin(); i!= PossibleValues.End(); ++i)
  896. {
  897.     BaseHandler::Plugin* pPlugin = (BaseHandler::Plugin*) *i;
  898.     if (HXR_OK == pPlugin->GetPluginInfo(pPluginValues) && pPluginValues)
  899.     {
  900. if (HXR_OK == pPluginValues->GetPropertyCString(PLUGIN_DESCRIPTION2, pBuffer) &&
  901.     pBuffer)
  902. {
  903.     if (strstr((const char*)pBuffer->GetBuffer(), "RealNetworks"))
  904.     {
  905. HX_RELEASE(pBuffer);
  906. if ( NO_ERRORS == pPlugin->GetInstance( pIUnkResult, pIUnkOuter ))
  907. {
  908.     return HXR_OK;
  909. }
  910. else
  911. {
  912.     return HXR_FAIL;
  913. }
  914.     }
  915. }
  916. HX_RELEASE(pBuffer);
  917.     }
  918. }
  919.     }
  921.     BaseHandler::Plugin* pPlug = (BaseHandler::Plugin*) *(PossibleValues.Begin());
  922.     Errors retVal = pPlug->GetInstance( pIUnkResult, pIUnkOuter );
  924.     return ( retVal == NO_ERRORS ) ? HXR_OK : HXR_FAIL;
  925. }
  928. STDMETHODIMP
  929. BaseHandler::FindPluginUsingStrings( char* PropName1, char* PropVal1,
  930. char* PropName2, char* PropVal2,
  931. char* PropName3, char* PropVal3,
  932. REF(IUnknown*) pIUnkResult,
  933. IUnknown* pIUnkOuter )
  934. {
  935.     // Initialize out params
  936.     pIUnkResult = NULL;
  938.     // PropName and PropVal have to to valid tuple
  939.     if ((PropName1 && !PropVal1)    ||
  940. (PropName2 && !PropVal2)    ||
  941. (PropName3 && !PropVal3)    ||
  942. (!PropName1 && PropVal1)    ||
  943. (!PropName2 && PropVal2)    ||
  944. (!PropName3 && PropVal3))
  945. return HXR_FAIL;
  947.     IHXValues* pValues;
  948.     HX_RESULT   retVal = HXR_FAIL;
  950.     CHXHeader* pHeader = new CHXHeader();
  951.     pHeader->QueryInterface(IID_IHXValues,  (void**)&pValues);
  952.     AddToValues(pValues, PropName1, PropVal1, eString);
  953.     AddToValues(pValues, PropName2, PropVal2, eString);
  954.     AddToValues(pValues, PropName3, PropVal3, eString);
  955.     retVal = FindPluginUsingValues( pValues, pIUnkResult, pIUnkOuter );
  956.     pValues->Release();
  957.     return retVal;
  958. }
  961. void
  962. BaseHandler::UnloadDeadDLLs()
  963. {
  964.     LISTPOSITION pos = m_PluginList.GetHeadPosition();
  965.     while( pos )
  966.     {
  967.         BaseHandler::Plugin* pPlugin = (BaseHandler::Plugin*) m_PluginList.GetNext( pos );
  968.         if( pPlugin )
  969.         {
  970.             PluginDLL * pPluginDll = pPlugin->GetDLL();
  971.             if( pPluginDll )
  972.             {
  973.                 pPluginDll->Unload();
  974.             }
  975.         }
  976.     }
  977. }
  979. STDMETHODIMP
  980. BaseHandler::GetPlugin( ULONG32 ulIndex, REF(IUnknown*) pIUnkResult,
  981.     IUnknown* pIUnkOuter )
  982. {
  983.     if( ulIndex <= (ULONG32)(m_PluginList.GetCount()-1) && m_PluginList.GetCount() )
  984.     {
  985. LISTPOSITION pPos = m_PluginList.FindIndex( ulIndex );
  986. if (pPos)
  987. {
  988.     BaseHandler::Plugin* pPlugin = (BaseHandler::Plugin*) m_PluginList.GetAt( pPos );
  989.     if( pPlugin )
  990.     {
  991. if (NO_ERRORS == pPlugin->GetInstance( pIUnkResult, pIUnkOuter ))
  992. {
  993.     return HXR_OK;
  994. }
  995. else
  996. {
  997.     return HXR_FAIL;
  998. }
  999.     }
  1000. }
  1001.     }
  1002.     return HXR_FAIL;
  1004. }
  1007. STDMETHODIMP
  1008. BaseHandler::UnloadPluginFromClassID(REFGUID GUIDClassID)
  1009. {
  1010.     return HXR_NOTIMPL;
  1011. }
  1013. STDMETHODIMP
  1014. BaseHandler::UnloadPackageByName(const char* pName)
  1015. {
  1016.     return HXR_NOTIMPL;
  1017. }
  1020. //------------------------------------ Class Methods
  1022. STDMETHODIMP BaseHandler::FindPluginUsingStrings (char* PropName1,
  1023.     char* PropVal1,
  1024.     char* PropName2,
  1025.     char* PropVal2,
  1026.     char* PropName3,
  1027.     char* PropVal3,
  1028.     REF(IUnknown*) pRetUnk)
  1029. {
  1030.     return FindPluginUsingStrings( PropName1, PropVal1, PropName2, PropVal2,
  1031.    PropName3, PropVal3, pRetUnk, NULL );
  1032. }
  1035. STDMETHODIMP
  1036. BaseHandler::FindImplementationFromClassID
  1037. (
  1038.     REFGUID GUIDClassID,
  1039.     REF(IUnknown*) pIUnknownInstance
  1040. )
  1041. {
  1042.     // Defer to the new version
  1043.     return FindImplementationFromClassID( GUIDClassID, pIUnknownInstance, NULL, m_pContext );
  1044. }
  1046. STDMETHODIMP BaseHandler::Close ()
  1047. {
  1048.     CHXSimpleList::Iterator i = m_PluginList.Begin();
  1050.     // Release all Plugins and Their Associated DLLs
  1051.     for(; i!=m_PluginList.End(); ++i)
  1052.     {
  1053. BaseHandler::Plugin* pPlug = (BaseHandler::Plugin*) *i;
  1054. pPlug->Release();
  1055.     }
  1056.     m_PluginList.RemoveAll();
  1058.     for(i = m_PluginDLLList.Begin(); i!=m_PluginDLLList.End(); ++i)
  1059.     {
  1060. BaseHandler::PluginDLL* pPlugDLL = (BaseHandler::PluginDLL*) *i;
  1061. pPlugDLL->Release();
  1062.     }
  1063.     m_PluginDLLList.RemoveAll();
  1065.     for(i = m_MiscDLLList.Begin(); i!=m_MiscDLLList.End(); ++i)
  1066.     {
  1067. BaseHandler::OtherDLL* pOtherDLL = (BaseHandler::OtherDLL*) *i;
  1068. delete pOtherDLL;
  1069.     }
  1070.     m_MiscDLLList.RemoveAll();
  1072.     for(CHXMapStringToOb::Iterator mp = m_MountPoints.Begin(); mp!=m_MountPoints.End(); ++mp)
  1073.     {
  1074. BaseHandler::PluginMountPoint* pMountPoint = (BaseHandler::PluginMountPoint*) *mp;
  1075. pMountPoint->Release();
  1076.     }
  1077.     m_MountPoints.RemoveAll();
  1079.     // release all of the CORE stuff...
  1080.     HX_RELEASE(m_pContext);
  1082.     return HXR_OK;
  1083. }
  1085. STDMETHODIMP BaseHandler::SetRequiredPlugins (const char** ppszRequiredPlugins)
  1086. {
  1087.     return HXR_OK;
  1088. }
  1091. HX_RESULT BaseHandler::AddToValues(IHXValues* pValues, char* pPropName, char* pPropVal, eValueTypes eValueType)
  1092. {
  1093.     if (!pPropName || !pPropVal)
  1094. return HXR_FAIL;
  1095.     // 1st make into a cstrig and to trim the buffer...
  1096.     CHXString theValue = (pPropVal);
  1097.     theValue.TrimLeft();
  1098.     theValue.TrimRight();
  1100.     switch (eValueType)
  1101.     {
  1102. case eString:
  1103. {
  1104.     IHXBuffer* pBuffer;
  1105.     CHXBuffer* pCHXBuffer;
  1106.     pCHXBuffer = new CHXBuffer;
  1107.     pCHXBuffer->QueryInterface(IID_IHXBuffer, (void**) &pBuffer);
  1108.     pBuffer->Set((const unsigned char*)(const char*)theValue, strlen(theValue)+1);
  1109.     pValues->SetPropertyCString(pPropName, pBuffer);
  1110.     pBuffer->Release();
  1111.     return HXR_OK;
  1112. }
  1113. case eInt:
  1114. {
  1115.     int val = atoi(theValue);
  1116.     pValues->SetPropertyULONG32(pPropName, (ULONG32)val);
  1117.     return HXR_OK;
  1118. }
  1119.     }
  1120.     return HXR_NOTIMPL;
  1121. }
  1123. STDMETHODIMP_(ULONG32) BaseHandler::GetNumOfPlugins()
  1124. {
  1125.     return m_PluginList.GetCount();
  1126. }
  1128. STDMETHODIMP BaseHandler::GetPlugin(ULONG32 ulIndex, REF(IUnknown*)  /*OUT*/ pInstance)
  1129. {
  1130.     return GetPlugin( ulIndex, pInstance, NULL );
  1131. }
  1134. STDMETHODIMP BaseHandler::FlushCache()
  1135. {
  1136.     return HXR_OK;
  1137. }
  1139. STDMETHODIMP BaseHandler::SetCacheSize(ULONG32 nSizeKB)
  1140. {
  1141.     return HXR_OK;
  1142. }
  1144. STDMETHODIMP BaseHandler::ReadFromRegistry()
  1145. {
  1146.     HX_RESULT result;
  1147.     IHXBuffer* pBuffer = NULL;
  1149. #if !defined(_STATICALLY_LINKED) || defined(HELIX_CONFIG_CONSOLIDATED_CORE)
  1151.     const char* pPath = GetDLLAccessPath()->GetPath(DLLTYPE_PLUGIN);
  1152.     if (pPath && *pPath)
  1153.     {
  1154. pBuffer = new CHXBuffer;
  1155. if (pBuffer)
  1156. {
  1157.     pBuffer->AddRef();
  1158.     HX_VERIFY(SUCCEEDED(pBuffer->Set((UCHAR*)pPath,
  1159.      strlen(pPath) + 1)));
  1160. }
  1161.     }
  1163. #endif
  1165.     // Set up a mount point with the default plugin location
  1166.     result = AddPluginMountPoint(HXVER_SDK_PRODUCT, 0, 0, pBuffer);
  1168.     HX_RELEASE(pBuffer);
  1170.     return result;
  1171. }
  1174. BOOL BaseHandler::FindPlugin(const char* pFileName, UINT32 nDLLIndex, REF(UINT32) nIndex)
  1175. {
  1176.     UINT32 nTempIndex = 0;
  1178.     for(CHXSimpleList::Iterator i = m_PluginList.Begin(); i!=m_PluginList.End(); ++i)
  1179.     {
  1180. BaseHandler::Plugin* pPlugin = (BaseHandler::Plugin*) *i;
  1181. IHXBuffer* pBuffer = pPlugin->GetFileName();
  1182. char* pPluginFileName = (char*) pBuffer->GetBuffer();
  1184. if (!strcasecmp(pPluginFileName, pFileName))
  1185. {
  1186.     if (pPlugin->GetIndex() == nDLLIndex)
  1187.     {
  1188. nIndex = nTempIndex;
  1189. HX_RELEASE(pBuffer);
  1190. return TRUE;
  1191.     }
  1192. }
  1193. HX_RELEASE(pBuffer);
  1194. nTempIndex++;
  1195.     }
  1196.     return FALSE;
  1197. }
  1199. /**********************************************************************************
  1200. ***     BaseHandler::Plugin ***
  1201. ***********************************************************************************/
  1204. BaseHandler::Plugin::Plugin(IUnknown* pContext) :
  1205. m_lRefCount(0)
  1206.     , m_pValues(0)
  1207.     , m_pPluginDLL(0)
  1208.     , m_pContext(pContext)
  1209.     ,  m_bInfoNeedsRefresh(FALSE)
  1210.     , m_nPluginIndex(0)
  1211.     , m_pClassFactory(NULL)
  1212. {
  1213.     m_pValues = new CHXHeader();
  1214.     m_pValues->AddRef();
  1215.     m_pContext->AddRef();
  1216.     m_pContext->QueryInterface(IID_IHXCommonClassFactory,
  1217.      (void**)&m_pClassFactory);
  1218. }
  1220. BaseHandler::Plugin::~Plugin()
  1221. {
  1222.     HX_RELEASE(m_pValues);
  1223.     HX_RELEASE(m_pPluginDLL);
  1224.     HX_RELEASE(m_pClassFactory);
  1225.     HX_RELEASE(m_pContext);
  1226.     //HX_RELEASE(m_pPluginWatcher);
  1227. }
  1229. void BaseHandler::Plugin::SetPluginProperty(const char* pszPluginType)
  1230. {
  1231.     IHXBuffer* pBuffer = NULL;
  1232.     m_pClassFactory->CreateInstance(CLSID_IHXBuffer,(void**)&pBuffer);
  1233.     pBuffer->Set((UCHAR*)pszPluginType, strlen(pszPluginType)+1);
  1234.     m_pValues->SetPropertyCString(PLUGIN_CLASS, pBuffer);
  1235.     pBuffer->Release();
  1236. }
  1239. BOOL BaseHandler::Plugin::DoesMatch(IHXValues* pValues)
  1240. {
  1241.     CHXSimpleList   PossibleValues1;
  1242.     CHXSimpleList   PossibleValues2;
  1243.     const char*     pPropName = NULL;
  1244.     ULONG32     nInValue;
  1245.     ULONG32     nOutValue;
  1246.     IHXBuffer*     pInBuffer = NULL;
  1247.     IHXBuffer*     pOutBuffer = NULL;
  1249.     // Check ULONGS 1st
  1250.     if (HXR_OK == pValues->GetFirstPropertyULONG32(pPropName, nInValue))
  1251.     {
  1252. if (HXR_OK==m_pValues->GetPropertyULONG32(pPropName, nOutValue))
  1253. {
  1254.     if (nInValue != nOutValue)
  1255.     {
  1256. goto notFoundexit;
  1257.     }
  1258. }
  1259. else
  1260. {
  1261.     goto notFoundexit;
  1262. }
  1263. while (HXR_OK == pValues->GetNextPropertyULONG32(pPropName, nInValue))
  1264. {
  1265.     if (HXR_OK == m_pValues->GetPropertyULONG32(pPropName, nOutValue))
  1266.     {
  1267. if (nInValue != nOutValue)
  1268. {
  1269.     goto notFoundexit;
  1270. }
  1271.     }
  1272.     else
  1273.     {
  1274. goto notFoundexit;
  1275.     }
  1276. }
  1277.     }
  1279.     // Test code to look at all of the data in the map.
  1280. #ifdef _DEBUG
  1281.     HX_RESULT tempresult;
  1283.     tempresult = HXR_OK;
  1285.     tempresult = m_pValues->GetFirstPropertyCString(pPropName, pInBuffer);
  1286.     HX_RELEASE(pInBuffer);
  1288.     while (tempresult == HXR_OK)
  1289.     {
  1290. tempresult = m_pValues->GetNextPropertyCString(pPropName, pInBuffer);
  1291. if (tempresult == HXR_OK)
  1292. {
  1293.     HX_RELEASE(pInBuffer);
  1294. }
  1295.     }
  1296. #endif /*_DEBUG*/
  1298.     // Check String Props.
  1299.     if (HXR_OK == pValues->GetFirstPropertyCString(pPropName, pInBuffer))
  1300.     {
  1301. if (HXR_OK == m_pValues->GetPropertyCString(pPropName, pOutBuffer))
  1302. {
  1303.     if (!AreBufferEqual(pOutBuffer, pInBuffer))
  1304.     {
  1305. goto notFoundexit;
  1306.     }
  1307. }
  1308. else
  1309. {
  1310.     goto notFoundexit;
  1311. }
  1313. HX_RELEASE(pInBuffer);
  1314. HX_RELEASE(pOutBuffer);
  1316. while (HXR_OK == pValues->GetNextPropertyCString(pPropName, pInBuffer))
  1317. {
  1318.     if (HXR_OK == m_pValues->GetPropertyCString(pPropName, pOutBuffer))
  1319.     {
  1320. if ( !AreBufferEqual(pOutBuffer, pInBuffer))
  1321. {
  1322.     goto notFoundexit;
  1323. }
  1324.     }
  1325.     else
  1326.     {
  1327. goto notFoundexit;
  1328.     }
  1330.     HX_RELEASE(pInBuffer);
  1331.     HX_RELEASE(pOutBuffer);
  1332. }
  1333.     }
  1336.      // Check Buffer Properties
  1337.     if (HXR_OK == pValues->GetFirstPropertyBuffer(pPropName, pInBuffer))
  1338.     {
  1339. // XXXND  Make some utility functions for doing this...
  1340. if (HXR_OK == m_pValues->GetPropertyBuffer(pPropName, pOutBuffer))
  1341. {
  1342.     if( pOutBuffer->GetSize() == pInBuffer->GetSize() )
  1343.     {
  1344. if( ::memcmp( pOutBuffer->GetBuffer(), pInBuffer->GetBuffer(), pOutBuffer->GetSize() ) )
  1345. {
  1346.     goto notFoundexit;
  1347. }
  1348.     }
  1349. }
  1350. else
  1351. {
  1352.     goto notFoundexit;
  1353. }
  1355. HX_RELEASE(pInBuffer);
  1356. HX_RELEASE(pOutBuffer);
  1358. while (HXR_OK == pValues->GetNextPropertyBuffer(pPropName, pInBuffer))
  1359. {
  1360.     if (HXR_OK == m_pValues->GetPropertyBuffer(pPropName, pOutBuffer))
  1361.     {
  1362. // XXXND  Make some utility functions for doing this...
  1363. if( pOutBuffer->GetSize() == pInBuffer->GetSize() )
  1364. {
  1365.     if( ::memcmp( pOutBuffer->GetBuffer(), pInBuffer->GetBuffer(), pOutBuffer->GetSize() ) )
  1366.     {
  1367. goto notFoundexit;
  1368.     }
  1369. }
  1370.     }
  1371.     else
  1372.     {
  1373. goto notFoundexit;
  1374.     }
  1376.     HX_RELEASE(pInBuffer);
  1377.     HX_RELEASE(pOutBuffer);
  1378. }
  1379.     }
  1381.     return TRUE;    // we made it!
  1383. notFoundexit:
  1384.     HX_RELEASE(pInBuffer);
  1385.     HX_RELEASE(pOutBuffer);
  1386.     return FALSE;
  1387. }
  1389. void BaseHandler::Plugin::SetDLL(PluginDLL * pPluginDll)
  1390. {
  1391.     m_pPluginDLL = pPluginDll;
  1392.     m_pPluginDLL->AddRef();
  1394.     IHXBuffer* pBuffer = pPluginDll->GetFileName();
  1395.     HX_ASSERT(pBuffer);
  1397.     m_pValues->SetPropertyCString(PLUGIN_FILENAME, pBuffer);
  1398.     HX_RELEASE(pBuffer);
  1399. }
  1401. void BaseHandler::Plugin::SetIndex(UINT16 nIndex)
  1402. {
  1403.     m_nPluginIndex = nIndex;
  1404.     m_pValues->SetPropertyULONG32(PLUGIN_INDEX, nIndex);
  1405. }
  1408. void BaseHandler::Plugin::SetPropertyULONG32(char* pName, char* pValue)
  1409. {
  1410.     if (m_pValues)
  1411.     {
  1412. m_pValues->SetPropertyULONG32(pName, atoi(pValue));
  1413.     }
  1414. }
  1416. void BaseHandler::Plugin::SetPropertyCString(char* pName, char* pValue)
  1417. {
  1418.     if (m_pValues)
  1419.     {
  1420. IHXBuffer* pTempBuffer = new CHXBuffer();
  1421. pTempBuffer->AddRef();
  1422. pTempBuffer->Set((UCHAR*)pValue, strlen(pValue)+1);
  1423. m_pValues->SetPropertyCString(pName, pTempBuffer);
  1424. HX_RELEASE(pTempBuffer);
  1425.     }
  1426. }
  1428. void BaseHandler::Plugin::SetPropertyBuffer(char* pName, BYTE* pData, UINT32 size )
  1429. {
  1430.     if (m_pValues)
  1431.     {
  1432. // XXXND  FIX  THis really shouldn't have to do this copy
  1433. IHXBuffer* pTempBuffer = new CHXBuffer();
  1434. pTempBuffer->AddRef();
  1435. pTempBuffer->Set( pData, size );
  1436. m_pValues->SetPropertyBuffer(pName, pTempBuffer);
  1437. HX_RELEASE(pTempBuffer);
  1438.     }
  1439. }
  1441. BOOL BaseHandler::Plugin::AreBufferEqual(IHXBuffer* pBigBuff,
  1442.    IHXBuffer* pSmallBuff)
  1443. {
  1444.     char*   pTemp;
  1445.     BOOL    bRetVal = FALSE;
  1447.     pTemp = new char[pBigBuff->GetSize()];
  1448.     strcpy(pTemp, (char*)pBigBuff->GetBuffer()); /* Flawfinder: ignore */
  1450.     char* token;
  1451.     token = strtok(pTemp, zm_pszValueSeperator);
  1452.     while (token)
  1453.     {
  1454. CHXString tokenCHXstring;
  1455. CHXString smallCHXstring;
  1457. tokenCHXstring = token;
  1458. smallCHXstring = (char*)pSmallBuff->GetBuffer();
  1459. tokenCHXstring.TrimLeft();
  1460. tokenCHXstring.TrimRight();
  1461. smallCHXstring.TrimLeft();
  1462. smallCHXstring.TrimRight();
  1464. if (!strcasecmp(tokenCHXstring, smallCHXstring))
  1465. {
  1466.     bRetVal = TRUE;
  1467.     break;
  1468. }
  1469. token = strtok(NULL, zm_pszValueSeperator);
  1470.     }
  1471.     delete[] pTemp;
  1473.     return bRetVal;
  1474. }
  1476. BaseHandler::Errors BaseHandler::Plugin::GetValuesFromDLL(IHXPlugin* pHXPlugin)
  1477. {
  1478.     BaseHandler::Errors  retVal;
  1480.     retVal = GetBasicValues(pHXPlugin);
  1481.     if (retVal == NO_ERRORS)
  1482.     {
  1483. retVal = GetExtendedValues(pHXPlugin);
  1484.     }
  1485.     return retVal;
  1486. }
  1488. BaseHandler::Errors BaseHandler::Plugin::GetPlugin(REF(IUnknown*) pUnknown )
  1489. {
  1490.     pUnknown = NULL;
  1491.     BaseHandler::Errors retVal = NO_ERRORS;
  1493.     if (!m_pPluginDLL)
  1494.     {
  1495. return PLUGIN_NOT_FOUND;
  1496.     }
  1497.     if (!m_pPluginDLL->IsLoaded())
  1498.     {
  1499. if (NO_ERRORS != (retVal = m_pPluginDLL->Load(m_pContext)))
  1500. {
  1501.     return retVal;
  1502. }
  1503.     }
  1504.     if (HXR_OK != m_pPluginDLL->CreateInstance(&pUnknown, m_nPluginIndex))
  1505.     {
  1506. return CREATE_INSTANCHXR_FAILURE;
  1507.     }
  1509.     return retVal;
  1510. }
  1513. BaseHandler::Errors BaseHandler::Plugin::GetInstance(REF(IUnknown*) pUnknown, IUnknown* pIUnkOuter )
  1514. {
  1515.     // Initialize out parameter
  1516.     pUnknown = NULL;
  1518.     IUnknown* pIUnkPlugin = NULL;
  1519.     BaseHandler::Errors retVal = GetPlugin( pIUnkPlugin );
  1520.     if( retVal == NO_ERRORS )
  1521.     {
  1522. IHXComponentPlugin* pIComp = NULL;
  1523. if( SUCCEEDED( pIUnkPlugin->QueryInterface( IID_IHXComponentPlugin, (void**) &pIComp ) ) )
  1524. {
  1525.     // Ask for the correct object by CLSID
  1526.     IHXBuffer* pCLSID = NULL;
  1527.     if( SUCCEEDED( m_pValues->GetPropertyBuffer( PLUGIN_COMPONENT_CLSID, pCLSID ) ) )
  1528.     {
  1529. if( FAILED( pIComp->CreateComponentInstance( *(GUID*) pCLSID->GetBuffer(), pUnknown, pIUnkOuter ) ) )
  1530. {
  1531.     retVal = CREATE_INSTANCHXR_FAILURE;
  1532. }
  1533. HX_RELEASE( pCLSID );
  1534.     }
  1535.     else
  1536.     {
  1537. // Hmmm...we have a component plugin without a CLSID.  Serious internal error
  1538. retVal = BAD_PLUGIN;
  1539.     }
  1541.     // Release the interface, and destroy the plugin
  1542.     HX_RELEASE( pIComp );
  1543.     HX_RELEASE( pIUnkPlugin );
  1544. }
  1545. else
  1546. {
  1547.     // If this isn't a component plugin, then we can't aggregate anything
  1548.     if( pIUnkOuter )
  1549.     {
  1550. HX_RELEASE( pIUnkPlugin );
  1551. retVal = AGGREGATION_NOT_SUPPORTED;
  1552.     }
  1553.     else
  1554.     {
  1555. pUnknown = pIUnkPlugin;
  1556.     }
  1557. }
  1558.     }
  1560.     return retVal;
  1561. }
  1563. BOOL BaseHandler::Plugin::IsLoaded()
  1564. {
  1565.     if (!m_pPluginDLL)
  1566. return FALSE;
  1568.     return m_pPluginDLL->IsLoaded();
  1569. }
  1571. HX_RESULT BaseHandler::Plugin::GetPluginInfo(REF(IHXValues*) pVals)
  1572. {
  1573.     if (m_pValues)
  1574.     {
  1575. pVals = m_pValues;
  1576. return HXR_OK;
  1577.     }
  1578.     pVals = NULL;
  1579.     return HXR_FAIL;
  1580. }
  1582. IHXBuffer* BaseHandler::Plugin::GetFileName()
  1583. {
  1584.     IHXBuffer* retVal = NULL;
  1586.     // Get the filename from m_pValues.  We can't get it from the DLL,
  1587.     // because we may be in the process of loading, and we just got it
  1588.     // from the preferences
  1589.     if( m_pValues )
  1590.     {
  1591. m_pValues->GetPropertyCString( PLUGIN_FILENAME, retVal );
  1592.     }
  1594.     return retVal;
  1595. }
  1597. BaseHandler::Errors
  1598. BaseHandler::Plugin::GetBasicValues(IHXPlugin* pHXPlugin)
  1599. {
  1600.     return NO_ERRORS;
  1602.     const char* pszDescription = NULL;
  1603.     const char* pszCopyright = NULL;
  1604.     const char* pszMoreInfoUrl = NULL;
  1605.     ULONG32 ulVersionNumber = 0;
  1606.     BOOL nload_multiple = 0;
  1608.     if (HXR_OK != pHXPlugin->GetPluginInfo(nload_multiple, pszDescription,
  1609.        pszCopyright, pszMoreInfoUrl, ulVersionNumber))
  1610.     {
  1611.         return BAD_PLUGIN;
  1612.     }
  1614.     IHXBuffer* pBuffer = NULL;
  1615.     m_pClassFactory->CreateInstance(CLSID_IHXBuffer,(void**)&pBuffer);
  1616.     if (pszDescription)
  1617.     {
  1618. pBuffer->Set((UCHAR*)pszDescription, strlen(pszDescription)+1);
  1619.     }
  1620.     m_pValues->SetPropertyCString(PLUGIN_DESCRIPTION2, pBuffer);
  1621.     pBuffer->Release();
  1622.     m_pClassFactory->CreateInstance(CLSID_IHXBuffer,(void**)&pBuffer);
  1623.     if (pszCopyright)
  1624.     {
  1625. pBuffer->Set((UCHAR*)pszCopyright, strlen(pszCopyright)+1);
  1626.     }
  1627.     m_pValues->SetPropertyCString(PLUGIN_COPYRIGHT2, pBuffer);
  1628.     pBuffer->Release();
  1629.     m_pClassFactory->CreateInstance(CLSID_IHXBuffer,(void**)&pBuffer);
  1630.     if (pszMoreInfoUrl)
  1631.     {
  1632. pBuffer->Set((UCHAR*)pszMoreInfoUrl, strlen(pszMoreInfoUrl)+1);
  1633.     }
  1634.     m_pValues->SetPropertyCString(PLUGIN_COPYRIGHT, pBuffer);
  1635.     pBuffer->Release();
  1637.     m_pValues->SetPropertyULONG32(PLUGIN_LOADMULTIPLE, nload_multiple);
  1638.     m_pValues->SetPropertyULONG32(PLUGIN_VERSION, ulVersionNumber);
  1639.     return NO_ERRORS;
  1640. }
  1643. BaseHandler::Errors
  1644. BaseHandler::Plugin::GetExtendedValues(IHXPlugin* pHXPlugin)
  1645. {
  1646. //    Errors result     = NO_ERRORS;
  1647.     IHXFileFormatObject* pFileFormat     = NULL;
  1648. //    IHXMetaFileFormatObject* pMetaFileFormat     = NULL;
  1649.     IHXFileWriter* pFileWriter     = NULL;
  1650.     IHXBroadcastFormatObject* pBroadcastFormat    = NULL;
  1651.     IHXFileSystemObject* pFileSystem     = NULL;
  1652.     IHXRenderer* pRenderer     = NULL;
  1653.     IHXDataRevert* pDataRevert     = NULL;
  1654.     IHXStreamDescription* pStreamDescription  = NULL;
  1655.     IHXPlayerConnectionAdviseSink* pAllowanceFormat    = NULL;
  1656.     IHXCommonClassFactory* pClassFactory       = NULL;
  1657.     IHXPluginProperties* pIHXPluginPropertiesThis = NULL;
  1658.     UINT32 nCountInterfaces    = 0;
  1661.     // file system
  1662.     if (HXR_OK == pHXPlugin->QueryInterface(IID_IHXFileSystemObject, (void**) &pFileSystem))
  1663.     {
  1664. const char* pszShortName;
  1665. const char* pszProtocol;
  1667. if (HXR_OK != pFileSystem->GetFileSystemInfo(pszShortName, pszProtocol))
  1668. {
  1669.     HX_RELEASE (pFileSystem);
  1670.     return  CANT_GET_RENDERER_INFO; //XXXAH Cleanup?
  1671. }
  1673. SetPluginProperty(PLUGIN_FILESYSTEM_TYPE);
  1675. IHXBuffer* pBuffer = NULL;
  1676. m_pClassFactory->CreateInstance(CLSID_IHXBuffer,(void**)&pBuffer);
  1677. if (pszShortName)
  1678. {
  1679.     pBuffer->Set((UCHAR*)pszShortName, strlen(pszShortName)+1);
  1680. }
  1681. m_pValues->SetPropertyCString(PLUGIN_FILESYSTEMSHORT, pBuffer);
  1682. pBuffer->Release();
  1683. m_pClassFactory->CreateInstance(CLSID_IHXBuffer,(void**)&pBuffer);
  1684. if (pszProtocol)
  1685. {
  1686.     pBuffer->Set((UCHAR*)pszProtocol, strlen(pszProtocol)+1);
  1687. }
  1688. m_pValues->SetPropertyCString(PLUGIN_FILESYSTEMPROTOCOL, pBuffer);
  1689. pBuffer->Release();
  1691. pFileSystem->Release();
  1692. nCountInterfaces++;
  1693.     }
  1695.     // file format
  1696.     if (HXR_OK == pHXPlugin->QueryInterface(IID_IHXFileFormatObject, (void**)&pFileFormat) ||
  1697. HXR_OK == pHXPlugin->QueryInterface(IID_IHXMetaFileFormatObject, (void**)&pFileFormat) ||
  1698. HXR_OK == pHXPlugin->QueryInterface(IID_IHXFileWriter, (void**)&pFileWriter))
  1699.     {
  1700. // fine we are in now we will get the correct type.
  1701. if (pFileFormat)
  1702. {
  1703.     pFileFormat->Release();
  1704. }
  1705. else
  1706. {
  1707.     pFileWriter->Release();
  1708. }
  1710. IHXMetaFileFormatObject* pMetaFileFormat;
  1712. const char** ppszMimeTypes = NULL;
  1713. const char** ppszExtensions = NULL;
  1714. const char** ppszOpenNames = NULL;
  1716. if (HXR_OK == pHXPlugin->QueryInterface(IID_IHXFileFormatObject, (void**)&pFileFormat))
  1717. {
  1718.     pFileFormat->GetFileFormatInfo( ppszMimeTypes,
  1719.     ppszExtensions,
  1720.     ppszOpenNames);
  1721.     pFileFormat->Release();
  1722.     SetPluginProperty(PLUGIN_FILEFORMAT_TYPE);
  1723. }
  1725. if (HXR_OK == pHXPlugin->QueryInterface(IID_IHXMetaFileFormatObject, (void**)&pMetaFileFormat))
  1726. {
  1727.     pMetaFileFormat->GetMetaFileFormatInfo( ppszMimeTypes,
  1728.     ppszExtensions,
  1729.     ppszOpenNames);
  1730.     pMetaFileFormat->Release();
  1732.     SetPluginProperty(PLUGIN_METAFILEFORMAT_TYPE);
  1733. }
  1735. if (HXR_OK == pHXPlugin->QueryInterface(IID_IHXFileWriter, (void**)&pFileWriter))
  1736. {
  1737.     pFileWriter->GetFileFormatInfo( ppszMimeTypes,
  1738.     ppszExtensions,
  1739.     ppszOpenNames);
  1740.     pFileWriter->Release();
  1742.     SetPluginProperty(PLUGIN_FILEWRITER_TYPE);
  1743. }
  1745. IHXBuffer* pBuffer = NULL;
  1746. if (ppszMimeTypes)
  1747. {
  1748.     CatStrings((char**)ppszMimeTypes, pBuffer);     //XXXAH this had better be const in reality!
  1749.     m_pValues->SetPropertyCString(PLUGIN_FILEMIMETYPES, pBuffer);
  1750.     pBuffer->Release();
  1751. }
  1753. if (ppszExtensions)
  1754. {
  1755.     CatStrings((char**)ppszExtensions, pBuffer); //XXXAH this had better be const in reality!
  1756.     m_pValues->SetPropertyCString(PLUGIN_FILEEXTENSIONS, pBuffer);
  1757.     pBuffer->Release();
  1758. }
  1760. if (ppszOpenNames)
  1761. {
  1762.     CatStrings((char**)ppszOpenNames, pBuffer); //XXXAH this had better be const in reality!
  1763.     m_pValues->SetPropertyCString(PLUGIN_FILEOPENNAMES, pBuffer);
  1764.     pBuffer->Release();
  1765. }
  1766. nCountInterfaces++;
  1767.     }
  1769.     // renderer
  1770.     if (HXR_OK == pHXPlugin->QueryInterface(IID_IHXRenderer, (void**)&pRenderer))
  1771.     {
  1772. char** ppszMimeTypes;
  1773.         UINT32 initial_granularity = 0;
  1775. // get the basic info
  1776. if (HXR_OK == pRenderer->GetRendererInfo((const char**&)ppszMimeTypes, initial_granularity))
  1777. {
  1778.     IHXBuffer* pBuffer;
  1779.     if (ppszMimeTypes)
  1780.     {
  1781. CatStrings(ppszMimeTypes, pBuffer);
  1782.     }
  1783.     m_pValues->SetPropertyCString(PLUGIN_RENDERER_MIME, pBuffer);
  1784.     pBuffer->Release();
  1785.     m_pValues->SetPropertyULONG32(PLUGIN_RENDERER_GRANULARITY, initial_granularity);
  1786.     SetPluginProperty(PLUGIN_RENDERER_TYPE);
  1787. }
  1789. HX_RELEASE(pRenderer);
  1790. nCountInterfaces++;
  1791.     }
  1793.     // stream description
  1794.     if (HXR_OK == pHXPlugin->QueryInterface(IID_IHXStreamDescription, (void**)&pStreamDescription))
  1795.     {
  1796. const char* pszMimeType;
  1797. IHXBuffer* pBuffer;
  1798. if (HXR_OK != pStreamDescription->GetStreamDescriptionInfo(pszMimeType))
  1799. {
  1800.     HX_RELEASE (pStreamDescription);
  1801.     return CANT_GET_FILE_FORMAT_INFO; // XXXAH Cleanup?
  1802. }
  1803. pStreamDescription->Release();
  1804. m_pClassFactory->CreateInstance(CLSID_IHXBuffer,(void**)&pBuffer);
  1805. if (pszMimeType)
  1806. {
  1807.     pBuffer->Set((UCHAR*)pszMimeType, strlen(pszMimeType)+1);
  1808. }
  1809. m_pValues->SetPropertyCString(PLUGIN_STREAMDESCRIPTION, pBuffer);
  1810. pBuffer->Release();
  1812. SetPluginProperty(PLUGIN_STREAM_DESC_TYPE);
  1813. nCountInterfaces++;
  1814.     }
  1816.     // common class factory
  1817.     if(HXR_OK == pHXPlugin->QueryInterface(IID_IHXCommonClassFactory,
  1818. (void**)&pClassFactory))
  1819.     {
  1820. SetPluginProperty(PLUGIN_CLASS_FACTORY_TYPE);
  1821. HX_RELEASE (pClassFactory);
  1822. nCountInterfaces++;
  1823.     }
  1825.     // NO MORE NEW PLUGIN INFORMATION INTERFACES!!!!
  1826.     //
  1827.     // THIS IS THE LAST ONE!!!!!
  1828.     if( SUCCEEDED( pHXPlugin->QueryInterface( IID_IHXPluginProperties, (void**)&pIHXPluginPropertiesThis ) ) )
  1829.     {
  1830. IHXValues* pIHXValuesProperties = NULL;
  1832. pHXPlugin->InitPlugin(m_pContext);
  1834. if( SUCCEEDED( pIHXPluginPropertiesThis->GetProperties( pIHXValuesProperties ) ) && pIHXValuesProperties )
  1835. {
  1836.     CHXHeader::mergeHeaders( m_pValues, pIHXValuesProperties );
  1837. }
  1839. HX_RELEASE(pIHXValuesProperties);
  1841. // XXXkshoop Let this coincide with other interfaces.. for now..
  1842. //nCountInterfaces++;
  1843.     }
  1845.     HX_RELEASE(pIHXPluginPropertiesThis);
  1847.     HX_ASSERT(nCountInterfaces<2);
  1848.     return NO_ERRORS;
  1849. }
  1851. void BaseHandler::Plugin::InitializeComponentPlugin( IHXPlugin* pIPlugin, IHXValues* pIValues )
  1852. {
  1853.     // Setup basic data
  1854.     // XXXHP - this is unnecessary information as it is stored on a PER COMPONENT not PER PLUGIN basis in this case.
  1855.     // GetBasicValues( pIPlugin );
  1857.     // Copy data from pIValues
  1858.     CHXHeader::mergeHeaders( m_pValues, pIValues );
  1859. }
  1861. HX_RESULT BaseHandler::Plugin::CatStrings(char** pInStrings,
  1862.     REF(IHXBuffer*) pOutBuffer)
  1863. {
  1864.     ULONG32 nAllocedSpace   = 100;
  1865.     char*   ptemp     = new char[nAllocedSpace];
  1866.     char*   ptemp2     = NULL;
  1867.     ULONG32 nStrLen     = 0;
  1868.     ULONG32 nNewStrLen     = 0;
  1870.     *ptemp = 0;
  1871.     pOutBuffer = 0;
  1873.     for(; *pInStrings; pInStrings++)
  1874.     {
  1875. nNewStrLen = strlen(*pInStrings);
  1876. if (nNewStrLen+ nStrLen >= nAllocedSpace)
  1877. {
  1878.     // double if the new string is less than the new space
  1879.     // or add double what it required.
  1880.     if (nNewStrLen< nAllocedSpace)
  1881.     {
  1882. nAllocedSpace*=2;
  1883.     }
  1884.     else
  1885.     {
  1886. nAllocedSpace+=nNewStrLen*2;
  1887.     }
  1889.     ptemp2 = new char[nAllocedSpace];
  1890.     memcpy(ptemp2, ptemp, nStrLen+1); /* Flawfinder: ignore */
  1891.     delete [] ptemp;
  1892.     ptemp = ptemp2;
  1893. }
  1894. // XXXAH I must trim the strings before I add them to this string.
  1895. // the find function DEPENDS UPON THIS.
  1896. SafeStrCat(ptemp,  *pInStrings, nAllocedSpace);
  1897. if (*(pInStrings+1))
  1898. {
  1899.     SafeStrCat(ptemp,  BaseHandler::zm_pszValueSeperator, nAllocedSpace); // XXXAH Perhaps a define?
  1900. }
  1901. nStrLen+=nNewStrLen+1;
  1902.     }
  1903.     m_pClassFactory->CreateInstance(CLSID_IHXBuffer,(void**)&pOutBuffer);
  1904.     pOutBuffer->Set((UCHAR*)ptemp, strlen(ptemp)+1);
  1905.     delete[] ptemp;
  1906.     return HXR_OK;
  1907. }
  1909. /////////////////////////////////////////////////////////////////////////
  1910. //  Method:
  1911. //      BaseHandler::Plugin::QueryInterface
  1912. //  Purpose:
  1913. //      Implement this to export the interfaces supported by your
  1914. //      object.
  1915. //
  1916. STDMETHODIMP
  1917. BaseHandler::Plugin::QueryInterface(REFIID riid, void** ppvObj)
  1918. {
  1919.     if (IsEqualIID(riid, IID_IUnknown))
  1920.     {
  1921.         AddRef();
  1922.         *ppvObj = (IUnknown*)this;
  1923.         return HXR_OK;
  1924.     }
  1926.     *ppvObj = NULL;
  1927.     return HXR_NOINTERFACE;
  1928. }
  1930. /////////////////////////////////////////////////////////////////////////
  1931. //  Method:
  1932. //      BaseHandler::Plugin::AddRef
  1933. //  Purpose:
  1934. //      Everyone usually implements this the same... feel free to use
  1935. //      this implementation.
  1936. //
  1937. STDMETHODIMP_(ULONG32)
  1938. BaseHandler::Plugin::AddRef()
  1939. {
  1940.     return InterlockedIncrement(&m_lRefCount);
  1941. }
  1943. /////////////////////////////////////////////////////////////////////////
  1944. //  Method:
  1945. //      BaseHandler::Plugin::Release
  1946. //  Purpose:
  1947. //      Everyone usually implements this the same... feel free to use
  1948. //      this implementation.
  1949. //
  1950. STDMETHODIMP_(ULONG32)
  1951. BaseHandler::Plugin::Release()
  1952. {
  1953.     if (InterlockedDecrement(&m_lRefCount) > 0)
  1954.     {
  1955.         return m_lRefCount;
  1956.     }
  1958.     delete this;
  1959.     return 0;
  1960. }
  1963. /**********************************************************************************
  1964. ***     BaseHandler::PluginDLL ***
  1965. ***********************************************************************************/
  1967. BaseHandler::PluginDLL::PluginDLL( const char* pszFileName, PluginMountPoint* pMountPoint,
  1968. BaseHandler* pBaseHandler )
  1969.     : m_fpCreateInstance(NULL)
  1970.     , m_fpShutdown(NULL)
  1971.     , m_fCanUnload(NULL)
  1972.     , m_pMountPoint( pMountPoint )
  1973.     , m_pFileName( NULL )
  1974.     , m_pNamespace( NULL )
  1975.     , m_nSizeBites(0)
  1976.     , m_lRefCount(0)
  1977.     , m_NumOfPlugins(0)
  1978.     , m_pDLLAccess(NULL)
  1979.     , m_bHas_factory(FALSE)
  1980.     , m_bLoaded(FALSE)
  1981.     , m_nActiveReferences(0)
  1982.     , m_pBaseHandler(pBaseHandler)
  1983.     , m_bDoesExist(TRUE)
  1984. {
  1985.     // Always create an IHXBuffer and store the filename there
  1986.     CHXBuffer* pCHXBuffer = new CHXBuffer();
  1987.     if( SUCCEEDED( pCHXBuffer->QueryInterface( IID_IHXBuffer,(void**) &m_pFileName ) ) )
  1988.     {
  1989. if (pszFileName)
  1990. {
  1991.     // Make sure there are no path components in the filename
  1992.     HX_ASSERT( !strrchr( pszFileName, BaseHandler::zm_cDirectorySeperator ) );
  1994.     m_pFileName->Set( (BYTE*) pszFileName, ::strlen( pszFileName ) + 1 );
  1995. }
  1996.     }
  1998.     m_pDLLAccess = new DLLAccess();
  1999. }
  2002. BaseHandler::PluginDLL::~PluginDLL()
  2003. {
  2004.     HX_RELEASE( m_pFileName );
  2005.     HX_RELEASE( m_pNamespace );
  2007.     if (m_pDLLAccess)
  2008.     {
  2009.         if (m_bLoaded)
  2010. {
  2011.     if (m_fpShutdown)
  2012.     {
  2013. m_fpShutdown();
  2014. m_fpShutdown = NULL;
  2015.     }
  2017.     m_pDLLAccess->close();
  2018. }
  2020. delete m_pDLLAccess;
  2021. m_pDLLAccess = 0;
  2022.     }
  2023. }
  2026. BaseHandler::Errors
  2027. BaseHandler::PluginDLL::Load(IUnknown* pContext)
  2028. {
  2029.     HX_LOG_BLOCK( "BaseHandler::PluginDLL::Load()" );
  2031.     Errors result     = NO_ERRORS;
  2033.     IUnknown* pInstance   = NULL;
  2034.     IHXPlugin* pPlugin = NULL;
  2035.     IHXPluginFactory* pIFactory = NULL;
  2038.     if (m_bLoaded)
  2039.     {
  2040. return PLUGIN_ALREADY_HAS_MOUNT_POINT; //XXXAH Huh?
  2041.     }
  2043.     if( m_pFileName->GetSize() <= 1 )
  2044.     {
  2045. return PLUGIN_NOT_FOUND;
  2046.     }
  2048.     // Build complete path for DLL
  2049.     CHXString fileNameWithPath;
  2051. #if !defined(_STATICALLY_LINKED) || defined(HELIX_CONFIG_CONSOLIDATED_CORE)
  2052.     // we're not statically linked so we must use the mount point path
  2053.     IHXBuffer* pBuffer = m_pMountPoint->Path();
  2054.     if (pBuffer)
  2055.     {
  2056. fileNameWithPath = (char*)pBuffer->GetBuffer();
  2057. UINT32 len = fileNameWithPath.GetLength();
  2058. if (len && fileNameWithPath.GetAt(len - 1) != BaseHandler::zm_cDirectorySeperator)
  2059. {
  2060.     fileNameWithPath += BaseHandler::zm_pszDirectorySeperator;
  2061. }
  2062. HX_RELEASE(pBuffer);
  2063.     }
  2064. #endif
  2066.     fileNameWithPath += (char*) m_pFileName->GetBuffer();
  2068.     // 1st load the DLL into memory
  2069.     HX_PRIME_ACCUMULATOR( 'pdll', "Total DLL Load Time" );
  2070.     int dllLoadResult = m_pDLLAccess->open(fileNameWithPath);
  2071.     HX_UPDATE_ACCUMULATOR( 'pdll' );
  2073.     if( dllLoadResult != DLLAccess::DLL_OK )
  2074.     {
  2075. m_pBaseHandler->ReportError( HXLOG_DEBUG, (char *) m_pFileName->GetBuffer(), m_pDLLAccess->getErrorString() );
  2076. return CANT_OPEN_DLL;
  2077.     }
  2079.     HX_LOG_CHECKPOINT( "DLL Loaded" );
  2081.     // Now look for the HXCreateInstance exported function
  2082.     m_fpCreateInstance = (FPCREATEINSTANCE) m_pDLLAccess->getSymbol(HXCREATEINSTANCESTR);
  2083.     if (NULL == m_fpCreateInstance)
  2084.     {
  2085. m_pBaseHandler->ReportError( HXLOG_DEBUG, "NO HXCreateInstance", NULL );
  2086. return NO_HX_CREATE_INSTANCE;
  2087.     }
  2089.     // And look for HXShutdown exported function... not required.
  2090.     m_fpShutdown    = (FPSHUTDOWN) m_pDLLAccess->getSymbol(HXSHUTDOWNSTR);
  2092.     // and look for CanUnload2 exported function
  2093.     //JE 3/26/01: look for CanUnload2 instead of CanUnload. This way we will
  2094.     //not try and unload any DLLs that may have incorrectly implemented the old
  2095.     // CanUnload. If you implement CanUnload2, you better get it right ;)
  2096.     m_fCanUnload    = (FPSHUTDOWN) m_pDLLAccess->getSymbol("CanUnload2");
  2098.     HX_LOG_CHECKPOINT( "Exported symbols found" );
  2100.     // Does this thing support the IHXPlugin Interface
  2101.     // Now we will test to see if the DLL contains multiple Plugins.
  2102.     HX_PRIME_ACCUMULATOR( 'plmk', "Total Plugin Allocation time" );
  2103.     HX_RESULT createResult = m_fpCreateInstance( &pInstance );
  2104.     HX_UPDATE_ACCUMULATOR( 'plmk' );
  2106.     if( HXR_OK != createResult )
  2107.     {
  2108. m_pBaseHandler->ReportError( HXLOG_DEBUG, "HXCreateInstance Failure", NULL );
  2109. result = CREATE_INSTANCHXR_FAILURE;
  2110. goto cleanup;
  2111.     }
  2114.     HX_LOG_CHECKPOINT( "Plugin instance created" );
  2116.     // To be a valid plugin a DLL must support IHXPlugin
  2117.     // In addition, it may support IHXPluginFactory
  2118.     if( SUCCEEDED( pInstance->QueryInterface( IID_IHXPluginFactory, (void**) &pIFactory ) ) )
  2119.     {
  2120. m_bHas_factory = TRUE;
  2121. m_NumOfPlugins = pIFactory->GetNumPlugins();
  2123. HX_RELEASE( pIFactory );
  2124.     }
  2125.     else if( SUCCEEDED( pInstance->QueryInterface( IID_IHXPlugin, (void**) &pPlugin ) ) )
  2126.     {
  2127. m_bHas_factory = FALSE;
  2128. m_NumOfPlugins = 1;
  2130. IHXComponentPlugin* pIPackage = NULL;
  2131. if (SUCCEEDED (pInstance->QueryInterface (IID_IHXComponentPlugin, (void**) &pIPackage)))
  2132. {
  2133. #ifndef _WINDOWS // XXXHP TEMPORARY - viper team has requested that this shouldn't assert for now on windows.
  2134.     HX_ASSERT (m_fpShutdown);
  2135. #endif
  2136.     pPlugin->InitPlugin (pContext);
  2137.     m_packageName = pIPackage->GetPackageName ();
  2138.     HX_RELEASE (pIPackage);
  2139. }
  2141. HX_RELEASE( pPlugin );
  2142.     }
  2143.     else
  2144.     {
  2145. result = BAD_PLUGIN;
  2146. goto cleanup;
  2147.     }
  2149.     // We are now loaded.
  2150.     HX_RELEASE(pInstance);
  2151.     m_bLoaded = TRUE;
  2153. cleanup:
  2155.     HX_LOG_CHECKPOINT( "BaseHandler::PluginDLL::Load() exiting" );
  2157.     return result;
  2158. }
  2161. HX_RESULT BaseHandler::PluginDLL::Unload(BOOL safe)
  2162. {
  2163.     if (m_bLoaded)
  2164.     {
  2165. if (!safe || ( m_fCanUnload && m_fCanUnload()==HXR_OK ) )
  2166. {
  2167.     if (m_fpShutdown)
  2168.     {
  2169. if (FAILED (m_fpShutdown ())) return HXR_FAIL;
  2170. m_fpShutdown = NULL;
  2171.     }
  2173.             if (DLLAccess::DLL_OK == m_pDLLAccess->close())
  2174.     {
  2175. m_bLoaded = FALSE;
  2176. return HXR_OK;
  2177.     }
  2178. }
  2179.     }
  2180.     return HXR_FAIL;
  2181. }
  2183. BOOL BaseHandler::PluginDLL::IsLoaded()
  2184. {
  2185.     return m_bLoaded;
  2186. }
  2188. BaseHandler::Errors BaseHandler::PluginDLL::CreateInstance(IUnknown** ppUnk,
  2189.  UINT32 uIndex)
  2190. {
  2191.     if (!m_bLoaded)
  2192. return PLUGIN_NOT_FOUND;
  2194.     if (!m_bHas_factory)
  2195.     {
  2196. if (HXR_OK != m_fpCreateInstance(ppUnk))
  2197. {
  2198.     return CREATE_INSTANCHXR_FAILURE;
  2199. }
  2200.     }
  2201.     else
  2202.     {
  2203. if (uIndex > (ULONG32)(m_NumOfPlugins-1) && m_NumOfPlugins)
  2204. {
  2205.     return CANT_LOAD_INTERFACE;
  2206. }
  2207. IUnknown* pUnk;
  2208. IHXPluginFactory* pPluginFactory;
  2210. m_fpCreateInstance(&pUnk);
  2211. if (HXR_OK != pUnk->QueryInterface
  2212. (IID_IHXPluginFactory, (void**) &pPluginFactory))
  2213. {
  2214.     HX_RELEASE(pUnk);
  2215.     return CREATE_INSTANCHXR_FAILURE;
  2216. }
  2217. else
  2218. {
  2219.     HX_RELEASE(pUnk);
  2220.     if (HXR_OK != pPluginFactory->GetPlugin((UINT16)uIndex, ppUnk))
  2221.     {
  2222. HX_RELEASE(pPluginFactory);
  2223. return CREATE_INSTANCHXR_FAILURE;
  2224.     }
  2225.     HX_RELEASE(pPluginFactory);
  2226. }
  2227.     }
  2228.     //m_pPlugin2Handler->AddtoLRU(this);
  2229.     //m_pPlugin2Handler->UpdateCache();
  2230.     return NO_ERRORS;
  2231. }
  2233. IHXBuffer* BaseHandler::PluginDLL::GetFileName()
  2234. {
  2235.     m_pFileName->AddRef();
  2236.     return m_pFileName;
  2237. }
  2239. IHXBuffer* BaseHandler::PluginDLL::GetNamespace()
  2240. {
  2241.     if (m_pNamespace)
  2242.     {
  2243. m_pNamespace->AddRef();
  2244.     }
  2246.     return m_pNamespace;
  2247. }
  2249. void BaseHandler::PluginDLL::SetNamespace(IHXBuffer* pNamespace)
  2250. {
  2251.     m_pNamespace = pNamespace;
  2253.     if (m_pNamespace)
  2254.     {
  2255. m_pNamespace->AddRef();
  2256.     }
  2257. }
  2259. UINT32 BaseHandler::PluginDLL::AddDLLReference()
  2260. {
  2261.     return ++m_nActiveReferences;
  2262. }
  2265. UINT32 BaseHandler::PluginDLL::ReleaseDLLReference()
  2266. {
  2267.     --m_nActiveReferences;
  2268.     Unload();     //XXXAH this should only happen if we have set DLL unloading to true.
  2270.     return 0;
  2271. }
  2274. /////////////////////////////////////////////////////////////////////////
  2275. //  Method:
  2276. //      BaseHandler::PluginDLL::QueryInterface
  2277. //  Purpose:
  2278. //      Implement this to export the interfaces supported by your
  2279. //      object.
  2280. //
  2281. STDMETHODIMP
  2282. BaseHandler::PluginDLL::QueryInterface(REFIID riid, void** ppvObj)
  2283. {
  2284.     if (IsEqualIID(riid, IID_IUnknown))
  2285.     {
  2286.         AddRef();
  2287.         *ppvObj = (IUnknown*)this;
  2288.         return HXR_OK;
  2289.     }
  2291.     *ppvObj = NULL;
  2292.     return HXR_NOINTERFACE;
  2293. }
  2295. /////////////////////////////////////////////////////////////////////////
  2296. //  Method:
  2297. //      BaseHandler::PluginDLL::AddRef
  2298. //  Purpose:
  2299. //      Everyone usually implements this the same... feel free to use
  2300. //      this implementation.
  2301. //
  2302. STDMETHODIMP_(ULONG32)
  2303. BaseHandler::PluginDLL::AddRef()
  2304. {
  2305.     return InterlockedIncrement(&m_lRefCount);
  2306. }
  2308. /////////////////////////////////////////////////////////////////////////
  2309. //  Method:
  2310. //      BaseHandler::PluginDLL::Release
  2311. //  Purpose:
  2312. //      Everyone usually implements this the same... feel free to use
  2313. //      this implementation.
  2314. //
  2315. STDMETHODIMP_(ULONG32)
  2316. BaseHandler::PluginDLL::Release()
  2317. {
  2318.     if (InterlockedDecrement(&m_lRefCount) > 0)
  2319.     {
  2320.         return m_lRefCount;
  2321.     }
  2323.     delete this;
  2324.     return 0;
  2325. }
  2328. /**********************************************************************************
  2329. ***     BaseHandler::PluginMountPoint ***
  2330. ***********************************************************************************/
  2332. BaseHandler::PluginMountPoint::PluginMountPoint( BaseHandler* pContext, const char* pName,
  2333.  UINT32 majorVersion, UINT32 minorVersion, IHXBuffer* pPath ) :
  2334.     m_lRefCount( 0 )
  2335. {
  2336. #if !defined(_STATICALLY_LINKED) || defined(HELIX_CONFIG_CONSOLIDATED_CORE)
  2337.     m_pPath = pPath;
  2338.     if (m_pPath)
  2339.     {
  2340. m_pPath->AddRef();
  2341.     }
  2342. #endif
  2343. }
  2346. #if !defined(_STATICALLY_LINKED) || defined(HELIX_CONFIG_CONSOLIDATED_CORE)
  2347. IHXBuffer*
  2348. BaseHandler::PluginMountPoint::Path()
  2349. {
  2350.     if (m_pPath)
  2351.     {
  2352. m_pPath->AddRef();
  2353.     }
  2354.     return m_pPath;
  2355. }
  2356. #endif
  2358. BaseHandler::PluginMountPoint::~PluginMountPoint()
  2359. {
  2360. #if !defined(_STATICALLY_LINKED) || defined(HELIX_CONFIG_CONSOLIDATED_CORE)
  2361.     HX_RELEASE(m_pPath);
  2362. #endif
  2363. }
  2366. STDMETHODIMP_(ULONG32)
  2367. BaseHandler::PluginMountPoint::AddRef()
  2368. {
  2369.     return InterlockedIncrement(&m_lRefCount);
  2370. }
  2373. STDMETHODIMP_(ULONG32)
  2374. BaseHandler::PluginMountPoint::Release()
  2375. {
  2376.     if (InterlockedDecrement(&m_lRefCount) > 0)
  2377.     {
  2378.         return m_lRefCount;
  2379.     }
  2381.     delete this;
  2382.     return 0;
  2383. }
  2385. ///////////////////////////////////////////////////////////////////////////////
  2386. //
  2387. // BaseHandler::CheckDirectory
  2388. //
  2389. ///////////////////////////////////////////////////////////////////////////////
  2391. BaseHandler::Errors BaseHandler::Stat(const char* pszFilename, struct stat* pStatBuffer)
  2392. {
  2393.     CHXString strFileName;
  2395.     memset(pStatBuffer,0,sizeof(*pStatBuffer));
  2396. #if !defined(_STATICALLY_LINKED)
  2397.     if(stat(pszFilename, pStatBuffer) < 0)
  2398. return CANT_OPEN_DLL;
  2399. #endif
  2400.     pStatBuffer->st_atime = 0;
  2401.     return NO_ERRORS ;
  2402. }
  2405. IHXBuffer* BaseHandler::ConvertToAsciiString(char* pBuffer, UINT32 nBuffLen)
  2406. {
  2407.     char* pszOut = new char[nBuffLen*2+1];
  2408.     char* pszStartOut = pszOut;
  2409.     char Nibble;
  2411.     IHXBuffer* pOutBuffer = new CHXBuffer(); // This is the ONLY place where this is done!
  2412.     pOutBuffer->AddRef();
  2414.     for (int i = 0; i<(int)nBuffLen; i++)
  2415.     {
  2416. Nibble = (*pBuffer >> 4) & 15;
  2417. *pszOut= (Nibble > 9 ) ? Nibble+55 : Nibble +48;
  2418. pszOut++;
  2419. Nibble = *pBuffer & 15;
  2420. *pszOut= (Nibble> 9 ) ? Nibble+ 55 : Nibble+48;
  2421. pszOut++;
  2422. pBuffer++;
  2423.     }
  2424.     *pszOut = 0;
  2425.     pOutBuffer->Set((UCHAR*)pszStartOut, strlen(pszStartOut)+1);
  2426.     delete[] pszStartOut;
  2427.     return pOutBuffer;
  2428. }
  2431. IHXBuffer* BaseHandler::ChecksumFile(char* pszFileName, IHXBuffer* pPathBuffer)
  2432. {
  2433.     return ConvertToAsciiString("abc", 3);
  2434. }
  2436. /********************************************************************
  2437. *
  2438. * Plugin Enumeration
  2439. *
  2440. ********************************************************************/
  2442. BEGIN_INTERFACE_LIST_NOCREATE( CPluginEnumerator )
  2443.     INTERFACE_LIST_ENTRY_SIMPLE( IHXPluginSearchEnumerator )
  2444. END_INTERFACE_LIST
  2446. CPluginEnumerator::CPluginEnumerator() :
  2447.     m_nIndex(0)
  2448. {
  2449. }
  2451. CPluginEnumerator::~CPluginEnumerator()
  2452. {
  2453. }
  2456. STDMETHODIMP_( UINT32 )
  2457. CPluginEnumerator::GetNumPlugins()
  2458. {
  2459.     return m_ListOfPlugins.GetCount();
  2460. }
  2462. STDMETHODIMP_( void )
  2463. CPluginEnumerator::GoHead()
  2464. {
  2465.     m_nIndex = 0;
  2466. }
  2469. STDMETHODIMP
  2470. CPluginEnumerator::GetNextPlugin( REF(IUnknown*) pIUnkResult, IUnknown* pIUnkOuter )
  2471. {
  2472.     // Initialize out params
  2473.     pIUnkResult = NULL;
  2475.     HX_RESULT res = GetPluginAt( m_nIndex, pIUnkResult, pIUnkOuter );
  2476.     m_nIndex++;
  2478.     return res;
  2479. }
  2481. STDMETHODIMP
  2482. CPluginEnumerator::GetNextPluginInfo( REF(IHXValues*) pRetValues )
  2483. {
  2484.     // Initialize out params
  2485.     pRetValues = NULL;
  2487.     HX_RESULT res = GetPluginInfoAt( m_nIndex, pRetValues );
  2488.     m_nIndex++;
  2490.     return res;
  2491. }
  2494. STDMETHODIMP
  2495. CPluginEnumerator::GetPluginAt( UINT32 index, REF(IUnknown*) pIUnkResult, IUnknown* pIUnkOuter )
  2496. {
  2497.     // Initialize out params
  2498.     pIUnkResult = NULL;
  2500.     HX_RESULT res = HXR_FAIL;
  2502.     LISTPOSITION pos = m_ListOfPlugins.FindIndex(index);
  2503.     if (pos)
  2504.     {
  2505. BaseHandler::Plugin* pPlugin = (BaseHandler::Plugin*) m_ListOfPlugins.GetAt(pos);
  2506. if (pPlugin)
  2507. {
  2508.     if (BaseHandler::NO_ERRORS == pPlugin->GetInstance( pIUnkResult, pIUnkOuter ))
  2509.     {
  2510. res = HXR_OK;
  2511.     }
  2512. }
  2513.     }
  2514.     return res;
  2515. }
  2518. STDMETHODIMP
  2519. CPluginEnumerator::GetPluginInfoAt( UINT32 index, REF(IHXValues*) pRetValues )
  2520. {
  2521.     // Initialize out params
  2522.     pRetValues = NULL;
  2524.     HX_RESULT res = HXR_FAIL;
  2526.     LISTPOSITION pos = m_ListOfPlugins.FindIndex(m_nIndex);
  2527.     m_nIndex++;
  2528.     if (pos)
  2529.     {
  2530. BaseHandler::Plugin* pPlugin = (BaseHandler::Plugin*) m_ListOfPlugins.GetAt(pos);
  2531. if (pPlugin)
  2532. {
  2533.     res = pPlugin->GetPluginInfo( pRetValues );
  2534. }
  2535.     }
  2537.     return res;
  2538. }
  2541. void CPluginEnumerator::Add(BaseHandler::Plugin* pPlugin)
  2542. {
  2543.     IHXValues*     pPluginValues   = NULL;
  2544.     IHXBuffer*     pBuffer     = NULL;
  2545.     BOOL     bAdded     = FALSE;
  2547.     if (HXR_OK == pPlugin->GetPluginInfo(pPluginValues) && pPluginValues)
  2548.     {
  2549. if (HXR_OK == pPluginValues->GetPropertyCString(PLUGIN_DESCRIPTION2, pBuffer) &&
  2550.     pBuffer)
  2551. {
  2552.     if (strstr((const char*)pBuffer->GetBuffer(), "RealNetworks"))
  2553.     {
  2554. m_ListOfPlugins.AddHead(pPlugin);
  2555. bAdded = TRUE;
  2556.     }
  2557. }
  2558. HX_RELEASE(pBuffer);
  2559.     }
  2560.     if (!bAdded)
  2561.     {
  2562. m_ListOfPlugins.AddTail(pPlugin);
  2563.     }
  2564. }
  2566. HX_RESULT CPluginEnumerator::GetNext(REF(IUnknown*) pRetUnk)
  2567. {
  2568.     pRetUnk = NULL;
  2569.     return GetNextPlugin( pRetUnk, NULL );
  2570. }