qmgr/tests: Detect when the service is disabled.
[wine/multimedia.git] / dlls / msi / automation.c
blobd6ef5c98781de5c322d44d8250adb5093691417a
1 /*
2 * Implementation of OLE Automation for Microsoft Installer (msi.dll)
4 * Copyright 2007 Misha Koshelev
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.
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.
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
21 #define COBJMACROS
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"
37 #include "msiserver.h"
38 #include "msiserver_dispids.h"
40 WINE_DEFAULT_DEBUG_CHANNEL(msi);
42 #define REG_INDEX_CLASSES_ROOT 0
43 #define REG_INDEX_DYN_DATA 6
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.
50 typedef interface AutomationObject AutomationObject;
52 interface AutomationObject {
54 * VTables - We provide IDispatch, IProvideClassInfo, IProvideClassInfo2, IProvideMultipleClassInfo
56 const IDispatchVtbl *lpVtbl;
57 const IProvideMultipleClassInfoVtbl *lpvtblIProvideMultipleClassInfo;
59 /* Object reference count */
60 LONG ref;
62 /* Clsid for this class and it's appropriate ITypeInfo object */
63 LPCLSID clsid;
64 ITypeInfo *iTypeInfo;
66 /* The MSI handle of the current object */
67 MSIHANDLE msiHandle;
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);
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);
87 * ListEnumerator - IEnumVARIANT implementation for MSI automation lists.
90 typedef interface ListEnumerator ListEnumerator;
92 interface ListEnumerator {
93 /* VTables */
94 const IEnumVARIANTVtbl *lpVtbl;
96 /* Object reference count */
97 LONG ref;
99 /* Current position and pointer to AutomationObject that stores actual data */
100 ULONG ulPos;
101 AutomationObject *pObj;
105 * Structures for additional data required by specific automation objects
108 typedef struct {
109 ULONG ulCount;
110 VARIANT *pVars;
111 } ListData;
113 typedef struct {
114 /* The parent Installer object */
115 IDispatch *pInstaller;
116 } SessionData;
118 /* VTables */
119 static const struct IDispatchVtbl AutomationObject_Vtbl;
120 static const struct IProvideMultipleClassInfoVtbl AutomationObject_IProvideMultipleClassInfo_Vtbl;
121 static const struct IEnumVARIANTVtbl ListEnumerator_Vtbl;
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)
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'};
131 TRACE("(%p)->(%s,%d)\n", iface, debugstr_guid(clsid), lcid);
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;
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;
150 *pptinfo = pInfo;
151 return S_OK;
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)
162 AutomationObject *object;
163 HRESULT hr;
165 TRACE("(%d,%p,%p,%s,%p,%p,%ld)\n", msiHandle, pUnkOuter, ppObj, debugstr_guid(clsid), funcInvoke, funcFree, sizetPrivateData);
167 if( pUnkOuter )
168 return CLASS_E_NOAGGREGATION;
170 object = msi_alloc_zero( sizeof(AutomationObject) + sizetPrivateData );
172 /* Set all the VTable references */
173 object->lpVtbl = &AutomationObject_Vtbl;
174 object->lpvtblIProvideMultipleClassInfo = &AutomationObject_IProvideMultipleClassInfo_Vtbl;
175 object->ref = 1;
177 /* Store data that was passed */
178 object->msiHandle = msiHandle;
179 object->clsid = (LPCLSID)clsid;
180 object->funcInvoke = funcInvoke;
181 object->funcFree = funcFree;
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;
191 *ppObj = object;
193 return S_OK;
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)
199 ListEnumerator *object;
201 TRACE("(%p,%p,%p,%uld)\n", pUnkOuter, ppObj, pObj, ulPos);
203 if( pUnkOuter )
204 return CLASS_E_NOAGGREGATION;
206 object = msi_alloc_zero( sizeof(ListEnumerator) );
208 /* Set all the VTable references */
209 object->lpVtbl = &ListEnumerator_Vtbl;
210 object->ref = 1;
212 /* Store data that was passed */
213 object->ulPos = ulPos;
214 object->pObj = pObj;
215 if (pObj) IDispatch_AddRef((IDispatch *)pObj);
217 *ppObj = object;
218 return S_OK;
221 /* Macros to get pointer to AutomationObject from the other VTables. */
222 static inline AutomationObject *obj_from_IProvideMultipleClassInfo( IProvideMultipleClassInfo *iface )
224 return (AutomationObject *)((char*)iface - FIELD_OFFSET(AutomationObject, lpvtblIProvideMultipleClassInfo));
227 /* Macro to get pointer to private object data */
228 static inline void *private_data( AutomationObject *This )
230 return This + 1;
234 * AutomationObject methods
237 /*** IUnknown methods ***/
238 static HRESULT WINAPI AutomationObject_QueryInterface(IDispatch* iface, REFIID riid, void** ppvObject)
240 AutomationObject *This = (AutomationObject *)iface;
242 TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
244 if (ppvObject == NULL)
245 return E_INVALIDARG;
247 *ppvObject = 0;
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
257 TRACE("() : asking for unsupported interface %s\n",debugstr_guid(riid));
258 return E_NOINTERFACE;
262 * Query Interface always increases the reference count by one when it is
263 * successful
265 IClassFactory_AddRef(iface);
267 return S_OK;
270 static ULONG WINAPI AutomationObject_AddRef(IDispatch* iface)
272 AutomationObject *This = (AutomationObject *)iface;
274 TRACE("(%p/%p)\n", iface, This);
276 return InterlockedIncrement(&This->ref);
279 static ULONG WINAPI AutomationObject_Release(IDispatch* iface)
281 AutomationObject *This = (AutomationObject *)iface;
282 ULONG ref = InterlockedDecrement(&This->ref);
284 TRACE("(%p/%p)\n", iface, This);
286 if (!ref)
288 if (This->funcFree) This->funcFree(This);
289 ITypeInfo_Release(This->iTypeInfo);
290 MsiCloseHandle(This->msiHandle);
291 msi_free(This);
294 return ref;
297 /*** IDispatch methods ***/
298 static HRESULT WINAPI AutomationObject_GetTypeInfoCount(
299 IDispatch* iface,
300 UINT* pctinfo)
302 AutomationObject *This = (AutomationObject *)iface;
304 TRACE("(%p/%p)->(%p)\n", iface, This, pctinfo);
305 *pctinfo = 1;
306 return S_OK;
309 static HRESULT WINAPI AutomationObject_GetTypeInfo(
310 IDispatch* iface,
311 UINT iTInfo,
312 LCID lcid,
313 ITypeInfo** ppTInfo)
315 AutomationObject *This = (AutomationObject *)iface;
316 TRACE("(%p/%p)->(%d,%d,%p)\n", iface, This, iTInfo, lcid, ppTInfo);
318 ITypeInfo_AddRef(This->iTypeInfo);
319 *ppTInfo = This->iTypeInfo;
320 return S_OK;
323 static HRESULT WINAPI AutomationObject_GetIDsOfNames(
324 IDispatch* iface,
325 REFIID riid,
326 LPOLESTR* rgszNames,
327 UINT cNames,
328 LCID lcid,
329 DISPID* rgDispId)
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);
335 if (!IsEqualGUID(riid, &IID_NULL)) return E_INVALIDARG;
336 hr = ITypeInfo_GetIDsOfNames(This->iTypeInfo, rgszNames, cNames, rgDispId);
337 if (hr == DISP_E_UNKNOWNNAME)
339 UINT idx;
340 for (idx=0; idx<cNames; idx++)
342 if (rgDispId[idx] == DISPID_UNKNOWN)
343 FIXME("Unknown member %s, clsid %s\n", debugstr_w(rgszNames[idx]), debugstr_guid(This->clsid));
346 return hr;
349 /* Maximum number of allowed function parameters+1 */
350 #define MAX_FUNC_PARAMS 20
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)
364 AutomationObject *This = (AutomationObject *)iface;
365 HRESULT hr;
366 unsigned int uArgErr;
367 VARIANT varResultDummy;
368 BSTR bstrName = NULL;
370 TRACE("(%p/%p)->(%d,%p,%d,%d,%p,%p,%p,%p)\n", iface, This, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
372 if (!IsEqualIID(riid, &IID_NULL))
374 ERR("riid was %s instead of IID_NULL\n", debugstr_guid(riid));
375 return DISP_E_UNKNOWNNAME;
378 if (wFlags & DISPATCH_PROPERTYGET && !pVarResult)
380 ERR("NULL pVarResult not allowed when DISPATCH_PROPERTYGET specified\n");
381 return DISP_E_PARAMNOTOPTIONAL;
384 /* This simplifies our individual object invocation functions */
385 if (puArgErr == NULL) puArgErr = &uArgErr;
386 if (pVarResult == NULL) pVarResult = &varResultDummy;
388 /* Assume return type is void unless determined otherwise */
389 VariantInit(pVarResult);
391 /* If we are tracing, we want to see the name of the member we are invoking */
392 if (TRACE_ON(msi))
394 ITypeInfo_GetDocumentation(This->iTypeInfo, dispIdMember, &bstrName, NULL, NULL, NULL);
395 TRACE("Method %d, %s\n", dispIdMember, debugstr_w(bstrName));
398 hr = This->funcInvoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr);
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));
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;
414 if (FAILED(ITypeInfo_GetNames(This->iTypeInfo, dispIdMember, bstrParamNames,
415 MAX_FUNC_PARAMS, &namesNo)))
417 TRACE("Failed to retrieve names for dispIdMember %d\n", dispIdMember);
419 else
421 memset(szExceptionDescription, 0, sizeof(szExceptionDescription));
422 for (i=0; i<namesNo; i++)
424 if (bFirst) bFirst = FALSE;
425 else {
426 lstrcpyW(&szExceptionDescription[lstrlenW(szExceptionDescription)], szComma);
428 lstrcpyW(&szExceptionDescription[lstrlenW(szExceptionDescription)], bstrParamNames[i]);
429 SysFreeString(bstrParamNames[i]);
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;
440 /* Make sure we free the return variant if it is our dummy variant */
441 if (pVarResult == &varResultDummy) VariantClear(pVarResult);
443 /* Free function name if we retrieved it */
444 SysFreeString(bstrName);
446 TRACE("Returning 0x%08x, %s\n", hr, SUCCEEDED(hr) ? "ok" : "not ok");
448 return hr;
451 static const struct IDispatchVtbl AutomationObject_Vtbl =
453 AutomationObject_QueryInterface,
454 AutomationObject_AddRef,
455 AutomationObject_Release,
456 AutomationObject_GetTypeInfoCount,
457 AutomationObject_GetTypeInfo,
458 AutomationObject_GetIDsOfNames,
459 AutomationObject_Invoke
463 * IProvideMultipleClassInfo methods
466 static HRESULT WINAPI AutomationObject_IProvideMultipleClassInfo_QueryInterface(
467 IProvideMultipleClassInfo* iface,
468 REFIID riid,
469 VOID** ppvoid)
471 AutomationObject *This = obj_from_IProvideMultipleClassInfo(iface);
472 return AutomationObject_QueryInterface((IDispatch *)This, riid, ppvoid);
475 static ULONG WINAPI AutomationObject_IProvideMultipleClassInfo_AddRef(IProvideMultipleClassInfo* iface)
477 AutomationObject *This = obj_from_IProvideMultipleClassInfo(iface);
478 return AutomationObject_AddRef((IDispatch *)This);
481 static ULONG WINAPI AutomationObject_IProvideMultipleClassInfo_Release(IProvideMultipleClassInfo* iface)
483 AutomationObject *This = obj_from_IProvideMultipleClassInfo(iface);
484 return AutomationObject_Release((IDispatch *)This);
487 static HRESULT WINAPI AutomationObject_IProvideMultipleClassInfo_GetClassInfo(IProvideMultipleClassInfo* iface, ITypeInfo** ppTI)
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);
494 static HRESULT WINAPI AutomationObject_IProvideMultipleClassInfo_GetGUID(IProvideMultipleClassInfo* iface, DWORD dwGuidKind, GUID* pGUID)
496 AutomationObject *This = obj_from_IProvideMultipleClassInfo(iface);
497 TRACE("(%p/%p)->(%d,%s)\n", iface, This, dwGuidKind, debugstr_guid(pGUID));
499 if (dwGuidKind != GUIDKIND_DEFAULT_SOURCE_DISP_IID)
500 return E_INVALIDARG;
501 else {
502 *pGUID = *This->clsid;
503 return S_OK;
507 static HRESULT WINAPI AutomationObject_GetMultiTypeInfoCount(IProvideMultipleClassInfo* iface, ULONG* pcti)
509 AutomationObject *This = obj_from_IProvideMultipleClassInfo(iface);
511 TRACE("(%p/%p)->(%p)\n", iface, This, pcti);
512 *pcti = 1;
513 return S_OK;
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)
525 AutomationObject *This = obj_from_IProvideMultipleClassInfo(iface);
527 TRACE("(%p/%p)->(%d,%d,%p,%p,%p,%p,%p)\n", iface, This, iti, dwFlags, pptiCoClass, pdwTIFlags, pcdispidReserved, piidPrimary, piidSource);
529 if (iti != 0)
530 return E_INVALIDARG;
532 if (dwFlags & MULTICLASSINFO_GETTYPEINFO)
533 load_type_info((IDispatch *)This, pptiCoClass, This->clsid, 0);
535 if (dwFlags & MULTICLASSINFO_GETNUMRESERVEDDISPIDS)
537 *pdwTIFlags = 0;
538 *pcdispidReserved = 0;
541 if (dwFlags & MULTICLASSINFO_GETIIDPRIMARY){
542 *piidPrimary = *This->clsid;
545 if (dwFlags & MULTICLASSINFO_GETIIDSOURCE){
546 *piidSource = *This->clsid;
549 return S_OK;
552 static const IProvideMultipleClassInfoVtbl AutomationObject_IProvideMultipleClassInfo_Vtbl =
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
564 * ListEnumerator methods
567 /*** IUnknown methods ***/
568 static HRESULT WINAPI ListEnumerator_QueryInterface(IEnumVARIANT* iface, REFIID riid, void** ppvObject)
570 ListEnumerator *This = (ListEnumerator *)iface;
572 TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
574 if (ppvObject == NULL)
575 return E_INVALIDARG;
577 *ppvObject = 0;
579 if (IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IEnumVARIANT))
580 *ppvObject = This;
581 else
583 TRACE("() : asking for unsupported interface %s\n",debugstr_guid(riid));
584 return E_NOINTERFACE;
587 IClassFactory_AddRef(iface);
588 return S_OK;
591 static ULONG WINAPI ListEnumerator_AddRef(IEnumVARIANT* iface)
593 ListEnumerator *This = (ListEnumerator *)iface;
595 TRACE("(%p/%p)\n", iface, This);
597 return InterlockedIncrement(&This->ref);
600 static ULONG WINAPI ListEnumerator_Release(IEnumVARIANT* iface)
602 ListEnumerator *This = (ListEnumerator *)iface;
603 ULONG ref = InterlockedDecrement(&This->ref);
605 TRACE("(%p/%p)\n", iface, This);
607 if (!ref)
609 if (This->pObj) IDispatch_Release((IDispatch *)This->pObj);
610 msi_free(This);
613 return ref;
616 /* IEnumVARIANT methods */
618 static HRESULT WINAPI ListEnumerator_Next(IEnumVARIANT* iface, ULONG celt, VARIANT *rgVar, ULONG *pCeltFetched)
620 ListEnumerator *This = (ListEnumerator *)iface;
621 ListData *data = private_data(This->pObj);
622 ULONG idx, local;
624 TRACE("(%p,%uld,%p,%p)\n", iface, celt, rgVar, pCeltFetched);
626 if (pCeltFetched != NULL)
627 *pCeltFetched = 0;
629 if (rgVar == NULL)
630 return S_FALSE;
632 for (local = 0; local < celt; local++)
633 VariantInit(&rgVar[local]);
635 for (idx = This->ulPos, local = 0; idx < data->ulCount && local < celt; idx++, local++)
636 VariantCopy(&rgVar[local], &data->pVars[idx]);
638 if (pCeltFetched != NULL)
639 *pCeltFetched = local;
640 This->ulPos = idx;
642 return (local < celt) ? S_FALSE : S_OK;
645 static HRESULT WINAPI ListEnumerator_Skip(IEnumVARIANT* iface, ULONG celt)
647 ListEnumerator *This = (ListEnumerator *)iface;
648 ListData *data = private_data(This->pObj);
650 TRACE("(%p,%uld)\n", iface, celt);
652 This->ulPos += celt;
653 if (This->ulPos >= data->ulCount)
655 This->ulPos = data->ulCount;
656 return S_FALSE;
658 return S_OK;
661 static HRESULT WINAPI ListEnumerator_Reset(IEnumVARIANT* iface)
663 ListEnumerator *This = (ListEnumerator *)iface;
665 TRACE("(%p)\n", iface);
667 This->ulPos = 0;
668 return S_OK;
671 static HRESULT WINAPI ListEnumerator_Clone(IEnumVARIANT* iface, IEnumVARIANT **ppEnum)
673 ListEnumerator *This = (ListEnumerator *)iface;
674 HRESULT hr;
676 TRACE("(%p,%p)\n", iface, ppEnum);
678 if (ppEnum == NULL)
679 return S_FALSE;
681 *ppEnum = NULL;
682 hr = create_list_enumerator(NULL, (LPVOID *)ppEnum, This->pObj, 0);
683 if (FAILED(hr))
685 if (*ppEnum)
686 IUnknown_Release(*ppEnum);
687 return hr;
690 return S_OK;
693 static const struct IEnumVARIANTVtbl ListEnumerator_Vtbl =
695 ListEnumerator_QueryInterface,
696 ListEnumerator_AddRef,
697 ListEnumerator_Release,
698 ListEnumerator_Next,
699 ListEnumerator_Skip,
700 ListEnumerator_Reset,
701 ListEnumerator_Clone
705 * Individual Object Invocation Functions
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 */
716 /* position is counted backwards */
717 UINT pos;
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;
729 if (pos==pdispparams->cNamedArgs)
730 return DISP_E_PARAMNOTFOUND;
732 *position = pos;
733 return VariantCopyInd(pvarResult,
734 &pdispparams->rgvarg[pos]);
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)
748 UINT ret;
749 VARIANTARG varg0, varg1;
750 FILETIME ft, ftlocal;
751 SYSTEMTIME st;
752 HRESULT hr;
754 VariantInit(&varg0);
755 VariantInit(&varg1);
757 switch (dispIdMember)
759 case DISPID_SUMMARYINFO_PROPERTY:
760 if (wFlags & DISPATCH_PROPERTYGET)
762 UINT type;
763 INT value;
764 DWORD size = 0;
765 DATE date;
766 LPWSTR str;
768 static WCHAR szEmpty[] = {0};
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)
777 ERR("MsiSummaryInfoGetProperty returned %d\n", ret);
778 return DISP_E_EXCEPTION;
781 switch (type)
783 case VT_EMPTY:
784 break;
786 case VT_I2:
787 case VT_I4:
788 V_VT(pVarResult) = VT_I4;
789 V_I4(pVarResult) = value;
790 break;
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
800 V_VT(pVarResult) = VT_BSTR;
801 V_BSTR(pVarResult) = SysAllocString(str);
803 msi_free(str);
804 break;
806 case VT_FILETIME:
807 FileTimeToLocalFileTime(&ft, &ftlocal);
808 FileTimeToSystemTime(&ftlocal, &st);
809 SystemTimeToVariantTime(&st, &date);
811 V_VT(pVarResult) = VT_DATE;
812 V_DATE(pVarResult) = date;
813 break;
815 default:
816 ERR("Unhandled variant type %d\n", type);
819 else if (wFlags & DISPATCH_PROPERTYPUT)
821 UINT posValue = DISPID_PROPERTYPUT;
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))
828 *puArgErr = posValue;
829 return hr;
832 switch (V_VT(&varg1))
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;
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;
846 case VT_BSTR:
847 ret = MsiSummaryInfoSetPropertyW(This->msiHandle, V_I4(&varg0), VT_LPSTR, 0, NULL, V_BSTR(&varg1));
848 break;
850 default:
851 FIXME("Unhandled variant type %d\n", V_VT(&varg1));
852 VariantClear(&varg1);
853 return DISP_E_EXCEPTION;
856 if (ret != ERROR_SUCCESS)
858 ERR("MsiSummaryInfoSetPropertyW returned %d\n", ret);
859 return DISP_E_EXCEPTION;
862 else return DISP_E_MEMBERNOTFOUND;
863 break;
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
872 V_VT(pVarResult) = VT_I4;
873 V_I4(pVarResult) = count;
876 else return DISP_E_MEMBERNOTFOUND;
877 break;
879 default:
880 return DISP_E_MEMBERNOTFOUND;
883 VariantClear(&varg1);
884 VariantClear(&varg0);
886 return S_OK;
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)
900 WCHAR *szString;
901 DWORD dwLen;
902 UINT ret;
903 VARIANTARG varg0, varg1;
904 HRESULT hr;
906 VariantInit(&varg0);
907 VariantInit(&varg1);
909 switch (dispIdMember)
911 case DISPID_RECORD_FIELDCOUNT:
912 if (wFlags & DISPATCH_PROPERTYGET) {
913 V_VT(pVarResult) = VT_I4;
914 V_I4(pVarResult) = MsiRecordGetFieldCount(This->msiHandle);
916 else return DISP_E_MEMBERNOTFOUND;
917 break;
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)
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);
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)
942 VariantClear(&varg1);
943 ERR("MsiRecordSetString returned %d\n", ret);
944 return DISP_E_EXCEPTION;
947 else return DISP_E_MEMBERNOTFOUND;
948 break;
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)
963 ERR("MsiRecordSetInteger returned %d\n", ret);
964 return DISP_E_EXCEPTION;
967 else return DISP_E_MEMBERNOTFOUND;
968 break;
970 default:
971 return DISP_E_MEMBERNOTFOUND;
974 VariantClear(&varg1);
975 VariantClear(&varg0);
977 return S_OK;
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)
991 ListData *data = private_data(This);
992 HRESULT hr;
993 VARIANTARG varg0;
994 IUnknown *pUnk = NULL;
996 VariantInit(&varg0);
998 switch (dispIdMember)
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);
1008 else return DISP_E_MEMBERNOTFOUND;
1009 break;
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)]);
1019 else return DISP_E_MEMBERNOTFOUND;
1020 break;
1022 case DISPID_LIST_COUNT:
1023 if (wFlags & DISPATCH_PROPERTYGET) {
1024 V_VT(pVarResult) = VT_I4;
1025 V_I4(pVarResult) = data->ulCount;
1027 else return DISP_E_MEMBERNOTFOUND;
1028 break;
1030 default:
1031 return DISP_E_MEMBERNOTFOUND;
1034 VariantClear(&varg0);
1036 return S_OK;
1039 static void WINAPI ListImpl_Free(AutomationObject *This)
1041 ListData *data = private_data(This);
1042 ULONG idx;
1044 for (idx=0; idx<data->ulCount; idx++)
1045 VariantClear(&data->pVars[idx]);
1046 msi_free(data->pVars);
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)
1060 MSIHANDLE msiHandle;
1061 IDispatch *pDispatch = NULL;
1062 UINT ret;
1063 VARIANTARG varg0, varg1;
1064 HRESULT hr;
1066 VariantInit(&varg0);
1067 VariantInit(&varg1);
1069 switch (dispIdMember)
1071 case DISPID_VIEW_EXECUTE:
1072 if (wFlags & DISPATCH_METHOD)
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);
1080 else return DISP_E_MEMBERNOTFOUND;
1081 break;
1083 case DISPID_VIEW_FETCH:
1084 if (wFlags & DISPATCH_METHOD)
1086 V_VT(pVarResult) = VT_DISPATCH;
1087 if ((ret = MsiViewFetch(This->msiHandle, &msiHandle)) == ERROR_SUCCESS)
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);
1094 else if (ret == ERROR_NO_MORE_ITEMS)
1095 V_DISPATCH(pVarResult) = NULL;
1096 else
1098 ERR("MsiViewFetch returned %d\n", ret);
1099 return DISP_E_EXCEPTION;
1102 else return DISP_E_MEMBERNOTFOUND;
1103 break;
1105 case DISPID_VIEW_MODIFY:
1106 if (wFlags & DISPATCH_METHOD)
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)
1115 VariantClear(&varg1);
1116 ERR("MsiViewModify returned %d\n", ret);
1117 return DISP_E_EXCEPTION;
1120 else return DISP_E_MEMBERNOTFOUND;
1121 break;
1123 case DISPID_VIEW_CLOSE:
1124 if (wFlags & DISPATCH_METHOD)
1126 MsiViewClose(This->msiHandle);
1128 else return DISP_E_MEMBERNOTFOUND;
1129 break;
1131 default:
1132 return DISP_E_MEMBERNOTFOUND;
1135 VariantClear(&varg1);
1136 VariantClear(&varg0);
1138 return S_OK;
1141 static HRESULT DatabaseImpl_LastErrorRecord(WORD wFlags,
1142 DISPPARAMS* pDispParams,
1143 VARIANT* pVarResult,
1144 EXCEPINFO* pExcepInfo,
1145 UINT* puArgErr)
1147 if (!(wFlags & DISPATCH_METHOD))
1148 return DISP_E_MEMBERNOTFOUND;
1150 FIXME("\n");
1152 VariantInit(pVarResult);
1153 return S_OK;
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)
1167 MSIHANDLE msiHandle;
1168 IDispatch *pDispatch = NULL;
1169 UINT ret;
1170 VARIANTARG varg0, varg1;
1171 HRESULT hr;
1173 VariantInit(&varg0);
1174 VariantInit(&varg1);
1176 switch (dispIdMember)
1178 case DISPID_DATABASE_SUMMARYINFORMATION:
1179 if (wFlags & DISPATCH_PROPERTYGET)
1181 hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
1182 if (FAILED(hr))
1183 V_I4(&varg0) = 0;
1185 V_VT(pVarResult) = VT_DISPATCH;
1186 if ((ret = MsiGetSummaryInformationW(This->msiHandle, NULL, V_I4(&varg0), &msiHandle)) == ERROR_SUCCESS)
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);
1194 else
1196 ERR("MsiGetSummaryInformation returned %d\n", ret);
1197 return DISP_E_EXCEPTION;
1200 else return DISP_E_MEMBERNOTFOUND;
1201 break;
1203 case DISPID_DATABASE_OPENVIEW:
1204 if (wFlags & DISPATCH_METHOD)
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)
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);
1216 else
1218 VariantClear(&varg0);
1219 ERR("MsiDatabaseOpenView returned %d\n", ret);
1220 return DISP_E_EXCEPTION;
1223 else return DISP_E_MEMBERNOTFOUND;
1224 break;
1226 case DISPID_INSTALLER_LASTERRORRECORD:
1227 return DatabaseImpl_LastErrorRecord(wFlags, pDispParams,
1228 pVarResult, pExcepInfo,
1229 puArgErr);
1231 default:
1232 return DISP_E_MEMBERNOTFOUND;
1235 VariantClear(&varg1);
1236 VariantClear(&varg0);
1238 return S_OK;
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)
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;
1263 VariantInit(&varg0);
1264 VariantInit(&varg1);
1266 switch (dispIdMember)
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;
1274 else return DISP_E_MEMBERNOTFOUND;
1275 break;
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)
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);
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;
1301 if ((ret = MsiSetPropertyW(This->msiHandle, V_BSTR(&varg0), V_BSTR(&varg1))) != ERROR_SUCCESS)
1303 VariantClear(&varg0);
1304 VariantClear(&varg1);
1305 ERR("MsiSetProperty returned %d\n", ret);
1306 return DISP_E_EXCEPTION;
1309 else return DISP_E_MEMBERNOTFOUND;
1310 break;
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;
1318 else return DISP_E_MEMBERNOTFOUND;
1319 break;
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)
1334 ERR("MsiSetMode returned %d\n", ret);
1335 return DISP_E_EXCEPTION;
1338 else return DISP_E_MEMBERNOTFOUND;
1339 break;
1341 case DISPID_SESSION_DATABASE:
1342 if (wFlags & DISPATCH_PROPERTYGET) {
1343 V_VT(pVarResult) = VT_DISPATCH;
1344 if ((msiHandle = MsiGetActiveDatabase(This->msiHandle)))
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);
1351 else
1353 ERR("MsiGetActiveDatabase failed\n");
1354 return DISP_E_EXCEPTION;
1357 else return DISP_E_MEMBERNOTFOUND;
1358 break;
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)
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;
1398 else return DISP_E_MEMBERNOTFOUND;
1399 break;
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));
1408 else return DISP_E_MEMBERNOTFOUND;
1409 break;
1411 case DISPID_SESSION_MESSAGE:
1412 if(!(wFlags & DISPATCH_METHOD))
1413 return DISP_E_MEMBERNOTFOUND;
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;
1420 V_VT(pVarResult) = VT_I4;
1421 V_I4(pVarResult) =
1422 MsiProcessMessage(This->msiHandle, V_I4(&varg0), ((AutomationObject *)V_DISPATCH(&varg1))->msiHandle);
1423 break;
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)
1431 ERR("MsiSetInstallLevel returned %d\n", ret);
1432 return DISP_E_EXCEPTION;
1435 else return DISP_E_MEMBERNOTFOUND;
1436 break;
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
1447 ERR("MsiGetFeatureState returned %d\n", ret);
1448 V_I4(pVarResult) = msiInstallStateUnknown;
1451 else return DISP_E_MEMBERNOTFOUND;
1452 break;
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
1463 ERR("MsiGetFeatureState returned %d\n", ret);
1464 V_I4(pVarResult) = msiInstallStateUnknown;
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;
1474 if ((ret = MsiSetFeatureStateW(This->msiHandle, V_BSTR(&varg0), V_I4(&varg1))) != ERROR_SUCCESS)
1476 VariantClear(&varg0);
1477 ERR("MsiSetFeatureState returned %d\n", ret);
1478 return DISP_E_EXCEPTION;
1481 else return DISP_E_MEMBERNOTFOUND;
1482 break;
1484 default:
1485 return DISP_E_MEMBERNOTFOUND;
1488 VariantClear(&varg1);
1489 VariantClear(&varg0);
1491 return S_OK;
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)
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;
1505 switch (dwType)
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;
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
1527 V_VT(pVarResult) = VT_BSTR;
1528 V_BSTR(pVarResult) = SysAllocStringLen(szNewString, dwNewSize);
1530 msi_free(szNewString);
1531 break;
1533 case REG_DWORD:
1534 V_VT(pVarResult) = VT_I4;
1535 V_I4(pVarResult) = *((DWORD *)lpData);
1536 break;
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;
1543 case REG_BINARY:
1544 V_VT(pVarResult) = VT_BSTR;
1545 V_BSTR(pVarResult) = SysAllocString(szREG_BINARY);
1546 break;
1548 case REG_NONE:
1549 V_VT(pVarResult) = VT_EMPTY;
1550 break;
1552 default:
1553 FIXME("Unhandled registry value type %d\n", dwType);
1557 static HRESULT InstallerImpl_CreateRecord(WORD wFlags,
1558 DISPPARAMS* pDispParams,
1559 VARIANT* pVarResult,
1560 EXCEPINFO* pExcepInfo,
1561 UINT* puArgErr)
1563 HRESULT hr;
1564 VARIANTARG varg0;
1565 MSIHANDLE hrec;
1566 IDispatch* dispatch;
1568 if (!(wFlags & DISPATCH_METHOD))
1569 return DISP_E_MEMBERNOTFOUND;
1571 VariantInit(&varg0);
1572 hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
1573 if (FAILED(hr))
1574 return hr;
1576 V_VT(pVarResult) = VT_DISPATCH;
1578 hrec = MsiCreateRecord(V_I4(&varg0));
1579 if (!hrec)
1580 return DISP_E_EXCEPTION;
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;
1587 return hr;
1590 static HRESULT InstallerImpl_OpenPackage(AutomationObject* This,
1591 WORD wFlags,
1592 DISPPARAMS* pDispParams,
1593 VARIANT* pVarResult,
1594 EXCEPINFO* pExcepInfo,
1595 UINT* puArgErr)
1597 UINT ret;
1598 HRESULT hr;
1599 MSIHANDLE hpkg;
1600 IDispatch* dispatch;
1601 VARIANTARG varg0, varg1;
1603 if (!(wFlags & DISPATCH_METHOD))
1604 return DISP_E_MEMBERNOTFOUND;
1606 if (pDispParams->cArgs == 0)
1607 return DISP_E_TYPEMISMATCH;
1609 if (V_VT(&pDispParams->rgvarg[pDispParams->cArgs - 1]) != VT_BSTR)
1610 return DISP_E_TYPEMISMATCH;
1612 VariantInit(&varg0);
1613 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1614 if (FAILED(hr))
1615 return hr;
1617 VariantInit(&varg1);
1618 if (pDispParams->cArgs == 2)
1620 hr = DispGetParam(pDispParams, 1, VT_I4, &varg1, puArgErr);
1621 if (FAILED(hr))
1622 goto done;
1624 else
1626 V_VT(&varg1) = VT_I4;
1627 V_I4(&varg1) = 0;
1630 V_VT(pVarResult) = VT_DISPATCH;
1632 ret = MsiOpenPackageExW(V_BSTR(&varg0), V_I4(&varg1), &hpkg);
1633 if (ret != ERROR_SUCCESS)
1635 hr = DISP_E_EXCEPTION;
1636 goto done;
1639 hr = create_session(hpkg, (IDispatch *)This, &dispatch);
1640 if (SUCCEEDED(hr))
1641 V_DISPATCH(pVarResult) = dispatch;
1643 done:
1644 VariantClear(&varg0);
1645 VariantClear(&varg1);
1646 return hr;
1649 static HRESULT InstallerImpl_OpenProduct(WORD wFlags,
1650 DISPPARAMS* pDispParams,
1651 VARIANT* pVarResult,
1652 EXCEPINFO* pExcepInfo,
1653 UINT* puArgErr)
1655 HRESULT hr;
1656 VARIANTARG varg0;
1658 if (!(wFlags & DISPATCH_METHOD))
1659 return DISP_E_MEMBERNOTFOUND;
1661 VariantInit(&varg0);
1662 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1663 if (FAILED(hr))
1664 return hr;
1666 FIXME("%s\n", debugstr_w(V_BSTR(&varg0)));
1668 VariantInit(pVarResult);
1670 VariantClear(&varg0);
1671 return S_OK;
1674 static HRESULT InstallerImpl_OpenDatabase(WORD wFlags,
1675 DISPPARAMS* pDispParams,
1676 VARIANT* pVarResult,
1677 EXCEPINFO* pExcepInfo,
1678 UINT* puArgErr)
1680 UINT ret;
1681 HRESULT hr;
1682 MSIHANDLE hdb;
1683 IDispatch* dispatch;
1684 VARIANTARG varg0, varg1;
1686 if (!(wFlags & DISPATCH_METHOD))
1687 return DISP_E_MEMBERNOTFOUND;
1689 VariantInit(&varg0);
1690 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1691 if (FAILED(hr))
1692 return hr;
1694 VariantInit(&varg1);
1695 hr = DispGetParam(pDispParams, 1, VT_BSTR, &varg1, puArgErr);
1696 if (FAILED(hr))
1697 goto done;
1699 V_VT(pVarResult) = VT_DISPATCH;
1701 ret = MsiOpenDatabaseW(V_BSTR(&varg0), V_BSTR(&varg1), &hdb);
1702 if (ret != ERROR_SUCCESS)
1704 hr = DISP_E_EXCEPTION;
1705 goto done;
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;
1713 done:
1714 VariantClear(&varg0);
1715 VariantClear(&varg1);
1716 return hr;
1719 static HRESULT InstallerImpl_SummaryInformation(WORD wFlags,
1720 DISPPARAMS* pDispParams,
1721 VARIANT* pVarResult,
1722 EXCEPINFO* pExcepInfo,
1723 UINT* puArgErr)
1725 if (!(wFlags & DISPATCH_METHOD))
1726 return DISP_E_MEMBERNOTFOUND;
1728 FIXME("\n");
1730 VariantInit(pVarResult);
1731 return S_OK;
1734 static HRESULT InstallerImpl_UILevel(WORD wFlags,
1735 DISPPARAMS* pDispParams,
1736 VARIANT* pVarResult,
1737 EXCEPINFO* pExcepInfo,
1738 UINT* puArgErr)
1740 HRESULT hr;
1741 VARIANTARG varg0;
1742 INSTALLUILEVEL ui;
1744 if (!(wFlags & DISPATCH_PROPERTYPUT) && !(wFlags & DISPATCH_PROPERTYGET))
1745 return DISP_E_MEMBERNOTFOUND;
1747 if (wFlags & DISPATCH_PROPERTYPUT)
1749 VariantInit(&varg0);
1750 hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
1751 if (FAILED(hr))
1752 return hr;
1754 ui = MsiSetInternalUI(V_I4(&varg0), NULL);
1755 if (ui == INSTALLUILEVEL_NOCHANGE)
1756 return DISP_E_EXCEPTION;
1758 else if (wFlags & DISPATCH_PROPERTYGET)
1760 ui = MsiSetInternalUI(INSTALLUILEVEL_NOCHANGE, NULL);
1761 if (ui == INSTALLUILEVEL_NOCHANGE)
1762 return DISP_E_EXCEPTION;
1764 V_VT(pVarResult) = VT_I4;
1765 V_I4(pVarResult) = ui;
1768 return S_OK;
1771 static HRESULT InstallerImpl_EnableLog(WORD wFlags,
1772 DISPPARAMS* pDispParams,
1773 VARIANT* pVarResult,
1774 EXCEPINFO* pExcepInfo,
1775 UINT* puArgErr)
1777 if (!(wFlags & DISPATCH_METHOD))
1778 return DISP_E_MEMBERNOTFOUND;
1780 FIXME("\n");
1782 VariantInit(pVarResult);
1783 return S_OK;
1786 static HRESULT InstallerImpl_InstallProduct(WORD wFlags,
1787 DISPPARAMS* pDispParams,
1788 VARIANT* pVarResult,
1789 EXCEPINFO* pExcepInfo,
1790 UINT* puArgErr)
1792 UINT ret;
1793 HRESULT hr;
1794 VARIANTARG varg0, varg1;
1796 if (!(wFlags & DISPATCH_METHOD))
1797 return DISP_E_MEMBERNOTFOUND;
1799 VariantInit(&varg0);
1800 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
1801 if (FAILED(hr))
1802 return hr;
1804 VariantInit(&varg1);
1805 hr = DispGetParam(pDispParams, 1, VT_BSTR, &varg1, puArgErr);
1806 if (FAILED(hr))
1807 goto done;
1809 ret = MsiInstallProductW(V_BSTR(&varg0), V_BSTR(&varg1));
1810 if (ret != ERROR_SUCCESS)
1812 hr = DISP_E_EXCEPTION;
1813 goto done;
1816 done:
1817 VariantClear(&varg0);
1818 VariantClear(&varg1);
1819 return hr;
1822 static HRESULT InstallerImpl_Version(WORD wFlags,
1823 VARIANT* pVarResult,
1824 EXCEPINFO* pExcepInfo,
1825 UINT* puArgErr)
1827 HRESULT hr;
1828 DLLVERSIONINFO verinfo;
1829 WCHAR version[MAX_PATH];
1831 static const WCHAR format[] = {
1832 '%','d','.','%','d','.','%','d','.','%','d',0};
1834 if (!(wFlags & DISPATCH_PROPERTYGET))
1835 return DISP_E_MEMBERNOTFOUND;
1837 verinfo.cbSize = sizeof(DLLVERSIONINFO);
1838 hr = DllGetVersion(&verinfo);
1839 if (FAILED(hr))
1840 return hr;
1842 sprintfW(version, format, verinfo.dwMajorVersion, verinfo.dwMinorVersion,
1843 verinfo.dwBuildNumber, verinfo.dwPlatformID);
1845 V_VT(pVarResult) = VT_BSTR;
1846 V_BSTR(pVarResult) = SysAllocString(version);
1847 return S_OK;
1850 static HRESULT InstallerImpl_LastErrorRecord(WORD wFlags,
1851 DISPPARAMS* pDispParams,
1852 VARIANT* pVarResult,
1853 EXCEPINFO* pExcepInfo,
1854 UINT* puArgErr)
1856 if (!(wFlags & DISPATCH_METHOD))
1857 return DISP_E_MEMBERNOTFOUND;
1859 FIXME("\n");
1861 VariantInit(pVarResult);
1862 return S_OK;
1865 static HRESULT InstallerImpl_RegistryValue(WORD wFlags,
1866 DISPPARAMS* pDispParams,
1867 VARIANT* pVarResult,
1868 EXCEPINFO* pExcepInfo,
1869 UINT* puArgErr)
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;
1879 if (!(wFlags & DISPATCH_METHOD))
1880 return DISP_E_MEMBERNOTFOUND;
1882 VariantInit(&varg0);
1883 hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
1884 if (FAILED(hr))
1885 return hr;
1887 VariantInit(&varg1);
1888 hr = DispGetParam(pDispParams, 1, VT_BSTR, &varg1, puArgErr);
1889 if (FAILED(hr))
1890 goto done;
1892 /* Save valuePos so we can save puArgErr if we are unable to do our type
1893 * conversions.
1895 posValue = 2;
1896 VariantInit(&varg2);
1897 hr = DispGetParam_CopyOnly(pDispParams, &posValue, &varg2);
1898 if (FAILED(hr))
1899 goto done;
1901 if (V_I4(&varg0) >= REG_INDEX_CLASSES_ROOT &&
1902 V_I4(&varg0) <= REG_INDEX_DYN_DATA)
1904 V_I4(&varg0) |= (UINT_PTR)HKEY_CLASSES_ROOT;
1907 ret = RegOpenKeyW((HKEY)(UINT_PTR)V_I4(&varg0), V_BSTR(&varg1), &hkey);
1909 /* Only VT_EMPTY case can do anything if the key doesn't exist. */
1910 if (ret != ERROR_SUCCESS && V_VT(&varg2) != VT_EMPTY)
1912 hr = DISP_E_BADINDEX;
1913 goto done;
1916 /* Third parameter can be VT_EMPTY, VT_I4, or VT_BSTR */
1917 switch (V_VT(&varg2))
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;
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)
1931 hr = DISP_E_BADINDEX;
1932 goto done;
1935 szString = msi_alloc(size);
1936 if (!szString)
1938 hr = E_OUTOFMEMORY;
1939 goto done;
1942 ret = RegQueryValueExW(hkey, V_BSTR(&varg2), NULL,
1943 &type, (LPBYTE)szString, &size);
1944 if (ret != ERROR_SUCCESS)
1946 msi_free(szString);
1947 hr = DISP_E_BADINDEX;
1948 goto done;
1951 variant_from_registry_value(pVarResult, type,
1952 (LPBYTE)szString, size);
1953 msi_free(szString);
1954 break;
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))
1961 if (hr == DISP_E_TYPEMISMATCH)
1962 *puArgErr = posValue;
1964 goto done;
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);
1978 if (ret != ERROR_SUCCESS)
1979 goto done;
1981 szString = msi_alloc(++size * sizeof(WCHAR));
1982 if (!szString)
1984 hr = E_OUTOFMEMORY;
1985 goto done;
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);
1997 if (ret == ERROR_SUCCESS)
1999 V_VT(pVarResult) = VT_BSTR;
2000 V_BSTR(pVarResult) = SysAllocString(szString);
2003 msi_free(szString);
2006 done:
2007 VariantClear(&varg0);
2008 VariantClear(&varg1);
2009 VariantClear(&varg2);
2010 RegCloseKey(hkey);
2011 return hr;
2014 static HRESULT InstallerImpl_Environment(WORD wFlags,
2015 DISPPARAMS* pDispParams,
2016 VARIANT* pVarResult,
2017 EXCEPINFO* pExcepInfo,
2018 UINT* puArgErr)
2020 if (!(wFlags & DISPATCH_METHOD))
2021 return DISP_E_MEMBERNOTFOUND;
2023 FIXME("\n");
2025 VariantInit(pVarResult);
2026 return S_OK;
2029 static HRESULT InstallerImpl_FileAttributes(WORD wFlags,
2030 DISPPARAMS* pDispParams,
2031 VARIANT* pVarResult,
2032 EXCEPINFO* pExcepInfo,
2033 UINT* puArgErr)
2035 if (!(wFlags & DISPATCH_METHOD))
2036 return DISP_E_MEMBERNOTFOUND;
2038 FIXME("\n");
2040 VariantInit(pVarResult);
2041 return S_OK;
2044 static HRESULT InstallerImpl_FileSize(WORD wFlags,
2045 DISPPARAMS* pDispParams,
2046 VARIANT* pVarResult,
2047 EXCEPINFO* pExcepInfo,
2048 UINT* puArgErr)
2050 if (!(wFlags & DISPATCH_METHOD))
2051 return DISP_E_MEMBERNOTFOUND;
2053 FIXME("\n");
2055 VariantInit(pVarResult);
2056 return S_OK;
2059 static HRESULT InstallerImpl_FileVersion(WORD wFlags,
2060 DISPPARAMS* pDispParams,
2061 VARIANT* pVarResult,
2062 EXCEPINFO* pExcepInfo,
2063 UINT* puArgErr)
2065 if (!(wFlags & DISPATCH_METHOD))
2066 return DISP_E_MEMBERNOTFOUND;
2068 FIXME("\n");
2070 VariantInit(pVarResult);
2071 return S_OK;
2074 static HRESULT InstallerImpl_ProductState(WORD wFlags,
2075 DISPPARAMS* pDispParams,
2076 VARIANT* pVarResult,
2077 EXCEPINFO* pExcepInfo,
2078 UINT* puArgErr)
2080 HRESULT hr;
2081 VARIANTARG varg0;
2083 if (!(wFlags & DISPATCH_PROPERTYGET))
2084 return DISP_E_MEMBERNOTFOUND;
2086 VariantInit(&varg0);
2087 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
2088 if (FAILED(hr))
2089 return hr;
2091 V_VT(pVarResult) = VT_I4;
2092 V_I4(pVarResult) = MsiQueryProductStateW(V_BSTR(&varg0));
2094 VariantClear(&varg0);
2095 return S_OK;
2098 static HRESULT InstallerImpl_ProductInfo(WORD wFlags,
2099 DISPPARAMS* pDispParams,
2100 VARIANT* pVarResult,
2101 EXCEPINFO* pExcepInfo,
2102 UINT* puArgErr)
2104 UINT ret;
2105 HRESULT hr;
2106 DWORD size;
2107 LPWSTR str = NULL;
2108 VARIANTARG varg0, varg1;
2110 if (!(wFlags & DISPATCH_PROPERTYGET))
2111 return DISP_E_MEMBERNOTFOUND;
2113 VariantInit(&varg0);
2114 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
2115 if (FAILED(hr))
2116 return hr;
2118 VariantInit(&varg1);
2119 hr = DispGetParam(pDispParams, 1, VT_BSTR, &varg1, puArgErr);
2120 if (FAILED(hr))
2121 goto done;
2123 V_VT(pVarResult) = VT_BSTR;
2124 V_BSTR(pVarResult) = NULL;
2126 ret = MsiGetProductInfoW(V_BSTR(&varg0), V_BSTR(&varg1), NULL, &size);
2127 if (ret != ERROR_SUCCESS)
2129 hr = DISP_E_EXCEPTION;
2130 goto done;
2133 str = msi_alloc(++size * sizeof(WCHAR));
2134 if (!str)
2136 hr = E_OUTOFMEMORY;
2137 goto done;
2140 ret = MsiGetProductInfoW(V_BSTR(&varg0), V_BSTR(&varg1), str, &size);
2141 if (ret != ERROR_SUCCESS)
2143 hr = DISP_E_EXCEPTION;
2144 goto done;
2147 V_BSTR(pVarResult) = SysAllocString(str);
2148 hr = S_OK;
2150 done:
2151 msi_free(str);
2152 VariantClear(&varg0);
2153 VariantClear(&varg1);
2154 return hr;
2157 static void cleanup_products(IDispatch* dispatch, ULONG count)
2159 UINT i;
2160 ListData* ldata = private_data((AutomationObject *)dispatch);
2162 for (i = 0; i < count - 1; i++)
2163 VariantClear(&ldata->pVars[i]);
2165 ldata->ulCount = 0;
2166 msi_free(ldata->pVars);
2168 IDispatch_Release(dispatch);
2171 static HRESULT InstallerImpl_Products(WORD wFlags,
2172 DISPPARAMS* pDispParams,
2173 VARIANT* pVarResult,
2174 EXCEPINFO* pExcepInfo,
2175 UINT* puArgErr)
2177 UINT ret;
2178 HRESULT hr;
2179 ULONG idx = 0;
2180 ListData *ldata;
2181 IDispatch *dispatch;
2182 WCHAR product[GUID_SIZE];
2184 if (!(wFlags & DISPATCH_PROPERTYGET))
2185 return DISP_E_MEMBERNOTFOUND;
2187 /* Find number of products. */
2188 while ((ret = MsiEnumProductsW(idx, product)) == ERROR_SUCCESS)
2189 idx++;
2191 if (ret != ERROR_NO_MORE_ITEMS)
2192 return DISP_E_EXCEPTION;
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;
2201 V_DISPATCH(pVarResult) = dispatch;
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)
2209 IDispatch_Release(dispatch);
2210 return E_OUTOFMEMORY;
2213 ldata->ulCount = idx;
2214 for (idx = 0; idx < ldata->ulCount; idx++)
2216 ret = MsiEnumProductsW(idx, product);
2217 if (ret != ERROR_SUCCESS)
2219 cleanup_products(dispatch, idx - 1);
2220 return DISP_E_EXCEPTION;
2223 VariantInit(&ldata->pVars[idx]);
2224 V_VT(&ldata->pVars[idx]) = VT_BSTR;
2225 V_BSTR(&ldata->pVars[idx]) = SysAllocString(product);
2228 return S_OK;
2231 static HRESULT InstallerImpl_RelatedProducts(WORD wFlags,
2232 DISPPARAMS* pDispParams,
2233 VARIANT* pVarResult,
2234 EXCEPINFO* pExcepInfo,
2235 UINT* puArgErr)
2237 UINT ret;
2238 ULONG idx;
2239 HRESULT hr;
2240 ListData *ldata;
2241 VARIANTARG varg0;
2242 IDispatch* dispatch;
2243 WCHAR product[GUID_SIZE];
2245 if (!(wFlags & DISPATCH_PROPERTYGET))
2246 return DISP_E_MEMBERNOTFOUND;
2248 VariantInit(&varg0);
2249 hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
2250 if (FAILED(hr))
2251 return hr;
2253 /* Find number of related products. */
2254 idx = 0;
2257 ret = MsiEnumRelatedProductsW(V_BSTR(&varg0), 0, idx, product);
2258 if (ret == ERROR_SUCCESS)
2259 idx++;
2260 } while (ret == ERROR_SUCCESS);
2262 if (ret != ERROR_NO_MORE_ITEMS)
2264 hr = DISP_E_EXCEPTION;
2265 goto done;
2268 V_VT(pVarResult) = VT_DISPATCH;
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;
2276 V_DISPATCH(pVarResult) = dispatch;
2278 /* Save product strings. */
2279 ldata = private_data((AutomationObject *)dispatch);
2280 ldata->pVars = msi_alloc(sizeof(VARIANT) * idx);
2281 if (!ldata->pVars)
2283 IDispatch_Release(dispatch);
2284 hr = E_OUTOFMEMORY;
2285 goto done;
2288 ldata->ulCount = idx;
2289 for (idx = 0; idx < ldata->ulCount; idx++)
2291 ret = MsiEnumRelatedProductsW(V_BSTR(&varg0), 0, idx, product);
2292 if (ret != ERROR_SUCCESS)
2294 cleanup_products(dispatch, idx - 1);
2295 hr = DISP_E_EXCEPTION;
2296 goto done;
2299 VariantInit(&ldata->pVars[idx]);
2300 V_VT(&ldata->pVars[idx]) = VT_BSTR;
2301 V_BSTR(&ldata->pVars[idx]) = SysAllocString(product);
2304 hr = S_OK;
2306 done:
2307 VariantClear(&varg0);
2308 return hr;
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)
2322 switch (dispIdMember)
2324 case DISPID_INSTALLER_CREATERECORD:
2325 return InstallerImpl_CreateRecord(wFlags, pDispParams,
2326 pVarResult, pExcepInfo, puArgErr);
2328 case DISPID_INSTALLER_OPENPACKAGE:
2329 return InstallerImpl_OpenPackage(This, wFlags, pDispParams,
2330 pVarResult, pExcepInfo, puArgErr);
2332 case DISPID_INSTALLER_OPENPRODUCT:
2333 return InstallerImpl_OpenProduct(wFlags, pDispParams,
2334 pVarResult, pExcepInfo, puArgErr);
2336 case DISPID_INSTALLER_OPENDATABASE:
2337 return InstallerImpl_OpenDatabase(wFlags, pDispParams,
2338 pVarResult, pExcepInfo, puArgErr);
2340 case DISPID_INSTALLER_SUMMARYINFORMATION:
2341 return InstallerImpl_SummaryInformation(wFlags, pDispParams,
2342 pVarResult, pExcepInfo,
2343 puArgErr);
2345 case DISPID_INSTALLER_UILEVEL:
2346 return InstallerImpl_UILevel(wFlags, pDispParams,
2347 pVarResult, pExcepInfo, puArgErr);
2349 case DISPID_INSTALLER_ENABLELOG:
2350 return InstallerImpl_EnableLog(wFlags, pDispParams,
2351 pVarResult, pExcepInfo, puArgErr);
2353 case DISPID_INSTALLER_INSTALLPRODUCT:
2354 return InstallerImpl_InstallProduct(wFlags, pDispParams,
2355 pVarResult, pExcepInfo,
2356 puArgErr);
2358 case DISPID_INSTALLER_VERSION:
2359 return InstallerImpl_Version(wFlags, pVarResult,
2360 pExcepInfo, puArgErr);
2362 case DISPID_INSTALLER_LASTERRORRECORD:
2363 return InstallerImpl_LastErrorRecord(wFlags, pDispParams,
2364 pVarResult, pExcepInfo,
2365 puArgErr);
2367 case DISPID_INSTALLER_REGISTRYVALUE:
2368 return InstallerImpl_RegistryValue(wFlags, pDispParams,
2369 pVarResult, pExcepInfo,
2370 puArgErr);
2372 case DISPID_INSTALLER_ENVIRONMENT:
2373 return InstallerImpl_Environment(wFlags, pDispParams,
2374 pVarResult, pExcepInfo, puArgErr);
2376 case DISPID_INSTALLER_FILEATTRIBUTES:
2377 return InstallerImpl_FileAttributes(wFlags, pDispParams,
2378 pVarResult, pExcepInfo,
2379 puArgErr);
2381 case DISPID_INSTALLER_FILESIZE:
2382 return InstallerImpl_FileSize(wFlags, pDispParams,
2383 pVarResult, pExcepInfo, puArgErr);
2385 case DISPID_INSTALLER_FILEVERSION:
2386 return InstallerImpl_FileVersion(wFlags, pDispParams,
2387 pVarResult, pExcepInfo, puArgErr);
2389 case DISPID_INSTALLER_PRODUCTSTATE:
2390 return InstallerImpl_ProductState(wFlags, pDispParams,
2391 pVarResult, pExcepInfo, puArgErr);
2393 case DISPID_INSTALLER_PRODUCTINFO:
2394 return InstallerImpl_ProductInfo(wFlags, pDispParams,
2395 pVarResult, pExcepInfo, puArgErr);
2397 case DISPID_INSTALLER_PRODUCTS:
2398 return InstallerImpl_Products(wFlags, pDispParams,
2399 pVarResult, pExcepInfo, puArgErr);
2401 case DISPID_INSTALLER_RELATEDPRODUCTS:
2402 return InstallerImpl_RelatedProducts(wFlags, pDispParams,
2403 pVarResult, pExcepInfo,
2404 puArgErr);
2406 default:
2407 return DISP_E_MEMBERNOTFOUND;
2411 /* Wrapper around create_automation_object to create an installer object. */
2412 HRESULT create_msiserver(IUnknown *pOuter, LPVOID *ppObj)
2414 return create_automation_object(0, pOuter, ppObj, &DIID_Installer, InstallerImpl_Invoke, NULL, 0);
2417 /* Wrapper around create_automation_object to create a session object. */
2418 HRESULT create_session(MSIHANDLE msiHandle, IDispatch *pInstaller, IDispatch **pDispatch)
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;