| /* |
| * DirectX DLL registration and unregistration |
| * |
| * Copyright (C) 2005 Rolf Kalbermatter |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| #include "config.h" |
| |
| #include <stdarg.h> |
| #include <assert.h> |
| |
| #define COBJMACROS |
| #define NONAMELESSSTRUCT |
| #define NONAMELESSUNION |
| |
| #include "windef.h" |
| #include "winbase.h" |
| #include "winerror.h" |
| #include "winreg.h" |
| #include "objbase.h" |
| #include "uuids.h" |
| |
| #include "dllsetup.h" |
| |
| #include "wine/unicode.h" |
| #include "wine/debug.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(qcap); |
| |
| /* |
| * defines and constants |
| */ |
| #define MAX_KEY_LEN 260 |
| |
| static WCHAR const clsid_keyname[6] = |
| {'C','L','S','I','D',0 }; |
| static WCHAR const ips32_keyname[15] = |
| {'I','n','P','r','o','c','S','e','r','v','e','r','3','2',0}; |
| static WCHAR const tmodel_keyname[15] = |
| {'T','h','r','e','a','d','i','n','g','M','o','d','e','l',0}; |
| static WCHAR const tmodel_both[] = |
| {'B','o','t','h',0}; |
| |
| /* |
| * Delete a key and all its subkeys |
| */ |
| HRESULT DeleteEntireSubKey(HKEY hkey, LPWSTR strSubKey) |
| { |
| WCHAR buffer[MAX_KEY_LEN]; |
| DWORD dw = MAX_KEY_LEN; |
| FILETIME ft; |
| HKEY hk; |
| LONG ret = RegOpenKeyExW(hkey, strSubKey, 0, MAXIMUM_ALLOWED, &hk); |
| |
| if (ERROR_SUCCESS == ret) |
| { |
| /* Keep on enumerating the first key and deleting that */ |
| for( ; ; ) |
| { |
| dw = MAX_KEY_LEN; |
| |
| ret = RegEnumKeyExW(hk, 0, buffer, &dw, NULL, NULL, NULL, &ft); |
| |
| if (ERROR_SUCCESS == ret) |
| DeleteEntireSubKey(hk, buffer); |
| else |
| break; |
| } |
| RegCloseKey(hk); |
| RegDeleteKeyW(hkey, strSubKey); |
| } |
| return NOERROR; |
| } |
| |
| /* |
| * SetupRegisterClass() |
| */ |
| static HRESULT SetupRegisterClass(HKEY clsid, LPCWSTR szCLSID, |
| LPCWSTR szDescription, |
| LPCWSTR szFileName, |
| LPCWSTR szServerType, |
| LPCWSTR szThreadingModel) |
| { |
| HKEY hkey, hsubkey; |
| LONG ret = RegCreateKeyW(clsid, szCLSID, &hkey); |
| if (ERROR_SUCCESS != ret) |
| return HRESULT_FROM_WIN32(ret); |
| |
| /* set description string */ |
| ret = RegSetValueW(hkey, NULL, REG_SZ, szDescription, |
| sizeof(WCHAR) * (lstrlenW(szDescription) + 1)); |
| if (ERROR_SUCCESS != ret) |
| goto err_out; |
| |
| /* create CLSID\\{"CLSID"}\\"ServerType" key, using key to CLSID\\{"CLSID"} |
| passed back by last call to RegCreateKeyW(). */ |
| ret = RegCreateKeyW(hkey, szServerType, &hsubkey); |
| if (ERROR_SUCCESS != ret) |
| goto err_out; |
| |
| /* set server path */ |
| ret = RegSetValueW(hsubkey, NULL, REG_SZ, szFileName, |
| sizeof(WCHAR) * (lstrlenW(szFileName) + 1)); |
| if (ERROR_SUCCESS != ret) |
| goto err_out; |
| |
| /* set threading model */ |
| ret = RegSetValueExW(hsubkey, tmodel_keyname, 0L, REG_SZ, |
| (const BYTE*)szThreadingModel, |
| sizeof(WCHAR) * (lstrlenW(szThreadingModel) + 1)); |
| err_out: |
| if (hsubkey) |
| RegCloseKey(hsubkey); |
| RegCloseKey(hkey); |
| return HRESULT_FROM_WIN32(ret); |
| } |
| |
| /* |
| * SetupRegisterFilter through IFilterMapper2 |
| */ |
| static HRESULT SetupRegisterFilter2(const AMOVIESETUP_FILTER * const pSetup, |
| IFilterMapper2 * pIFM2, BOOL bRegister) |
| { |
| HRESULT hr; |
| |
| if (NULL == pSetup) |
| return S_FALSE; |
| |
| /* unregister filter */ |
| hr = IFilterMapper2_UnregisterFilter(pIFM2, 0, 0, pSetup->clsID); |
| |
| if (bRegister) |
| { |
| REGFILTER2 rf2; |
| rf2.dwVersion = 1; |
| rf2.dwMerit = pSetup->dwMerit; |
| rf2.u.s.cPins = pSetup->nPins; |
| rf2.u.s.rgPins = pSetup->lpPin; |
| |
| /* register filter */ |
| hr = IFilterMapper2_RegisterFilter(pIFM2, pSetup->clsID, |
| pSetup->strName, 0, 0, NULL, &rf2); |
| } |
| else |
| { |
| /* filter not found is ignored here, |
| but there is no #define for 0x80070002 */ |
| if (HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) == hr) |
| hr = NOERROR; |
| } |
| return hr; |
| } |
| |
| /* |
| * SetupRegisterFilter through IFilterMapper |
| */ |
| static HRESULT SetupRegisterFilter(const AMOVIESETUP_FILTER * const pSetup, |
| IFilterMapper * pIFM, BOOL bRegister) |
| { |
| HRESULT hr; |
| |
| if (NULL == pSetup) |
| return S_FALSE; |
| |
| /* unregister filter */ |
| hr = IFilterMapper_UnregisterFilter(pIFM, *pSetup->clsID); |
| |
| if (bRegister) |
| { |
| /* register filter */ |
| hr = IFilterMapper_RegisterFilter(pIFM, *pSetup->clsID, |
| pSetup->strName, pSetup->dwMerit); |
| if (SUCCEEDED(hr)) |
| { |
| const AMOVIESETUP_PIN *lpPin = pSetup->lpPin; |
| const AMOVIESETUP_MEDIATYPE *lpType; |
| UINT i, j; |
| |
| for (i = 0; i < pSetup->nPins; i++, lpPin++) |
| { |
| hr = IFilterMapper_RegisterPin(pIFM, *(pSetup->clsID), |
| lpPin->strName, |
| lpPin->bRendered, |
| lpPin->bOutput, |
| lpPin->bZero, |
| lpPin->bMany, |
| *(lpPin->clsConnectsToFilter), |
| lpPin->strConnectsToPin); |
| |
| if (SUCCEEDED(hr)) |
| { |
| lpType = lpPin->lpMediaType; |
| |
| /* and each pin's media types */ |
| for (j = 0; j < lpPin->nMediaTypes; j++, lpType++) |
| { |
| hr = IFilterMapper_RegisterPinType(pIFM, *(pSetup->clsID), |
| lpPin->strName, |
| *(lpType->clsMajorType), |
| *(lpType->clsMinorType)); |
| if (FAILED(hr)) break; |
| } |
| if (FAILED(hr)) break; |
| } |
| if (FAILED(hr)) break; |
| } |
| } |
| } |
| else |
| { |
| /* filter not registered is ignored here, there is no definition for 0x80070002 */ |
| if (HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) == hr) |
| hr = NOERROR; |
| } |
| return hr; |
| } |
| |
| /* |
| * RegisterAllClasses() |
| */ |
| static HRESULT SetupRegisterAllClasses(const CFactoryTemplate * pList, int num, |
| LPCWSTR szFileName, BOOL bRegister) |
| { |
| HRESULT hr = NOERROR; |
| HKEY hkey; |
| OLECHAR szCLSID[CHARS_IN_GUID]; |
| LONG i, ret = RegCreateKeyW(HKEY_CLASSES_ROOT, clsid_keyname, &hkey); |
| if (ERROR_SUCCESS != ret) |
| return HRESULT_FROM_WIN32(ret); |
| |
| for (i = 0; i < num; i++, pList++) |
| { |
| /* (un)register CLSID and InprocServer32 */ |
| hr = StringFromGUID2(pList->m_ClsID, szCLSID, CHARS_IN_GUID); |
| if (SUCCEEDED(hr)) |
| { |
| if (bRegister ) |
| hr = SetupRegisterClass(hkey, szCLSID, |
| pList->m_Name, szFileName, |
| ips32_keyname, tmodel_both); |
| else |
| hr = DeleteEntireSubKey(hkey, szCLSID); |
| } |
| } |
| RegCloseKey(hkey); |
| return hr; |
| } |
| |
| |
| /**************************************************************************** |
| * SetupRegisterServers |
| * |
| * This function is table driven using the static members of the |
| * CFactoryTemplate class defined in the Dll. |
| * |
| * It registers the Dll as the InprocServer32 for all the classes in |
| * CFactoryTemplate |
| * |
| ****************************************************************************/ |
| HRESULT SetupRegisterServers(const CFactoryTemplate * pList, int num, |
| HINSTANCE hinst, BOOL bRegister) |
| { |
| HRESULT hr = NOERROR; |
| WCHAR szFileName[MAX_PATH]; |
| IFilterMapper2 *pIFM2 = NULL; |
| IFilterMapper *pIFM = NULL; |
| |
| /* Win95 wouldn't support the Unicode version of this API!! */ |
| if (!GetModuleFileNameW(hinst, szFileName, MAX_PATH)) |
| return HRESULT_FROM_WIN32(GetLastError()); |
| |
| /* first register all server classes, just to make sure */ |
| if (bRegister) |
| hr = SetupRegisterAllClasses(pList, num, szFileName, TRUE ); |
| |
| /* next, register/unregister all filters */ |
| if (SUCCEEDED(hr)) |
| { |
| hr = CoInitialize(NULL); |
| |
| TRACE("Getting IFilterMapper2\r\n"); |
| hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC_SERVER, |
| &IID_IFilterMapper2, (void **)&pIFM2); |
| if (FAILED(hr)) |
| { |
| TRACE("- trying IFilterMapper instead\r\n"); |
| |
| hr = CoCreateInstance(&CLSID_FilterMapper, NULL, CLSCTX_INPROC_SERVER, |
| &IID_IFilterMapper, (void **)&pIFM); |
| } |
| |
| if (SUCCEEDED(hr)) |
| { |
| int i; |
| |
| /* scan through array of CFactoryTemplates registering all filters */ |
| for (i = 0; i < num; i++, pList++) |
| { |
| if (NULL != pList->m_pAMovieSetup_Filter) |
| { |
| if (pIFM2) |
| hr = SetupRegisterFilter2(pList->m_pAMovieSetup_Filter, |
| pIFM2, bRegister); |
| else |
| hr = SetupRegisterFilter(pList->m_pAMovieSetup_Filter, |
| pIFM, bRegister); |
| } |
| |
| /* check final error for this pass and break loop if we failed */ |
| if (FAILED(hr)) |
| break; |
| } |
| |
| /* release interface */ |
| if (pIFM2) |
| IFilterMapper2_Release(pIFM2); |
| else |
| IFilterMapper_Release(pIFM); |
| } |
| |
| /* and clear up */ |
| CoFreeUnusedLibraries(); |
| CoUninitialize(); |
| } |
| |
| /* if unregistering, unregister all OLE servers */ |
| if (SUCCEEDED(hr) && !bRegister) |
| hr = SetupRegisterAllClasses(pList, num, szFileName, FALSE); |
| return hr; |
| } |
| |
| /**************************************************************************** |
| * SetupInitializeServers |
| * |
| * This function is table driven using the static members of the |
| * CFactoryTemplate class defined in the Dll. |
| * |
| * It calls the intialize function for any class in CFactoryTemplate with |
| * one defined. |
| * |
| ****************************************************************************/ |
| void SetupInitializeServers(const CFactoryTemplate * pList, int num, |
| BOOL bLoading) |
| { |
| int i; |
| |
| for (i = 0; i < num; i++, pList++) |
| { |
| if (pList->m_lpfnInit) |
| pList->m_lpfnInit(bLoading, pList->m_ClsID); |
| } |
| } |
