dll/win32/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 = msi_alloc_zero( 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         msi_free( 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 = msi_alloc_zero( 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         msi_free(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         msi_free(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     msi_free(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 DatabaseImpl_LastErrorRecord(WORD wFlags,
1142                                             DISPPARAMS* pDispParams,
1143                                             VARIANT* pVarResult,
1144                                             EXCEPINFO* pExcepInfo,
1145                                             UINT* puArgErr)
1146 {
1147     if (!(wFlags & DISPATCH_METHOD))
1148         return DISP_E_MEMBERNOTFOUND;
1149
1150     FIXME("\n");
1151
1152     VariantInit(pVarResult);
1153     return S_OK;
1154 }
1155
1156 static HRESULT WINAPI DatabaseImpl_Invoke(
1157         AutomationObject* This,
1158         DISPID dispIdMember,
1159         REFIID riid,
1160         LCID lcid,
1161         WORD wFlags,
1162         DISPPARAMS* pDispParams,
1163         VARIANT* pVarResult,
1164         EXCEPINFO* pExcepInfo,
1165         UINT* puArgErr)
1166 {
1167     MSIHANDLE msiHandle;
1168     IDispatch *pDispatch = NULL;
1169     UINT ret;
1170     VARIANTARG varg0, varg1;
1171     HRESULT hr;
1172
1173     VariantInit(&varg0);
1174     VariantInit(&varg1);
1175
1176     switch (dispIdMember)
1177     {
1178         case DISPID_DATABASE_SUMMARYINFORMATION:
1179             if (wFlags & DISPATCH_PROPERTYGET)
1180             {
1181                 hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
1182                 if (FAILED(hr))
1183                     V_I4(&varg0) = 0;
1184
1185                 V_VT(pVarResult) = VT_DISPATCH;
1186                 if ((ret = MsiGetSummaryInformationW(This->msiHandle, NULL, V_I4(&varg0), &msiHandle)) == ERROR_SUCCESS)
1187                 {
1188                     hr = create_automation_object(msiHandle, NULL, (LPVOID *)&pDispatch, &DIID_SummaryInfo, SummaryInfoImpl_Invoke, NULL, 0);
1189                     if (SUCCEEDED(hr))
1190                         V_DISPATCH(pVarResult) = pDispatch;
1191                     else
1192                         ERR("Failed to create SummaryInfo object: 0x%08x\n", hr);
1193                 }
1194                 else
1195                 {
1196                     ERR("MsiGetSummaryInformation returned %d\n", ret);
1197                     return DISP_E_EXCEPTION;
1198                 }
1199             }
1200             else return DISP_E_MEMBERNOTFOUND;
1201             break;
1202
1203         case DISPID_DATABASE_OPENVIEW:
1204             if (wFlags & DISPATCH_METHOD)
1205             {
1206                 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1207                 if (FAILED(hr)) return hr;
1208                 V_VT(pVarResult) = VT_DISPATCH;
1209                 if ((ret = MsiDatabaseOpenViewW(This->msiHandle, V_BSTR(&varg0), &msiHandle)) == ERROR_SUCCESS)
1210                 {
1211                     if (SUCCEEDED(hr = create_automation_object(msiHandle, NULL, (LPVOID*)&pDispatch, &DIID_View, ViewImpl_Invoke, NULL, 0)))
1212                         V_DISPATCH(pVarResult) = pDispatch;
1213                     else
1214                         ERR("Failed to create View object, hresult 0x%08x\n", hr);
1215                 }
1216                 else
1217                 {
1218                     VariantClear(&varg0);
1219                     ERR("MsiDatabaseOpenView returned %d\n", ret);
1220                     return DISP_E_EXCEPTION;
1221                 }
1222             }
1223             else return DISP_E_MEMBERNOTFOUND;
1224             break;
1225
1226         case DISPID_INSTALLER_LASTERRORRECORD:
1227             return DatabaseImpl_LastErrorRecord(wFlags, pDispParams,
1228                                                 pVarResult, pExcepInfo,
1229                                                 puArgErr);
1230
1231          default:
1232             return DISP_E_MEMBERNOTFOUND;
1233     }
1234
1235     VariantClear(&varg1);
1236     VariantClear(&varg0);
1237
1238     return S_OK;
1239 }
1240
1241 static HRESULT WINAPI SessionImpl_Invoke(
1242         AutomationObject* This,
1243         DISPID dispIdMember,
1244         REFIID riid,
1245         LCID lcid,
1246         WORD wFlags,
1247         DISPPARAMS* pDispParams,
1248         VARIANT* pVarResult,
1249         EXCEPINFO* pExcepInfo,
1250         UINT* puArgErr)
1251 {
1252     SessionData *data = private_data(This);
1253     WCHAR *szString;
1254     DWORD dwLen;
1255     IDispatch *pDispatch = NULL;
1256     MSIHANDLE msiHandle;
1257     LANGID langId;
1258     UINT ret;
1259     INSTALLSTATE iInstalled, iAction;
1260     VARIANTARG varg0, varg1;
1261     HRESULT hr;
1262
1263     VariantInit(&varg0);
1264     VariantInit(&varg1);
1265
1266     switch (dispIdMember)
1267     {
1268         case DISPID_SESSION_INSTALLER:
1269             if (wFlags & DISPATCH_PROPERTYGET) {
1270                 V_VT(pVarResult) = VT_DISPATCH;
1271                 IDispatch_AddRef(data->pInstaller);
1272                 V_DISPATCH(pVarResult) = data->pInstaller;
1273             }
1274             else return DISP_E_MEMBERNOTFOUND;
1275             break;
1276
1277         case DISPID_SESSION_PROPERTY:
1278             if (wFlags & DISPATCH_PROPERTYGET) {
1279                 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1280                 if (FAILED(hr)) return hr;
1281                 V_VT(pVarResult) = VT_BSTR;
1282                 V_BSTR(pVarResult) = NULL;
1283                 if ((ret = MsiGetPropertyW(This->msiHandle, V_BSTR(&varg0), NULL, &dwLen)) == ERROR_SUCCESS)
1284                 {
1285                     if (!(szString = msi_alloc((++dwLen)*sizeof(WCHAR))))
1286                         ERR("Out of memory\n");
1287                     else if ((ret = MsiGetPropertyW(This->msiHandle, V_BSTR(&varg0), szString, &dwLen)) == ERROR_SUCCESS)
1288                         V_BSTR(pVarResult) = SysAllocString(szString);
1289                     msi_free(szString);
1290                 }
1291                 if (ret != ERROR_SUCCESS)
1292                     ERR("MsiGetProperty returned %d\n", ret);
1293             } else if (wFlags & DISPATCH_PROPERTYPUT) {
1294                 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1295                 if (FAILED(hr)) return hr;
1296                 hr = DispGetParam(pDispParams, DISPID_PROPERTYPUT, VT_BSTR, &varg1, puArgErr);
1297                 if (FAILED(hr)) {
1298                     VariantClear(&varg0);
1299                     return hr;
1300                 }
1301                 if ((ret = MsiSetPropertyW(This->msiHandle, V_BSTR(&varg0), V_BSTR(&varg1))) != ERROR_SUCCESS)
1302                 {
1303                     VariantClear(&varg0);
1304                     VariantClear(&varg1);
1305                     ERR("MsiSetProperty returned %d\n", ret);
1306                     return DISP_E_EXCEPTION;
1307                 }
1308             }
1309             else return DISP_E_MEMBERNOTFOUND;
1310             break;
1311
1312         case DISPID_SESSION_LANGUAGE:
1313             if (wFlags & DISPATCH_PROPERTYGET) {
1314                 langId = MsiGetLanguage(This->msiHandle);
1315                 V_VT(pVarResult) = VT_I4;
1316                 V_I4(pVarResult) = langId;
1317             }
1318             else return DISP_E_MEMBERNOTFOUND;
1319             break;
1320
1321         case DISPID_SESSION_MODE:
1322             if (wFlags & DISPATCH_PROPERTYGET) {
1323                 hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
1324                 if (FAILED(hr)) return hr;
1325                 V_VT(pVarResult) = VT_BOOL;
1326                 V_BOOL(pVarResult) = MsiGetMode(This->msiHandle, V_I4(&varg0));
1327             } else if (wFlags & DISPATCH_PROPERTYPUT) {
1328                 hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
1329                 if (FAILED(hr)) return hr;
1330                 hr = DispGetParam(pDispParams, DISPID_PROPERTYPUT, VT_BOOL, &varg1, puArgErr);
1331                 if (FAILED(hr)) return hr;
1332                 if ((ret = MsiSetMode(This->msiHandle, V_I4(&varg0), V_BOOL(&varg1))) != ERROR_SUCCESS)
1333                 {
1334                     ERR("MsiSetMode returned %d\n", ret);
1335                     return DISP_E_EXCEPTION;
1336                 }
1337             }
1338             else return DISP_E_MEMBERNOTFOUND;
1339             break;
1340
1341         case DISPID_SESSION_DATABASE:
1342             if (wFlags & DISPATCH_PROPERTYGET) {
1343                 V_VT(pVarResult) = VT_DISPATCH;
1344                 if ((msiHandle = MsiGetActiveDatabase(This->msiHandle)))
1345                 {
1346                     if (SUCCEEDED(hr = create_automation_object(msiHandle, NULL, (LPVOID*)&pDispatch, &DIID_Database, DatabaseImpl_Invoke, NULL, 0)))
1347                         V_DISPATCH(pVarResult) = pDispatch;
1348                     else
1349                         ERR("Failed to create Database object, hresult 0x%08x\n", hr);
1350                 }
1351                 else
1352                 {
1353                     ERR("MsiGetActiveDatabase failed\n");
1354                     return DISP_E_EXCEPTION;
1355                 }
1356             }
1357             else return DISP_E_MEMBERNOTFOUND;
1358             break;
1359
1360         case DISPID_SESSION_DOACTION:
1361             if (wFlags & DISPATCH_METHOD) {
1362                 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1363                 if (FAILED(hr)) return hr;
1364                 ret = MsiDoActionW(This->msiHandle, V_BSTR(&varg0));
1365                 V_VT(pVarResult) = VT_I4;
1366                 switch (ret)
1367                 {
1368                     case ERROR_FUNCTION_NOT_CALLED:
1369                         V_I4(pVarResult) = msiDoActionStatusNoAction;
1370                         break;
1371                     case ERROR_SUCCESS:
1372                         V_I4(pVarResult) = msiDoActionStatusSuccess;
1373                         break;
1374                     case ERROR_INSTALL_USEREXIT:
1375                         V_I4(pVarResult) = msiDoActionStatusUserExit;
1376                         break;
1377                     case ERROR_INSTALL_FAILURE:
1378                         V_I4(pVarResult) = msiDoActionStatusFailure;
1379                         break;
1380                     case ERROR_INSTALL_SUSPEND:
1381                         V_I4(pVarResult) = msiDoActionStatusSuspend;
1382                         break;
1383                     case ERROR_MORE_DATA:
1384                         V_I4(pVarResult) = msiDoActionStatusFinished;
1385                         break;
1386                     case ERROR_INVALID_HANDLE_STATE:
1387                         V_I4(pVarResult) = msiDoActionStatusWrongState;
1388                         break;
1389                     case ERROR_INVALID_DATA:
1390                         V_I4(pVarResult) = msiDoActionStatusBadActionData;
1391                         break;
1392                     default:
1393                         VariantClear(&varg0);
1394                         FIXME("MsiDoAction returned unhandled value %d\n", ret);
1395                         return DISP_E_EXCEPTION;
1396                 }
1397             }
1398             else return DISP_E_MEMBERNOTFOUND;
1399             break;
1400
1401         case DISPID_SESSION_EVALUATECONDITION:
1402             if (wFlags & DISPATCH_METHOD) {
1403                 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1404                 if (FAILED(hr)) return hr;
1405                 V_VT(pVarResult) = VT_I4;
1406                 V_I4(pVarResult) = MsiEvaluateConditionW(This->msiHandle, V_BSTR(&varg0));
1407             }
1408             else return DISP_E_MEMBERNOTFOUND;
1409             break;
1410
1411         case DISPID_SESSION_MESSAGE:
1412             if(!(wFlags & DISPATCH_METHOD))
1413                 return DISP_E_MEMBERNOTFOUND;
1414
1415             hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
1416             if (FAILED(hr)) return hr;
1417             hr = DispGetParam(pDispParams, 1, VT_DISPATCH, &varg1, puArgErr);
1418             if (FAILED(hr)) return hr;
1419
1420             V_VT(pVarResult) = VT_I4;
1421             V_I4(pVarResult) =
1422                 MsiProcessMessage(This->msiHandle, V_I4(&varg0), ((AutomationObject *)V_DISPATCH(&varg1))->msiHandle);
1423             break;
1424
1425         case DISPID_SESSION_SETINSTALLLEVEL:
1426             if (wFlags & DISPATCH_METHOD) {
1427                 hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
1428                 if (FAILED(hr)) return hr;
1429                 if ((ret = MsiSetInstallLevel(This->msiHandle, V_I4(&varg0))) != ERROR_SUCCESS)
1430                 {
1431                     ERR("MsiSetInstallLevel returned %d\n", ret);
1432                     return DISP_E_EXCEPTION;
1433                 }
1434             }
1435             else return DISP_E_MEMBERNOTFOUND;
1436             break;
1437
1438         case DISPID_SESSION_FEATURECURRENTSTATE:
1439             if (wFlags & DISPATCH_PROPERTYGET) {
1440                 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1441                 if (FAILED(hr)) return hr;
1442                 V_VT(pVarResult) = VT_I4;
1443                 if ((ret = MsiGetFeatureStateW(This->msiHandle, V_BSTR(&varg0), &iInstalled, &iAction)) == ERROR_SUCCESS)
1444                     V_I4(pVarResult) = iInstalled;
1445                 else
1446                 {
1447                     ERR("MsiGetFeatureState returned %d\n", ret);
1448                     V_I4(pVarResult) = msiInstallStateUnknown;
1449                 }
1450             }
1451             else return DISP_E_MEMBERNOTFOUND;
1452             break;
1453
1454         case DISPID_SESSION_FEATUREREQUESTSTATE:
1455             if (wFlags & DISPATCH_PROPERTYGET) {
1456                 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1457                 if (FAILED(hr)) return hr;
1458                 V_VT(pVarResult) = VT_I4;
1459                 if ((ret = MsiGetFeatureStateW(This->msiHandle, V_BSTR(&varg0), &iInstalled, &iAction)) == ERROR_SUCCESS)
1460                     V_I4(pVarResult) = iAction;
1461                 else
1462                 {
1463                     ERR("MsiGetFeatureState returned %d\n", ret);
1464                     V_I4(pVarResult) = msiInstallStateUnknown;
1465                 }
1466             } else if (wFlags & DISPATCH_PROPERTYPUT) {
1467                 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1468                 if (FAILED(hr)) return hr;
1469                 hr = DispGetParam(pDispParams, DISPID_PROPERTYPUT, VT_I4, &varg1, puArgErr);
1470                 if (FAILED(hr)) {
1471                     VariantClear(&varg0);
1472                     return hr;
1473                 }
1474                 if ((ret = MsiSetFeatureStateW(This->msiHandle, V_BSTR(&varg0), V_I4(&varg1))) != ERROR_SUCCESS)
1475                 {
1476                     VariantClear(&varg0);
1477                     ERR("MsiSetFeatureState returned %d\n", ret);
1478                     return DISP_E_EXCEPTION;
1479                 }
1480             }
1481             else return DISP_E_MEMBERNOTFOUND;
1482             break;
1483
1484          default:
1485             return DISP_E_MEMBERNOTFOUND;
1486     }
1487
1488     VariantClear(&varg1);
1489     VariantClear(&varg0);
1490
1491     return S_OK;
1492 }
1493
1494 /* Fill the variant pointed to by pVarResult with the value & size returned by RegQueryValueEx as dictated by the
1495  * registry value type. Used by Installer::RegistryValue. */
1496 static void variant_from_registry_value(VARIANT *pVarResult, DWORD dwType, LPBYTE lpData, DWORD dwSize)
1497 {
1498     static const WCHAR szREG_BINARY[] = { '(','R','E','G','_','B','I','N','A','R','Y',')',0 };
1499     static const WCHAR szREG_[] = { '(','R','E','G','_',']',0 };
1500     WCHAR *szString = (WCHAR *)lpData;
1501     LPWSTR szNewString = NULL;
1502     DWORD dwNewSize = 0;
1503     int idx;
1504
1505     switch (dwType)
1506     {
1507         /* Registry strings may not be null terminated so we must use SysAllocStringByteLen/Len */
1508         case REG_MULTI_SZ: /* Multi SZ change internal null characters to newlines */
1509             idx = (dwSize/sizeof(WCHAR))-1;
1510             while (idx >= 0 && !szString[idx]) idx--;
1511             for (; idx >= 0; idx--)
1512                 if (!szString[idx]) szString[idx] = '\n';
1513         case REG_SZ:
1514             V_VT(pVarResult) = VT_BSTR;
1515             V_BSTR(pVarResult) = SysAllocStringByteLen((LPCSTR)szString, dwSize);
1516             break;
1517
1518         case REG_EXPAND_SZ:
1519             if (!(dwNewSize = ExpandEnvironmentStringsW(szString, szNewString, dwNewSize)))
1520                 ERR("ExpandEnvironmentStrings returned error %d\n", GetLastError());
1521             else if (!(szNewString = msi_alloc(dwNewSize * sizeof(WCHAR))))
1522                 ERR("Out of memory\n");
1523             else if (!(dwNewSize = ExpandEnvironmentStringsW(szString, szNewString, dwNewSize)))
1524                 ERR("ExpandEnvironmentStrings returned error %d\n", GetLastError());
1525             else
1526             {
1527                 V_VT(pVarResult) = VT_BSTR;
1528                 V_BSTR(pVarResult) = SysAllocStringLen(szNewString, dwNewSize);
1529             }
1530             msi_free(szNewString);
1531             break;
1532
1533         case REG_DWORD:
1534             V_VT(pVarResult) = VT_I4;
1535             V_I4(pVarResult) = *((DWORD *)lpData);
1536             break;
1537
1538         case REG_QWORD:
1539             V_VT(pVarResult) = VT_BSTR;
1540             V_BSTR(pVarResult) = SysAllocString(szREG_);   /* Weird string, don't know why native returns it */
1541             break;
1542
1543         case REG_BINARY:
1544             V_VT(pVarResult) = VT_BSTR;
1545             V_BSTR(pVarResult) = SysAllocString(szREG_BINARY);
1546             break;
1547
1548         case REG_NONE:
1549             V_VT(pVarResult) = VT_EMPTY;
1550             break;
1551
1552         default:
1553             FIXME("Unhandled registry value type %d\n", dwType);
1554     }
1555 }
1556
1557 static HRESULT InstallerImpl_CreateRecord(WORD wFlags,
1558                                           DISPPARAMS* pDispParams,
1559                                           VARIANT* pVarResult,
1560                                           EXCEPINFO* pExcepInfo,
1561                                           UINT* puArgErr)
1562 {
1563     HRESULT hr;
1564     VARIANTARG varg0;
1565     MSIHANDLE hrec;
1566     IDispatch* dispatch;
1567
1568     if (!(wFlags & DISPATCH_METHOD))
1569         return DISP_E_MEMBERNOTFOUND;
1570
1571     VariantInit(&varg0);
1572     hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
1573     if (FAILED(hr))
1574         return hr;
1575
1576     V_VT(pVarResult) = VT_DISPATCH;
1577
1578     hrec = MsiCreateRecord(V_I4(&varg0));
1579     if (!hrec)
1580         return DISP_E_EXCEPTION;
1581
1582     hr = create_automation_object(hrec, NULL, (LPVOID*)&dispatch,
1583                                   &DIID_Record, RecordImpl_Invoke, NULL, 0);
1584     if (SUCCEEDED(hr))
1585         V_DISPATCH(pVarResult) = dispatch;
1586
1587     return hr;
1588 }
1589
1590 static HRESULT InstallerImpl_OpenPackage(AutomationObject* This,
1591                                          WORD wFlags,
1592                                          DISPPARAMS* pDispParams,
1593                                          VARIANT* pVarResult,
1594                                          EXCEPINFO* pExcepInfo,
1595                                          UINT* puArgErr)
1596 {
1597     UINT ret;
1598     HRESULT hr;
1599     MSIHANDLE hpkg;
1600     IDispatch* dispatch;
1601     VARIANTARG varg0, varg1;
1602
1603     if (!(wFlags & DISPATCH_METHOD))
1604         return DISP_E_MEMBERNOTFOUND;
1605
1606     if (pDispParams->cArgs == 0)
1607         return DISP_E_TYPEMISMATCH;
1608
1609     if (V_VT(&pDispParams->rgvarg[pDispParams->cArgs - 1]) != VT_BSTR)
1610         return DISP_E_TYPEMISMATCH;
1611
1612     VariantInit(&varg0);
1613     hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1614     if (FAILED(hr))
1615         return hr;
1616
1617     VariantInit(&varg1);
1618     if (pDispParams->cArgs == 2)
1619     {
1620         hr = DispGetParam(pDispParams, 1, VT_I4, &varg1, puArgErr);
1621         if (FAILED(hr))
1622             goto done;
1623     }
1624     else
1625     {
1626         V_VT(&varg1) = VT_I4;
1627         V_I4(&varg1) = 0;
1628     }
1629
1630     V_VT(pVarResult) = VT_DISPATCH;
1631
1632     ret = MsiOpenPackageExW(V_BSTR(&varg0), V_I4(&varg1), &hpkg);
1633     if (ret != ERROR_SUCCESS)
1634     {
1635         hr = DISP_E_EXCEPTION;
1636         goto done;
1637     }
1638
1639     hr = create_session(hpkg, (IDispatch *)This, &dispatch);
1640     if (SUCCEEDED(hr))
1641         V_DISPATCH(pVarResult) = dispatch;
1642
1643 done:
1644     VariantClear(&varg0);
1645     VariantClear(&varg1);
1646     return hr;
1647 }
1648
1649 static HRESULT InstallerImpl_OpenProduct(WORD wFlags,
1650                                          DISPPARAMS* pDispParams,
1651                                          VARIANT* pVarResult,
1652                                          EXCEPINFO* pExcepInfo,
1653                                          UINT* puArgErr)
1654 {
1655     HRESULT hr;
1656     VARIANTARG varg0;
1657
1658     if (!(wFlags & DISPATCH_METHOD))
1659         return DISP_E_MEMBERNOTFOUND;
1660
1661     VariantInit(&varg0);
1662     hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1663     if (FAILED(hr))
1664         return hr;
1665
1666     FIXME("%s\n", debugstr_w(V_BSTR(&varg0)));
1667
1668     VariantInit(pVarResult);
1669
1670     VariantClear(&varg0);
1671     return S_OK;
1672 }
1673
1674 static HRESULT InstallerImpl_OpenDatabase(WORD wFlags,
1675                                           DISPPARAMS* pDispParams,
1676                                           VARIANT* pVarResult,
1677                                           EXCEPINFO* pExcepInfo,
1678                                           UINT* puArgErr)
1679 {
1680     UINT ret;
1681     HRESULT hr;
1682     MSIHANDLE hdb;
1683     IDispatch* dispatch;
1684     VARIANTARG varg0, varg1;
1685
1686     if (!(wFlags & DISPATCH_METHOD))
1687         return DISP_E_MEMBERNOTFOUND;
1688
1689     VariantInit(&varg0);
1690     hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1691     if (FAILED(hr))
1692         return hr;
1693
1694     VariantInit(&varg1);
1695     hr = DispGetParam(pDispParams, 1, VT_BSTR, &varg1, puArgErr);
1696     if (FAILED(hr))
1697         goto done;
1698
1699     V_VT(pVarResult) = VT_DISPATCH;
1700
1701     ret = MsiOpenDatabaseW(V_BSTR(&varg0), V_BSTR(&varg1), &hdb);
1702     if (ret != ERROR_SUCCESS)
1703     {
1704         hr = DISP_E_EXCEPTION;
1705         goto done;
1706     }
1707
1708     hr = create_automation_object(hdb, NULL, (LPVOID *)&dispatch,
1709                                   &DIID_Database, DatabaseImpl_Invoke, NULL, 0);
1710     if (SUCCEEDED(hr))
1711         V_DISPATCH(pVarResult) = dispatch;
1712
1713 done:
1714     VariantClear(&varg0);
1715     VariantClear(&varg1);
1716     return hr;
1717 }
1718
1719 static HRESULT InstallerImpl_SummaryInformation(WORD wFlags,
1720                                                 DISPPARAMS* pDispParams,
1721                                                 VARIANT* pVarResult,
1722                                                 EXCEPINFO* pExcepInfo,
1723                                                 UINT* puArgErr)
1724 {
1725     if (!(wFlags & DISPATCH_METHOD))
1726         return DISP_E_MEMBERNOTFOUND;
1727
1728     FIXME("\n");
1729
1730     VariantInit(pVarResult);
1731     return S_OK;
1732 }
1733
1734 static HRESULT InstallerImpl_UILevel(WORD wFlags,
1735                                      DISPPARAMS* pDispParams,
1736                                      VARIANT* pVarResult,
1737                                      EXCEPINFO* pExcepInfo,
1738                                      UINT* puArgErr)
1739 {
1740     HRESULT hr;
1741     VARIANTARG varg0;
1742     INSTALLUILEVEL ui;
1743
1744     if (!(wFlags & DISPATCH_PROPERTYPUT) && !(wFlags & DISPATCH_PROPERTYGET))
1745         return DISP_E_MEMBERNOTFOUND;
1746
1747     if (wFlags & DISPATCH_PROPERTYPUT)
1748     {
1749         VariantInit(&varg0);
1750         hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
1751         if (FAILED(hr))
1752             return hr;
1753
1754         ui = MsiSetInternalUI(V_I4(&varg0), NULL);
1755         if (ui == INSTALLUILEVEL_NOCHANGE)
1756             return DISP_E_EXCEPTION;
1757     }
1758     else if (wFlags & DISPATCH_PROPERTYGET)
1759     {
1760         ui = MsiSetInternalUI(INSTALLUILEVEL_NOCHANGE, NULL);
1761         if (ui == INSTALLUILEVEL_NOCHANGE)
1762             return DISP_E_EXCEPTION;
1763
1764         V_VT(pVarResult) = VT_I4;
1765         V_I4(pVarResult) = ui;
1766     }
1767
1768     return S_OK;
1769 }
1770
1771 static HRESULT InstallerImpl_EnableLog(WORD wFlags,
1772                                        DISPPARAMS* pDispParams,
1773                                        VARIANT* pVarResult,
1774                                        EXCEPINFO* pExcepInfo,
1775                                        UINT* puArgErr)
1776 {
1777     if (!(wFlags & DISPATCH_METHOD))
1778         return DISP_E_MEMBERNOTFOUND;
1779
1780     FIXME("\n");
1781
1782     VariantInit(pVarResult);
1783     return S_OK;
1784 }
1785
1786 static HRESULT InstallerImpl_InstallProduct(WORD wFlags,
1787                                             DISPPARAMS* pDispParams,
1788                                             VARIANT* pVarResult,
1789                                             EXCEPINFO* pExcepInfo,
1790                                             UINT* puArgErr)
1791 {
1792     UINT ret;
1793     HRESULT hr;
1794     VARIANTARG varg0, varg1;
1795
1796     if (!(wFlags & DISPATCH_METHOD))
1797         return DISP_E_MEMBERNOTFOUND;
1798
1799     VariantInit(&varg0);
1800     hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1801     if (FAILED(hr))
1802         return hr;
1803
1804     VariantInit(&varg1);
1805     hr = DispGetParam(pDispParams, 1, VT_BSTR, &varg1, puArgErr);
1806     if (FAILED(hr))
1807         goto done;
1808
1809     ret = MsiInstallProductW(V_BSTR(&varg0), V_BSTR(&varg1));
1810     if (ret != ERROR_SUCCESS)
1811     {
1812         hr = DISP_E_EXCEPTION;
1813         goto done;
1814     }
1815
1816 done:
1817     VariantClear(&varg0);
1818     VariantClear(&varg1);
1819     return hr;
1820 }
1821
1822 static HRESULT InstallerImpl_Version(WORD wFlags,
1823                                      VARIANT* pVarResult,
1824                                      EXCEPINFO* pExcepInfo,
1825                                      UINT* puArgErr)
1826 {
1827     HRESULT hr;
1828     DLLVERSIONINFO verinfo;
1829     WCHAR version[MAX_PATH];
1830
1831     static const WCHAR format[] = {
1832         '%','d','.','%','d','.','%','d','.','%','d',0};
1833
1834     if (!(wFlags & DISPATCH_PROPERTYGET))
1835         return DISP_E_MEMBERNOTFOUND;
1836
1837     verinfo.cbSize = sizeof(DLLVERSIONINFO);
1838     hr = DllGetVersion(&verinfo);
1839     if (FAILED(hr))
1840         return hr;
1841
1842     sprintfW(version, format, verinfo.dwMajorVersion, verinfo.dwMinorVersion,
1843              verinfo.dwBuildNumber, verinfo.dwPlatformID);
1844
1845     V_VT(pVarResult) = VT_BSTR;
1846     V_BSTR(pVarResult) = SysAllocString(version);
1847     return S_OK;
1848 }
1849
1850 static HRESULT InstallerImpl_LastErrorRecord(WORD wFlags,
1851                                              DISPPARAMS* pDispParams,
1852                                              VARIANT* pVarResult,
1853                                              EXCEPINFO* pExcepInfo,
1854                                              UINT* puArgErr)
1855 {
1856     if (!(wFlags & DISPATCH_METHOD))
1857         return DISP_E_MEMBERNOTFOUND;
1858
1859     FIXME("\n");
1860
1861     VariantInit(pVarResult);
1862     return S_OK;
1863 }
1864
1865 static HRESULT InstallerImpl_RegistryValue(WORD wFlags,
1866                                            DISPPARAMS* pDispParams,
1867                                            VARIANT* pVarResult,
1868                                            EXCEPINFO* pExcepInfo,
1869                                            UINT* puArgErr)
1870 {
1871     UINT ret;
1872     HKEY hkey = NULL;
1873     HRESULT hr;
1874     UINT posValue;
1875     DWORD type, size;
1876     LPWSTR szString = NULL;
1877     VARIANTARG varg0, varg1, varg2;
1878
1879     if (!(wFlags & DISPATCH_METHOD))
1880         return DISP_E_MEMBERNOTFOUND;
1881
1882     VariantInit(&varg0);
1883     hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
1884     if (FAILED(hr))
1885         return hr;
1886
1887     VariantInit(&varg1);
1888     hr = DispGetParam(pDispParams, 1, VT_BSTR, &varg1, puArgErr);
1889     if (FAILED(hr))
1890         goto done;
1891
1892     /* Save valuePos so we can save puArgErr if we are unable to do our type
1893      * conversions.
1894      */
1895     posValue = 2;
1896     VariantInit(&varg2);
1897     hr = DispGetParam_CopyOnly(pDispParams, &posValue, &varg2);
1898     if (FAILED(hr))
1899         goto done;
1900
1901     if (V_I4(&varg0) >= REG_INDEX_CLASSES_ROOT &&
1902         V_I4(&varg0) <= REG_INDEX_DYN_DATA)
1903     {
1904         V_I4(&varg0) |= (UINT_PTR)HKEY_CLASSES_ROOT;
1905     }
1906
1907     ret = RegOpenKeyW((HKEY)(UINT_PTR)V_I4(&varg0), V_BSTR(&varg1), &hkey);
1908
1909     /* Only VT_EMPTY case can do anything if the key doesn't exist. */
1910     if (ret != ERROR_SUCCESS && V_VT(&varg2) != VT_EMPTY)
1911     {
1912         hr = DISP_E_BADINDEX;
1913         goto done;
1914     }
1915
1916     /* Third parameter can be VT_EMPTY, VT_I4, or VT_BSTR */
1917     switch (V_VT(&varg2))
1918     {
1919         /* Return VT_BOOL clarifying whether registry key exists or not. */
1920         case VT_EMPTY:
1921             V_VT(pVarResult) = VT_BOOL;
1922             V_BOOL(pVarResult) = (ret == ERROR_SUCCESS);
1923             break;
1924
1925         /* Return the value of specified key if it exists. */
1926         case VT_BSTR:
1927             ret = RegQueryValueExW(hkey, V_BSTR(&varg2),
1928                                    NULL, NULL, NULL, &size);
1929             if (ret != ERROR_SUCCESS)
1930             {
1931                 hr = DISP_E_BADINDEX;
1932                 goto done;
1933             }
1934
1935             szString = msi_alloc(size);
1936             if (!szString)
1937             {
1938                 hr = E_OUTOFMEMORY;
1939                 goto done;
1940             }
1941
1942             ret = RegQueryValueExW(hkey, V_BSTR(&varg2), NULL,
1943                                    &type, (LPBYTE)szString, &size);
1944             if (ret != ERROR_SUCCESS)
1945             {
1946                 msi_free(szString);
1947                 hr = DISP_E_BADINDEX;
1948                 goto done;
1949             }
1950
1951             variant_from_registry_value(pVarResult, type,
1952                                         (LPBYTE)szString, size);
1953             msi_free(szString);
1954             break;
1955
1956         /* Try to make it into VT_I4, can use VariantChangeType for this. */
1957         default:
1958             hr = VariantChangeType(&varg2, &varg2, 0, VT_I4);
1959             if (FAILED(hr))
1960             {
1961                 if (hr == DISP_E_TYPEMISMATCH)
1962                     *puArgErr = posValue;
1963
1964                 goto done;
1965             }
1966
1967             /* Retrieve class name or maximum value name or subkey name size. */
1968             if (!V_I4(&varg2))
1969                 ret = RegQueryInfoKeyW(hkey, NULL, &size, NULL, NULL, NULL,
1970                                        NULL, NULL, NULL, NULL, NULL, NULL);
1971             else if (V_I4(&varg2) > 0)
1972                 ret = RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL,
1973                                        NULL, NULL, &size, NULL, NULL, NULL);
1974             else /* V_I4(&varg2) < 0 */
1975                 ret = RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, &size,
1976                                        NULL, NULL, NULL, NULL, NULL, NULL);
1977
1978             if (ret != ERROR_SUCCESS)
1979                 goto done;
1980
1981             szString = msi_alloc(++size * sizeof(WCHAR));
1982             if (!szString)
1983             {
1984                 hr = E_OUTOFMEMORY;
1985                 goto done;
1986             }
1987
1988             if (!V_I4(&varg2))
1989                 ret = RegQueryInfoKeyW(hkey, szString, &size,NULL, NULL, NULL,
1990                                        NULL, NULL, NULL, NULL, NULL, NULL);
1991             else if (V_I4(&varg2) > 0)
1992                 ret = RegEnumValueW(hkey, V_I4(&varg2)-1, szString,
1993                                     &size, 0, 0, NULL, NULL);
1994             else /* V_I4(&varg2) < 0 */
1995                 ret = RegEnumKeyW(hkey, -1 - V_I4(&varg2), szString, size);
1996
1997             if (ret == ERROR_SUCCESS)
1998             {
1999                 V_VT(pVarResult) = VT_BSTR;
2000                 V_BSTR(pVarResult) = SysAllocString(szString);
2001             }
2002
2003             msi_free(szString);
2004     }
2005
2006 done:
2007     VariantClear(&varg0);
2008     VariantClear(&varg1);
2009     VariantClear(&varg2);
2010     RegCloseKey(hkey);
2011     return hr;
2012 }
2013
2014 static HRESULT InstallerImpl_Environment(WORD wFlags,
2015                                          DISPPARAMS* pDispParams,
2016                                          VARIANT* pVarResult,
2017                                          EXCEPINFO* pExcepInfo,
2018                                          UINT* puArgErr)
2019 {
2020     if (!(wFlags & DISPATCH_METHOD))
2021         return DISP_E_MEMBERNOTFOUND;
2022
2023     FIXME("\n");
2024
2025     VariantInit(pVarResult);
2026     return S_OK;
2027 }
2028
2029 static HRESULT InstallerImpl_FileAttributes(WORD wFlags,
2030                                             DISPPARAMS* pDispParams,
2031                                             VARIANT* pVarResult,
2032                                             EXCEPINFO* pExcepInfo,
2033                                             UINT* puArgErr)
2034 {
2035     if (!(wFlags & DISPATCH_METHOD))
2036         return DISP_E_MEMBERNOTFOUND;
2037
2038     FIXME("\n");
2039
2040     VariantInit(pVarResult);
2041     return S_OK;
2042 }
2043
2044 static HRESULT InstallerImpl_FileSize(WORD wFlags,
2045                                       DISPPARAMS* pDispParams,
2046                                       VARIANT* pVarResult,
2047                                       EXCEPINFO* pExcepInfo,
2048                                       UINT* puArgErr)
2049 {
2050     if (!(wFlags & DISPATCH_METHOD))
2051         return DISP_E_MEMBERNOTFOUND;
2052
2053     FIXME("\n");
2054
2055     VariantInit(pVarResult);
2056     return S_OK;
2057 }
2058
2059 static HRESULT InstallerImpl_FileVersion(WORD wFlags,
2060                                          DISPPARAMS* pDispParams,
2061                                          VARIANT* pVarResult,
2062                                          EXCEPINFO* pExcepInfo,
2063                                          UINT* puArgErr)
2064 {
2065     if (!(wFlags & DISPATCH_METHOD))
2066         return DISP_E_MEMBERNOTFOUND;
2067
2068     FIXME("\n");
2069
2070     VariantInit(pVarResult);
2071     return S_OK;
2072 }
2073
2074 static HRESULT InstallerImpl_ProductState(WORD wFlags,
2075                                           DISPPARAMS* pDispParams,
2076                                           VARIANT* pVarResult,
2077                                           EXCEPINFO* pExcepInfo,
2078                                           UINT* puArgErr)
2079 {
2080     HRESULT hr;
2081     VARIANTARG varg0;
2082
2083     if (!(wFlags & DISPATCH_PROPERTYGET))
2084         return DISP_E_MEMBERNOTFOUND;
2085
2086     VariantInit(&varg0);
2087     hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
2088     if (FAILED(hr))
2089         return hr;
2090
2091     V_VT(pVarResult) = VT_I4;
2092     V_I4(pVarResult) = MsiQueryProductStateW(V_BSTR(&varg0));
2093
2094     VariantClear(&varg0);
2095     return S_OK;
2096 }
2097
2098 static HRESULT InstallerImpl_ProductInfo(WORD wFlags,
2099                                          DISPPARAMS* pDispParams,
2100                                          VARIANT* pVarResult,
2101                                          EXCEPINFO* pExcepInfo,
2102                                          UINT* puArgErr)
2103 {
2104     UINT ret;
2105     HRESULT hr;
2106     DWORD size;
2107     LPWSTR str = NULL;
2108     VARIANTARG varg0, varg1;
2109
2110     if (!(wFlags & DISPATCH_PROPERTYGET))
2111         return DISP_E_MEMBERNOTFOUND;
2112
2113     VariantInit(&varg0);
2114     hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
2115     if (FAILED(hr))
2116         return hr;
2117
2118     VariantInit(&varg1);
2119     hr = DispGetParam(pDispParams, 1, VT_BSTR, &varg1, puArgErr);
2120     if (FAILED(hr))
2121         goto done;
2122
2123     V_VT(pVarResult) = VT_BSTR;
2124     V_BSTR(pVarResult) = NULL;
2125
2126     ret = MsiGetProductInfoW(V_BSTR(&varg0), V_BSTR(&varg1), NULL, &size);
2127     if (ret != ERROR_SUCCESS)
2128     {
2129         hr = DISP_E_EXCEPTION;
2130         goto done;
2131     }
2132
2133     str = msi_alloc(++size * sizeof(WCHAR));
2134     if (!str)
2135     {
2136         hr = E_OUTOFMEMORY;
2137         goto done;
2138     }
2139
2140     ret = MsiGetProductInfoW(V_BSTR(&varg0), V_BSTR(&varg1), str, &size);
2141     if (ret != ERROR_SUCCESS)
2142     {
2143         hr = DISP_E_EXCEPTION;
2144         goto done;
2145     }
2146
2147     V_BSTR(pVarResult) = SysAllocString(str);
2148     hr = S_OK;
2149
2150 done:
2151     msi_free(str);
2152     VariantClear(&varg0);
2153     VariantClear(&varg1);
2154     return hr;
2155 }
2156
2157 static void cleanup_products(IDispatch* dispatch, ULONG count)
2158 {
2159     UINT i;
2160     ListData* ldata = private_data((AutomationObject *)dispatch);
2161
2162     for (i = 0; i < count - 1; i++)
2163         VariantClear(&ldata->pVars[i]);
2164
2165     ldata->ulCount = 0;
2166     msi_free(ldata->pVars);
2167
2168     IDispatch_Release(dispatch);
2169 }
2170
2171 static HRESULT InstallerImpl_Products(WORD wFlags,
2172                                       DISPPARAMS* pDispParams,
2173                                       VARIANT* pVarResult,
2174                                       EXCEPINFO* pExcepInfo,
2175                                       UINT* puArgErr)
2176 {
2177     UINT ret;
2178     HRESULT hr;
2179     ULONG idx = 0;
2180     ListData *ldata;
2181     IDispatch *dispatch;
2182     WCHAR product[GUID_SIZE];
2183
2184     if (!(wFlags & DISPATCH_PROPERTYGET))
2185         return DISP_E_MEMBERNOTFOUND;
2186
2187     /* Find number of products. */
2188     while ((ret = MsiEnumProductsW(idx, product)) == ERROR_SUCCESS)
2189         idx++;
2190
2191     if (ret != ERROR_NO_MORE_ITEMS)
2192         return DISP_E_EXCEPTION;
2193
2194     V_VT(pVarResult) = VT_DISPATCH;
2195     hr = create_automation_object(0, NULL, (LPVOID*)&dispatch,
2196                                   &DIID_StringList, ListImpl_Invoke,
2197                                   ListImpl_Free, sizeof(ListData));
2198     if (FAILED(hr))
2199         return hr;
2200
2201     V_DISPATCH(pVarResult) = dispatch;
2202
2203     /* Save product strings. */
2204     ldata = private_data((AutomationObject *)dispatch);
2205     ldata->ulCount = 0;
2206     ldata->pVars = msi_alloc_zero(sizeof(VARIANT) * idx);
2207     if (!ldata->pVars)
2208     {
2209         IDispatch_Release(dispatch);
2210         return E_OUTOFMEMORY;
2211     }
2212
2213     ldata->ulCount = idx;
2214     for (idx = 0; idx < ldata->ulCount; idx++)
2215     {
2216         ret = MsiEnumProductsW(idx, product);
2217         if (ret != ERROR_SUCCESS)
2218         {
2219             cleanup_products(dispatch, idx - 1);
2220             return DISP_E_EXCEPTION;
2221         }
2222
2223         VariantInit(&ldata->pVars[idx]);
2224         V_VT(&ldata->pVars[idx]) = VT_BSTR;
2225         V_BSTR(&ldata->pVars[idx]) = SysAllocString(product);
2226     }
2227
2228     return S_OK;
2229 }
2230
2231 static HRESULT InstallerImpl_RelatedProducts(WORD wFlags,
2232                                              DISPPARAMS* pDispParams,
2233                                              VARIANT* pVarResult,
2234                                              EXCEPINFO* pExcepInfo,
2235                                              UINT* puArgErr)
2236 {
2237     UINT ret;
2238     ULONG idx;
2239     HRESULT hr;
2240     ListData *ldata;
2241     VARIANTARG varg0;
2242     IDispatch* dispatch;
2243     WCHAR product[GUID_SIZE];
2244
2245     if (!(wFlags & DISPATCH_PROPERTYGET))
2246         return DISP_E_MEMBERNOTFOUND;
2247
2248     VariantInit(&varg0);
2249     hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
2250     if (FAILED(hr))
2251         return hr;
2252
2253     /* Find number of related products. */
2254     idx = 0;
2255     do
2256     {
2257         ret = MsiEnumRelatedProductsW(V_BSTR(&varg0), 0, idx, product);
2258         if (ret == ERROR_SUCCESS)
2259             idx++;
2260     } while (ret == ERROR_SUCCESS);
2261
2262     if (ret != ERROR_NO_MORE_ITEMS)
2263     {
2264         hr = DISP_E_EXCEPTION;
2265         goto done;
2266     }
2267
2268     V_VT(pVarResult) = VT_DISPATCH;
2269
2270     hr = create_automation_object(0, NULL, (LPVOID*)&dispatch,
2271                                   &DIID_StringList, ListImpl_Invoke,
2272                                   ListImpl_Free, sizeof(ListData));
2273     if (FAILED(hr))
2274         goto done;
2275
2276     V_DISPATCH(pVarResult) = dispatch;
2277
2278     /* Save product strings. */
2279     ldata = private_data((AutomationObject *)dispatch);
2280     ldata->pVars = msi_alloc(sizeof(VARIANT) * idx);
2281     if (!ldata->pVars)
2282     {
2283         IDispatch_Release(dispatch);
2284         hr = E_OUTOFMEMORY;
2285         goto done;
2286     }
2287
2288     ldata->ulCount = idx;
2289     for (idx = 0; idx < ldata->ulCount; idx++)
2290     {
2291         ret = MsiEnumRelatedProductsW(V_BSTR(&varg0), 0, idx, product);
2292         if (ret != ERROR_SUCCESS)
2293         {
2294             cleanup_products(dispatch, idx - 1);
2295             hr = DISP_E_EXCEPTION;
2296             goto done;
2297         }
2298
2299         VariantInit(&ldata->pVars[idx]);
2300         V_VT(&ldata->pVars[idx]) = VT_BSTR;
2301         V_BSTR(&ldata->pVars[idx]) = SysAllocString(product);
2302     }
2303
2304     hr = S_OK;
2305
2306 done:
2307     VariantClear(&varg0);
2308     return hr;
2309 }
2310
2311 static HRESULT WINAPI InstallerImpl_Invoke(
2312         AutomationObject* This,
2313         DISPID dispIdMember,
2314         REFIID riid,
2315         LCID lcid,
2316         WORD wFlags,
2317         DISPPARAMS* pDispParams,
2318         VARIANT* pVarResult,
2319         EXCEPINFO* pExcepInfo,
2320         UINT* puArgErr)
2321 {
2322     switch (dispIdMember)
2323     {
2324         case DISPID_INSTALLER_CREATERECORD:
2325             return InstallerImpl_CreateRecord(wFlags, pDispParams,
2326                                               pVarResult, pExcepInfo, puArgErr);
2327
2328         case DISPID_INSTALLER_OPENPACKAGE:
2329             return InstallerImpl_OpenPackage(This, wFlags, pDispParams,
2330                                              pVarResult, pExcepInfo, puArgErr);
2331
2332         case DISPID_INSTALLER_OPENPRODUCT:
2333             return InstallerImpl_OpenProduct(wFlags, pDispParams,
2334                                              pVarResult, pExcepInfo, puArgErr);
2335
2336         case DISPID_INSTALLER_OPENDATABASE:
2337             return InstallerImpl_OpenDatabase(wFlags, pDispParams,
2338                                               pVarResult, pExcepInfo, puArgErr);
2339
2340         case DISPID_INSTALLER_SUMMARYINFORMATION:
2341             return InstallerImpl_SummaryInformation(wFlags, pDispParams,
2342                                                     pVarResult, pExcepInfo,
2343                                                     puArgErr);
2344
2345         case DISPID_INSTALLER_UILEVEL:
2346             return InstallerImpl_UILevel(wFlags, pDispParams,
2347                                          pVarResult, pExcepInfo, puArgErr);
2348
2349         case DISPID_INSTALLER_ENABLELOG:
2350             return InstallerImpl_EnableLog(wFlags, pDispParams,
2351                                            pVarResult, pExcepInfo, puArgErr);
2352
2353         case DISPID_INSTALLER_INSTALLPRODUCT:
2354             return InstallerImpl_InstallProduct(wFlags, pDispParams,
2355                                                 pVarResult, pExcepInfo,
2356                                                 puArgErr);
2357
2358         case DISPID_INSTALLER_VERSION:
2359             return InstallerImpl_Version(wFlags, pVarResult,
2360                                          pExcepInfo, puArgErr);
2361
2362         case DISPID_INSTALLER_LASTERRORRECORD:
2363             return InstallerImpl_LastErrorRecord(wFlags, pDispParams,
2364                                                  pVarResult, pExcepInfo,
2365                                                  puArgErr);
2366
2367         case DISPID_INSTALLER_REGISTRYVALUE:
2368             return InstallerImpl_RegistryValue(wFlags, pDispParams,
2369                                                pVarResult, pExcepInfo,
2370                                                puArgErr);
2371
2372         case DISPID_INSTALLER_ENVIRONMENT:
2373             return InstallerImpl_Environment(wFlags, pDispParams,
2374                                              pVarResult, pExcepInfo, puArgErr);
2375
2376         case DISPID_INSTALLER_FILEATTRIBUTES:
2377             return InstallerImpl_FileAttributes(wFlags, pDispParams,
2378                                                 pVarResult, pExcepInfo,
2379                                                 puArgErr);
2380
2381         case DISPID_INSTALLER_FILESIZE:
2382             return InstallerImpl_FileSize(wFlags, pDispParams,
2383                                           pVarResult, pExcepInfo, puArgErr);
2384
2385         case DISPID_INSTALLER_FILEVERSION:
2386             return InstallerImpl_FileVersion(wFlags, pDispParams,
2387                                              pVarResult, pExcepInfo, puArgErr);
2388
2389         case DISPID_INSTALLER_PRODUCTSTATE:
2390             return InstallerImpl_ProductState(wFlags, pDispParams,
2391                                               pVarResult, pExcepInfo, puArgErr);
2392
2393         case DISPID_INSTALLER_PRODUCTINFO:
2394             return InstallerImpl_ProductInfo(wFlags, pDispParams,
2395                                              pVarResult, pExcepInfo, puArgErr);
2396
2397         case DISPID_INSTALLER_PRODUCTS:
2398             return InstallerImpl_Products(wFlags, pDispParams,
2399                                           pVarResult, pExcepInfo, puArgErr);
2400
2401         case DISPID_INSTALLER_RELATEDPRODUCTS:
2402             return InstallerImpl_RelatedProducts(wFlags, pDispParams,
2403                                                  pVarResult, pExcepInfo,
2404                                                  puArgErr);
2405
2406         default:
2407             return DISP_E_MEMBERNOTFOUND;
2408     }
2409 }
2410
2411 /* Wrapper around create_automation_object to create an installer object. */
2412 HRESULT create_msiserver(IUnknown *pOuter, LPVOID *ppObj)
2413 {
2414     return create_automation_object(0, pOuter, ppObj, &DIID_Installer, InstallerImpl_Invoke, NULL, 0);
2415 }
2416
2417 /* Wrapper around create_automation_object to create a session object. */
2418 HRESULT create_session(MSIHANDLE msiHandle, IDispatch *pInstaller, IDispatch **pDispatch)
2419 {
2420     HRESULT hr = create_automation_object(msiHandle, NULL, (LPVOID)pDispatch, &DIID_Session, SessionImpl_Invoke, NULL, sizeof(SessionData));
2421     if (SUCCEEDED(hr) && pDispatch && *pDispatch)
2422         ((SessionData *)private_data((AutomationObject *)*pDispatch))->pInstaller = pInstaller;
2423     return hr;
2424 }