plghand2.cpp

linux下的一款播放器

//------------------------------------ IHXPluginDatabase interface methods


STDMETHODIMP
Plugin2Handler::AddPluginIndex( THIS_ const char* pKeyName, EPluginIndexType indexType, BOOL bScanExisting )
{
    HX_LOG_BLOCK( "Plugin2Handler::AddPluginIndex" );

    HX_RESULT result = HXR_FAIL;

    CPluginDatabaseIndex* pNewIndex = CPluginDatabaseIndex::CreateIndex( indexType );
    if( pNewIndex )
    {
	m_dbIndices.SetAt( pKeyName, pNewIndex );

	if( bScanExisting )
	{
	    // XXXND FIX  Scan the existing plugins and add them to this index
	}

	result = HXR_OK;
    }


    return result;
}


STDMETHODIMP
Plugin2Handler::RemovePluginIndex( THIS_ const char* pKeyName )
{
    HX_RESULT result = HXR_UNEXPECTED;

    CPluginDatabaseIndex* pIndex = FindDBIndex( pKeyName );
    if( pIndex )
    {
	if( !m_dbIndices.RemoveKey( pKeyName ) )
	{
	    result = HXR_FAIL;
	}
	else
	{
	    HX_DELETE( pIndex );
	    result = HXR_OK;
	}
    }

    return result;
}


STDMETHODIMP
Plugin2Handler::FindPluginInfoViaIndex( THIS_ const char* pKeyName, const void* pValue, IHXValues** ppIInfo )
{
    HX_RESULT result = HXR_INVALID_PARAMETER;

    if( ppIInfo )
    {
	result = HXR_FAIL;
	*ppIInfo = NULL;

	CPluginDatabaseIndex* pIndex = FindDBIndex( pKeyName );
	if( pIndex )
	{
	    IUnknown* pIUnk = NULL;
	    if( SUCCEEDED( pIndex->FindItem( pValue, &pIUnk ) ) )
	    {
		Plugin2Handler::Plugin* pPlugin = (Plugin2Handler::Plugin*) pIUnk;
		if( SUCCEEDED( result = pPlugin->GetPluginInfo( *ppIInfo ) ) )
		{
		    // Since GetPluginInfo() doesn't addref, we have to here.
		    (*ppIInfo)->AddRef();
		}

		HX_RELEASE( pIUnk );
	    }
	}
    }

    return result;
}


STDMETHODIMP
Plugin2Handler::FindPluginSetViaIndex( THIS_ const char* pKeyName, const void* pValue, IHXPluginSearchEnumerator** ppIEnumerator )
{
    // XXXND  Implement this
    *ppIEnumerator = NULL;
    return HXR_NOTIMPL;
}


STDMETHODIMP
Plugin2Handler::CreatePluginViaIndex( THIS_ const char* pKeyName, const void* pValue, IUnknown** ppIUnkPlugin, IUnknown* pIUnkOuter )
{
    HX_RESULT result = HXR_INVALID_PARAMETER;

    if( ppIUnkPlugin )
    {
	result = HXR_FAIL;
	*ppIUnkPlugin = NULL;

	CPluginDatabaseIndex* pIndex = FindDBIndex( pKeyName );
	if( pIndex )
	{
	    IUnknown* pIUnk = NULL;
	    if( SUCCEEDED( pIndex->FindItem( pValue, &pIUnk ) ) )
	    {
		Plugin2Handler::Plugin* pPlugin = (Plugin2Handler::Plugin*) pIUnk;
		if( NO_ERRORS == pPlugin->GetInstance( *ppIUnkPlugin, pIUnkOuter ) )
		{
		    result = HXR_OK;
		}

		HX_RELEASE( pIUnk );
	    }
	}
    }

    return result;
}

STDMETHODIMP
Plugin2Handler::UnloadPluginFromClassID(REFGUID GUIDClassID)
{
    HX_RESULT res = HXR_FAIL;

    CPluginDatabaseIndex* pIndex = FindDBIndex( PLUGIN_COMPONENT_CLSID );
    if( pIndex )
    {
	IUnknown* pIUnk = NULL;
	if( SUCCEEDED( pIndex->FindItem( &GUIDClassID, &pIUnk ) ) )
	{
	    Plugin2Handler::Plugin* pPlugin = (Plugin2Handler::Plugin*) pIUnk;
	    if(pPlugin->GetDLL())
	    {
		res = pPlugin->GetDLL()->Unload();
	    }
	    HX_RELEASE( pIUnk );
	}
    }

    return res;
}

STDMETHODIMP
Plugin2Handler::UnloadPackageByName(const char* pName)
{
    if (!pName)
	return HXR_INVALID_PARAMETER;

    for (CHXSimpleList::Iterator i = m_PluginDLLList.Begin(); i != m_PluginDLLList.End(); ++i)
    {
	PluginDLL* pPluginDLL = (PluginDLL*) *i;
	if (pPluginDLL->GetPackageName() == pName)
	{
	    return pPluginDLL->Unload(FALSE);
	}
    }

    return HXR_FAIL;
}


//------------------------------------ Class Methods


HX_RESULT Plugin2Handler::FindImplementationFromClassIDInternal(
					    REFGUID GUIDClassID,
					    REF(IUnknown*) pIUnknownInstance,
					    IUnknown* pContext )
{
    // Initialize out params
    pIUnknownInstance = NULL;

    HX_RESULT HX_RESULTThis = HXR_OK;
    UINT32 ulNumClassFactories = 0;
    UINT32 ulCurrentClassFactory = 0;
    UINT32 ulCurrentClassFactoryIndex = 0;
    IUnknown* pIUnknownClassFactoryCurrent = NULL;
    IHXCommonClassFactory* pIHXCommonClassFactoryCurrent = NULL;
    IHXPlugin* pIHXPluginCurrent = NULL;
    IHXObjectConfiguration* pIHXObjectConfigurationCurrent = NULL;

   AddSupportedIID(IID_IHXCommonClassFactory);

    HX_RESULTThis = GetNumPluginsSupporting( IID_IHXCommonClassFactory, ulNumClassFactories );

    if( SUCCEEDED(HX_RESULTThis) && ulNumClassFactories > 0 )
    {
	for( ulCurrentClassFactory = 0, ulCurrentClassFactoryIndex = 0;
		ulCurrentClassFactoryIndex < ulNumClassFactories; ++ulCurrentClassFactoryIndex )
	{
	    HX_RESULTThis = GetPluginIndexSupportingIID( IID_IHXCommonClassFactory,
							    ulCurrentClassFactoryIndex,
							    ulCurrentClassFactory );

	    // Create an instance of the plugin at the index ulCurrentClassFactory
	    if( SUCCEEDED(HX_RESULTThis) )
	    {
		HX_RESULTThis = GetInstance( ulCurrentClassFactory, pIUnknownClassFactoryCurrent );
	    }

	    // If we got a plugin, see if we can get the correct object from it.
	    if( SUCCEEDED(HX_RESULTThis) && pIUnknownClassFactoryCurrent )
	    {
		// Initialize the plugin either through IHXPlugin or IHXObjectConfiguration
		if( SUCCEEDED( pIUnknownClassFactoryCurrent->QueryInterface( IID_IHXPlugin,
									    (void**)&pIHXPluginCurrent ) )
									    && pIHXPluginCurrent )
		{
		    pIHXPluginCurrent->InitPlugin( pContext );
		}
		HX_RELEASE(pIHXPluginCurrent);

		if( SUCCEEDED( pIUnknownClassFactoryCurrent->QueryInterface( IID_IHXObjectConfiguration,
									    (void**)&pIHXObjectConfigurationCurrent ) )
									    && pIHXObjectConfigurationCurrent )
		{
		    pIHXObjectConfigurationCurrent->SetContext( pContext );
		}
		HX_RELEASE(pIHXObjectConfigurationCurrent);


		// Now that it's initialized, get the IHXCommonClassFactory interface
		HX_RESULTThis = pIUnknownClassFactoryCurrent->QueryInterface( IID_IHXCommonClassFactory,
									    (void**)&pIHXCommonClassFactoryCurrent );
	    }

	    HX_RELEASE(pIUnknownClassFactoryCurrent);


	    // We have IHXCommonClassFactory on an intialized plugin.
	    // See if it can create the object we want
	    if( SUCCEEDED(HX_RESULTThis) && pIHXCommonClassFactoryCurrent )
	    {
		HX_RESULTThis = pIHXCommonClassFactoryCurrent->CreateInstance( GUIDClassID, (void **)&pIUnknownInstance );
	    }

	    HX_RELEASE(pIHXCommonClassFactoryCurrent);

	    // Check to see if CreateInstance succeeded.  If so, this is the plugin we want
	    if( SUCCEEDED(HX_RESULTThis) && pIUnknownInstance )
	    {
		// got It!
		break;
	    }

	    // If CreateInstance allocated something, but returned a failure code, clean up
	    HX_RELEASE(pIUnknownInstance);
	}
    }
    else
    {
	// there are no Class factories.
	HX_RESULTThis = HXR_FAIL;
    }

    return HX_RESULTThis;
}




HX_RESULT Plugin2Handler::RefreshPluginInfo( PluginMountPoint* pMountPoint )
{
    HX_LOG_BLOCK( "Plugin2Handler::RefreshPluginInfo" );

    HX_RESULT result = HXR_FAIL;

    IHXPreferences* pIPrefs = pMountPoint->Prefs();

    if( pIPrefs )
    {
	if( zm_bFasterPrefs )
	{
	    result = ReadPluginInfoFast( pMountPoint );
	}
	else
	{
	    result = ReadPluginInfoSlow( pMountPoint );
	}
    }

    if (FAILED (result))
    {
	result = ClearMountPoint_ (pMountPoint);
    }

    if( !pIPrefs || SUCCEEDED( result ) )
	result = ReloadPluginsNoPropagate( pMountPoint );

    HX_RELEASE( pIPrefs );

    return result;
}

HX_RESULT Plugin2Handler::ClearMountPoint_ (PluginMountPoint* pMountPoint)
{
    HX_LOG_BLOCK( "Plugin2Handler::ClearMountPoint_" );

    IHXPreferences* pIPrefs = pMountPoint->Prefs();
    REQUIRE_RETURN_QUIET (pIPrefs, HXR_FAIL);

    IHXPreferences3* pIPrefs3 = NULL;
    if (FAILED (pIPrefs->QueryInterface(IID_IHXPreferences3, (void**)&pIPrefs3)))
    {
	HX_RELEASE (pIPrefs);
	return HXR_FAIL;
    }

    char szRegKey[255]; /* Flawfinder: ignore */

    // delete file info
    SafeStrCpy(szRegKey,  PLUGIN_REGKEY_ROOT, 255);
    SafeStrCat(szRegKey,  zm_pszRegKeySeperator, 255);
    SafeStrCat(szRegKey,  PLUGIN_FILENAMES, 255);

    DeleteHugePref_ (pIPrefs, pIPrefs3, szRegKey);

    // delete plugin info
    SafeStrCpy(szRegKey,  PLUGIN_REGKEY_ROOT, 255);
    SafeStrCat(szRegKey,  zm_pszRegKeySeperator, 255);
    SafeStrCat(szRegKey,  PLUGIN_PLUGININFO, 255);

    DeleteHugePref_ (pIPrefs, pIPrefs3, szRegKey);

    // delete guid info
    SafeStrCpy(szRegKey,  PLUGIN_REGKEY_ROOT, 255);
    SafeStrCat(szRegKey,  zm_pszRegKeySeperator, 255);
    SafeStrCat(szRegKey,  PLUGIN_GUIDINFO, 255);

    DeleteHugePref_ (pIPrefs, pIPrefs3, szRegKey);

    // delete non RMA plugin info
    SafeStrCpy(szRegKey,  PLUGIN_REGKEY_ROOT, 255);
    SafeStrCat(szRegKey,  zm_pszRegKeySeperator, 255);
    SafeStrCat(szRegKey,  PLUGIN_NONHXINFO, 255);

    DeleteHugePref_ (pIPrefs, pIPrefs3, szRegKey);

    HX_RELEASE (pIPrefs);
    HX_RELEASE (pIPrefs3);

    return HXR_OK;
}

void Plugin2Handler::DeleteHugePref_ (IHXPreferences* pIPrefs, IHXPreferences3* pIPrefs3, const char* pszKeyName)
{
    HX_LOG_BLOCK( "Plugin2Handler::DeleteHugePref_" );

    char szNewKeyName [1024]; /* Flawfinder: ignore */
    char szNumber [16]; /* Flawfinder: ignore */
    IHXBuffer* pIBuffer = NULL;

    for (int i = 0; ; ++i)
    {
	SafeStrCpy(szNewKeyName,  pszKeyName, 1024);
	sprintf (szNumber, "%d", i); /* Flawfinder: ignore */
	SafeStrCat(szNewKeyName,  szNumber, 1024);

        // unfortunately delete pref doesn't give us the return value we want so we will read the prefs for now to
	// determine if they are there.
	if (FAILED (pIPrefs->ReadPref (szNewKeyName, pIBuffer))) break;

        LogRegistryRegeneration_ (szNewKeyName, pIBuffer);

	HX_RELEASE (pIBuffer);
	pIPrefs3->DeletePref (szNewKeyName);
    }
}

HX_RESULT Plugin2Handler::WritePluginInfo( PluginMountPoint* pMountPoint )
{
    HX_LOG_BLOCK( "Plugin2Handler::WritePluginInfo" );

    HX_RESULT result = HXR_FAIL;

    IHXPreferences* pIPrefs = pMountPoint->Prefs();
    if( pIPrefs )
    {
	if( zm_bFasterPrefs )
	{
	    result = WritePluginInfoFast( pMountPoint );
	}
	else
	{
	    result = WritePluginInfoSlow( pMountPoint );
	}
    }

    HX_RELEASE( pIPrefs );

    return result;
}


HX_RESULT Plugin2Handler::ReadPluginInfoFast( PluginMountPoint* pMountPoint )
{
    HX_LOG_BLOCK( "Plugin2Handler::ReadPluginInfoFast" );

    /*
    *	Code to read from the preferences in one big chunk since
    *   it seems that using many readable preferences is not efficient
    *	on either windows or on macintosh.
    */
    IHXPreferences* pIPrefs = pMountPoint->Prefs();
    if( !pIPrefs )
    {
	// If there are no prefs, there's nothing to read
	return HXR_OK;
    }
    IHXBuffer* pIPathBuffer = pMountPoint->Path();
    if( !pIPathBuffer )
    {
	HX_RELEASE( pIPrefs );

	return HXR_FAIL;
    }


    char szRegKey[255]; /* Flawfinder: ignore */
    SafeStrCpy(szRegKey,  PLUGIN_REGKEY_ROOT, 255);
    SafeStrCat(szRegKey,  zm_pszRegKeySeperator, 255);
    SafeStrCat(szRegKey,  PLUGIN_FILENAMES, 255);

    /*
     *  Get the DLL info.
     */

    HX_LOG_CHECKPOINT( "Get DLL info" );

    IHXBuffer*	    pInfo = NULL;
    if (HXR_OK == ReadHugePref( pIPrefs, szRegKey, pInfo))
    {
	// the string is defined as follows:
	// {name, checksum, BOOL has factory, size, INT numplugins}{ditto}checksum
	char*	pszName = NULL;
	char*	pszCheckSum = NULL;
	BOOL	bFactory = FALSE;
	int	nDLLSize = 0, nNumberPlugins = 0;

	char* pszCurrentPos = (char*) pInfo->GetBuffer();
	if (FAILED (VerifyChecksum_ (pszCurrentPos)))
	{
	    HX_RELEASE(pIPathBuffer);
	    HX_RELEASE(pIPrefs);
	    HX_RELEASE(pInfo);
#ifdef _WINDOWS
	    HX_ASSERT (!"Plugin handler data is corrupt. Regenerating data.");
#endif
	    return HXR_FAIL;
	}

	while( GetPluginFileInfo( pszCurrentPos, pszName, pszCheckSum, bFactory, nDLLSize, nNumberPlugins ) )
	{
	    // validate the plugin by comparing the hash of the
	    // stats info to the one stored in memory.
	    IHXBuffer* pNewChecksum;
	    pNewChecksum = ChecksumFile(pszName, pIPathBuffer);

	    if( pNewChecksum && (!strcasecmp((const char*)pNewChecksum->GetBuffer(), pszCheckSum)))
	    {
		Plugin2Handler::PluginDLL* pDLL = ne