dll/win32/shdocvw/shlinstobj.c

   1 /*
   2  * Shell Instance Objects - Add hot water and stir until dissolved.
   3  *
   4  * Copyright 2005 Michael Jung
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 /* 'Shell Instance Objects' allow you to add a node to the shell namespace
  22  * (typically a shortcut to some location in the filesystem), just by setting
  23  * some registry entries. This feature was introduced with win2k. Please
  24  * search for 'Shell Instance Objects' on MSDN to get more information. */
  25
  26 #include <stdarg.h>
  27
  28 #define COBJMACROS
  29
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "winreg.h"
  33 #include "objbase.h"
  34 #include "oleauto.h"
  35
  36 #include "shdocvw.h"
  37
  38 #include "wine/unicode.h"
  39 #include "wine/debug.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(shdocvw);
  42
  43 #define ADJUST_THIS(c,m,p) ((c*)(((long)p)-(long)&(((c*)0)->lp##m##Vtbl)))
  44 #define STATIC_CAST(i,p) ((i*)&p->lp##i##Vtbl)
  45 #define CHARS_IN_GUID 39
  46
  47 /******************************************************************************
  48  * RegistryPropertyBag
  49  *
  50  * Gives access to a registry key's values via the IPropertyBag interface.
  51  */
  52 typedef struct _RegistryPropertyBag {
  53     const IPropertyBagVtbl *lpIPropertyBagVtbl;
  54     LONG                   m_cRef;
  55     HKEY                   m_hInitPropertyBagKey;
  56 } RegistryPropertyBag;
  57
  58 static void RegistryPropertyBag_Destroy(RegistryPropertyBag *This) {
  59     TRACE("This=%p)\n", This);
  60
  61     RegCloseKey(This->m_hInitPropertyBagKey);
  62     heap_free(This);
  63 }
  64
  65 static HRESULT WINAPI RegistryPropertyBag_IPropertyBag_QueryInterface(IPropertyBag *iface,
  66     REFIID riid, void **ppv)
  67 {
  68     RegistryPropertyBag *This = ADJUST_THIS(RegistryPropertyBag, IPropertyBag, iface);
  69
  70     TRACE("(iface=%p, riid=%s, ppv=%p)\n", iface, debugstr_guid(riid), ppv);
  71
  72     if (!ppv)
  73         return E_INVALIDARG;
  74
  75     if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IPropertyBag, riid)) {
  76         *ppv = STATIC_CAST(IPropertyBag, This);
  77     } else {
  78         *ppv = NULL;
  79         return E_NOINTERFACE;
  80     }
  81
  82     IUnknown_AddRef((IUnknown*)*ppv);
  83     return S_OK;
  84 }
  85
  86 static ULONG WINAPI RegistryPropertyBag_IPropertyBag_AddRef(IPropertyBag *iface) {
  87     RegistryPropertyBag *This = ADJUST_THIS(RegistryPropertyBag, IPropertyBag, iface);
  88     ULONG cRef;
  89
  90     TRACE("(iface=%p)\n", iface);
  91
  92     cRef = InterlockedIncrement(&This->m_cRef);
  93
  94     if (cRef == 1)
  95         SHDOCVW_LockModule();
  96
  97     return cRef;
  98 }
  99
 100 static ULONG WINAPI RegistryPropertyBag_IPropertyBag_Release(IPropertyBag *iface) {
 101     RegistryPropertyBag *This = ADJUST_THIS(RegistryPropertyBag, IPropertyBag, iface);
 102     ULONG cRef;
 103
 104     TRACE("(iface=%p)\n", iface);
 105
 106     cRef = InterlockedDecrement(&This->m_cRef);
 107
 108     if (cRef == 0) {
 109         RegistryPropertyBag_Destroy(This);
 110         SHDOCVW_UnlockModule();
 111     }
 112
 113     return cRef;
 114 }
 115
 116 static HRESULT WINAPI RegistryPropertyBag_IPropertyBag_Read(IPropertyBag *iface,
 117     LPCOLESTR pwszPropName, VARIANT *pVar, IErrorLog *pErrorLog)
 118 {
 119     RegistryPropertyBag *This = ADJUST_THIS(RegistryPropertyBag, IPropertyBag, iface);
 120     WCHAR *pwszValue;
 121     DWORD dwType, cbData;
 122     LONG res;
 123     VARTYPE vtDst = V_VT(pVar);
 124     HRESULT hr = S_OK;
 125
 126     TRACE("(iface=%p, pwszPropName=%s, pVar=%p, pErrorLog=%p)\n", iface, debugstr_w(pwszPropName),
 127           pVar, pErrorLog);
 128
 129     res = RegQueryValueExW(This->m_hInitPropertyBagKey, pwszPropName, NULL, &dwType, NULL, &cbData);
 130     if (res != ERROR_SUCCESS)
 131         return E_INVALIDARG;
 132
 133     pwszValue = heap_alloc(cbData);
 134     if (!pwszValue)
 135         return E_OUTOFMEMORY;
 136
 137     res = RegQueryValueExW(This->m_hInitPropertyBagKey, pwszPropName, NULL, &dwType,
 138                            (LPBYTE)pwszValue, &cbData);
 139     if (res != ERROR_SUCCESS) {
 140         heap_free(pwszValue);
 141         return E_INVALIDARG;
 142     }
 143
 144     V_VT(pVar) = VT_BSTR;
 145     V_BSTR(pVar) = SysAllocString(pwszValue);
 146     heap_free(pwszValue);
 147
 148     if (vtDst != VT_BSTR) {
 149         hr = VariantChangeTypeEx(pVar, pVar, LOCALE_SYSTEM_DEFAULT, 0, vtDst);
 150         if (FAILED(hr))
 151             SysFreeString(V_BSTR(pVar));
 152     }
 153
 154     return hr;
 155 }
 156
 157 static HRESULT WINAPI RegistryPropertyBag_IPropertyBag_Write(IPropertyBag *iface,
 158     LPCOLESTR pwszPropName, VARIANT *pVar)
 159 {
 160     FIXME("(iface=%p, pwszPropName=%s, pVar=%p) stub\n", iface, debugstr_w(pwszPropName), pVar);
 161     return E_NOTIMPL;
 162 }
 163
 164 static const IPropertyBagVtbl RegistryPropertyBag_IPropertyBagVtbl = {
 165     RegistryPropertyBag_IPropertyBag_QueryInterface,
 166     RegistryPropertyBag_IPropertyBag_AddRef,
 167     RegistryPropertyBag_IPropertyBag_Release,
 168     RegistryPropertyBag_IPropertyBag_Read,
 169     RegistryPropertyBag_IPropertyBag_Write
 170 };
 171
 172 static HRESULT RegistryPropertyBag_Constructor(HKEY hInitPropertyBagKey, REFIID riid, LPVOID *ppvObject) {
 173     HRESULT hr = E_FAIL;
 174     RegistryPropertyBag *pRegistryPropertyBag;
 175
 176     TRACE("(hInitPropertyBagKey=%p, riid=%s, ppvObject=%p)\n", hInitPropertyBagKey,
 177         debugstr_guid(riid), ppvObject);
 178
 179     pRegistryPropertyBag = heap_alloc(sizeof(RegistryPropertyBag));
 180     if (pRegistryPropertyBag) {
 181         pRegistryPropertyBag->lpIPropertyBagVtbl = &RegistryPropertyBag_IPropertyBagVtbl;
 182         pRegistryPropertyBag->m_cRef = 0;
 183         pRegistryPropertyBag->m_hInitPropertyBagKey = hInitPropertyBagKey;
 184
 185         /* The clasping AddRef/Release is for the case that QueryInterface fails, which will result
 186          * in a reference count of 0 in the Release call, which will result in object destruction.*/
 187         IPropertyBag_AddRef(STATIC_CAST(IPropertyBag, pRegistryPropertyBag));
 188         hr = IPropertyBag_QueryInterface(STATIC_CAST(IPropertyBag, pRegistryPropertyBag), riid, ppvObject);
 189         IPropertyBag_Release(STATIC_CAST(IPropertyBag, pRegistryPropertyBag));
 190     }
 191
 192     return hr;
 193 }
 194
 195 /******************************************************************************
 196  * InstanceObjectFactory
 197  * Builds Instance Objects and asks them to initialize themselves based on the
 198  * values of a PropertyBag.
 199  */
 200 typedef struct _InstanceObjectFactory {
 201     const IClassFactoryVtbl *lpIClassFactoryVtbl;
 202     LONG                    m_cRef;
 203     CLSID                   m_clsidInstance; /* CLSID of the objects to create. */
 204     IPropertyBag            *m_pPropertyBag; /* PropertyBag to initialize those objects. */
 205 } InstanceObjectFactory;
 206
 207 static void InstanceObjectFactory_Destroy(InstanceObjectFactory *This) {
 208     IPropertyBag_Release(This->m_pPropertyBag);
 209     heap_free(This);
 210 }
 211
 212 static HRESULT WINAPI InstanceObjectFactory_IClassFactory_QueryInterface(IClassFactory *iface,
 213     REFIID riid, LPVOID* ppv)
 214 {
 215     InstanceObjectFactory *This = ADJUST_THIS(InstanceObjectFactory, IClassFactory, iface);
 216
 217     TRACE("iface=%p, riid=%s, ppv=%p)\n", iface, debugstr_guid(riid), ppv);
 218
 219     if (!ppv)
 220         return E_INVALIDARG;
 221
 222     if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IClassFactory, riid)) {
 223         *ppv = STATIC_CAST(IClassFactory, This);
 224     } else {
 225         *ppv = NULL;
 226         return E_NOINTERFACE;
 227     }
 228
 229     IUnknown_AddRef((IUnknown*)*ppv);
 230     return S_OK;
 231 }
 232
 233 static ULONG WINAPI InstanceObjectFactory_IClassFactory_AddRef(IClassFactory *iface)
 234 {
 235     InstanceObjectFactory *This = ADJUST_THIS(InstanceObjectFactory, IClassFactory, iface);
 236     ULONG cRef;
 237
 238     TRACE("(iface=%p)\n", iface);
 239
 240     cRef = InterlockedIncrement(&This->m_cRef);
 241
 242     if (cRef == 1)
 243         IClassFactory_LockServer(iface, TRUE);
 244
 245     return cRef;
 246 }
 247
 248 static ULONG WINAPI InstanceObjectFactory_IClassFactory_Release(IClassFactory *iface)
 249 {
 250     InstanceObjectFactory *This = ADJUST_THIS(InstanceObjectFactory, IClassFactory, iface);
 251     ULONG cRef;
 252
 253     TRACE("(iface=%p)\n", iface);
 254
 255     cRef = InterlockedDecrement(&This->m_cRef);
 256
 257     if (cRef == 0) {
 258         IClassFactory_LockServer(iface, FALSE);
 259         InstanceObjectFactory_Destroy(This);
 260     }
 261
 262     return cRef;
 263 }
 264
 265 static HRESULT WINAPI InstanceObjectFactory_IClassFactory_CreateInstance(IClassFactory *iface,
 266     IUnknown *pUnkOuter, REFIID riid, LPVOID *ppvObj)
 267 {
 268     InstanceObjectFactory *This = ADJUST_THIS(InstanceObjectFactory, IClassFactory, iface);
 269     IPersistPropertyBag *pPersistPropertyBag;
 270     HRESULT hr;
 271
 272     TRACE("(pUnkOuter=%p, riid=%s, ppvObj=%p)\n", pUnkOuter, debugstr_guid(riid), ppvObj);
 273
 274     hr = CoCreateInstance(&This->m_clsidInstance, NULL, CLSCTX_INPROC_SERVER,
 275                           &IID_IPersistPropertyBag, (LPVOID*)&pPersistPropertyBag);
 276     if (FAILED(hr)) {
 277         TRACE("Failed to create instance of %s. hr = %08x\n",
 278               debugstr_guid(&This->m_clsidInstance), hr);
 279         return hr;
 280     }
 281
 282     hr = IPersistPropertyBag_Load(pPersistPropertyBag, This->m_pPropertyBag, NULL);
 283     if (FAILED(hr)) {
 284         TRACE("Failed to initialize object from ProperyBag: hr = %08x\n", hr);
 285         IPersistPropertyBag_Release(pPersistPropertyBag);
 286         return hr;
 287     }
 288
 289     hr = IPersistPropertyBag_QueryInterface(pPersistPropertyBag, riid, ppvObj);
 290     IPersistPropertyBag_Release(pPersistPropertyBag);
 291
 292     return hr;
 293 }
 294
 295 static HRESULT WINAPI InstanceObjectFactory_IClassFactory_LockServer(IClassFactory *iface,
 296     BOOL fLock)
 297 {
 298     TRACE("(iface=%p, fLock=%d) stub\n", iface, fLock);
 299
 300     if (fLock)
 301         SHDOCVW_LockModule();
 302     else
 303         SHDOCVW_UnlockModule();
 304
 305     return S_OK;
 306 }
 307
 308 static const IClassFactoryVtbl InstanceObjectFactory_IClassFactoryVtbl = {
 309     InstanceObjectFactory_IClassFactory_QueryInterface,
 310     InstanceObjectFactory_IClassFactory_AddRef,
 311     InstanceObjectFactory_IClassFactory_Release,
 312     InstanceObjectFactory_IClassFactory_CreateInstance,
 313     InstanceObjectFactory_IClassFactory_LockServer
 314 };
 315
 316 static HRESULT InstanceObjectFactory_Constructor(REFCLSID rclsid, IPropertyBag *pPropertyBag,
 317                                                  REFIID riid, LPVOID *ppvObject)
 318 {
 319     InstanceObjectFactory *pInstanceObjectFactory;
 320     HRESULT hr = E_FAIL;
 321
 322     TRACE("(RegistryPropertyBag=%p, riid=%s, ppvObject=%p)\n", pPropertyBag,
 323         debugstr_guid(riid), ppvObject);
 324
 325     pInstanceObjectFactory = heap_alloc(sizeof(InstanceObjectFactory));
 326     if (pInstanceObjectFactory) {
 327         pInstanceObjectFactory->lpIClassFactoryVtbl = &InstanceObjectFactory_IClassFactoryVtbl;
 328         pInstanceObjectFactory->m_cRef = 0;
 329         pInstanceObjectFactory->m_clsidInstance = *rclsid;
 330         pInstanceObjectFactory->m_pPropertyBag = pPropertyBag;
 331         IPropertyBag_AddRef(pPropertyBag);
 332
 333         IClassFactory_AddRef(STATIC_CAST(IClassFactory, pInstanceObjectFactory));
 334         hr = IClassFactory_QueryInterface(STATIC_CAST(IClassFactory, pInstanceObjectFactory),
 335                                           riid, ppvObject);
 336         IClassFactory_Release(STATIC_CAST(IClassFactory, pInstanceObjectFactory));
 337     }
 338
 339     return hr;
 340 }
 341
 342 /******************************************************************************
 343  * SHDOCVW_GetShellInstanceObjectClassObject [Internal]
 344  *
 345  *  Figure if there is a 'Shell Instance Object' conformant registry entry for
 346  *  the given CLSID and if so create and return a corresponding ClassObject.
 347  *
 348  * PARAMS
 349  *  rclsid      [I] CLSID of the 'Shell Instance Object'.
 350  *  riid        [I] Desired interface. Only IClassFactory supported.
 351  *  ppvClassObj [O] The corresponding ClassObject.
 352  *
 353  * RETURNS
 354  *  Success: S_OK,
 355  *  Failure: CLASS_E_CLASSNOTAVAILABLE
 356  */
 357 HRESULT SHDOCVW_GetShellInstanceObjectClassObject(REFCLSID rclsid, REFIID riid,
 358     LPVOID *ppvClassObj)
 359 {
 360     WCHAR wszInstanceKey[] = { 'C','L','S','I','D','\\','{','0','0','0','0','0','0','0','0','-',
 361         '0','0','0','0','-','0','0','0','0','-','0','0','0','0','-','0','0','0','0','0','0','0','0',
 362         '0','0','0','0','}','\\','I','n','s','t','a','n','c','e', 0 };
 363     const WCHAR wszCLSID[] = { 'C','L','S','I','D',0 };
 364     const WCHAR wszInitPropertyBag[] =
 365         { 'I','n','i','t','P','r','o','p','e','r','t','y','B','a','g',0 };
 366     WCHAR wszCLSIDInstance[CHARS_IN_GUID];
 367     CLSID clsidInstance;
 368     HKEY hInstanceKey, hInitPropertyBagKey;
 369     DWORD dwType, cbBytes = sizeof(wszCLSIDInstance);
 370     IPropertyBag *pInitPropertyBag;
 371     HRESULT hr;
 372     LONG res;
 373
 374     TRACE("(rclsid=%s, riid=%s, ppvClassObject=%p)\n", debugstr_guid(rclsid), debugstr_guid(riid),
 375           ppvClassObj);
 376
 377     /* Figure if there is an 'Instance' subkey for the given CLSID and acquire a handle. */
 378     if (!StringFromGUID2(rclsid, wszInstanceKey + 6, CHARS_IN_GUID) ||
 379         !(wszInstanceKey[5+CHARS_IN_GUID]='\\') || /* Repair the null-termination. */
 380         ERROR_SUCCESS != RegOpenKeyExW(HKEY_CLASSES_ROOT, wszInstanceKey, 0, KEY_READ, &hInstanceKey))
 381     {
 382         /* If there is no 'Instance' subkey, then it's not a Shell Instance Object. */
 383         return CLASS_E_CLASSNOTAVAILABLE;
 384     }
 385
 386     if (RegQueryValueExW(hInstanceKey, wszCLSID, NULL, &dwType, (LPBYTE)wszCLSIDInstance, &cbBytes)
 387         != ERROR_SUCCESS || FAILED(CLSIDFromString(wszCLSIDInstance, &clsidInstance)))
 388     {
 389         /* 'Instance' should have a 'CLSID' value with a well-formed clsid-string. */
 390         FIXME("Failed to infer instance CLSID! %s\n", debugstr_w(wszCLSIDInstance));
 391         RegCloseKey(hInstanceKey);
 392         return CLASS_E_CLASSNOTAVAILABLE;
 393     }
 394
 395     /* Try to open the 'InitPropertyBag' subkey. */
 396     res = RegOpenKeyExW(hInstanceKey, wszInitPropertyBag, 0, KEY_READ, &hInitPropertyBagKey);
 397     RegCloseKey(hInstanceKey);
 398     if (res != ERROR_SUCCESS) {
 399         /* Besides 'InitPropertyBag's, shell instance objects might be initialized by streams.
 400          * So this case might not be an error. */
 401         TRACE("No InitPropertyBag key found!\n");
 402         return CLASS_E_CLASSNOTAVAILABLE;
 403     }
 404
 405     /* If the construction succeeds, the new RegistryPropertyBag is responsible for closing
 406      * hInitProperyBagKey. */
 407     hr = RegistryPropertyBag_Constructor(hInitPropertyBagKey, &IID_IPropertyBag,
 408                                          (LPVOID*)&pInitPropertyBag);
 409     if (FAILED(hr)) {
 410         RegCloseKey(hInitPropertyBagKey);
 411         return hr;
 412     }
 413
 414     /* Construct an Instance Object Factory, which creates objects of class 'clsidInstance'
 415      * and asks them to initialize themselves with the help of the 'pInitiPropertyBag' */
 416     hr = InstanceObjectFactory_Constructor(&clsidInstance, pInitPropertyBag, riid, ppvClassObj);
 417     IPropertyBag_Release(pInitPropertyBag); /* The factory will hold a reference the bag. */
 418
 419     return hr;
 420 }