dlls/strmbase/dllfunc.c

   1 /*
   2  * Strmbase DLL functions
   3  *
   4  * Copyright (C) 2005 Rolf Kalbermatter
   5  * Copyright (C) 2010 Aric Stewart, CodeWeavers
   6 *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21 #include "config.h"
  22
  23 #include <stdarg.h>
  24 #include <assert.h>
  25
  26 #define COBJMACROS
  27 #define NONAMELESSSTRUCT
  28 #define NONAMELESSUNION
  29
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "wingdi.h"
  33 #include "winerror.h"
  34 #include "winreg.h"
  35 #include "objbase.h"
  36 #include "uuids.h"
  37 #include "strmif.h"
  38
  39 #include "wine/unicode.h"
  40 #include "wine/debug.h"
  41 #include "wine/strmbase.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(strmbase);
  44
  45 extern const int g_cTemplates;
  46 extern const FactoryTemplate g_Templates[];
  47
  48 static HINSTANCE g_hInst = NULL;
  49 static LONG server_locks = 0;
  50
  51 /*
  52  * defines and constants
  53  */
  54 #define MAX_KEY_LEN  260
  55
  56 static const WCHAR clsid_keyname[] = {'C','L','S','I','D',0 };
  57 static const WCHAR ips32_keyname[] = {'I','n','P','r','o','c','S','e','r','v','e','r','3','2',0};
  58 static const WCHAR tmodel_keyname[] = {'T','h','r','e','a','d','i','n','g','M','o','d','e','l',0};
  59 static const WCHAR tmodel_both[] = {'B','o','t','h',0};
  60
  61 /*
  62  * SetupRegisterClass()
  63  */
  64 static HRESULT SetupRegisterClass(HKEY clsid, LPCWSTR szCLSID,
  65                                   LPCWSTR szDescription,
  66                                   LPCWSTR szFileName,
  67                                   LPCWSTR szServerType,
  68                                   LPCWSTR szThreadingModel)
  69 {
  70     HKEY hkey, hsubkey = NULL;
  71     LONG ret = RegCreateKeyW(clsid, szCLSID, &hkey);
  72     if (ERROR_SUCCESS != ret)
  73         return HRESULT_FROM_WIN32(ret);
  74
  75     /* set description string */
  76     ret = RegSetValueW(hkey, NULL, REG_SZ, szDescription,
  77                        sizeof(WCHAR) * (lstrlenW(szDescription) + 1));
  78     if (ERROR_SUCCESS != ret)
  79         goto err_out;
  80
  81     /* create CLSID\\{"CLSID"}\\"ServerType" key, using key to CLSID\\{"CLSID"}
  82        passed back by last call to RegCreateKeyW(). */
  83     ret = RegCreateKeyW(hkey,  szServerType, &hsubkey);
  84     if (ERROR_SUCCESS != ret)
  85         goto err_out;
  86
  87     /* set server path */
  88     ret = RegSetValueW(hsubkey, NULL, REG_SZ, szFileName,
  89                        sizeof(WCHAR) * (lstrlenW(szFileName) + 1));
  90     if (ERROR_SUCCESS != ret)
  91         goto err_out;
  92
  93     /* set threading model */
  94     ret = RegSetValueExW(hsubkey, tmodel_keyname, 0L, REG_SZ,
  95                          (const BYTE*)szThreadingModel,
  96                          sizeof(WCHAR) * (lstrlenW(szThreadingModel) + 1));
  97 err_out:
  98     if (hsubkey)
  99         RegCloseKey(hsubkey);
 100     RegCloseKey(hkey);
 101     return HRESULT_FROM_WIN32(ret);
 102 }
 103
 104 /*
 105  * RegisterAllClasses()
 106  */
 107 static HRESULT SetupRegisterAllClasses(const FactoryTemplate * pList, int num,
 108                                        LPCWSTR szFileName, BOOL bRegister)
 109 {
 110     HRESULT hr = NOERROR;
 111     HKEY hkey;
 112     OLECHAR szCLSID[CHARS_IN_GUID];
 113     LONG i, ret = RegCreateKeyW(HKEY_CLASSES_ROOT, clsid_keyname, &hkey);
 114     if (ERROR_SUCCESS != ret)
 115         return HRESULT_FROM_WIN32(ret);
 116
 117     for (i = 0; i < num; i++, pList++)
 118     {
 119         /* (un)register CLSID and InprocServer32 */
 120         hr = StringFromGUID2(pList->m_ClsID, szCLSID, CHARS_IN_GUID);
 121         if (SUCCEEDED(hr))
 122         {
 123             if (bRegister )
 124                 hr = SetupRegisterClass(hkey, szCLSID,
 125                                         pList->m_Name, szFileName,
 126                                         ips32_keyname, tmodel_both);
 127             else
 128                 hr = RegDeleteTreeW(hkey, szCLSID);
 129         }
 130     }
 131     RegCloseKey(hkey);
 132     return hr;
 133 }
 134
 135 HRESULT WINAPI AMovieSetupRegisterFilter2(const AMOVIESETUP_FILTER *pFilter, IFilterMapper2  *pIFM2, BOOL  bRegister)
 136 {
 137     if (!pFilter)
 138         return S_OK;
 139
 140     if (bRegister)
 141     {
 142         {
 143             REGFILTER2 rf2;
 144             rf2.dwVersion = 1;
 145             rf2.dwMerit = pFilter->merit;
 146             rf2.u.s1.cPins = pFilter->pins;
 147             rf2.u.s1.rgPins = pFilter->pPin;
 148
 149             return IFilterMapper2_RegisterFilter(pIFM2, pFilter->clsid, pFilter->name, NULL, &CLSID_LegacyAmFilterCategory, NULL, &rf2);
 150         }
 151     }
 152     else
 153        return IFilterMapper2_UnregisterFilter(pIFM2, &CLSID_LegacyAmFilterCategory, NULL, pFilter->clsid);
 154 }
 155
 156 HRESULT WINAPI AMovieDllRegisterServer2(BOOL bRegister)
 157 {
 158     HRESULT hr;
 159     int i;
 160     IFilterMapper2 *pIFM2 = NULL;
 161     WCHAR szFileName[MAX_PATH];
 162
 163     if (!GetModuleFileNameW(g_hInst, szFileName, MAX_PATH))
 164     {
 165         ERR("Failed to get module file name for registration\n");
 166         return E_FAIL;
 167     }
 168
 169     if (bRegister)
 170         hr = SetupRegisterAllClasses(g_Templates, g_cTemplates, szFileName, TRUE );
 171
 172     hr = CoInitialize(NULL);
 173
 174     TRACE("Getting IFilterMapper2\r\n");
 175     hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC_SERVER,
 176                           &IID_IFilterMapper2, (void **)&pIFM2);
 177
 178     for (i = 0; SUCCEEDED(hr) && i < g_cTemplates; i++)
 179         hr = AMovieSetupRegisterFilter2(g_Templates[i].m_pAMovieSetup_Filter, pIFM2, bRegister);
 180
 181     /* release interface */
 182     if (pIFM2)
 183         IFilterMapper2_Release(pIFM2);
 184
 185     /* and clear up */
 186     CoFreeUnusedLibraries();
 187     CoUninitialize();
 188
 189     /* if unregistering, unregister all OLE servers */
 190     if (SUCCEEDED(hr) && !bRegister)
 191         hr = SetupRegisterAllClasses(g_Templates, g_cTemplates, szFileName, FALSE);
 192
 193     return hr;
 194 }
 195
 196 /****************************************************************************
 197  * SetupInitializeServers
 198  *
 199  * This function is table driven using the static members of the
 200  * CFactoryTemplate class defined in the Dll.
 201  *
 202  * It calls the initialize function for any class in CFactoryTemplate with
 203  * one defined.
 204  *
 205  ****************************************************************************/
 206 static void SetupInitializeServers(const FactoryTemplate * pList, int num,
 207                             BOOL bLoading)
 208 {
 209     int i;
 210
 211     for (i = 0; i < num; i++, pList++)
 212     {
 213         if (pList->m_lpfnInit)
 214             pList->m_lpfnInit(bLoading, pList->m_ClsID);
 215     }
 216 }
 217
 218 BOOL WINAPI STRMBASE_DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv)
 219 {
 220     switch (fdwReason)
 221     {
 222         case DLL_PROCESS_ATTACH:
 223             g_hInst = hInstDLL;
 224             DisableThreadLibraryCalls(hInstDLL);
 225             SetupInitializeServers(g_Templates, g_cTemplates, TRUE);
 226             break;
 227         case DLL_PROCESS_DETACH:
 228             SetupInitializeServers(g_Templates, g_cTemplates, FALSE);
 229             break;
 230     }
 231     return TRUE;
 232 }
 233
 234 /******************************************************************************
 235  * DLL ClassFactory
 236  */
 237 typedef struct {
 238     IClassFactory ITF_IClassFactory;
 239
 240     LONG ref;
 241     LPFNNewCOMObject pfnCreateInstance;
 242 } IClassFactoryImpl;
 243
 244 static HRESULT WINAPI
 245 DSCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj)
 246 {
 247     IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
 248
 249     if (IsEqualGUID(riid, &IID_IUnknown) ||
 250         IsEqualGUID(riid, &IID_IClassFactory))
 251     {
 252         IClassFactory_AddRef(iface);
 253         *ppobj = This;
 254         return S_OK;
 255     }
 256
 257     WARN("(%p)->(%s,%p), not found\n", This, debugstr_guid(riid), ppobj);
 258     return E_NOINTERFACE;
 259 }
 260
 261 static ULONG WINAPI DSCF_AddRef(LPCLASSFACTORY iface)
 262 {
 263     IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
 264     return InterlockedIncrement(&This->ref);
 265 }
 266
 267 static ULONG WINAPI DSCF_Release(LPCLASSFACTORY iface)
 268 {
 269     IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
 270
 271     ULONG ref = InterlockedDecrement(&This->ref);
 272
 273     if (ref == 0)
 274         HeapFree(GetProcessHeap(), 0, This);
 275
 276     return ref;
 277 }
 278
 279 static HRESULT WINAPI DSCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter,
 280                                           REFIID riid, LPVOID *ppobj)
 281 {
 282     IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
 283     HRESULT hres = ERROR_SUCCESS;
 284     LPUNKNOWN punk;
 285
 286     TRACE("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
 287
 288     if (!ppobj)
 289         return E_POINTER;
 290
 291     /* Enforce the normal OLE rules regarding interfaces and delegation */
 292     if (pOuter && !IsEqualGUID(riid, &IID_IUnknown))
 293         return E_NOINTERFACE;
 294
 295     *ppobj = NULL;
 296     punk = This->pfnCreateInstance(pOuter, &hres);
 297     if (!punk)
 298     {
 299         /* No object created, update error if it isn't done already and return */
 300         if (SUCCEEDED(hres))
 301             hres = E_OUTOFMEMORY;
 302     return hres;
 303     }
 304
 305     if (SUCCEEDED(hres))
 306     {
 307         hres = IUnknown_QueryInterface(punk, riid, ppobj);
 308     }
 309     /* Releasing the object. If everything was successful, QueryInterface
 310        should have incremented the refcount once more, otherwise this will
 311        purge the object. */
 312     IUnknown_Release(punk);
 313     return hres;
 314 }
 315
 316 static HRESULT WINAPI DSCF_LockServer(LPCLASSFACTORY iface, BOOL dolock)
 317 {
 318     IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
 319     TRACE("(%p)->(%d)\n",This, dolock);
 320
 321     if (dolock)
 322         InterlockedIncrement(&server_locks);
 323     else
 324         InterlockedDecrement(&server_locks);
 325     return S_OK;
 326 }
 327
 328 static const IClassFactoryVtbl DSCF_Vtbl =
 329 {
 330     DSCF_QueryInterface,
 331     DSCF_AddRef,
 332     DSCF_Release,
 333     DSCF_CreateInstance,
 334     DSCF_LockServer
 335 };
 336
 337 /***********************************************************************
 338  *    DllGetClassObject
 339  */
 340 HRESULT WINAPI STRMBASE_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
 341 {
 342     const FactoryTemplate *pList = g_Templates;
 343     IClassFactoryImpl *factory;
 344     int i;
 345
 346     TRACE("(%s,%s,%p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
 347
 348     if (!ppv)
 349         return E_POINTER;
 350
 351     *ppv = NULL;
 352
 353     if (!IsEqualGUID(&IID_IClassFactory, riid) &&
 354         !IsEqualGUID(&IID_IUnknown, riid))
 355         return E_NOINTERFACE;
 356
 357     for (i = 0; i < g_cTemplates; i++, pList++)
 358     {
 359         if (IsEqualGUID(pList->m_ClsID, rclsid))
 360             break;
 361     }
 362
 363     if (i == g_cTemplates)
 364     {
 365         char dllname[MAX_PATH];
 366         if (!GetModuleFileNameA(g_hInst, dllname, sizeof(dllname)))
 367             strcpy(dllname, "???");
 368         ERR("%s: no class found in %s.\n", debugstr_guid(rclsid), dllname);
 369         return CLASS_E_CLASSNOTAVAILABLE;
 370     }
 371     else if (!pList->m_lpfnNew)
 372     {
 373         FIXME("%s: class not implemented yet.\n", debugstr_guid(rclsid));
 374         return CLASS_E_CLASSNOTAVAILABLE;
 375     }
 376
 377     factory = HeapAlloc(GetProcessHeap(), 0, sizeof(IClassFactoryImpl));
 378     if (!factory)
 379         return E_OUTOFMEMORY;
 380
 381     factory->ITF_IClassFactory.lpVtbl = &DSCF_Vtbl;
 382     factory->ref = 1;
 383
 384     factory->pfnCreateInstance = pList->m_lpfnNew;
 385
 386     *ppv = &(factory->ITF_IClassFactory);
 387     return S_OK;
 388 }
 389
 390 /***********************************************************************
 391  *    DllCanUnloadNow
 392  */
 393 HRESULT WINAPI STRMBASE_DllCanUnloadNow(void)
 394 {
 395     TRACE("\n");
 396
 397     if (server_locks == 0)
 398         return S_OK;
 399     return S_FALSE;
 400 }