INSENG, IActiveSetup and ICifFile interfaces ...

[Mike McCormack]

Hi All,

This is a stub implemenation of the undocumented IActiveSetup from 
Internet Explorer's INSENG.DLL.  I'm not sure that any other software 
except for Internet Explorer uses INSENG, however incase anybody is ever 
interested in it, I'm posting it here.

To build this dll in wine place the following 3 files in dlls/inseng, 
remove the #MKDLL_SKIP line from Makefile.in, add dlls/inseng/Makefile 
to configure.ac and run make_dlls.

Hopefully this will be of use to somebody someday...

Mike

#MKDLL_SKIP
TOPSRCDIR = @top_srcdir@
TOPOBJDIR = ../..
SRCDIR    = @srcdir@
VPATH     = @srcdir@
MODULE    = inseng.dll
IMPORTS   = user32 advapi32 kernel32 ntdll
EXTRALIBS = $(LIBUNICODE) $(LIBUUID)
EXTRADEFS = -DCOM_NO_WINDOWS_H

C_SRCS = \
    inseng.c

@MAKE_DLL_RULES@

### Dependencies:

/*
 *    INSENG Implementation
 *
 * Copyright 2002 Lionel Ulmer
 * Copyright 2003 Mike McCormack
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "config.h"

#include <stdarg.h>

#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "ole2.h"

#include "uuids.h"

#include "wine/debug.h"

#include "initguid.h"

DEFINE_GUID(CLSID_DLManager, 0xBFC880F1,0x7484,0x11D0,0x83,0x09,0x00,0xAA,0x00,0xB6,0x01,0x5C);
DEFINE_GUID(CLSID_ActiveSetupEng, 0x6e449686,0xc509,0x11cf,0xaa,0xfa,0x00,0xaa,0x00,0xb6,0x01,0x5c );
DEFINE_GUID(IID_IActiveSetupUnknown, 0x6e449689,0xc509,0x11cf,0xaa,0xfa,0x00,0xaa,0x00,0xb6,0x01,0x5c );

WINE_DEFAULT_DEBUG_CHANNEL(inseng);

static HRESULT create_activesetup(IUnknown *pUnkOuter, LPVOID *ppObj);

/* For the moment, do nothing here. */
BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv)
{
    switch(fdwReason) {
        case DLL_PROCESS_ATTACH:
            DisableThreadLibraryCalls(hInstDLL);
        break;
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}

/******************************************************************************
 * INSENG ClassFactory
 */
typedef struct {
    IClassFactory ITF_IClassFactory;

DWORD ref;
    HRESULT (*pfnCreateInstance)(IUnknown *pUnkOuter, LPVOID *ppObj);
} IClassFactoryImpl;

struct object_creation_info
{
    const CLSID *clsid;
    LPCSTR szClassName;
    HRESULT (*pfnCreateInstance)(IUnknown *pUnkOuter, LPVOID *ppObj);
};

static const struct object_creation_info object_creation[] =
{
    { &CLSID_DLManager, "Active Download Manager", NULL },
    { &CLSID_ActiveSetupEng, "Active Setup Engine", create_activesetup },
};

static HRESULT WINAPI
INSENGCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj)
{
    ICOM_THIS(IClassFactoryImpl,iface);

if (IsEqualGUID(riid, &IID_IUnknown)
    || IsEqualGUID(riid, &IID_IClassFactory))
    {
    IClassFactory_AddRef(iface);
    *ppobj = This;
    return S_OK;
    }

WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj);
    return E_NOINTERFACE;
}

static ULONG WINAPI INSENGCF_AddRef(LPCLASSFACTORY iface) {
    ICOM_THIS(IClassFactoryImpl,iface);
    return ++(This->ref);
}

static ULONG WINAPI INSENGCF_Release(LPCLASSFACTORY iface) {
    ICOM_THIS(IClassFactoryImpl,iface);

ULONG ref = --This->ref;

TRACE("%p\n",This);

if (ref == 0)
    HeapFree(GetProcessHeap(), 0, This);

return ref;
}

static HRESULT WINAPI INSENGCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter,
    				  REFIID riid, LPVOID *ppobj) {
    ICOM_THIS(IClassFactoryImpl,iface);
    HRESULT hres;
    LPUNKNOWN punk;

TRACE("(%p)->(%p,%s,%p)\n",This,pOuter,debugstr_guid(riid),ppobj);

hres = This->pfnCreateInstance(pOuter, (LPVOID *) &punk);
    if (FAILED(hres)) {
        *ppobj = NULL;
        return hres;
    }
    hres = IUnknown_QueryInterface(punk, riid, ppobj);
    if (FAILED(hres)) {
        *ppobj = NULL;
    return hres;
    }
    IUnknown_Release(punk);
    return hres;
}

static HRESULT WINAPI INSENGCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
    ICOM_THIS(IClassFactoryImpl,iface);
    FIXME("(%p)->(%d),stub!\n",This,dolock);
    return S_OK;
}

static ICOM_VTABLE(IClassFactory) INSENGCF_Vtbl =
{
    ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
    INSENGCF_QueryInterface,
    INSENGCF_AddRef,
    INSENGCF_Release,
    INSENGCF_CreateInstance,
    INSENGCF_LockServer
};

HRESULT WINAPI INSENG_DllGetClassObject(REFCLSID rclsid, REFIID iid, LPVOID *ppv)
{
    int i;
    IClassFactoryImpl *factory;

TRACE("%s %s %p\n",debugstr_guid(rclsid), debugstr_guid(iid), ppv);

if ( !IsEqualGUID( &IID_IClassFactory, iid )
     && ! IsEqualGUID( &IID_IUnknown, iid) )
    return E_NOINTERFACE;

for (i=0; i < sizeof(object_creation)/sizeof(object_creation[0]); i++)
    {
    if (IsEqualGUID(object_creation[i].clsid, rclsid))
        break;
    }

if (i == sizeof(object_creation)/sizeof(object_creation[0]))
    {
    FIXME("%s: no class found.\n", debugstr_guid(rclsid));
    return CLASS_E_CLASSNOTAVAILABLE;
    }

TRACE("Creating a class factory for %s\n",object_creation[i].szClassName);

if( !object_creation[i].pfnCreateInstance)
        return CLASS_E_CLASSNOTAVAILABLE;

factory = HeapAlloc(GetProcessHeap(), 0, sizeof(*factory));
    if (factory == NULL) return E_OUTOFMEMORY;

factory->ITF_IClassFactory.lpVtbl = &INSENGCF_Vtbl;
    factory->ref = 1;

factory->pfnCreateInstance = object_creation[i].pfnCreateInstance;

*ppv = &(factory->ITF_IClassFactory);

TRACE("(%p) <- %p\n", ppv, &(factory->ITF_IClassFactory) );

return S_OK;
}

HRESULT WINAPI INSENG_DllCanUnloadNow(void)
{
    FIXME("\n");
    return S_FALSE;
}

STDAPI DllRegisterServer(void)
{
    FIXME("\n");
    return S_OK;
}

BOOL WINAPI CheckTrustEx( LPVOID a, LPVOID b, LPVOID c, LPVOID d, LPVOID e )
{
    FIXME("%p %p %p %p %p\n", a, b, c, d, e );
    return TRUE;
}

/*************************************************************************/

typedef struct IENUMSetupModes IENUMSetupModes;
typedef struct IENUMSetupModes_Vtbl IENUMSetupModes_Vtbl;

struct IENUMSetupModes {
    const IENUMSetupModes_Vtbl* lpVtbl;
};

struct IENUMSetupModes_Vtbl {
    ICOM_MSVTABLE_COMPAT_FIELDS

/*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IENUMSetupModes* This,
        REFIID riid,
        void** ppvObject);

ULONG (STDMETHODCALLTYPE *AddRef)(
        IENUMSetupModes* This);

ULONG (STDMETHODCALLTYPE *Release)(
        IENUMSetupModes* This);

ULONG (STDMETHODCALLTYPE *Method1)(
        IENUMSetupModes* This, LPVOID *ptr);
};

static HRESULT WINAPI
IENUMSetupModes_QueryInterface(IENUMSetupModes * iface,REFIID riid,LPVOID *ppobj);
static ULONG WINAPI 
IENUMSetupModes_AddRef(IENUMSetupModes * iface);
static ULONG WINAPI 
IENUMSetupModes_Release(IENUMSetupModes * iface);
static ULONG WINAPI 
IENUMSetupModes_Method1(IENUMSetupModes * iface, LPVOID *ptr);

const struct IENUMSetupModes_Vtbl enummodes_vtbl =
{
    ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
    IENUMSetupModes_QueryInterface,
    IENUMSetupModes_AddRef,
    IENUMSetupModes_Release,
    IENUMSetupModes_Method1
};

typedef struct
{
    IENUMSetupModes ITF_IENUMSetupModes;
    DWORD ref;
} enummodes_impl;

static HRESULT WINAPI
IENUMSetupModes_QueryInterface(IENUMSetupModes * iface,REFIID riid,LPVOID *ppobj)
{
    ICOM_THIS(enummodes_impl,iface);
    FIXME("%p %s %p\n", This, debugstr_guid(riid), ppobj);

return E_NOINTERFACE;
}

static ULONG WINAPI 
IENUMSetupModes_AddRef(IENUMSetupModes * iface)
{
    ICOM_THIS(enummodes_impl,iface);
    TRACE("%p\n",This);
    return ++(This->ref);
}

static ULONG WINAPI 
IENUMSetupModes_Release(IENUMSetupModes * iface)
{
    ICOM_THIS(enummodes_impl,iface);

ULONG ref = --This->ref;

TRACE("%p\n",This);

if (ref == 0)
    HeapFree(GetProcessHeap(), 0, This);

return ref;
}

static ULONG WINAPI 
IENUMSetupModes_Method1(IENUMSetupModes * iface, LPVOID *ptr)
{
    ICOM_THIS(enummodes_impl,iface);
    FIXME("%p %p\n",This, ptr);
    return E_NOTIMPL;
}

static HRESULT create_enummodes( LPVOID *ppObj )
{
    enummodes_impl *em;

em = HeapAlloc( GetProcessHeap(), 0, sizeof (enummodes_impl) );
    if (em == NULL) return E_OUTOFMEMORY;

em->ITF_IENUMSetupModes.lpVtbl = &enummodes_vtbl;
    em->ref = 1;
    *ppObj = em;

TRACE("%p\n",em);

return S_OK;
}

/*************************************************************************/

typedef struct ICifFile ICifFile;
typedef struct ICifFile_Vtbl ICifFile_Vtbl;

struct ICifFile {
    const ICifFile_Vtbl* lpVtbl;
};

struct ICifFile_Vtbl {
    ICOM_MSVTABLE_COMPAT_FIELDS

/*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        ICifFile* This,
        REFIID riid,
        void** ppvObject);

ULONG (STDMETHODCALLTYPE *AddRef)(
        ICifFile* This);

ULONG (STDMETHODCALLTYPE *Release)(
        ICifFile* This);

ULONG (STDMETHODCALLTYPE *EnumComponents)(
        ICifFile* This, LPVOID *ppObj, LPVOID b, LPVOID c);

ULONG (STDMETHODCALLTYPE *Method2)(
        ICifFile* This);

ULONG (STDMETHODCALLTYPE *EnumGroups)(
        ICifFile* This, LPVOID *ppObj, LPVOID b, LPVOID c);

ULONG (STDMETHODCALLTYPE *Method4)(
        ICifFile* This);

ULONG (STDMETHODCALLTYPE *EnumModes)(
        ICifFile* This, LPVOID *ppObj, LPVOID b, LPVOID c);

ULONG (STDMETHODCALLTYPE *Method6)(
        ICifFile* This);

ULONG (STDMETHODCALLTYPE *Method7)(
        ICifFile* This);
};

static HRESULT WINAPI
ICifFile_QueryInterface(ICifFile * iface,REFIID riid,LPVOID *ppobj);
static ULONG WINAPI 
ICifFile_AddRef(ICifFile * iface);
static ULONG WINAPI 
ICifFile_Release(ICifFile * iface);
static ULONG WINAPI 
ICifFile_EnumComponents(ICifFile * iface, LPVOID *ppObj, LPVOID b, LPVOID c);
static ULONG WINAPI 
ICifFile_Method2(ICifFile * iface);
static ULONG WINAPI 
ICifFile_EnumGroups(ICifFile * iface, LPVOID *ppObj, LPVOID b, LPVOID c);
static ULONG WINAPI 
ICifFile_Method4(ICifFile * iface);
static ULONG WINAPI 
ICifFile_EnumModes(ICifFile * iface, LPVOID *ppObj, LPVOID b, LPVOID c);
static ULONG WINAPI 
ICifFile_Method6(ICifFile * iface);
static ULONG WINAPI 
ICifFile_Method7(ICifFile * iface);

const struct ICifFile_Vtbl ciffile_vtbl =
{
    ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
    ICifFile_QueryInterface,
    ICifFile_AddRef,
    ICifFile_Release,
    ICifFile_EnumComponents,
    ICifFile_Method2,
    ICifFile_EnumGroups,
    ICifFile_Method4,
    ICifFile_EnumModes,
    ICifFile_Method6,
    ICifFile_Method7
};

typedef struct
{
    ICifFile ITF_ICifFile;
    DWORD ref;
} ciffile_impl;

static HRESULT WINAPI
ICifFile_QueryInterface(ICifFile * iface,REFIID riid,LPVOID *ppobj)
{
    /* ICOM_THIS(ciffile_impl,iface); */

FIXME("%p %s %p\n", iface, debugstr_guid(riid), ppobj);

/*jif( IsEqualGUID(riid, &IID_IActiveSetupUnknown) )
    {
    activesetupimpl_AddRef(iface);
    *ppobj = This;
        ERR("OK\n");
    return S_OK;
    }*/
    return E_NOINTERFACE;
}

static ULONG WINAPI 
ICifFile_AddRef(ICifFile * iface)
{
    ICOM_THIS(ciffile_impl,iface);
    TRACE("%p\n",This);
    return ++(This->ref);
}

static ULONG WINAPI 
ICifFile_Release(ICifFile * iface)
{
    ICOM_THIS(ciffile_impl,iface);

ULONG ref = --This->ref;

TRACE("%p\n",This);
    if (ref == 0)
    HeapFree(GetProcessHeap(), 0, This);

return ref;
}

static ULONG WINAPI 
ICifFile_EnumComponents(ICifFile * iface, LPVOID *ppObj, LPVOID b, LPVOID c)
{
    ICOM_THIS(ciffile_impl,iface);
    FIXME("%p %p %p %p\n", This, ppObj, b, c);
    return create_enummodes( ppObj );
}

static ULONG WINAPI 
ICifFile_Method2(ICifFile * iface)
{
    ICOM_THIS(ciffile_impl,iface);
    FIXME("%p\n", This);
    return E_FAIL;
}

static ULONG WINAPI 
ICifFile_EnumGroups(ICifFile * iface, LPVOID *ppObj, LPVOID b, LPVOID c)
{
    ICOM_THIS(ciffile_impl,iface);
    FIXME("%p %p %p %p\n", This, ppObj, b, c);
    return create_enummodes( ppObj );
    //return E_FAIL;
}

static ULONG WINAPI 
ICifFile_Method4(ICifFile * iface)
{
    ICOM_THIS(ciffile_impl,iface);
    FIXME("%p\n", This);
    return E_FAIL;
}

static ULONG WINAPI 
ICifFile_EnumModes(ICifFile * iface, LPVOID *ppObj, LPVOID b, LPVOID c)
{
    ICOM_THIS(ciffile_impl,iface);

FIXME("%p %p %p %p\n", This, ppObj, b, c);
    return create_enummodes( ppObj );

//return E_NOTIMPL;
}

static ULONG WINAPI 
ICifFile_Method6(ICifFile * iface)
{
    ICOM_THIS(ciffile_impl,iface);
    FIXME("%p\n", This);
    return E_FAIL;
}

static ULONG WINAPI 
ICifFile_Method7(ICifFile * iface)
{
    ICOM_THIS(ciffile_impl,iface);
    FIXME("%p\n", This);
    return E_FAIL;
}

static HRESULT create_ciffile( LPVOID *ppObj )
{
    ciffile_impl *cf;

cf = HeapAlloc( GetProcessHeap(), 0, sizeof (ciffile_impl) );
    if (cf == NULL) return E_OUTOFMEMORY;

cf->ITF_ICifFile.lpVtbl = &ciffile_vtbl;
    cf->ref = 1;
    *ppObj = cf;

TRACE("%p\n",cf);

return S_OK;
}

/*************************************************************************/

typedef struct IActiveSetupUnknown IActiveSetupUnknown;
typedef struct IActiveSetupUnknown_Vtbl IActiveSetupUnknown_Vtbl;

struct IActiveSetupUnknown {
    const IActiveSetupUnknown_Vtbl* lpVtbl;
};

struct IActiveSetupUnknown_Vtbl {
    ICOM_MSVTABLE_COMPAT_FIELDS

/*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IActiveSetupUnknown* This,
        REFIID riid,
        void** ppvObject);

ULONG (STDMETHODCALLTYPE *AddRef)(
        IActiveSetupUnknown* This);

ULONG (STDMETHODCALLTYPE *Release)(
        IActiveSetupUnknown* This);

ULONG (STDMETHODCALLTYPE *Method1)(
        IActiveSetupUnknown* This);

ULONG (STDMETHODCALLTYPE *EnumModes)(
        IActiveSetupUnknown* This, LPVOID *ptr, DWORD b, DWORD c);

ULONG (STDMETHODCALLTYPE *Method3)(
        IActiveSetupUnknown* This);

ULONG (STDMETHODCALLTYPE *Method4)(
        IActiveSetupUnknown* This);

ULONG (STDMETHODCALLTYPE *Method5)(
        IActiveSetupUnknown* This);

ULONG (STDMETHODCALLTYPE *Method6)(
        IActiveSetupUnknown* This);

ULONG (STDMETHODCALLTYPE *Method7)(
        IActiveSetupUnknown* This);

ULONG (STDMETHODCALLTYPE *Method8)(
        IActiveSetupUnknown* This);

ULONG (STDMETHODCALLTYPE *Method9)(
        IActiveSetupUnknown* This);

ULONG (STDMETHODCALLTYPE *Method10)(
        IActiveSetupUnknown* This, DWORD a, DWORD b, DWORD c);

ULONG (STDMETHODCALLTYPE *Method11)(
        IActiveSetupUnknown* This, DWORD a, LPVOID b);

ULONG (STDMETHODCALLTYPE *Method12)(
        IActiveSetupUnknown* This);

ULONG (STDMETHODCALLTYPE *Method13)(
        IActiveSetupUnknown* This);

ULONG (STDMETHODCALLTYPE *Method14)(
        IActiveSetupUnknown* This);

ULONG (STDMETHODCALLTYPE *Method15)(
        IActiveSetupUnknown* This, LPVOID a);

ULONG (STDMETHODCALLTYPE *SetInstallDrive)(
        IActiveSetupUnknown* This, CHAR drive);

ULONG (STDMETHODCALLTYPE *SetInstallOption)(
        IActiveSetupUnknown* This, DWORD a);

ULONG (STDMETHODCALLTYPE *Method18)(
        IActiveSetupUnknown* This);

ULONG (STDMETHODCALLTYPE *Method19)(
        IActiveSetupUnknown* This, IStream * stm);

ULONG (STDMETHODCALLTYPE *Method20)(
        IActiveSetupUnknown* This);

ULONG (STDMETHODCALLTYPE *Method21)(
        IActiveSetupUnknown* This);

ULONG (STDMETHODCALLTYPE *Method22)(
        IActiveSetupUnknown* This);

ULONG (STDMETHODCALLTYPE *SetLocalCif)(
        IActiveSetupUnknown* This, LPCSTR name );

ULONG (STDMETHODCALLTYPE *GetICifFile)(
        IActiveSetupUnknown* This, LPVOID *ptr );

ULONG (STDMETHODCALLTYPE *Method25)(
        IActiveSetupUnknown* This);

ULONG (STDMETHODCALLTYPE *Method26)(
        IActiveSetupUnknown* This);

ULONG (STDMETHODCALLTYPE *Method27)(
        IActiveSetupUnknown* This);
};

static HRESULT WINAPI
activesetupimpl_QueryInterface(IActiveSetupUnknown * iface,REFIID riid,LPVOID *ppobj);
static ULONG WINAPI 
activesetupimpl_AddRef(IActiveSetupUnknown * iface);
static ULONG WINAPI 
activesetupimpl_Release(IActiveSetupUnknown * iface);
static ULONG WINAPI 
activesetupimpl_Method1(IActiveSetupUnknown * iface);
static ULONG WINAPI 
activesetupimpl_EnumModes(IActiveSetupUnknown * iface, LPVOID *ptr, DWORD b, DWORD c);
static ULONG WINAPI 
activesetupimpl_Method3(IActiveSetupUnknown * iface);
static ULONG WINAPI 
activesetupimpl_Method4(IActiveSetupUnknown * iface);
static ULONG WINAPI 
activesetupimpl_Method5(IActiveSetupUnknown * iface);
static ULONG WINAPI 
activesetupimpl_Method6(IActiveSetupUnknown * iface);
static ULONG WINAPI 
activesetupimpl_Method7(IActiveSetupUnknown * iface);
static ULONG WINAPI 
activesetupimpl_Method8(IActiveSetupUnknown * iface);
static ULONG WINAPI 
activesetupimpl_Method9(IActiveSetupUnknown * iface);
static ULONG WINAPI 
activesetupimpl_Method10(IActiveSetupUnknown * iface, DWORD a, DWORD b, DWORD c);
static ULONG WINAPI 
activesetupimpl_Method11(IActiveSetupUnknown * iface, DWORD a, LPVOID b );
static ULONG WINAPI 
activesetupimpl_Method12(IActiveSetupUnknown * iface);
static ULONG WINAPI 
activesetupimpl_Method13(IActiveSetupUnknown * iface);
static ULONG WINAPI 
activesetupimpl_Method14(IActiveSetupUnknown * iface);
static ULONG WINAPI 
activesetupimpl_Method15(IActiveSetupUnknown * iface, LPVOID a);
static ULONG WINAPI 
activesetupimpl_SetInstallDrive(IActiveSetupUnknown * iface, CHAR drive);
static ULONG WINAPI 
activesetupimpl_SetInstallOption(IActiveSetupUnknown * iface, DWORD a);
static ULONG WINAPI 
activesetupimpl_Method18(IActiveSetupUnknown * iface);
static ULONG WINAPI 
activesetupimpl_Method19(IActiveSetupUnknown * iface, IStream * stm );
static ULONG WINAPI 
activesetupimpl_Method20(IActiveSetupUnknown * iface);
static ULONG WINAPI 
activesetupimpl_Method21(IActiveSetupUnknown * iface);
static ULONG WINAPI 
activesetupimpl_Method22(IActiveSetupUnknown * iface);
static ULONG WINAPI 
activesetupimpl_SetLocalCif(IActiveSetupUnknown * iface, LPCSTR name );
static ULONG WINAPI 
activesetupimpl_GetICifFile(IActiveSetupUnknown * iface, LPVOID *ptr );
static ULONG WINAPI 
activesetupimpl_Method25(IActiveSetupUnknown * iface);
static ULONG WINAPI 
activesetupimpl_Method26(IActiveSetupUnknown * iface);

const struct IActiveSetupUnknown_Vtbl activesetupimpl_vtbl =
{
    ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
    activesetupimpl_QueryInterface,
    activesetupimpl_AddRef,
    activesetupimpl_Release,
    activesetupimpl_Method1,
    activesetupimpl_EnumModes,
    activesetupimpl_Method3,
    activesetupimpl_Method4,
    activesetupimpl_Method5,
    activesetupimpl_Method6,
    activesetupimpl_Method7,
    activesetupimpl_Method8,
    activesetupimpl_Method9,
    activesetupimpl_Method10,
    activesetupimpl_Method11,
    activesetupimpl_Method12,
    activesetupimpl_Method13,
    activesetupimpl_Method14,
    activesetupimpl_Method15,
    activesetupimpl_SetInstallDrive,
    activesetupimpl_SetInstallOption,
    activesetupimpl_Method18,
    activesetupimpl_Method19,
    activesetupimpl_Method20,
    activesetupimpl_Method21,
    activesetupimpl_Method22,
    activesetupimpl_SetLocalCif,
    activesetupimpl_GetICifFile,
    activesetupimpl_Method25,
    activesetupimpl_Method26
};

typedef struct
{
    IActiveSetupUnknown ITF_IActiveSetupUnknown;
    DWORD ref;
} activesetup_impl;

static HRESULT WINAPI
activesetupimpl_QueryInterface(IActiveSetupUnknown *iface,REFIID riid,LPVOID *ppobj)
{
    ICOM_THIS(activesetup_impl,iface);

TRACE("%p %s %p\n", iface, debugstr_guid(riid), ppobj);

if( IsEqualGUID(riid, &IID_IActiveSetupUnknown) )
    {
    activesetupimpl_AddRef(iface);
    *ppobj = This;
        ERR("OK\n");
    return S_OK;
    }
    return E_NOINTERFACE;
}

static ULONG WINAPI 
activesetupimpl_AddRef(IActiveSetupUnknown * iface)
{
    ICOM_THIS(activesetup_impl,iface);
    TRACE("%p\n",This);
    return ++(This->ref);
}

static ULONG WINAPI 
activesetupimpl_Release(IActiveSetupUnknown * iface)
{
    ICOM_THIS(activesetup_impl,iface);

ULONG ref = --This->ref;

TRACE("%p\n",This);
    if (ref == 0)
    HeapFree(GetProcessHeap(), 0, This);

return ref;
}

static ULONG WINAPI 
activesetupimpl_Method1(IActiveSetupUnknown * iface)
{
    ICOM_THIS(activesetup_impl,iface);

FIXME("%p\n", This );

return E_FAIL;
}

static ULONG WINAPI 
activesetupimpl_EnumModes(IActiveSetupUnknown * iface, LPVOID *ppObj, DWORD dwPlatform, DWORD c)
{
    ICOM_THIS(activesetup_impl,iface);

FIXME("%p %p %08lx %ld\n", This, ppObj, dwPlatform, c );

return E_FAIL;
    //return create_enummodes( ppObj );
}

static ULONG WINAPI 
activesetupimpl_Method3(IActiveSetupUnknown * iface)
{
    ICOM_THIS(activesetup_impl,iface);

FIXME("%p\n", This );

return E_FAIL;
}

static ULONG WINAPI 
activesetupimpl_Method4(IActiveSetupUnknown * iface)
{
    ICOM_THIS(activesetup_impl,iface);

FIXME("%p\n", This );

return E_FAIL;
}

static ULONG WINAPI 
activesetupimpl_Method5(IActiveSetupUnknown * iface)
{
    ICOM_THIS(activesetup_impl,iface);

FIXME("%p\n", This );

return E_FAIL;
}

static ULONG WINAPI 
activesetupimpl_Method6(IActiveSetupUnknown * iface)
{
    ICOM_THIS(activesetup_impl,iface);

FIXME("%p\n", This );

return E_FAIL;
}

static ULONG WINAPI 
activesetupimpl_Method7(IActiveSetupUnknown * iface)
{
    ICOM_THIS(activesetup_impl,iface);

FIXME("%p\n", This );

return E_FAIL;
}

static ULONG WINAPI 
activesetupimpl_Method8(IActiveSetupUnknown * iface)
{
    ICOM_THIS(activesetup_impl,iface);

FIXME("%p\n", This );

return E_FAIL;
}

static ULONG WINAPI 
activesetupimpl_Method9(IActiveSetupUnknown * iface)
{
    ICOM_THIS(activesetup_impl,iface);

FIXME("%p\n", This );

return E_FAIL;
}

static ULONG WINAPI 
activesetupimpl_Method10(IActiveSetupUnknown * iface, DWORD a, DWORD b, DWORD c)
{
    ICOM_THIS(activesetup_impl,iface);

FIXME("%p %ld %ld %ld\n", This, a, b, c );

return S_OK;
}

/*
 * the third parameter looks like a pointer to a structure
 *
 * struct {
 *     DWORD dwSize;     // size of this structure
 *     DWORD a1;
 *     DWORD a2;
 *     DWORD a3;
 *     DWORD x1;
 *     DWORD b1;
 *     DWORD b2;
 *     DWORD b3;
 *     DWORD b4;
 *     DWORD x2;
 * }
 */
static ULONG WINAPI 
activesetupimpl_Method11(IActiveSetupUnknown * iface, DWORD a, LPVOID b )
{
    ICOM_THIS(activesetup_impl,iface);

FIXME("%p %lx %p\n", This, a, b );

return S_OK;
}

static ULONG WINAPI 
activesetupimpl_Method12(IActiveSetupUnknown * iface)
{
    ICOM_THIS(activesetup_impl,iface);

FIXME("%p\n", This );

return E_FAIL;
}

static ULONG WINAPI 
activesetupimpl_Method13(IActiveSetupUnknown * iface)
{
    ICOM_THIS(activesetup_impl,iface);

FIXME("%p\n", This );

return E_FAIL;
}

static ULONG WINAPI 
activesetupimpl_Method14(IActiveSetupUnknown * iface)
{
    ICOM_THIS(activesetup_impl,iface);

FIXME("%p\n", This );

return E_FAIL;
}

static ULONG WINAPI 
activesetupimpl_Method15(IActiveSetupUnknown * iface, LPVOID a)
{
    ICOM_THIS(activesetup_impl,iface);

FIXME("%p %p\n", This, a );

return S_OK;
    //return E_FAIL;
}

static ULONG WINAPI 
activesetupimpl_SetInstallDrive(IActiveSetupUnknown * iface, CHAR drive)
{
    ICOM_THIS(activesetup_impl,iface);

FIXME("%p drive = %c\n", This, drive );

return E_FAIL;
}

static ULONG WINAPI 
activesetupimpl_SetInstallOption(IActiveSetupUnknown * iface, DWORD a)
{
    ICOM_THIS(activesetup_impl,iface);

FIXME("%p %08lx\n", This, a );

return E_NOTIMPL;
}

static ULONG WINAPI 
activesetupimpl_Method18(IActiveSetupUnknown * iface)
{
    ICOM_THIS(activesetup_impl,iface);

FIXME("%p\n", This );

return E_FAIL;
}

/* set the stream to log errors to */
static ULONG WINAPI 
activesetupimpl_Method19(IActiveSetupUnknown * iface, IStream *stm)
{
    ICOM_THIS(activesetup_impl,iface);

FIXME("%p %p\n", This, stm );

return E_FAIL;
}

static ULONG WINAPI 
activesetupimpl_Method20(IActiveSetupUnknown * iface)
{
    ICOM_THIS(activesetup_impl,iface);

FIXME("%p\n", This );

return E_FAIL;
}

static ULONG WINAPI 
activesetupimpl_Method21(IActiveSetupUnknown * iface)
{
    ICOM_THIS(activesetup_impl,iface);

FIXME("%p\n", This );

return E_FAIL;
}

static ULONG WINAPI 
activesetupimpl_Method22(IActiveSetupUnknown * iface)
{
    ICOM_THIS(activesetup_impl,iface);

FIXME("%p\n", This );

return E_FAIL;
}

static ULONG WINAPI 
activesetupimpl_SetLocalCif(IActiveSetupUnknown * iface, LPCSTR name)
{
    ICOM_THIS(activesetup_impl,iface);

FIXME("%p %s\n", This, debugstr_a( name ) );

return S_OK;
}

static ULONG WINAPI 
activesetupimpl_GetICifFile(IActiveSetupUnknown * iface, LPVOID *ppObj )
{
    ICOM_THIS(activesetup_impl,iface);

FIXME("%p %p\n", This, ppObj );

return create_ciffile( ppObj );
}

static ULONG WINAPI 
activesetupimpl_Method25(IActiveSetupUnknown * iface)
{
    ICOM_THIS(activesetup_impl,iface);

FIXME("%p\n", This );

return E_FAIL;
}

static ULONG WINAPI 
activesetupimpl_Method26(IActiveSetupUnknown * iface)
{
    ICOM_THIS(activesetup_impl,iface);

FIXME("%p\n", This );

return E_FAIL;
}

static HRESULT create_activesetup(IUnknown *pUnkOuter, LPVOID *ppObj)
{
    activesetup_impl *as;

as = HeapAlloc( GetProcessHeap(), 0, sizeof (activesetup_impl) );
    if (as == NULL) return E_OUTOFMEMORY;

as->ITF_IActiveSetupUnknown.lpVtbl = &activesetupimpl_vtbl;
    as->ref = 1;
    *ppObj = as;

TRACE("%p\n",as);

return S_OK;
}

@ stub DownloadFile
@ stub PurgeDownloadDirectory
@ stub CheckForVersionConflict
@ stub CheckTrust
@ stdcall CheckTrustEx(ptr ptr ptr ptr ptr)
@ stub DllCanUnloadNow
@ stdcall DllGetClassObject(ptr ptr ptr) INSENG_DllGetClassObject
@ stub DllInstall
@ stdcall DllRegisterServer()
@ stub DllUnregisterServer
@ stub GetICifFileFromFile
@ stub GetICifRWFileFromFile