dlls/msi/automation.c

   1 /*
   2  * Implementation of OLE Automation for Microsoft Installer (msi.dll)
   3  *
   4  * Copyright 2007 Misha Koshelev
   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 #define COBJMACROS
  22
  23 #include <stdarg.h>
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winerror.h"
  27 #include "winuser.h"
  28 #include "winreg.h"
  29 #include "msidefs.h"
  30 #include "msipriv.h"
  31 #include "activscp.h"
  32 #include "oleauto.h"
  33 #include "shlwapi.h"
  34 #include "wine/debug.h"
  35 #include "wine/unicode.h"
  36
  37 #include "msiserver.h"
  38 #include "msiserver_dispids.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  41
  42 #define REG_INDEX_CLASSES_ROOT 0
  43 #define REG_INDEX_DYN_DATA 6
  44
  45 /*
  46  * AutomationObject - "base" class for all automation objects. For each interface, we implement Invoke function
  47  *                    called from AutomationObject::Invoke, and pass this function to create_automation_object.
  48  */
  49
  50 typedef interface AutomationObject AutomationObject;
  51
  52 interface AutomationObject {
  53     /*
  54      * VTables - We provide IDispatch, IProvideClassInfo, IProvideClassInfo2, IProvideMultipleClassInfo
  55      */
  56     const IDispatchVtbl *lpVtbl;
  57     const IProvideMultipleClassInfoVtbl *lpvtblIProvideMultipleClassInfo;
  58
  59     /* Object reference count */
  60     LONG ref;
  61
  62     /* Clsid for this class and it's appropriate ITypeInfo object */
  63     LPCLSID clsid;
  64     ITypeInfo *iTypeInfo;
  65
  66     /* The MSI handle of the current object */
  67     MSIHANDLE msiHandle;
  68
  69     /* A function that is called from AutomationObject::Invoke, specific to this type of object. */
  70     HRESULT (STDMETHODCALLTYPE *funcInvoke)(
  71         AutomationObject* This,
  72         DISPID dispIdMember,
  73         REFIID riid,
  74         LCID lcid,
  75         WORD wFlags,
  76         DISPPARAMS* pDispParams,
  77         VARIANT* pVarResult,
  78         EXCEPINFO* pExcepInfo,
  79         UINT* puArgErr);
  80
  81     /* A function that is called from AutomationObject::Release when the object is being freed to free any private
  82      * data structures (or NULL) */
  83     void (STDMETHODCALLTYPE *funcFree)(AutomationObject* This);
  84 };
  85
  86 /*
  87  * ListEnumerator - IEnumVARIANT implementation for MSI automation lists.
  88  */
  89
  90 typedef interface ListEnumerator ListEnumerator;
  91
  92 interface ListEnumerator {
  93     /* VTables */
  94     const IEnumVARIANTVtbl *lpVtbl;
  95
  96     /* Object reference count */
  97     LONG ref;
  98
  99     /* Current position and pointer to AutomationObject that stores actual data */
 100     ULONG ulPos;
 101     AutomationObject *pObj;
 102 };
 103
 104 /*
 105  * Structures for additional data required by specific automation objects
 106  */
 107
 108 typedef struct {
 109     ULONG ulCount;
 110     VARIANT *pVars;
 111 } ListData;
 112
 113 typedef struct {
 114     /* The parent Installer object */
 115     IDispatch *pInstaller;
 116 } SessionData;
 117
 118 /* VTables */
 119 static const struct IDispatchVtbl AutomationObject_Vtbl;
 120 static const struct IProvideMultipleClassInfoVtbl AutomationObject_IProvideMultipleClassInfo_Vtbl;
 121 static const struct IEnumVARIANTVtbl ListEnumerator_Vtbl;
 122
 123 /* Load type info so we don't have to process GetIDsOfNames */
 124 HRESULT load_type_info(IDispatch *iface, ITypeInfo **pptinfo, REFIID clsid, LCID lcid)
 125 {
 126     HRESULT hr;
 127     LPTYPELIB pLib = NULL;
 128     LPTYPEINFO pInfo = NULL;
 129     static const WCHAR szMsiServer[] = {'m','s','i','s','e','r','v','e','r','.','t','l','b'};
 130
 131     TRACE("(%p)->(%s,%d)\n", iface, debugstr_guid(clsid), lcid);
 132
 133     /* Load registered type library */
 134     hr = LoadRegTypeLib(&LIBID_WindowsInstaller, 1, 0, lcid, &pLib);
 135     if (FAILED(hr)) {
 136         hr = LoadTypeLib(szMsiServer, &pLib);
 137         if (FAILED(hr)) {
 138             ERR("Could not load msiserver.tlb\n");
 139             return hr;
 140         }
 141     }
 142
 143     /* Get type information for object */
 144     hr = ITypeLib_GetTypeInfoOfGuid(pLib, clsid, &pInfo);
 145     ITypeLib_Release(pLib);
 146     if (FAILED(hr)) {
 147         ERR("Could not load ITypeInfo for %s\n", debugstr_guid(clsid));
 148         return hr;
 149     }
 150     *pptinfo = pInfo;
 151     return S_OK;
 152 }
 153
 154 /* Create the automation object, placing the result in the pointer ppObj. The automation object is created
 155  * with the appropriate clsid and invocation function. */
 156 static HRESULT create_automation_object(MSIHANDLE msiHandle, IUnknown *pUnkOuter, LPVOID *ppObj, REFIID clsid,
 157             HRESULT (STDMETHODCALLTYPE *funcInvoke)(AutomationObject*,DISPID,REFIID,LCID,WORD,DISPPARAMS*,
 158                                                     VARIANT*,EXCEPINFO*,UINT*),
 159                                  void (STDMETHODCALLTYPE *funcFree)(AutomationObject*),
 160                                  SIZE_T sizetPrivateData)
 161 {
 162     AutomationObject *object;
 163     HRESULT hr;
 164
 165     TRACE("(%d,%p,%p,%s,%p,%p,%ld)\n", msiHandle, pUnkOuter, ppObj, debugstr_guid(clsid), funcInvoke, funcFree, sizetPrivateData);
 166
 167     if( pUnkOuter )
 168         return CLASS_E_NOAGGREGATION;
 169
 170     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(AutomationObject)+sizetPrivateData);
 171
 172     /* Set all the VTable references */
 173     object->lpVtbl = &AutomationObject_Vtbl;
 174     object->lpvtblIProvideMultipleClassInfo = &AutomationObject_IProvideMultipleClassInfo_Vtbl;
 175     object->ref = 1;
 176
 177     /* Store data that was passed */
 178     object->msiHandle = msiHandle;
 179     object->clsid = (LPCLSID)clsid;
 180     object->funcInvoke = funcInvoke;
 181     object->funcFree = funcFree;
 182
 183     /* Load our TypeInfo so we don't have to process GetIDsOfNames */
 184     object->iTypeInfo = NULL;
 185     hr = load_type_info((IDispatch *)object, &object->iTypeInfo, clsid, 0x0);
 186     if (FAILED(hr)) {
 187         HeapFree(GetProcessHeap(), 0, object);
 188         return hr;
 189     }
 190
 191     *ppObj = object;
 192
 193     return S_OK;
 194 }
 195
 196 /* Create a list enumerator, placing the result in the pointer ppObj.  */
 197 static HRESULT create_list_enumerator(IUnknown *pUnkOuter, LPVOID *ppObj, AutomationObject *pObj, ULONG ulPos)
 198 {
 199     ListEnumerator *object;
 200
 201     TRACE("(%p,%p,%p,%uld)\n", pUnkOuter, ppObj, pObj, ulPos);
 202
 203     if( pUnkOuter )
 204         return CLASS_E_NOAGGREGATION;
 205
 206     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ListEnumerator));
 207
 208     /* Set all the VTable references */
 209     object->lpVtbl = &ListEnumerator_Vtbl;
 210     object->ref = 1;
 211
 212     /* Store data that was passed */
 213     object->ulPos = ulPos;
 214     object->pObj = pObj;
 215     if (pObj) IDispatch_AddRef((IDispatch *)pObj);
 216
 217     *ppObj = object;
 218     return S_OK;
 219 }
 220
 221 /* Macros to get pointer to AutomationObject from the other VTables. */
 222 static inline AutomationObject *obj_from_IProvideMultipleClassInfo( IProvideMultipleClassInfo *iface )
 223 {
 224     return (AutomationObject *)((char*)iface - FIELD_OFFSET(AutomationObject, lpvtblIProvideMultipleClassInfo));
 225 }
 226
 227 /* Macro to get pointer to private object data */
 228 static inline void *private_data( AutomationObject *This )
 229 {
 230     return This + 1;
 231 }
 232
 233 /*
 234  * AutomationObject methods
 235  */
 236
 237 /*** IUnknown methods ***/
 238 static HRESULT WINAPI AutomationObject_QueryInterface(IDispatch* iface, REFIID riid, void** ppvObject)
 239 {
 240     AutomationObject *This = (AutomationObject *)iface;
 241
 242     TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
 243
 244     if (ppvObject == NULL)
 245       return E_INVALIDARG;
 246
 247     *ppvObject = 0;
 248
 249     if (IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IDispatch) || IsEqualGUID(riid, This->clsid))
 250         *ppvObject = This;
 251     else if (IsEqualGUID(riid, &IID_IProvideClassInfo) ||
 252              IsEqualGUID(riid, &IID_IProvideClassInfo2) ||
 253              IsEqualGUID(riid, &IID_IProvideMultipleClassInfo))
 254         *ppvObject = &This->lpvtblIProvideMultipleClassInfo;
 255     else
 256     {
 257         TRACE("() : asking for unsupported interface %s\n",debugstr_guid(riid));
 258         return E_NOINTERFACE;
 259     }
 260
 261     /*
 262      * Query Interface always increases the reference count by one when it is
 263      * successful
 264      */
 265     IClassFactory_AddRef(iface);
 266
 267     return S_OK;
 268 }
 269
 270 static ULONG WINAPI AutomationObject_AddRef(IDispatch* iface)
 271 {
 272     AutomationObject *This = (AutomationObject *)iface;
 273
 274     TRACE("(%p/%p)\n", iface, This);
 275
 276     return InterlockedIncrement(&This->ref);
 277 }
 278
 279 static ULONG WINAPI AutomationObject_Release(IDispatch* iface)
 280 {
 281     AutomationObject *This = (AutomationObject *)iface;
 282     ULONG ref = InterlockedDecrement(&This->ref);
 283
 284     TRACE("(%p/%p)\n", iface, This);
 285
 286     if (!ref)
 287     {
 288         if (This->funcFree) This->funcFree(This);
 289         ITypeInfo_Release(This->iTypeInfo);
 290         MsiCloseHandle(This->msiHandle);
 291         HeapFree(GetProcessHeap(), 0, This);
 292     }
 293
 294     return ref;
 295 }
 296
 297 /*** IDispatch methods ***/
 298 static HRESULT WINAPI AutomationObject_GetTypeInfoCount(
 299         IDispatch* iface,
 300         UINT* pctinfo)
 301 {
 302     AutomationObject *This = (AutomationObject *)iface;
 303
 304     TRACE("(%p/%p)->(%p)\n", iface, This, pctinfo);
 305     *pctinfo = 1;
 306     return S_OK;
 307 }
 308
 309 static HRESULT WINAPI AutomationObject_GetTypeInfo(
 310         IDispatch* iface,
 311         UINT iTInfo,
 312         LCID lcid,
 313         ITypeInfo** ppTInfo)
 314 {
 315     AutomationObject *This = (AutomationObject *)iface;
 316     TRACE("(%p/%p)->(%d,%d,%p)\n", iface, This, iTInfo, lcid, ppTInfo);
 317
 318     ITypeInfo_AddRef(This->iTypeInfo);
 319     *ppTInfo = This->iTypeInfo;
 320     return S_OK;
 321 }
 322
 323 static HRESULT WINAPI AutomationObject_GetIDsOfNames(
 324         IDispatch* iface,
 325         REFIID riid,
 326         LPOLESTR* rgszNames,
 327         UINT cNames,
 328         LCID lcid,
 329         DISPID* rgDispId)
 330 {
 331     AutomationObject *This = (AutomationObject *)iface;
 332     HRESULT hr;
 333     TRACE("(%p/%p)->(%p,%p,%d,%d,%p)\n", iface, This, riid, rgszNames, cNames, lcid, rgDispId);
 334
 335     if (!IsEqualGUID(riid, &IID_NULL)) return E_INVALIDARG;
 336     hr = ITypeInfo_GetIDsOfNames(This->iTypeInfo, rgszNames, cNames, rgDispId);
 337     if (hr == DISP_E_UNKNOWNNAME)
 338     {
 339         UINT idx;
 340         for (idx=0; idx<cNames; idx++)
 341         {
 342             if (rgDispId[idx] == DISPID_UNKNOWN)
 343                 FIXME("Unknown member %s, clsid %s\n", debugstr_w(rgszNames[idx]), debugstr_guid(This->clsid));
 344         }
 345     }
 346     return hr;
 347 }
 348
 349 /* Maximum number of allowed function parameters+1 */
 350 #define MAX_FUNC_PARAMS 20
 351
 352 /* Some error checking is done here to simplify individual object function invocation */
 353 static HRESULT WINAPI AutomationObject_Invoke(
 354         IDispatch* iface,
 355         DISPID dispIdMember,
 356         REFIID riid,
 357         LCID lcid,
 358         WORD wFlags,
 359         DISPPARAMS* pDispParams,
 360         VARIANT* pVarResult,
 361         EXCEPINFO* pExcepInfo,
 362         UINT* puArgErr)
 363 {
 364     AutomationObject *This = (AutomationObject *)iface;
 365     HRESULT hr;
 366     unsigned int uArgErr;
 367     VARIANT varResultDummy;
 368     BSTR bstrName = NULL;
 369
 370     TRACE("(%p/%p)->(%d,%p,%d,%d,%p,%p,%p,%p)\n", iface, This, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 371
 372     if (!IsEqualIID(riid, &IID_NULL))
 373     {
 374         ERR("riid was %s instead of IID_NULL\n", debugstr_guid(riid));
 375         return DISP_E_UNKNOWNNAME;
 376     }
 377
 378     if (wFlags & DISPATCH_PROPERTYGET && !pVarResult)
 379     {
 380         ERR("NULL pVarResult not allowed when DISPATCH_PROPERTYGET specified\n");
 381         return DISP_E_PARAMNOTOPTIONAL;
 382     }
 383
 384     /* This simplifies our individual object invocation functions */
 385     if (puArgErr == NULL) puArgErr = &uArgErr;
 386     if (pVarResult == NULL) pVarResult = &varResultDummy;
 387
 388     /* Assume return type is void unless determined otherwise */
 389     VariantInit(pVarResult);
 390
 391     /* If we are tracing, we want to see the name of the member we are invoking */
 392     if (TRACE_ON(msi))
 393     {
 394         ITypeInfo_GetDocumentation(This->iTypeInfo, dispIdMember, &bstrName, NULL, NULL, NULL);
 395         TRACE("Method %d, %s\n", dispIdMember, debugstr_w(bstrName));
 396     }
 397
 398     hr = This->funcInvoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr);
 399
 400     if (hr == DISP_E_MEMBERNOTFOUND) {
 401         if (bstrName == NULL) ITypeInfo_GetDocumentation(This->iTypeInfo, dispIdMember, &bstrName, NULL, NULL, NULL);
 402         FIXME("Method %d, %s wflags %d not implemented, clsid %s\n", dispIdMember, debugstr_w(bstrName), wFlags, debugstr_guid(This->clsid));
 403     }
 404     else if (pExcepInfo &&
 405              (hr == DISP_E_PARAMNOTFOUND ||
 406               hr == DISP_E_EXCEPTION)) {
 407         static const WCHAR szComma[] = { ',',0 };
 408         static const WCHAR szExceptionSource[] = {'M','s','i',' ','A','P','I',' ','E','r','r','o','r',0};
 409         WCHAR szExceptionDescription[MAX_PATH];
 410         BSTR bstrParamNames[MAX_FUNC_PARAMS];
 411         unsigned namesNo, i;
 412         BOOL bFirst = TRUE;
 413
 414         if (FAILED(ITypeInfo_GetNames(This->iTypeInfo, dispIdMember, bstrParamNames,
 415                                       MAX_FUNC_PARAMS, &namesNo)))
 416         {
 417             TRACE("Failed to retrieve names for dispIdMember %d\n", dispIdMember);
 418         }
 419         else
 420         {
 421             memset(szExceptionDescription, 0, sizeof(szExceptionDescription));
 422             for (i=0; i<namesNo; i++)
 423             {
 424                 if (bFirst) bFirst = FALSE;
 425                 else {
 426                     lstrcpyW(&szExceptionDescription[lstrlenW(szExceptionDescription)], szComma);
 427                 }
 428                 lstrcpyW(&szExceptionDescription[lstrlenW(szExceptionDescription)], bstrParamNames[i]);
 429                 SysFreeString(bstrParamNames[i]);
 430             }
 431
 432             memset(pExcepInfo, 0, sizeof(EXCEPINFO));
 433             pExcepInfo->wCode = 1000;
 434             pExcepInfo->bstrSource = SysAllocString(szExceptionSource);
 435             pExcepInfo->bstrDescription = SysAllocString(szExceptionDescription);
 436             hr = DISP_E_EXCEPTION;
 437         }
 438     }
 439
 440     /* Make sure we free the return variant if it is our dummy variant */
 441     if (pVarResult == &varResultDummy) VariantClear(pVarResult);
 442
 443     /* Free function name if we retrieved it */
 444     SysFreeString(bstrName);
 445
 446     TRACE("Returning 0x%08x, %s\n", hr, SUCCEEDED(hr) ? "ok" : "not ok");
 447
 448     return hr;
 449 }
 450
 451 static const struct IDispatchVtbl AutomationObject_Vtbl =
 452 {
 453     AutomationObject_QueryInterface,
 454     AutomationObject_AddRef,
 455     AutomationObject_Release,
 456     AutomationObject_GetTypeInfoCount,
 457     AutomationObject_GetTypeInfo,
 458     AutomationObject_GetIDsOfNames,
 459     AutomationObject_Invoke
 460 };
 461
 462 /*
 463  * IProvideMultipleClassInfo methods
 464  */
 465
 466 static HRESULT WINAPI AutomationObject_IProvideMultipleClassInfo_QueryInterface(
 467   IProvideMultipleClassInfo* iface,
 468   REFIID     riid,
 469   VOID**     ppvoid)
 470 {
 471     AutomationObject *This = obj_from_IProvideMultipleClassInfo(iface);
 472     return AutomationObject_QueryInterface((IDispatch *)This, riid, ppvoid);
 473 }
 474
 475 static ULONG WINAPI AutomationObject_IProvideMultipleClassInfo_AddRef(IProvideMultipleClassInfo* iface)
 476 {
 477     AutomationObject *This = obj_from_IProvideMultipleClassInfo(iface);
 478     return AutomationObject_AddRef((IDispatch *)This);
 479 }
 480
 481 static ULONG WINAPI AutomationObject_IProvideMultipleClassInfo_Release(IProvideMultipleClassInfo* iface)
 482 {
 483     AutomationObject *This = obj_from_IProvideMultipleClassInfo(iface);
 484     return AutomationObject_Release((IDispatch *)This);
 485 }
 486
 487 static HRESULT WINAPI AutomationObject_IProvideMultipleClassInfo_GetClassInfo(IProvideMultipleClassInfo* iface, ITypeInfo** ppTI)
 488 {
 489     AutomationObject *This = obj_from_IProvideMultipleClassInfo(iface);
 490     TRACE("(%p/%p)->(%p)\n", iface, This, ppTI);
 491     return load_type_info((IDispatch *)This, ppTI, This->clsid, 0);
 492 }
 493
 494 static HRESULT WINAPI AutomationObject_IProvideMultipleClassInfo_GetGUID(IProvideMultipleClassInfo* iface, DWORD dwGuidKind, GUID* pGUID)
 495 {
 496     AutomationObject *This = obj_from_IProvideMultipleClassInfo(iface);
 497     TRACE("(%p/%p)->(%d,%s)\n", iface, This, dwGuidKind, debugstr_guid(pGUID));
 498
 499     if (dwGuidKind != GUIDKIND_DEFAULT_SOURCE_DISP_IID)
 500         return E_INVALIDARG;
 501     else {
 502         *pGUID = *This->clsid;
 503         return S_OK;
 504     }
 505 }
 506
 507 static HRESULT WINAPI AutomationObject_GetMultiTypeInfoCount(IProvideMultipleClassInfo* iface, ULONG* pcti)
 508 {
 509     AutomationObject *This = obj_from_IProvideMultipleClassInfo(iface);
 510
 511     TRACE("(%p/%p)->(%p)\n", iface, This, pcti);
 512     *pcti = 1;
 513     return S_OK;
 514 }
 515
 516 static HRESULT WINAPI AutomationObject_GetInfoOfIndex(IProvideMultipleClassInfo* iface,
 517         ULONG iti,
 518         DWORD dwFlags,
 519         ITypeInfo** pptiCoClass,
 520         DWORD* pdwTIFlags,
 521         ULONG* pcdispidReserved,
 522         IID* piidPrimary,
 523         IID* piidSource)
 524 {
 525     AutomationObject *This = obj_from_IProvideMultipleClassInfo(iface);
 526
 527     TRACE("(%p/%p)->(%d,%d,%p,%p,%p,%p,%p)\n", iface, This, iti, dwFlags, pptiCoClass, pdwTIFlags, pcdispidReserved, piidPrimary, piidSource);
 528
 529     if (iti != 0)
 530         return E_INVALIDARG;
 531
 532     if (dwFlags & MULTICLASSINFO_GETTYPEINFO)
 533         load_type_info((IDispatch *)This, pptiCoClass, This->clsid, 0);
 534
 535     if (dwFlags & MULTICLASSINFO_GETNUMRESERVEDDISPIDS)
 536     {
 537         *pdwTIFlags = 0;
 538         *pcdispidReserved = 0;
 539     }
 540
 541     if (dwFlags & MULTICLASSINFO_GETIIDPRIMARY){
 542         *piidPrimary = *This->clsid;
 543     }
 544
 545     if (dwFlags & MULTICLASSINFO_GETIIDSOURCE){
 546         *piidSource = *This->clsid;
 547     }
 548
 549     return S_OK;
 550 }
 551
 552 static const IProvideMultipleClassInfoVtbl AutomationObject_IProvideMultipleClassInfo_Vtbl =
 553 {
 554     AutomationObject_IProvideMultipleClassInfo_QueryInterface,
 555     AutomationObject_IProvideMultipleClassInfo_AddRef,
 556     AutomationObject_IProvideMultipleClassInfo_Release,
 557     AutomationObject_IProvideMultipleClassInfo_GetClassInfo,
 558     AutomationObject_IProvideMultipleClassInfo_GetGUID,
 559     AutomationObject_GetMultiTypeInfoCount,
 560     AutomationObject_GetInfoOfIndex
 561 };
 562
 563 /*
 564  * ListEnumerator methods
 565  */
 566
 567 /*** IUnknown methods ***/
 568 static HRESULT WINAPI ListEnumerator_QueryInterface(IEnumVARIANT* iface, REFIID riid, void** ppvObject)
 569 {
 570     ListEnumerator *This = (ListEnumerator *)iface;
 571
 572     TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
 573
 574     if (ppvObject == NULL)
 575       return E_INVALIDARG;
 576
 577     *ppvObject = 0;
 578
 579     if (IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IEnumVARIANT))
 580         *ppvObject = This;
 581     else
 582     {
 583         TRACE("() : asking for unsupported interface %s\n",debugstr_guid(riid));
 584         return E_NOINTERFACE;
 585     }
 586
 587     IClassFactory_AddRef(iface);
 588     return S_OK;
 589 }
 590
 591 static ULONG WINAPI ListEnumerator_AddRef(IEnumVARIANT* iface)
 592 {
 593     ListEnumerator *This = (ListEnumerator *)iface;
 594
 595     TRACE("(%p/%p)\n", iface, This);
 596
 597     return InterlockedIncrement(&This->ref);
 598 }
 599
 600 static ULONG WINAPI ListEnumerator_Release(IEnumVARIANT* iface)
 601 {
 602     ListEnumerator *This = (ListEnumerator *)iface;
 603     ULONG ref = InterlockedDecrement(&This->ref);
 604
 605     TRACE("(%p/%p)\n", iface, This);
 606
 607     if (!ref)
 608     {
 609         if (This->pObj) IDispatch_Release((IDispatch *)This->pObj);
 610         HeapFree(GetProcessHeap(), 0, This);
 611     }
 612
 613     return ref;
 614 }
 615
 616 /* IEnumVARIANT methods */
 617
 618 static HRESULT WINAPI ListEnumerator_Next(IEnumVARIANT* iface, ULONG celt, VARIANT *rgVar, ULONG *pCeltFetched)
 619 {
 620     ListEnumerator *This = (ListEnumerator *)iface;
 621     ListData *data = private_data(This->pObj);
 622     ULONG idx, local;
 623
 624     TRACE("(%p,%uld,%p,%p)\n", iface, celt, rgVar, pCeltFetched);
 625
 626     if (pCeltFetched != NULL)
 627         *pCeltFetched = 0;
 628
 629     if (rgVar == NULL)
 630         return S_FALSE;
 631
 632     for (local = 0; local < celt; local++)
 633         VariantInit(&rgVar[local]);
 634
 635     for (idx = This->ulPos, local = 0; idx < data->ulCount && local < celt; idx++, local++)
 636         VariantCopy(&rgVar[local], &data->pVars[idx]);
 637
 638     if (pCeltFetched != NULL)
 639         *pCeltFetched = local;
 640     This->ulPos = idx;
 641
 642     return (local < celt) ? S_FALSE : S_OK;
 643 }
 644
 645 static HRESULT WINAPI ListEnumerator_Skip(IEnumVARIANT* iface, ULONG celt)
 646 {
 647     ListEnumerator *This = (ListEnumerator *)iface;
 648     ListData *data = private_data(This->pObj);
 649
 650     TRACE("(%p,%uld)\n", iface, celt);
 651
 652     This->ulPos += celt;
 653     if (This->ulPos >= data->ulCount)
 654     {
 655         This->ulPos = data->ulCount;
 656         return S_FALSE;
 657     }
 658     return S_OK;
 659 }
 660
 661 static HRESULT WINAPI ListEnumerator_Reset(IEnumVARIANT* iface)
 662 {
 663     ListEnumerator *This = (ListEnumerator *)iface;
 664
 665     TRACE("(%p)\n", iface);
 666
 667     This->ulPos = 0;
 668     return S_OK;
 669 }
 670
 671 static HRESULT WINAPI ListEnumerator_Clone(IEnumVARIANT* iface, IEnumVARIANT **ppEnum)
 672 {
 673     ListEnumerator *This = (ListEnumerator *)iface;
 674     HRESULT hr;
 675
 676     TRACE("(%p,%p)\n", iface, ppEnum);
 677
 678     if (ppEnum == NULL)
 679         return S_FALSE;
 680
 681     *ppEnum = NULL;
 682     hr = create_list_enumerator(NULL, (LPVOID *)ppEnum, This->pObj, 0);
 683     if (FAILED(hr))
 684     {
 685         if (*ppEnum)
 686             IUnknown_Release(*ppEnum);
 687         return hr;
 688     }
 689
 690     return S_OK;
 691 }
 692
 693 static const struct IEnumVARIANTVtbl ListEnumerator_Vtbl =
 694 {
 695     ListEnumerator_QueryInterface,
 696     ListEnumerator_AddRef,
 697     ListEnumerator_Release,
 698     ListEnumerator_Next,
 699     ListEnumerator_Skip,
 700     ListEnumerator_Reset,
 701     ListEnumerator_Clone
 702 };
 703
 704 /*
 705  * Individual Object Invocation Functions
 706  */
 707
 708 /* Helper function that copies a passed parameter instead of using VariantChangeType like the actual DispGetParam.
 709    This function is only for VARIANT type parameters that have several types that cannot be properly discriminated
 710    using DispGetParam/VariantChangeType. */
 711 static HRESULT DispGetParam_CopyOnly(
 712         DISPPARAMS *pdispparams, /* [in] Parameter list */
 713         UINT        *position,    /* [in] Position of parameter to copy in pdispparams; on return will contain calculated position */
 714         VARIANT    *pvarResult)  /* [out] Destination for resulting variant */
 715 {
 716     /* position is counted backwards */
 717     UINT pos;
 718
 719     TRACE("position=%d, cArgs=%d, cNamedArgs=%d\n",
 720           *position, pdispparams->cArgs, pdispparams->cNamedArgs);
 721     if (*position < pdispparams->cArgs) {
 722       /* positional arg? */
 723       pos = pdispparams->cArgs - *position - 1;
 724     } else {
 725       /* FIXME: is this how to handle named args? */
 726       for (pos=0; pos<pdispparams->cNamedArgs; pos++)
 727         if (pdispparams->rgdispidNamedArgs[pos] == *position) break;
 728
 729       if (pos==pdispparams->cNamedArgs)
 730         return DISP_E_PARAMNOTFOUND;
 731     }
 732     *position = pos;
 733     return VariantCopyInd(pvarResult,
 734                         &pdispparams->rgvarg[pos]);
 735 }
 736
 737 static HRESULT WINAPI SummaryInfoImpl_Invoke(
 738         AutomationObject* This,
 739         DISPID dispIdMember,
 740         REFIID riid,
 741         LCID lcid,
 742         WORD wFlags,
 743         DISPPARAMS* pDispParams,
 744         VARIANT* pVarResult,
 745         EXCEPINFO* pExcepInfo,
 746         UINT* puArgErr)
 747 {
 748     UINT ret;
 749     VARIANTARG varg0, varg1;
 750     FILETIME ft, ftlocal;
 751     SYSTEMTIME st;
 752     HRESULT hr;
 753
 754     VariantInit(&varg0);
 755     VariantInit(&varg1);
 756
 757     switch (dispIdMember)
 758     {
 759         case DISPID_SUMMARYINFO_PROPERTY:
 760             if (wFlags & DISPATCH_PROPERTYGET)
 761             {
 762                 UINT type;
 763                 INT value;
 764                 DWORD size = 0;
 765                 DATE date;
 766                 LPWSTR str;
 767
 768                 static WCHAR szEmpty[] = {0};
 769
 770                 hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
 771                 if (FAILED(hr)) return hr;
 772                 ret = MsiSummaryInfoGetPropertyW(This->msiHandle, V_I4(&varg0), &type, &value,
 773                                                  &ft, szEmpty, &size);
 774                 if (ret != ERROR_SUCCESS &&
 775                     ret != ERROR_MORE_DATA)
 776                 {
 777                     ERR("MsiSummaryInfoGetProperty returned %d\n", ret);
 778                     return DISP_E_EXCEPTION;
 779                 }
 780
 781                 switch (type)
 782                 {
 783                     case VT_EMPTY:
 784                         break;
 785
 786                     case VT_I2:
 787                     case VT_I4:
 788                         V_VT(pVarResult) = VT_I4;
 789                         V_I4(pVarResult) = value;
 790                         break;
 791
 792                     case VT_LPSTR:
 793                         if (!(str = msi_alloc(++size * sizeof(WCHAR))))
 794                             ERR("Out of memory\n");
 795                         else if ((ret = MsiSummaryInfoGetPropertyW(This->msiHandle, V_I4(&varg0), &type, NULL,
 796                                                                    NULL, str, &size)) != ERROR_SUCCESS)
 797                             ERR("MsiSummaryInfoGetProperty returned %d\n", ret);
 798                         else
 799                         {
 800                             V_VT(pVarResult) = VT_BSTR;
 801                             V_BSTR(pVarResult) = SysAllocString(str);
 802                         }
 803                         msi_free(str);
 804                         break;
 805
 806                     case VT_FILETIME:
 807                         FileTimeToLocalFileTime(&ft, &ftlocal);
 808                         FileTimeToSystemTime(&ftlocal, &st);
 809                         SystemTimeToVariantTime(&st, &date);
 810
 811                         V_VT(pVarResult) = VT_DATE;
 812                         V_DATE(pVarResult) = date;
 813                         break;
 814
 815                     default:
 816                         ERR("Unhandled variant type %d\n", type);
 817                 }
 818             }
 819             else if (wFlags & DISPATCH_PROPERTYPUT)
 820             {
 821                 UINT posValue = DISPID_PROPERTYPUT;
 822
 823                 hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
 824                 if (FAILED(hr)) return hr;
 825                 hr = DispGetParam_CopyOnly(pDispParams, &posValue, &varg1);
 826                 if (FAILED(hr))
 827                 {
 828                     *puArgErr = posValue;
 829                     return hr;
 830                 }
 831
 832                 switch (V_VT(&varg1))
 833                 {
 834                     case VT_I2:
 835                     case VT_I4:
 836                         ret = MsiSummaryInfoSetPropertyW(This->msiHandle, V_I4(&varg0), V_VT(&varg1), V_I4(&varg1), NULL, NULL);
 837                         break;
 838
 839                     case VT_DATE:
 840                         VariantTimeToSystemTime(V_DATE(&varg1), &st);
 841                         SystemTimeToFileTime(&st, &ftlocal);
 842                         LocalFileTimeToFileTime(&ftlocal, &ft);
 843                         ret = MsiSummaryInfoSetPropertyW(This->msiHandle, V_I4(&varg0), VT_FILETIME, 0, &ft, NULL);
 844                         break;
 845
 846                     case VT_BSTR:
 847                         ret = MsiSummaryInfoSetPropertyW(This->msiHandle, V_I4(&varg0), VT_LPSTR, 0, NULL, V_BSTR(&varg1));
 848                         break;
 849
 850                     default:
 851                         FIXME("Unhandled variant type %d\n", V_VT(&varg1));
 852                         VariantClear(&varg1);
 853                         return DISP_E_EXCEPTION;
 854                 }
 855
 856                 if (ret != ERROR_SUCCESS)
 857                 {
 858                     ERR("MsiSummaryInfoSetPropertyW returned %d\n", ret);
 859                     return DISP_E_EXCEPTION;
 860                 }
 861             }
 862             else return DISP_E_MEMBERNOTFOUND;
 863             break;
 864
 865         case DISPID_SUMMARYINFO_PROPERTYCOUNT:
 866             if (wFlags & DISPATCH_PROPERTYGET) {
 867                 UINT count;
 868                 if ((ret = MsiSummaryInfoGetPropertyCount(This->msiHandle, &count)) != ERROR_SUCCESS)
 869                     ERR("MsiSummaryInfoGetPropertyCount returned %d\n", ret);
 870                 else
 871                 {
 872                     V_VT(pVarResult) = VT_I4;
 873                     V_I4(pVarResult) = count;
 874                 }
 875             }
 876             else return DISP_E_MEMBERNOTFOUND;
 877             break;
 878
 879         default:
 880             return DISP_E_MEMBERNOTFOUND;
 881     }
 882
 883     VariantClear(&varg1);
 884     VariantClear(&varg0);
 885
 886     return S_OK;
 887 }
 888
 889 static HRESULT WINAPI RecordImpl_Invoke(
 890         AutomationObject* This,
 891         DISPID dispIdMember,
 892         REFIID riid,
 893         LCID lcid,
 894         WORD wFlags,
 895         DISPPARAMS* pDispParams,
 896         VARIANT* pVarResult,
 897         EXCEPINFO* pExcepInfo,
 898         UINT* puArgErr)
 899 {
 900     WCHAR *szString;
 901     DWORD dwLen;
 902     UINT ret;
 903     VARIANTARG varg0, varg1;
 904     HRESULT hr;
 905
 906     VariantInit(&varg0);
 907     VariantInit(&varg1);
 908
 909     switch (dispIdMember)
 910     {
 911         case DISPID_RECORD_FIELDCOUNT:
 912             if (wFlags & DISPATCH_PROPERTYGET) {
 913                 V_VT(pVarResult) = VT_I4;
 914                 V_I4(pVarResult) = MsiRecordGetFieldCount(This->msiHandle);
 915             }
 916             else return DISP_E_MEMBERNOTFOUND;
 917             break;
 918
 919         case DISPID_RECORD_STRINGDATA:
 920             if (wFlags & DISPATCH_PROPERTYGET) {
 921                 hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
 922                 if (FAILED(hr)) return hr;
 923                 V_VT(pVarResult) = VT_BSTR;
 924                 V_BSTR(pVarResult) = NULL;
 925                 if ((ret = MsiRecordGetStringW(This->msiHandle, V_I4(&varg0), NULL, &dwLen)) == ERROR_SUCCESS)
 926                 {
 927                     if (!(szString = msi_alloc((++dwLen)*sizeof(WCHAR))))
 928                         ERR("Out of memory\n");
 929                     else if ((ret = MsiRecordGetStringW(This->msiHandle, V_I4(&varg0), szString, &dwLen)) == ERROR_SUCCESS)
 930                         V_BSTR(pVarResult) = SysAllocString(szString);
 931                     msi_free(szString);
 932                 }
 933                 if (ret != ERROR_SUCCESS)
 934                     ERR("MsiRecordGetString returned %d\n", ret);
 935             } else if (wFlags & DISPATCH_PROPERTYPUT) {
 936                 hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
 937                 if (FAILED(hr)) return hr;
 938                 hr = DispGetParam(pDispParams, DISPID_PROPERTYPUT, VT_BSTR, &varg1, puArgErr);
 939                 if (FAILED(hr)) return hr;
 940                 if ((ret = MsiRecordSetStringW(This->msiHandle, V_I4(&varg0), V_BSTR(&varg1))) != ERROR_SUCCESS)
 941                 {
 942                     VariantClear(&varg1);
 943                     ERR("MsiRecordSetString returned %d\n", ret);
 944                     return DISP_E_EXCEPTION;
 945                 }
 946             }
 947             else return DISP_E_MEMBERNOTFOUND;
 948             break;
 949
 950         case DISPID_RECORD_INTEGERDATA:
 951             if (wFlags & DISPATCH_PROPERTYGET) {
 952                 hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
 953                 if (FAILED(hr)) return hr;
 954                 V_VT(pVarResult) = VT_I4;
 955                 V_I4(pVarResult) = MsiRecordGetInteger(This->msiHandle, V_I4(&varg0));
 956             } else if (wFlags & DISPATCH_PROPERTYPUT) {
 957                 hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
 958                 if (FAILED(hr)) return hr;
 959                 hr = DispGetParam(pDispParams, DISPID_PROPERTYPUT, VT_I4, &varg1, puArgErr);
 960                 if (FAILED(hr)) return hr;
 961                 if ((ret = MsiRecordSetInteger(This->msiHandle, V_I4(&varg0), V_I4(&varg1))) != ERROR_SUCCESS)
 962                 {
 963                     ERR("MsiRecordSetInteger returned %d\n", ret);
 964                     return DISP_E_EXCEPTION;
 965                 }
 966             }
 967             else return DISP_E_MEMBERNOTFOUND;
 968             break;
 969
 970          default:
 971             return DISP_E_MEMBERNOTFOUND;
 972     }
 973
 974     VariantClear(&varg1);
 975     VariantClear(&varg0);
 976
 977     return S_OK;
 978 }
 979
 980 static HRESULT WINAPI ListImpl_Invoke(
 981         AutomationObject* This,
 982         DISPID dispIdMember,
 983         REFIID riid,
 984         LCID lcid,
 985         WORD wFlags,
 986         DISPPARAMS* pDispParams,
 987         VARIANT* pVarResult,
 988         EXCEPINFO* pExcepInfo,
 989         UINT* puArgErr)
 990 {
 991     ListData *data = private_data(This);
 992     HRESULT hr;
 993     VARIANTARG varg0;
 994     IUnknown *pUnk = NULL;
 995
 996     VariantInit(&varg0);
 997
 998     switch (dispIdMember)
 999     {
1000          case DISPID_LIST__NEWENUM:
1001              if (wFlags & DISPATCH_METHOD) {
1002                  V_VT(pVarResult) = VT_UNKNOWN;
1003                  if (SUCCEEDED(hr = create_list_enumerator(NULL, (LPVOID *)&pUnk, This, 0)))
1004                      V_UNKNOWN(pVarResult) = pUnk;
1005                  else
1006                      ERR("Failed to create IEnumVARIANT object, hresult 0x%08x\n", hr);
1007              }
1008              else return DISP_E_MEMBERNOTFOUND;
1009              break;
1010
1011          case DISPID_LIST_ITEM:
1012              if (wFlags & DISPATCH_PROPERTYGET) {
1013                 hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
1014                 if (FAILED(hr)) return hr;
1015                 if (V_I4(&varg0) < 0 || V_I4(&varg0) >= data->ulCount)
1016                     return DISP_E_BADINDEX;
1017                 VariantCopy(pVarResult, &data->pVars[V_I4(&varg0)]);
1018             }
1019             else return DISP_E_MEMBERNOTFOUND;
1020             break;
1021
1022          case DISPID_LIST_COUNT:
1023             if (wFlags & DISPATCH_PROPERTYGET) {
1024                 V_VT(pVarResult) = VT_I4;
1025                 V_I4(pVarResult) = data->ulCount;
1026             }
1027             else return DISP_E_MEMBERNOTFOUND;
1028             break;
1029
1030          default:
1031             return DISP_E_MEMBERNOTFOUND;
1032     }
1033
1034     VariantClear(&varg0);
1035
1036     return S_OK;
1037 }
1038
1039 static void WINAPI ListImpl_Free(AutomationObject *This)
1040 {
1041     ListData *data = private_data(This);
1042     ULONG idx;
1043
1044     for (idx=0; idx<data->ulCount; idx++)
1045         VariantClear(&data->pVars[idx]);
1046     HeapFree(GetProcessHeap(), 0, data->pVars);
1047 }
1048
1049 static HRESULT WINAPI ViewImpl_Invoke(
1050         AutomationObject* This,
1051         DISPID dispIdMember,
1052         REFIID riid,
1053         LCID lcid,
1054         WORD wFlags,
1055         DISPPARAMS* pDispParams,
1056         VARIANT* pVarResult,
1057         EXCEPINFO* pExcepInfo,
1058         UINT* puArgErr)
1059 {
1060     MSIHANDLE msiHandle;
1061     IDispatch *pDispatch = NULL;
1062     UINT ret;
1063     VARIANTARG varg0, varg1;
1064     HRESULT hr;
1065
1066     VariantInit(&varg0);
1067     VariantInit(&varg1);
1068
1069     switch (dispIdMember)
1070     {
1071         case DISPID_VIEW_EXECUTE:
1072             if (wFlags & DISPATCH_METHOD)
1073             {
1074                 hr = DispGetParam(pDispParams, 0, VT_DISPATCH, &varg0, puArgErr);
1075                 if (SUCCEEDED(hr) && V_DISPATCH(&varg0) != NULL)
1076                     MsiViewExecute(This->msiHandle, ((AutomationObject *)V_DISPATCH(&varg0))->msiHandle);
1077                 else
1078                     MsiViewExecute(This->msiHandle, 0);
1079             }
1080             else return DISP_E_MEMBERNOTFOUND;
1081             break;
1082
1083         case DISPID_VIEW_FETCH:
1084             if (wFlags & DISPATCH_METHOD)
1085             {
1086                 V_VT(pVarResult) = VT_DISPATCH;
1087                 if ((ret = MsiViewFetch(This->msiHandle, &msiHandle)) == ERROR_SUCCESS)
1088                 {
1089                     if (SUCCEEDED(hr = create_automation_object(msiHandle, NULL, (LPVOID*)&pDispatch, &DIID_Record, RecordImpl_Invoke, NULL, 0)))
1090                         V_DISPATCH(pVarResult) = pDispatch;
1091                     else
1092                         ERR("Failed to create Record object, hresult 0x%08x\n", hr);
1093                 }
1094                 else if (ret == ERROR_NO_MORE_ITEMS)
1095                     V_DISPATCH(pVarResult) = NULL;
1096                 else
1097                 {
1098                     ERR("MsiViewFetch returned %d\n", ret);
1099                     return DISP_E_EXCEPTION;
1100                 }
1101             }
1102             else return DISP_E_MEMBERNOTFOUND;
1103             break;
1104
1105         case DISPID_VIEW_MODIFY:
1106             if (wFlags & DISPATCH_METHOD)
1107             {
1108                 hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
1109                 if (FAILED(hr)) return hr;
1110                 hr = DispGetParam(pDispParams, 1, VT_DISPATCH, &varg1, puArgErr);
1111                 if (FAILED(hr)) return hr;
1112                 if (!V_DISPATCH(&varg1)) return DISP_E_EXCEPTION;
1113                 if ((ret = MsiViewModify(This->msiHandle, V_I4(&varg0), ((AutomationObject *)V_DISPATCH(&varg1))->msiHandle)) != ERROR_SUCCESS)
1114                 {
1115                     VariantClear(&varg1);
1116                     ERR("MsiViewModify returned %d\n", ret);
1117                     return DISP_E_EXCEPTION;
1118                 }
1119             }
1120             else return DISP_E_MEMBERNOTFOUND;
1121             break;
1122
1123         case DISPID_VIEW_CLOSE:
1124             if (wFlags & DISPATCH_METHOD)
1125             {
1126                 MsiViewClose(This->msiHandle);
1127             }
1128             else return DISP_E_MEMBERNOTFOUND;
1129             break;
1130
1131          default:
1132             return DISP_E_MEMBERNOTFOUND;
1133     }
1134
1135     VariantClear(&varg1);
1136     VariantClear(&varg0);
1137
1138     return S_OK;
1139 }
1140
1141 static HRESULT WINAPI DatabaseImpl_Invoke(
1142         AutomationObject* This,
1143         DISPID dispIdMember,
1144         REFIID riid,
1145         LCID lcid,
1146         WORD wFlags,
1147         DISPPARAMS* pDispParams,
1148         VARIANT* pVarResult,
1149         EXCEPINFO* pExcepInfo,
1150         UINT* puArgErr)
1151 {
1152     MSIHANDLE msiHandle;
1153     IDispatch *pDispatch = NULL;
1154     UINT ret;
1155     VARIANTARG varg0, varg1;
1156     HRESULT hr;
1157
1158     VariantInit(&varg0);
1159     VariantInit(&varg1);
1160
1161     switch (dispIdMember)
1162     {
1163         case DISPID_DATABASE_SUMMARYINFORMATION:
1164             if (wFlags & DISPATCH_PROPERTYGET)
1165             {
1166                 hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
1167                 if (FAILED(hr))
1168                     V_I4(&varg0) = 0;
1169
1170                 V_VT(pVarResult) = VT_DISPATCH;
1171                 if ((ret = MsiGetSummaryInformationW(This->msiHandle, NULL, V_I4(&varg0), &msiHandle)) == ERROR_SUCCESS)
1172                 {
1173                     hr = create_automation_object(msiHandle, NULL, (LPVOID *)&pDispatch, &DIID_SummaryInfo, SummaryInfoImpl_Invoke, NULL, 0);
1174                     if (SUCCEEDED(hr))
1175                         V_DISPATCH(pVarResult) = pDispatch;
1176                     else
1177                         ERR("Failed to create SummaryInfo object: 0x%08x\n", hr);
1178                 }
1179                 else
1180                 {
1181                     ERR("MsiGetSummaryInformation returned %d\n", ret);
1182                     return DISP_E_EXCEPTION;
1183                 }
1184             }
1185             else return DISP_E_MEMBERNOTFOUND;
1186             break;
1187
1188         case DISPID_DATABASE_OPENVIEW:
1189             if (wFlags & DISPATCH_METHOD)
1190             {
1191                 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1192                 if (FAILED(hr)) return hr;
1193                 V_VT(pVarResult) = VT_DISPATCH;
1194                 if ((ret = MsiDatabaseOpenViewW(This->msiHandle, V_BSTR(&varg0), &msiHandle)) == ERROR_SUCCESS)
1195                 {
1196                     if (SUCCEEDED(hr = create_automation_object(msiHandle, NULL, (LPVOID*)&pDispatch, &DIID_View, ViewImpl_Invoke, NULL, 0)))
1197                         V_DISPATCH(pVarResult) = pDispatch;
1198                     else
1199                         ERR("Failed to create View object, hresult 0x%08x\n", hr);
1200                 }
1201                 else
1202                 {
1203                     VariantClear(&varg0);
1204                     ERR("MsiDatabaseOpenView returned %d\n", ret);
1205                     return DISP_E_EXCEPTION;
1206                 }
1207             }
1208             else return DISP_E_MEMBERNOTFOUND;
1209             break;
1210
1211          default:
1212             return DISP_E_MEMBERNOTFOUND;
1213     }
1214
1215     VariantClear(&varg1);
1216     VariantClear(&varg0);
1217
1218     return S_OK;
1219 }
1220
1221 static HRESULT WINAPI SessionImpl_Invoke(
1222         AutomationObject* This,
1223         DISPID dispIdMember,
1224         REFIID riid,
1225         LCID lcid,
1226         WORD wFlags,
1227         DISPPARAMS* pDispParams,
1228         VARIANT* pVarResult,
1229         EXCEPINFO* pExcepInfo,
1230         UINT* puArgErr)
1231 {
1232     SessionData *data = private_data(This);
1233     WCHAR *szString;
1234     DWORD dwLen;
1235     IDispatch *pDispatch = NULL;
1236     MSIHANDLE msiHandle;
1237     LANGID langId;
1238     UINT ret;
1239     INSTALLSTATE iInstalled, iAction;
1240     VARIANTARG varg0, varg1;
1241     HRESULT hr;
1242
1243     VariantInit(&varg0);
1244     VariantInit(&varg1);
1245
1246     switch (dispIdMember)
1247     {
1248         case DISPID_SESSION_INSTALLER:
1249             if (wFlags & DISPATCH_PROPERTYGET) {
1250                 V_VT(pVarResult) = VT_DISPATCH;
1251                 IDispatch_AddRef(data->pInstaller);
1252                 V_DISPATCH(pVarResult) = data->pInstaller;
1253             }
1254             else return DISP_E_MEMBERNOTFOUND;
1255             break;
1256
1257         case DISPID_SESSION_PROPERTY:
1258             if (wFlags & DISPATCH_PROPERTYGET) {
1259                 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1260                 if (FAILED(hr)) return hr;
1261                 V_VT(pVarResult) = VT_BSTR;
1262                 V_BSTR(pVarResult) = NULL;
1263                 if ((ret = MsiGetPropertyW(This->msiHandle, V_BSTR(&varg0), NULL, &dwLen)) == ERROR_SUCCESS)
1264                 {
1265                     if (!(szString = msi_alloc((++dwLen)*sizeof(WCHAR))))
1266                         ERR("Out of memory\n");
1267                     else if ((ret = MsiGetPropertyW(This->msiHandle, V_BSTR(&varg0), szString, &dwLen)) == ERROR_SUCCESS)
1268                         V_BSTR(pVarResult) = SysAllocString(szString);
1269                     msi_free(szString);
1270                 }
1271                 if (ret != ERROR_SUCCESS)
1272                     ERR("MsiGetProperty returned %d\n", ret);
1273             } else if (wFlags & DISPATCH_PROPERTYPUT) {
1274                 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1275                 if (FAILED(hr)) return hr;
1276                 hr = DispGetParam(pDispParams, DISPID_PROPERTYPUT, VT_BSTR, &varg1, puArgErr);
1277                 if (FAILED(hr)) {
1278                     VariantClear(&varg0);
1279                     return hr;
1280                 }
1281                 if ((ret = MsiSetPropertyW(This->msiHandle, V_BSTR(&varg0), V_BSTR(&varg1))) != ERROR_SUCCESS)
1282                 {
1283                     VariantClear(&varg0);
1284                     VariantClear(&varg1);
1285                     ERR("MsiSetProperty returned %d\n", ret);
1286                     return DISP_E_EXCEPTION;
1287                 }
1288             }
1289             else return DISP_E_MEMBERNOTFOUND;
1290             break;
1291
1292         case DISPID_SESSION_LANGUAGE:
1293             if (wFlags & DISPATCH_PROPERTYGET) {
1294                 langId = MsiGetLanguage(This->msiHandle);
1295                 V_VT(pVarResult) = VT_I4;
1296                 V_I4(pVarResult) = langId;
1297             }
1298             else return DISP_E_MEMBERNOTFOUND;
1299             break;
1300
1301         case DISPID_SESSION_MODE:
1302             if (wFlags & DISPATCH_PROPERTYGET) {
1303                 hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
1304                 if (FAILED(hr)) return hr;
1305                 V_VT(pVarResult) = VT_BOOL;
1306                 V_BOOL(pVarResult) = MsiGetMode(This->msiHandle, V_I4(&varg0));
1307             } else if (wFlags & DISPATCH_PROPERTYPUT) {
1308                 hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
1309                 if (FAILED(hr)) return hr;
1310                 hr = DispGetParam(pDispParams, DISPID_PROPERTYPUT, VT_BOOL, &varg1, puArgErr);
1311                 if (FAILED(hr)) return hr;
1312                 if ((ret = MsiSetMode(This->msiHandle, V_I4(&varg0), V_BOOL(&varg1))) != ERROR_SUCCESS)
1313                 {
1314                     ERR("MsiSetMode returned %d\n", ret);
1315                     return DISP_E_EXCEPTION;
1316                 }
1317             }
1318             else return DISP_E_MEMBERNOTFOUND;
1319             break;
1320
1321         case DISPID_SESSION_DATABASE:
1322             if (wFlags & DISPATCH_PROPERTYGET) {
1323                 V_VT(pVarResult) = VT_DISPATCH;
1324                 if ((msiHandle = MsiGetActiveDatabase(This->msiHandle)))
1325                 {
1326                     if (SUCCEEDED(hr = create_automation_object(msiHandle, NULL, (LPVOID*)&pDispatch, &DIID_Database, DatabaseImpl_Invoke, NULL, 0)))
1327                         V_DISPATCH(pVarResult) = pDispatch;
1328                     else
1329                         ERR("Failed to create Database object, hresult 0x%08x\n", hr);
1330                 }
1331                 else
1332                 {
1333                     ERR("MsiGetActiveDatabase failed\n");
1334                     return DISP_E_EXCEPTION;
1335                 }
1336             }
1337             else return DISP_E_MEMBERNOTFOUND;
1338             break;
1339
1340         case DISPID_SESSION_DOACTION:
1341             if (wFlags & DISPATCH_METHOD) {
1342                 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1343                 if (FAILED(hr)) return hr;
1344                 ret = MsiDoActionW(This->msiHandle, V_BSTR(&varg0));
1345                 V_VT(pVarResult) = VT_I4;
1346                 switch (ret)
1347                 {
1348                     case ERROR_FUNCTION_NOT_CALLED:
1349                         V_I4(pVarResult) = msiDoActionStatusNoAction;
1350                         break;
1351                     case ERROR_SUCCESS:
1352                         V_I4(pVarResult) = msiDoActionStatusSuccess;
1353                         break;
1354                     case ERROR_INSTALL_USEREXIT:
1355                         V_I4(pVarResult) = msiDoActionStatusUserExit;
1356                         break;
1357                     case ERROR_INSTALL_FAILURE:
1358                         V_I4(pVarResult) = msiDoActionStatusFailure;
1359                         break;
1360                     case ERROR_INSTALL_SUSPEND:
1361                         V_I4(pVarResult) = msiDoActionStatusSuspend;
1362                         break;
1363                     case ERROR_MORE_DATA:
1364                         V_I4(pVarResult) = msiDoActionStatusFinished;
1365                         break;
1366                     case ERROR_INVALID_HANDLE_STATE:
1367                         V_I4(pVarResult) = msiDoActionStatusWrongState;
1368                         break;
1369                     case ERROR_INVALID_DATA:
1370                         V_I4(pVarResult) = msiDoActionStatusBadActionData;
1371                         break;
1372                     default:
1373                         VariantClear(&varg0);
1374                         FIXME("MsiDoAction returned unhandled value %d\n", ret);
1375                         return DISP_E_EXCEPTION;
1376                 }
1377             }
1378             else return DISP_E_MEMBERNOTFOUND;
1379             break;
1380
1381         case DISPID_SESSION_EVALUATECONDITION:
1382             if (wFlags & DISPATCH_METHOD) {
1383                 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1384                 if (FAILED(hr)) return hr;
1385                 V_VT(pVarResult) = VT_I4;
1386                 V_I4(pVarResult) = MsiEvaluateConditionW(This->msiHandle, V_BSTR(&varg0));
1387             }
1388             else return DISP_E_MEMBERNOTFOUND;
1389             break;
1390
1391         case DISPID_SESSION_MESSAGE:
1392             if(!(wFlags & DISPATCH_METHOD))
1393                 return DISP_E_MEMBERNOTFOUND;
1394
1395             hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
1396             if (FAILED(hr)) return hr;
1397             hr = DispGetParam(pDispParams, 1, VT_DISPATCH, &varg1, puArgErr);
1398             if (FAILED(hr)) return hr;
1399
1400             V_VT(pVarResult) = VT_I4;
1401             V_I4(pVarResult) =
1402                 MsiProcessMessage(This->msiHandle, V_I4(&varg0), ((AutomationObject *)V_DISPATCH(&varg1))->msiHandle);
1403             break;
1404
1405         case DISPID_SESSION_SETINSTALLLEVEL:
1406             if (wFlags & DISPATCH_METHOD) {
1407                 hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
1408                 if (FAILED(hr)) return hr;
1409                 if ((ret = MsiSetInstallLevel(This->msiHandle, V_I4(&varg0))) != ERROR_SUCCESS)
1410                 {
1411                     ERR("MsiSetInstallLevel returned %d\n", ret);
1412                     return DISP_E_EXCEPTION;
1413                 }
1414             }
1415             else return DISP_E_MEMBERNOTFOUND;
1416             break;
1417
1418         case DISPID_SESSION_FEATURECURRENTSTATE:
1419             if (wFlags & DISPATCH_PROPERTYGET) {
1420                 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1421                 if (FAILED(hr)) return hr;
1422                 V_VT(pVarResult) = VT_I4;
1423                 if ((ret = MsiGetFeatureStateW(This->msiHandle, V_BSTR(&varg0), &iInstalled, &iAction)) == ERROR_SUCCESS)
1424                     V_I4(pVarResult) = iInstalled;
1425                 else
1426                 {
1427                     ERR("MsiGetFeatureState returned %d\n", ret);
1428                     V_I4(pVarResult) = msiInstallStateUnknown;
1429                 }
1430             }
1431             else return DISP_E_MEMBERNOTFOUND;
1432             break;
1433
1434         case DISPID_SESSION_FEATUREREQUESTSTATE:
1435             if (wFlags & DISPATCH_PROPERTYGET) {
1436                 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1437                 if (FAILED(hr)) return hr;
1438                 V_VT(pVarResult) = VT_I4;
1439                 if ((ret = MsiGetFeatureStateW(This->msiHandle, V_BSTR(&varg0), &iInstalled, &iAction)) == ERROR_SUCCESS)
1440                     V_I4(pVarResult) = iAction;
1441                 else
1442                 {
1443                     ERR("MsiGetFeatureState returned %d\n", ret);
1444                     V_I4(pVarResult) = msiInstallStateUnknown;
1445                 }
1446             } else if (wFlags & DISPATCH_PROPERTYPUT) {
1447                 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1448                 if (FAILED(hr)) return hr;
1449                 hr = DispGetParam(pDispParams, DISPID_PROPERTYPUT, VT_I4, &varg1, puArgErr);
1450                 if (FAILED(hr)) {
1451                     VariantClear(&varg0);
1452                     return hr;
1453                 }
1454                 if ((ret = MsiSetFeatureStateW(This->msiHandle, V_BSTR(&varg0), V_I4(&varg1))) != ERROR_SUCCESS)
1455                 {
1456                     VariantClear(&varg0);
1457                     ERR("MsiSetFeatureState returned %d\n", ret);
1458                     return DISP_E_EXCEPTION;
1459                 }
1460             }
1461             else return DISP_E_MEMBERNOTFOUND;
1462             break;
1463
1464          default:
1465             return DISP_E_MEMBERNOTFOUND;
1466     }
1467
1468     VariantClear(&varg1);
1469     VariantClear(&varg0);
1470
1471     return S_OK;
1472 }
1473
1474 /* Fill the variant pointed to by pVarResult with the value & size returned by RegQueryValueEx as dictated by the
1475  * registry value type. Used by Installer::RegistryValue. */
1476 static void variant_from_registry_value(VARIANT *pVarResult, DWORD dwType, LPBYTE lpData, DWORD dwSize)
1477 {
1478     static const WCHAR szREG_BINARY[] = { '(','R','E','G','_','B','I','N','A','R','Y',')',0 };
1479     static const WCHAR szREG_[] = { '(','R','E','G','_',']',0 };
1480     WCHAR *szString = (WCHAR *)lpData;
1481     LPWSTR szNewString = NULL;
1482     DWORD dwNewSize = 0;
1483     int idx;
1484
1485     switch (dwType)
1486     {
1487         /* Registry strings may not be null terminated so we must use SysAllocStringByteLen/Len */
1488         case REG_MULTI_SZ: /* Multi SZ change internal null characters to newlines */
1489             idx = (dwSize/sizeof(WCHAR))-1;
1490             while (idx >= 0 && !szString[idx]) idx--;
1491             for (; idx >= 0; idx--)
1492                 if (!szString[idx]) szString[idx] = '\n';
1493         case REG_SZ:
1494             V_VT(pVarResult) = VT_BSTR;
1495             V_BSTR(pVarResult) = SysAllocStringByteLen((LPCSTR)szString, dwSize);
1496             break;
1497
1498         case REG_EXPAND_SZ:
1499             if (!(dwNewSize = ExpandEnvironmentStringsW(szString, szNewString, dwNewSize)))
1500                 ERR("ExpandEnvironmentStrings returned error %d\n", GetLastError());
1501             else if (!(szNewString = msi_alloc(dwNewSize)))
1502                 ERR("Out of memory\n");
1503             else if (!(dwNewSize = ExpandEnvironmentStringsW(szString, szNewString, dwNewSize)))
1504                 ERR("ExpandEnvironmentStrings returned error %d\n", GetLastError());
1505             else
1506             {
1507                 V_VT(pVarResult) = VT_BSTR;
1508                 V_BSTR(pVarResult) = SysAllocStringLen(szNewString, dwNewSize);
1509             }
1510             msi_free(szNewString);
1511             break;
1512
1513         case REG_DWORD:
1514             V_VT(pVarResult) = VT_I4;
1515             V_I4(pVarResult) = *((DWORD *)lpData);
1516             break;
1517
1518         case REG_QWORD:
1519             V_VT(pVarResult) = VT_BSTR;
1520             V_BSTR(pVarResult) = SysAllocString(szREG_);   /* Weird string, don't know why native returns it */
1521             break;
1522
1523         case REG_BINARY:
1524             V_VT(pVarResult) = VT_BSTR;
1525             V_BSTR(pVarResult) = SysAllocString(szREG_BINARY);
1526             break;
1527
1528         case REG_NONE:
1529             V_VT(pVarResult) = VT_EMPTY;
1530             break;
1531
1532         default:
1533             FIXME("Unhandled registry value type %d\n", dwType);
1534     }
1535 }
1536
1537 static HRESULT WINAPI InstallerImpl_Invoke(
1538         AutomationObject* This,
1539         DISPID dispIdMember,
1540         REFIID riid,
1541         LCID lcid,
1542         WORD wFlags,
1543         DISPPARAMS* pDispParams,
1544         VARIANT* pVarResult,
1545         EXCEPINFO* pExcepInfo,
1546         UINT* puArgErr)
1547 {
1548     MSIHANDLE msiHandle;
1549     IDispatch *pDispatch = NULL;
1550     UINT ret;
1551     VARIANTARG varg0, varg1, varg2;
1552     HRESULT hr;
1553     LPWSTR szString = NULL;
1554     DWORD dwSize = 0;
1555     INSTALLUILEVEL ui;
1556
1557     VariantInit(&varg0);
1558     VariantInit(&varg1);
1559     VariantInit(&varg2);
1560
1561     switch (dispIdMember)
1562     {
1563         case DISPID_INSTALLER_CREATERECORD:
1564             if (wFlags & DISPATCH_METHOD)
1565             {
1566                 hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
1567                 if (FAILED(hr)) return hr;
1568                 V_VT(pVarResult) = VT_DISPATCH;
1569                 if ((msiHandle = MsiCreateRecord(V_I4(&varg0))))
1570                 {
1571                     if (SUCCEEDED(hr = create_automation_object(msiHandle, NULL, (LPVOID*)&pDispatch, &DIID_Record, RecordImpl_Invoke, NULL, 0)))
1572                         V_DISPATCH(pVarResult) = pDispatch;
1573                     else
1574                         ERR("Failed to create Record object, hresult 0x%08x\n", hr);
1575                 }
1576                 else
1577                 {
1578                     ERR("MsiCreateRecord failed\n");
1579                     return DISP_E_EXCEPTION;
1580                 }
1581             }
1582             else return DISP_E_MEMBERNOTFOUND;
1583             break;
1584
1585         case DISPID_INSTALLER_OPENPACKAGE:
1586             if (wFlags & DISPATCH_METHOD)
1587             {
1588                 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1589                 if (FAILED(hr)) return hr;
1590                 hr = DispGetParam(pDispParams, 1, VT_I4, &varg1, puArgErr);
1591                 if (FAILED(hr))
1592                 {
1593                     VariantClear(&varg0);
1594                     return hr;
1595                 }
1596                 V_VT(pVarResult) = VT_DISPATCH;
1597                 if ((ret = MsiOpenPackageExW(V_BSTR(&varg0), V_I4(&varg1), &msiHandle)) == ERROR_SUCCESS)
1598                 {
1599                     if (SUCCEEDED(hr = create_session(msiHandle, (IDispatch *)This, &pDispatch)))
1600                         V_DISPATCH(pVarResult) = pDispatch;
1601                     else
1602                         ERR("Failed to create Session object, hresult 0x%08x\n", hr);
1603                 }
1604                 else
1605                 {
1606                     VariantClear(&varg0);
1607                     ERR("MsiOpenPackageEx returned %d\n", ret);
1608                     return DISP_E_EXCEPTION;
1609                 }
1610             }
1611             else return DISP_E_MEMBERNOTFOUND;
1612             break;
1613
1614         case DISPID_INSTALLER_OPENDATABASE:
1615             if (wFlags & DISPATCH_METHOD)
1616             {
1617                 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1618                 if (FAILED(hr)) return hr;
1619
1620                 hr = DispGetParam(pDispParams, 1, VT_BSTR, &varg1, puArgErr);
1621                 if (FAILED(hr))
1622                 {
1623                     VariantClear(&varg0);
1624                     return hr;
1625                 }
1626
1627                 V_VT(pVarResult) = VT_DISPATCH;
1628                 if ((ret = MsiOpenDatabaseW(V_BSTR(&varg0), V_BSTR(&varg1), &msiHandle)) == ERROR_SUCCESS)
1629                 {
1630                     hr = create_automation_object(msiHandle, NULL, (LPVOID *)&pDispatch,
1631                                                   &DIID_Database, DatabaseImpl_Invoke, NULL, 0);
1632                     if (SUCCEEDED(hr))
1633                         V_DISPATCH(pVarResult) = pDispatch;
1634                     else
1635                         ERR("Failed to create Database object: 0x%08x\n", hr);
1636                 }
1637                 else
1638                 {
1639                     VariantClear(&varg0);
1640                     VariantClear(&varg1);
1641                     ERR("MsiOpenDatabase returned %d\n", ret);
1642                     return DISP_E_EXCEPTION;
1643                 }
1644             }
1645             else return DISP_E_MEMBERNOTFOUND;
1646             break;
1647
1648         case DISPID_INSTALLER_UILEVEL:
1649             if (wFlags & DISPATCH_PROPERTYPUT)
1650             {
1651                 hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
1652                 if (FAILED(hr)) return hr;
1653                 if ((ui = MsiSetInternalUI(V_I4(&varg0), NULL) == INSTALLUILEVEL_NOCHANGE))
1654                 {
1655                     ERR("MsiSetInternalUI failed\n");
1656                     return DISP_E_EXCEPTION;
1657                 }
1658             }
1659             else if (wFlags & DISPATCH_PROPERTYGET)
1660             {
1661                 if ((ui = MsiSetInternalUI(INSTALLUILEVEL_NOCHANGE, NULL) == INSTALLUILEVEL_NOCHANGE))
1662                 {
1663                     ERR("MsiSetInternalUI failed\n");
1664                     return DISP_E_EXCEPTION;
1665                 }
1666
1667                 V_VT(pVarResult) = VT_I4;
1668                 V_I4(pVarResult) = ui;
1669             }
1670             else return DISP_E_MEMBERNOTFOUND;
1671             break;
1672
1673         case DISPID_INSTALLER_INSTALLPRODUCT:
1674             if (wFlags & DISPATCH_METHOD)
1675             {
1676                 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1677                 if (FAILED(hr)) return hr;
1678                 hr = DispGetParam(pDispParams, 1, VT_BSTR, &varg1, puArgErr);
1679                 if (FAILED(hr))
1680                 {
1681                     VariantClear(&varg0);
1682                     return hr;
1683                 }
1684                 if ((ret = MsiInstallProductW(V_BSTR(&varg0), V_BSTR(&varg1))) != ERROR_SUCCESS)
1685                 {
1686                     VariantClear(&varg1);
1687                     VariantClear(&varg0);
1688                     ERR("MsiInstallProduct returned %d\n", ret);
1689                     return DISP_E_EXCEPTION;
1690                 }
1691             }
1692             else return DISP_E_MEMBERNOTFOUND;
1693             break;
1694
1695         case DISPID_INSTALLER_VERSION:
1696             if (wFlags & DISPATCH_PROPERTYGET) {
1697                 DLLVERSIONINFO verinfo;
1698                 WCHAR version[MAX_PATH];
1699
1700                 static const WCHAR format[] = {'%','d','.','%','d','.','%','d','.','%','d',0};
1701
1702                 verinfo.cbSize = sizeof(DLLVERSIONINFO);
1703                 hr = DllGetVersion(&verinfo);
1704                 if (FAILED(hr)) return hr;
1705
1706                 sprintfW(version, format, verinfo.dwMajorVersion, verinfo.dwMinorVersion,
1707                          verinfo.dwBuildNumber, verinfo.dwPlatformID);
1708
1709                 V_VT(pVarResult) = VT_BSTR;
1710                 V_BSTR(pVarResult) = SysAllocString(version);
1711             }
1712             else return DISP_E_MEMBERNOTFOUND;
1713             break;
1714
1715         case DISPID_INSTALLER_REGISTRYVALUE:
1716             if (wFlags & DISPATCH_METHOD) {
1717                 HKEY hkey;
1718                 DWORD dwType;
1719                 UINT posValue = 2;    /* Save valuePos so we can save puArgErr if we are unable to do our type conversions */
1720
1721                 hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
1722                 if (FAILED(hr)) return hr;
1723                 hr = DispGetParam(pDispParams, 1, VT_BSTR, &varg1, puArgErr);
1724                 if (FAILED(hr)) return hr;
1725                 hr = DispGetParam_CopyOnly(pDispParams, &posValue, &varg2);
1726                 if (FAILED(hr))
1727                 {
1728                     VariantClear(&varg1);
1729                     return hr;
1730                 }
1731
1732                 if (V_I4(&varg0) >= REG_INDEX_CLASSES_ROOT &&
1733                     V_I4(&varg0) <= REG_INDEX_DYN_DATA)
1734                     V_I4(&varg0) |= (UINT_PTR)HKEY_CLASSES_ROOT;
1735
1736                 ret = RegOpenKeyW((HKEY)(UINT_PTR)V_I4(&varg0), V_BSTR(&varg1), &hkey);
1737
1738                 /* Third parameter can be VT_EMPTY, VT_I4, or VT_BSTR */
1739                 switch (V_VT(&varg2))
1740                 {
1741                     case VT_EMPTY:  /* Return VT_BOOL as to whether or not registry key exists */
1742                         V_VT(pVarResult) = VT_BOOL;
1743                         V_BOOL(pVarResult) = (ret == ERROR_SUCCESS);
1744                         break;
1745
1746                     case VT_BSTR:   /* Return value of specified key if it exists */
1747                         if (ret == ERROR_SUCCESS &&
1748                             (ret = RegQueryValueExW(hkey, V_BSTR(&varg2), NULL, NULL, NULL, &dwSize)) == ERROR_SUCCESS)
1749                         {
1750                             if (!(szString = msi_alloc(dwSize)))
1751                                 ERR("Out of memory\n");
1752                             else if ((ret = RegQueryValueExW(hkey, V_BSTR(&varg2), NULL, &dwType, (LPBYTE)szString, &dwSize)) == ERROR_SUCCESS)
1753                                 variant_from_registry_value(pVarResult, dwType, (LPBYTE)szString, dwSize);
1754                         }
1755
1756                         if (ret != ERROR_SUCCESS)
1757                         {
1758                             msi_free(szString);
1759                             VariantClear(&varg2);
1760                             VariantClear(&varg1);
1761                             return DISP_E_BADINDEX;
1762                         }
1763                         break;
1764
1765                     default:     /* Try to make it into VT_I4, can use VariantChangeType for this */
1766                         hr = VariantChangeType(&varg2, &varg2, 0, VT_I4);
1767                         if (SUCCEEDED(hr) && ret != ERROR_SUCCESS) hr = DISP_E_BADINDEX; /* Conversion fine, but couldn't find key */
1768                         if (FAILED(hr))
1769                         {
1770                             if (hr == DISP_E_TYPEMISMATCH) *puArgErr = posValue;
1771                             VariantClear(&varg2);   /* Unknown type, so let's clear it */
1772                             VariantClear(&varg1);
1773                             return hr;
1774                         }
1775
1776                         /* Retrieve class name or maximum value name or subkey name size */
1777                         if (!V_I4(&varg2))
1778                             ret = RegQueryInfoKeyW(hkey, NULL, &dwSize, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
1779                         else if (V_I4(&varg2) > 0)
1780                             ret = RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &dwSize, NULL, NULL, NULL);
1781                         else /* V_I4(&varg2) < 0 */
1782                             ret = RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, &dwSize, NULL, NULL, NULL, NULL, NULL, NULL);
1783
1784                         if (ret == ERROR_SUCCESS)
1785                         {
1786                             if (!(szString = msi_alloc(++dwSize * sizeof(WCHAR))))
1787                                 ERR("Out of memory\n");
1788                             else if (!V_I4(&varg2))
1789                                 ret = RegQueryInfoKeyW(hkey, szString, &dwSize, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
1790                             else if (V_I4(&varg2) > 0)
1791                                 ret = RegEnumValueW(hkey, V_I4(&varg2)-1, szString, &dwSize, 0, 0, NULL, NULL);
1792                             else /* V_I4(&varg2) < 0 */
1793                                 ret = RegEnumKeyW(hkey, -1 - V_I4(&varg2), szString, dwSize);
1794
1795                             if (szString && ret == ERROR_SUCCESS)
1796                             {
1797                                 V_VT(pVarResult) = VT_BSTR;
1798                                 V_BSTR(pVarResult) = SysAllocString(szString);
1799                             }
1800                         }
1801                 }
1802
1803                 msi_free(szString);
1804                 RegCloseKey(hkey);
1805             }
1806             else return DISP_E_MEMBERNOTFOUND;
1807             break;
1808
1809         case DISPID_INSTALLER_PRODUCTSTATE:
1810             if (wFlags & DISPATCH_PROPERTYGET) {
1811                 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1812                 if (FAILED(hr)) return hr;
1813                 V_VT(pVarResult) = VT_I4;
1814                 V_I4(pVarResult) = MsiQueryProductStateW(V_BSTR(&varg0));
1815             }
1816             else return DISP_E_MEMBERNOTFOUND;
1817             break;
1818
1819         case DISPID_INSTALLER_PRODUCTINFO:
1820             if (wFlags & DISPATCH_PROPERTYGET) {
1821                 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1822                 if (FAILED(hr)) return hr;
1823                 hr = DispGetParam(pDispParams, 1, VT_BSTR, &varg1, puArgErr);
1824                 if (FAILED(hr))
1825                 {
1826                     VariantClear(&varg0);
1827                     return hr;
1828                 }
1829                 V_VT(pVarResult) = VT_BSTR;
1830                 V_BSTR(pVarResult) = NULL;
1831                 if ((ret = MsiGetProductInfoW(V_BSTR(&varg0), V_BSTR(&varg1), NULL, &dwSize)) == ERROR_SUCCESS)
1832                 {
1833                     if (!(szString = msi_alloc((++dwSize)*sizeof(WCHAR))))
1834                         ERR("Out of memory\n");
1835                     else if ((ret = MsiGetProductInfoW(V_BSTR(&varg0), V_BSTR(&varg1), szString, &dwSize)) == ERROR_SUCCESS)
1836                         V_BSTR(pVarResult) = SysAllocString(szString);
1837                     msi_free(szString);
1838                 }
1839                 if (ret != ERROR_SUCCESS)
1840                 {
1841                     ERR("MsiGetProductInfo returned %d\n", ret);
1842                     VariantClear(&varg1);
1843                     VariantClear(&varg0);
1844                     return DISP_E_EXCEPTION;
1845                 }
1846             }
1847             else return DISP_E_MEMBERNOTFOUND;
1848             break;
1849
1850         case DISPID_INSTALLER_PRODUCTS:
1851             if (wFlags & DISPATCH_PROPERTYGET)
1852             {
1853                 ListData *ldata = NULL;
1854                 ULONG idx = 0;
1855                 WCHAR szProductBuf[GUID_SIZE];
1856
1857                 /* Find number of products */
1858                 while ((ret = MsiEnumProductsW(idx, szProductBuf)) == ERROR_SUCCESS) idx++;
1859                 if (ret != ERROR_NO_MORE_ITEMS)
1860                 {
1861                     ERR("MsiEnumProducts returned %d\n", ret);
1862                     return DISP_E_EXCEPTION;
1863                 }
1864
1865                 V_VT(pVarResult) = VT_DISPATCH;
1866                 if (SUCCEEDED(hr = create_automation_object(0, NULL, (LPVOID*)&pDispatch, &DIID_StringList, ListImpl_Invoke, ListImpl_Free, sizeof(ListData))))
1867                 {
1868                     V_DISPATCH(pVarResult) = pDispatch;
1869
1870                     /* Save product strings */
1871                     ldata = private_data((AutomationObject *)pDispatch);
1872                     if (!(ldata->pVars = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(VARIANT)*idx)))
1873                         ERR("Out of memory\n");
1874                     else
1875                     {
1876                         ldata->ulCount = idx;
1877                         for (idx = 0; idx < ldata->ulCount; idx++)
1878                         {
1879                             ret = MsiEnumProductsW(idx, szProductBuf);
1880                             VariantInit(&ldata->pVars[idx]);
1881                             V_VT(&ldata->pVars[idx]) = VT_BSTR;
1882                             V_BSTR(&ldata->pVars[idx]) = SysAllocString(szProductBuf);
1883                         }
1884                     }
1885                 }
1886                 else
1887                     ERR("Failed to create StringList object, hresult 0x%08x\n", hr);
1888             }
1889             else return DISP_E_MEMBERNOTFOUND;
1890             break;
1891
1892         case DISPID_INSTALLER_RELATEDPRODUCTS:
1893             if (wFlags & DISPATCH_PROPERTYGET)
1894             {
1895                 ListData *ldata = NULL;
1896                 ULONG idx = 0;
1897                 WCHAR szProductBuf[GUID_SIZE];
1898
1899                 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1900                 if (FAILED(hr)) return hr;
1901
1902                 /* Find number of related products */
1903                 while ((ret = MsiEnumRelatedProductsW(V_BSTR(&varg0), 0, idx, szProductBuf)) == ERROR_SUCCESS) idx++;
1904                 if (ret != ERROR_NO_MORE_ITEMS)
1905                 {
1906                     VariantClear(&varg0);
1907                     ERR("MsiEnumRelatedProducts returned %d\n", ret);
1908                     return DISP_E_EXCEPTION;
1909                 }
1910
1911                 V_VT(pVarResult) = VT_DISPATCH;
1912                 if (SUCCEEDED(hr = create_automation_object(0, NULL, (LPVOID*)&pDispatch, &DIID_StringList, ListImpl_Invoke, ListImpl_Free, sizeof(ListData))))
1913                 {
1914                     V_DISPATCH(pVarResult) = pDispatch;
1915
1916                     /* Save product strings */
1917                     ldata = private_data((AutomationObject *)pDispatch);
1918                     if (!(ldata->pVars = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(VARIANT)*idx)))
1919                         ERR("Out of memory\n");
1920                     else
1921                     {
1922                         ldata->ulCount = idx;
1923                         for (idx = 0; idx < ldata->ulCount; idx++)
1924                         {
1925                             ret = MsiEnumRelatedProductsW(V_BSTR(&varg0), 0, idx, szProductBuf);
1926                             VariantInit(&ldata->pVars[idx]);
1927                             V_VT(&ldata->pVars[idx]) = VT_BSTR;
1928                             V_BSTR(&ldata->pVars[idx]) = SysAllocString(szProductBuf);
1929                         }
1930                     }
1931                 }
1932                 else
1933                     ERR("Failed to create StringList object, hresult 0x%08x\n", hr);
1934             }
1935             else return DISP_E_MEMBERNOTFOUND;
1936             break;
1937
1938          default:
1939             return DISP_E_MEMBERNOTFOUND;
1940     }
1941
1942     VariantClear(&varg2);
1943     VariantClear(&varg1);
1944     VariantClear(&varg0);
1945
1946     return S_OK;
1947 }
1948
1949 /* Wrapper around create_automation_object to create an installer object. */
1950 HRESULT create_msiserver(IUnknown *pOuter, LPVOID *ppObj)
1951 {
1952     return create_automation_object(0, pOuter, ppObj, &DIID_Installer, InstallerImpl_Invoke, NULL, 0);
1953 }
1954
1955 /* Wrapper around create_automation_object to create a session object. */
1956 HRESULT create_session(MSIHANDLE msiHandle, IDispatch *pInstaller, IDispatch **pDispatch)
1957 {
1958     HRESULT hr = create_automation_object(msiHandle, NULL, (LPVOID)pDispatch, &DIID_Session, SessionImpl_Invoke, NULL, sizeof(SessionData));
1959     if (SUCCEEDED(hr) && pDispatch && *pDispatch)
1960         ((SessionData *)private_data((AutomationObject *)*pDispatch))->pInstaller = pInstaller;
1961     return hr;
1962 }