win32/inseng/icif.c

/*
 * Copyright 2016 Michael Müller
 *
 * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

#define COBJMACROS

#include "config.h"

#include <stdarg.h>
#include <string.h>

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

#include "inseng_private.h"

#include "wine/list.h"
#include "wine/debug.h"

WINE_DEFAULT_DEBUG_CHANNEL(inseng);

#define DEFAULT_INSTALLER_DESC "Active Setup Installation"

struct cifgroup
{
    ICifGroup ICifGroup_iface;

    struct list entry;

    ICifFile *parent;

    char *id;
    char *description;
    DWORD priority;
};

struct ciffenum_components
{
    IEnumCifComponents IEnumCifComponents_iface;
    LONG ref;

    ICifFile *file;
    struct list *start;
    struct list *position;

    char *group_id;
};

struct ciffenum_groups
{
    IEnumCifGroups IEnumCifGroups_iface;
    LONG ref;

    ICifFile *file;
    struct list *start;
    struct list *position;
};

struct url_info
{
    struct list entry;
    INT index;
    char *url;
    DWORD flags;
};

struct dependency_info
{
    struct list entry;
    char *id;
    char *type;
};

struct cifcomponent
{
    ICifComponent ICifComponent_iface;

    struct list entry;

    ICifFile *parent;

    char *id;
    char *guid;
    char *description;
    char *details;
    char *group;


    DWORD version;
    DWORD build;
    char *patchid;

    char *locale;
    char *key_uninstall;

    DWORD size_win;
    DWORD size_app;
    DWORD size_download;
    DWORD size_extracted;

    char *key_success;
    char *key_progress;
    char *key_cancel;

    DWORD as_aware;
    DWORD reboot;
    DWORD admin;
    DWORD visibleui;

    DWORD priority;
    DWORD platform;

    struct list dependencies;
    struct list urls;

    /* mode */
    /* det version */
    /* one component */
    /* custom data */

    /* in memory state */
    DWORD queue_state;
    DWORD current_priority;
    DWORD size_actual_download;
    BOOL downloaded;
    BOOL installed;
};

struct ciffile
{
    ICifFile ICifFile_iface;
    LONG ref;

    struct list components;
    struct list groups;

    char *name;
};

static inline struct ciffile *impl_from_ICiffile(ICifFile *iface)
{
    return CONTAINING_RECORD(iface, struct ciffile, ICifFile_iface);
}

static inline struct cifcomponent *impl_from_ICifComponent(ICifComponent *iface)
{
    return CONTAINING_RECORD(iface, struct cifcomponent, ICifComponent_iface);
}

static inline struct cifgroup *impl_from_ICifGroup(ICifGroup *iface)
{
    return CONTAINING_RECORD(iface, struct cifgroup, ICifGroup_iface);
}

static inline struct ciffenum_components *impl_from_IEnumCifComponents(IEnumCifComponents *iface)
{
    return CONTAINING_RECORD(iface, struct ciffenum_components, IEnumCifComponents_iface);
}

static inline struct ciffenum_groups *impl_from_IEnumCifGroups(IEnumCifGroups *iface)
{
    return CONTAINING_RECORD(iface, struct ciffenum_groups, IEnumCifGroups_iface);
}

static HRESULT enum_components_create(ICifFile *file, struct list *start, char *group_id, IEnumCifComponents **iface);

static HRESULT copy_substring_null(char *dest, int max_len, char *src)
{
    if (!src)
        return E_FAIL;

    if (max_len <= 0)
        return S_OK;

    if (!dest)
        return E_FAIL;

    while (*src && max_len-- > 1)
        *dest++ = *src++;
    *dest = 0;

    return S_OK;
}

static void url_entry_free(struct url_info *url)
{
    heap_free(url->url);
    heap_free(url);
}

static void dependency_entry_free(struct dependency_info *dependency)
{
    heap_free(dependency->id);
    heap_free(dependency);
}

static void component_free(struct cifcomponent *comp)
{
    struct dependency_info *dependency, *dependency_next;
    struct url_info *url, *url_next;

    heap_free(comp->id);
    heap_free(comp->guid);
    heap_free(comp->description);
    heap_free(comp->details);
    heap_free(comp->group);

    heap_free(comp->patchid);

    heap_free(comp->locale);
    heap_free(comp->key_uninstall);

    heap_free(comp->key_success);
    heap_free(comp->key_progress);
    heap_free(comp->key_cancel);

    LIST_FOR_EACH_ENTRY_SAFE(dependency, dependency_next, &comp->dependencies, struct dependency_info, entry)
    {
        list_remove(&dependency->entry);
        dependency_entry_free(dependency);
    }

    LIST_FOR_EACH_ENTRY_SAFE(url, url_next, &comp->urls, struct url_info, entry)
    {
        list_remove(&url->entry);
        url_entry_free(url);
    }

    heap_free(comp);
}

static void group_free(struct cifgroup *group)
{
    heap_free(group->id);
    heap_free(group->description);
    heap_free(group);
}

static HRESULT WINAPI group_GetID(ICifGroup *iface, char *id, DWORD size)
{
    struct cifgroup *This = impl_from_ICifGroup(iface);

    TRACE("(%p)->(%p, %u)\n", This, id, size);

    return copy_substring_null(id, size, This->id);
}

static HRESULT WINAPI group_GetDescription(ICifGroup *iface, char *desc, DWORD size)
{
    struct cifgroup *This = impl_from_ICifGroup(iface);

    TRACE("(%p)->(%p, %u)\n", This, desc, size);

    return copy_substring_null(desc, size, This->description);
}

static DWORD WINAPI group_GetPriority(ICifGroup *iface)
{
    struct cifgroup *This = impl_from_ICifGroup(iface);

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

    return This->priority;
}

static HRESULT WINAPI group_EnumComponents(ICifGroup *iface, IEnumCifComponents **enum_components, DWORD filter, LPVOID pv)
{
    struct cifgroup *This = impl_from_ICifGroup(iface);
    struct ciffile *file;

    TRACE("(%p)->(%p, %u, %p)\n", This, enum_components, filter, pv);

    if (filter)
        FIXME("filter (%x) not supported\n", filter);
    if (pv)
        FIXME("how to handle pv (%p)?\n", pv);

    file = impl_from_ICiffile(This->parent);
    return enum_components_create(This->parent, &file->components, This->id, enum_components);
}

static DWORD WINAPI group_GetCurrentPriority(ICifGroup *iface)
{
    struct cifgroup *This = impl_from_ICifGroup(iface);

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

    return 0;
}

static const ICifGroupVtbl cifgroupVtbl =
{
    group_GetID,
    group_GetDescription,
    group_GetPriority,
    group_EnumComponents,
    group_GetCurrentPriority,
};

void component_set_actual_download_size(ICifComponent *iface, DWORD size)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

    This->size_actual_download = size;
}

void component_set_downloaded(ICifComponent *iface, BOOL value)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

    This->downloaded = value;
}

void component_set_installed(ICifComponent *iface, BOOL value)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

    This->installed = value;
}

char *component_get_id(ICifComponent *iface)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

    return This->id;
}

static HRESULT WINAPI component_GetID(ICifComponent *iface, char *id, DWORD size)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

    TRACE("(%p)->(%p, %u)\n", This, id, size);

    return copy_substring_null(id, size, This->id);
}

static HRESULT WINAPI component_GetGUID(ICifComponent *iface, char *guid, DWORD size)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

    TRACE("(%p)->(%p, %u)\n", This, guid, size);

    return copy_substring_null(guid, size, This->guid);
}

static HRESULT WINAPI component_GetDescription(ICifComponent *iface, char *desc, DWORD size)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

    TRACE("(%p)->(%p, %u)\n", This, desc, size);

    return copy_substring_null(desc, size, This->description);
}

static HRESULT WINAPI component_GetDetails(ICifComponent *iface, char *details, DWORD size)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

    TRACE("(%p)->(%p, %u)\n", This, details, size);

    return copy_substring_null(details, size, This->details);
}

static HRESULT WINAPI component_GetUrl(ICifComponent *iface, UINT index, char *url, DWORD size, DWORD *flags)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);
    struct url_info *entry;

    TRACE("(%p)->(%u, %p, %u, %p)\n", This, index, url, size, flags);

    /* FIXME: check how functions behaves for url == NULL */

    if (!flags)
        return E_FAIL;

    LIST_FOR_EACH_ENTRY(entry, &This->urls, struct url_info, entry)
    {
        if (entry->index != index)
            continue;

        *flags = entry->flags;
        return copy_substring_null(url, size, entry->url);
    }

    return E_FAIL;
}

static HRESULT WINAPI component_GetFileExtractList(ICifComponent *iface, UINT index, char *list, DWORD size)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

    FIXME("(%p)->(%u, %p, %u): stub\n", This, index, list, size);

    return E_NOTIMPL;
}

static HRESULT WINAPI component_GetUrlCheckRange(ICifComponent *iface, UINT index, DWORD *min, DWORD *max)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

    FIXME("(%p)->(%u, %p, %p): stub\n", This, index, min, max);

    return E_NOTIMPL;
}

static HRESULT WINAPI component_GetCommand(ICifComponent *iface, UINT index, char *cmd, DWORD cmd_size, char *switches, DWORD switch_size, DWORD *type)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

    FIXME("(%p)->(%u, %p, %u, %p, %u, %p): stub\n", This, index, cmd, cmd_size, switches, switch_size, type);

    return E_NOTIMPL;
}

static HRESULT WINAPI component_GetVersion(ICifComponent *iface, DWORD *version, DWORD *build)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

    TRACE("(%p)->(%p, %p)\n", This, version, build);

    if (!version || !build)
        return E_FAIL;

    *version = This->version;
    *build = This->build;

    return S_OK;
}

static HRESULT WINAPI component_GetLocale(ICifComponent *iface, char *locale, DWORD size)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

    TRACE("(%p)->(%p, %u)\n", This, locale, size);

    return copy_substring_null(locale, size, This->locale);
}

static HRESULT WINAPI component_GetUninstallKey(ICifComponent *iface, char *key, DWORD size)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

    TRACE("(%p)->(%p, %u)\n", This, key, size);

    return copy_substring_null(key, size, This->key_uninstall);
}

static HRESULT WINAPI component_GetInstalledSize(ICifComponent *iface, DWORD *win, DWORD *app)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

    TRACE("(%p)->(%p, %p)\n", This, win, app);

    if (!win || !app)
        return E_FAIL;

    *win = This->size_win;
    *app = This->size_app;

    return S_OK;
}

static DWORD WINAPI component_GetDownloadSize(ICifComponent *iface)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

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

    return This->size_download;
}

static DWORD WINAPI component_GetExtractSize(ICifComponent *iface)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

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

    return This->size_extracted;
}

static HRESULT WINAPI component_GetSuccessKey(ICifComponent *iface, char *key, DWORD size)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

    TRACE("(%p)->(%p, %u)\n", This, key, size);

    return copy_substring_null(key, size, This->key_success);
}

static HRESULT WINAPI component_GetProgressKeys(ICifComponent *iface, char *progress, DWORD progress_size,
                                                char *cancel, DWORD cancel_size)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);
    HRESULT hr;

    TRACE("(%p)->(%p, %u, %p, %u): semi-stub\n", This, progress, progress_size, cancel, cancel_size);

    hr = copy_substring_null(progress, progress_size, This->key_progress);
    if (hr != S_OK) return hr;

    if (cancel_size > 0 && cancel)
        *cancel = 0;

    return S_OK;
}

static HRESULT WINAPI component_IsActiveSetupAware(ICifComponent *iface)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

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

    return This->as_aware ? S_OK : S_FALSE;
}

static HRESULT WINAPI component_IsRebootRequired(ICifComponent *iface)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

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

    return This->reboot ? S_OK : S_FALSE;
}

static HRESULT WINAPI component_RequiresAdminRights(ICifComponent *iface)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

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

    return This->admin ? S_OK : S_FALSE;
}

static DWORD WINAPI component_GetPriority(ICifComponent *iface)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

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

    return This->priority;
}

static HRESULT WINAPI component_GetDependency(ICifComponent *iface, UINT index, char *id, DWORD id_size, char *type, DWORD *ver, DWORD *build)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);
    struct dependency_info *entry;
    ICifComponent *dependency;
    int pos = 0;

    TRACE("(%p)->(%u, %p, %u, %p, %p, %p)\n", This, index, id, id_size, type, ver, build);

    if (!id || !ver || !build)
        return E_FAIL;

    LIST_FOR_EACH_ENTRY(entry, &This->dependencies, struct dependency_info, entry)
    {
        if (pos++ < index)
            continue;

        if (ICifFile_FindComponent(This->parent, entry->id, &dependency) == S_OK)
        {
            ICifComponent_GetVersion(dependency, ver, build);
        }
        else
        {
            *ver = -1;
            *build = -1;
        }

        if (entry->type)
            *type = *entry->type;
        else
            *type = 'I';

        return copy_substring_null(id, id_size, entry->id);
    }

    return E_FAIL;
}

static DWORD WINAPI component_GetPlatform(ICifComponent *iface)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

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

    return This->platform;
}

static HRESULT WINAPI component_GetMode(ICifComponent *iface, UINT index, char *mode, DWORD size)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

    FIXME("(%p)->(%u, %p, %u): stub\n", This, index, mode, size);

    return E_NOTIMPL;
}

static HRESULT WINAPI component_GetGroup(ICifComponent *iface, char *id, DWORD size)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

    TRACE("(%p)->(%p, %u)\n", This, id, size);

    return copy_substring_null(id, size, This->group);
}

static HRESULT WINAPI component_IsUIVisible(ICifComponent *iface)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

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

    return This->visibleui ? S_OK : S_FALSE;
}

static HRESULT WINAPI component_GetPatchID(ICifComponent *iface, char *id, DWORD size)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

    TRACE("(%p)->(%p, %u)\n", This, id, size);

    return copy_substring_null(id, size, This->patchid);
}

static HRESULT WINAPI component_GetDetVersion(ICifComponent *iface, char *dll, DWORD dll_size, char *entry, DWORD entry_size)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

    FIXME("(%p)->(%p, %u, %p, %u): stub\n", This, dll, dll_size, entry, entry_size);

    return E_NOTIMPL;
}

static HRESULT WINAPI component_GetTreatAsOneComponents(ICifComponent *iface, UINT index, char *id, DWORD size)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

    FIXME("(%p)->(%u, %p, %u): stub\n", This, index, id, size);

    return E_NOTIMPL;
}

static HRESULT WINAPI component_GetCustomData(ICifComponent *iface, char *key, char *data, DWORD size)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

    FIXME("(%p)->(%s, %p, %u): stub\n", This, debugstr_a(key), data, size);

    return E_NOTIMPL;
}

static DWORD WINAPI component_IsComponentInstalled(ICifComponent *iface)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

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

    return This->installed;
}

static HRESULT WINAPI component_IsComponentDownloaded(ICifComponent *iface)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

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

    return This->downloaded ? S_OK : S_FALSE;
}

static DWORD WINAPI component_IsThisVersionInstalled(ICifComponent *iface, DWORD version, DWORD build, DWORD *ret_version, DWORD *ret_build)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

    FIXME("(%p)->(%u, %u, %p, %p): stub\n", This, version, build, ret_version, ret_build);

    return 0;
}

static DWORD WINAPI component_GetInstallQueueState(ICifComponent *iface)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

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

    return This->queue_state;
}

static HRESULT WINAPI component_SetInstallQueueState(ICifComponent *iface, DWORD state)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

    TRACE("(%p)->(%u)\n", This, state);

    This->queue_state = state;
    return S_OK;
}

static DWORD WINAPI component_GetActualDownloadSize(ICifComponent *iface)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

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

    return This->size_download;
}

static DWORD WINAPI component_GetCurrentPriority(ICifComponent *iface)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

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

    return This->current_priority;
}


static HRESULT WINAPI component_SetCurrentPriority(ICifComponent *iface, DWORD priority)
{
    struct cifcomponent *This = impl_from_ICifComponent(iface);

    TRACE("(%p)->(%u)\n", This, priority);

    This->current_priority = priority;
    return S_OK;
}

static const ICifComponentVtbl cifcomponentVtbl =
{
    component_GetID,
    component_GetGUID,
    component_GetDescription,
    component_GetDetails,
    component_GetUrl,
    component_GetFileExtractList,
    component_GetUrlCheckRange,
    component_GetCommand,
    component_GetVersion,
    component_GetLocale,
    component_GetUninstallKey,
    component_GetInstalledSize,
    component_GetDownloadSize,
    component_GetExtractSize,
    component_GetSuccessKey,
    component_GetProgressKeys,
    component_IsActiveSetupAware,
    component_IsRebootRequired,
    component_RequiresAdminRights,
    component_GetPriority,
    component_GetDependency,
    component_GetPlatform,
    component_GetMode,
    component_GetGroup,
    component_IsUIVisible,
    component_GetPatchID,
    component_GetDetVersion,
    component_GetTreatAsOneComponents,
    component_GetCustomData,
    component_IsComponentInstalled,
    component_IsComponentDownloaded,
    component_IsThisVersionInstalled,
    component_GetInstallQueueState,
    component_SetInstallQueueState,
    component_GetActualDownloadSize,
    component_GetCurrentPriority,
    component_SetCurrentPriority,
};

static HRESULT WINAPI enum_components_QueryInterface(IEnumCifComponents *iface, REFIID riid, void **ppv)
{
    struct ciffenum_components *This = impl_from_IEnumCifComponents(iface);

    if (IsEqualGUID(&IID_IUnknown, riid))
    {
        TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
        *ppv = &This->IEnumCifComponents_iface;
    }
    /*
    else if (IsEqualGUID(&IID_IEnumCifComponents, riid))
    {
        TRACE("(%p)->(IID_ICifFile %p)\n", This, ppv);
        *ppv = &This->IEnumCifComponents_iface;
    }
    */
    else
    {
        FIXME("(%p)->(%s %p) not found\n", This, debugstr_guid(riid), ppv);
        *ppv = NULL;
        return E_NOINTERFACE;
    }

    IUnknown_AddRef((IUnknown *)*ppv);
    return S_OK;
}

static ULONG WINAPI enum_components_AddRef(IEnumCifComponents *iface)
{
    struct ciffenum_components *This = impl_from_IEnumCifComponents(iface);
    LONG ref = InterlockedIncrement(&This->ref);

    TRACE("(%p) ref=%d\n", This, ref);

    return ref;
}

static ULONG WINAPI enum_components_Release(IEnumCifComponents *iface)
{
    struct ciffenum_components *This = impl_from_IEnumCifComponents(iface);
    LONG ref = InterlockedDecrement(&This->ref);

    TRACE("(%p) ref=%d\n", This, ref);

    if(!ref)
    {
        ICifFile_Release(This->file);
        heap_free(This);
    }

    return ref;
}

static HRESULT WINAPI enum_components_Next(IEnumCifComponents *iface, ICifComponent **component)
{
    struct ciffenum_components *This = impl_from_IEnumCifComponents(iface);
    struct cifcomponent *comp;

    TRACE("(%p)->(%p)\n", This, component);

    if (!component)
        return E_FAIL;

    if (!This->position)
    {
        *component = NULL;
        return E_FAIL;
    }

    do
    {
        This->position = list_next(This->start, This->position);
        if (!This->position)
        {
            *component = NULL;
            return E_FAIL;
        }

        comp = CONTAINING_RECORD(This->position, struct cifcomponent, entry);
    } while (This->group_id && (!comp->group || strcmp(This->group_id, comp->group)));

    *component = &comp->ICifComponent_iface;
    return S_OK;
}

static HRESULT WINAPI enum_components_Reset(IEnumCifComponents *iface)
{
    struct ciffenum_components *This = impl_from_IEnumCifComponents(iface);

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

    This->position = This->start;
    return S_OK;
}

static const IEnumCifComponentsVtbl enum_componentsVtbl =
{
    enum_components_QueryInterface,
    enum_components_AddRef,
    enum_components_Release,
    enum_components_Next,
    enum_components_Reset,
};

static HRESULT enum_components_create(ICifFile *file, struct list *start, char *group_id, IEnumCifComponents **iface)
{
    struct ciffenum_components *enumerator;

    enumerator = heap_alloc_zero(sizeof(*enumerator));
    if (!enumerator) return E_OUTOFMEMORY;

    enumerator->IEnumCifComponents_iface.lpVtbl = &enum_componentsVtbl;
    enumerator->ref      = 1;
    enumerator->file     = file;
    enumerator->start    = start;
    enumerator->position = start;
    enumerator->group_id = group_id;

    ICifFile_AddRef(file);

    *iface = &enumerator->IEnumCifComponents_iface;
    return S_OK;
}

static HRESULT WINAPI enum_groups_QueryInterface(IEnumCifGroups *iface, REFIID riid, void **ppv)
{
    struct ciffenum_groups *This = impl_from_IEnumCifGroups(iface);

    if (IsEqualGUID(&IID_IUnknown, riid))
    {
        TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
        *ppv = &This->IEnumCifGroups_iface;
    }
    /*
    else if (IsEqualGUID(&IID_IEnumCifGroups, riid))
    {
        TRACE("(%p)->(IID_ICifFile %p)\n", This, ppv);
        *ppv = &This->IEnumCifGroups_iface;
    }
    */
    else
    {
        FIXME("(%p)->(%s %p) not found\n", This, debugstr_guid(riid), ppv);
        *ppv = NULL;
        return E_NOINTERFACE;
    }

    IUnknown_AddRef((IUnknown *)*ppv);
    return S_OK;
}

static ULONG WINAPI enum_groups_AddRef(IEnumCifGroups *iface)
{
    struct ciffenum_groups *This = impl_from_IEnumCifGroups(iface);
    LONG ref = InterlockedIncrement(&This->ref);

    TRACE("(%p) ref=%d\n", This, ref);

    return ref;
}

static ULONG WINAPI enum_groups_Release(IEnumCifGroups *iface)
{
    struct ciffenum_groups *This = impl_from_IEnumCifGroups(iface);
    LONG ref = InterlockedDecrement(&This->ref);

    TRACE("(%p) ref=%d\n", This, ref);

    if(!ref)
    {
        ICifFile_Release(This->file);
        heap_free(This);
    }

    return ref;
}

static HRESULT WINAPI enum_groups_Next(IEnumCifGroups *iface, ICifGroup **group)
{
    struct ciffenum_groups *This = impl_from_IEnumCifGroups(iface);
    struct cifgroup *gp;

    TRACE("(%p)->(%p)\n", This, group);

    if (!This->position || !group)
        return E_FAIL;

    This->position = list_next(This->start, This->position);

    if (!This->position)
        return E_FAIL;

    gp = CONTAINING_RECORD(This->position, struct cifgroup, entry);
    *group = &gp->ICifGroup_iface;
    return S_OK;
}

static HRESULT WINAPI enum_groups_Reset(IEnumCifGroups *iface)
{
    struct ciffenum_groups *This = impl_from_IEnumCifGroups(iface);

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

    This->position = This->start;
    return S_OK;
}

static const IEnumCifGroupsVtbl enum_groupsVtbl =
{
    enum_groups_QueryInterface,
    enum_groups_AddRef,
    enum_groups_Release,
    enum_groups_Next,
    enum_groups_Reset,
};

static HRESULT enum_groups_create(ICifFile *file, struct list *start, IEnumCifGroups **iface)
{
    struct ciffenum_groups *enumerator;

    enumerator = heap_alloc_zero(sizeof(*enumerator));
    if (!enumerator) return E_OUTOFMEMORY;

    enumerator->IEnumCifGroups_iface.lpVtbl = &enum_groupsVtbl;
    enumerator->ref      = 1;
    enumerator->file     = file;
    enumerator->start    = start;
    enumerator->position = start;

    ICifFile_AddRef(file);

    *iface = &enumerator->IEnumCifGroups_iface;
    return S_OK;
}

static HRESULT WINAPI ciffile_QueryInterface(ICifFile *iface, REFIID riid, void **ppv)
{
    struct ciffile *This = impl_from_ICiffile(iface);

    if (IsEqualGUID(&IID_IUnknown, riid))
    {
        TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
        *ppv = &This->ICifFile_iface;
    }
    else if (IsEqualGUID(&IID_ICifFile, riid))
    {
        TRACE("(%p)->(IID_ICifFile %p)\n", This, ppv);
        *ppv = &This->ICifFile_iface;
    }
    else
    {
        FIXME("(%p)->(%s %p) not found\n", This, debugstr_guid(riid), ppv);
        *ppv = NULL;
        return E_NOINTERFACE;
    }

    IUnknown_AddRef((IUnknown *)*ppv);
    return S_OK;
}

static ULONG WINAPI ciffile_AddRef(ICifFile *iface)
{
    struct ciffile *This = impl_from_ICiffile(iface);
    LONG ref = InterlockedIncrement(&This->ref);

    TRACE("(%p) ref=%d\n", This, ref);

    return ref;
}

static ULONG WINAPI ciffile_Release(ICifFile *iface)
{
    struct ciffile *This = impl_from_ICiffile(iface);
    LONG ref = InterlockedDecrement(&This->ref);

    TRACE("(%p) ref=%d\n", This, ref);

    if(!ref)
    {
        struct cifcomponent *comp, *comp_next;
        struct cifgroup *group, *group_next;

        heap_free(This->name);

        LIST_FOR_EACH_ENTRY_SAFE(comp, comp_next, &This->components, struct cifcomponent, entry)
        {
            list_remove(&comp->entry);
            component_free(comp);
        }

        LIST_FOR_EACH_ENTRY_SAFE(group, group_next, &This->groups, struct cifgroup, entry)
        {
            list_remove(&group->entry);
            group_free(group);
        }

        heap_free(This);
    }

    return ref;
}

static HRESULT WINAPI ciffile_EnumComponents(ICifFile *iface, IEnumCifComponents **enum_components, DWORD filter, void *pv)
{
    struct ciffile *This = impl_from_ICiffile(iface);

    TRACE("(%p)->(%p, %u, %p)\n", This, enum_components, filter, pv);

    if (filter)
        FIXME("filter (%x) not supported\n", filter);
    if (pv)
        FIXME("how to handle pv (%p)?\n", pv);

    return enum_components_create(iface, &This->components, NULL, enum_components);
}

static HRESULT WINAPI ciffile_FindComponent(ICifFile *iface, const char *id, ICifComponent **component)
{
    struct ciffile *This = impl_from_ICiffile(iface);
    struct cifcomponent *comp;

    TRACE("(%p)->(%s, %p)\n", This, debugstr_a(id), component);

    LIST_FOR_EACH_ENTRY(comp, &This->components, struct cifcomponent, entry)
    {
        if (strcmp(comp->id, id) != 0)
            continue;

        *component = &comp->ICifComponent_iface;
        return S_OK;
    }

    return E_FAIL;
}

static HRESULT WINAPI ciffile_EnumGroups(ICifFile *iface, IEnumCifGroups **enum_groups, DWORD filter, void *pv)
{
    struct ciffile *This = impl_from_ICiffile(iface);

    TRACE("(%p)->(%p, %u, %p)\n", This, enum_groups, filter, pv);

    if (filter)
        FIXME("filter (%x) not supported\n", filter);
    if (pv)
        FIXME("how to handle pv (%p)?\n", pv);

    return enum_groups_create(iface, &This->groups, enum_groups);
}

static HRESULT WINAPI ciffile_FindGroup(ICifFile *iface, const char *id, ICifGroup **group)
{
    struct ciffile *This = impl_from_ICiffile(iface);
    struct cifgroup *gp;

    TRACE("(%p)->(%s, %p)\n", This, debugstr_a(id), group);

    LIST_FOR_EACH_ENTRY(gp, &This->groups, struct cifgroup, entry)
    {
        if (strcmp(gp->id, id) != 0)
            continue;

        *group = &gp->ICifGroup_iface;
        return S_OK;
    }

    return E_FAIL;
}

static HRESULT WINAPI ciffile_EnumModes(ICifFile *iface, IEnumCifModes **cuf_modes, DWORD filter, void *pv)
{
    struct ciffile *This = impl_from_ICiffile(iface);

    FIXME("(%p)->(%p, %u, %p): stub\n", This, cuf_modes, filter, pv);

    return E_NOTIMPL;
}

static HRESULT WINAPI ciffile_FindMode(ICifFile *iface, const char *id, ICifMode **mode)
{
    struct ciffile *This = impl_from_ICiffile(iface);

    FIXME("(%p)->(%s, %p): stub\n", This, debugstr_a(id), mode);

    return E_NOTIMPL;
}

static HRESULT WINAPI ciffile_GetDescription(ICifFile *iface, char *desc, DWORD size)
{
    struct ciffile *This = impl_from_ICiffile(iface);

    TRACE("(%p)->(%p, %u)\n", This, desc, size);

    return copy_substring_null(desc, size, This->name);
}

static HRESULT WINAPI ciffile_GetDetDlls(ICifFile *iface, char *dlls, DWORD size)
{
    struct ciffile *This = impl_from_ICiffile(iface);

    FIXME("(%p)->(%p, %u): stub\n", This, dlls, size);

    return E_NOTIMPL;
}

static const ICifFileVtbl ciffileVtbl =
{
    ciffile_QueryInterface,
    ciffile_AddRef,
    ciffile_Release,
    ciffile_EnumComponents,
    ciffile_FindComponent,
    ciffile_EnumGroups,
    ciffile_FindGroup,
    ciffile_EnumModes,
    ciffile_FindMode,
    ciffile_GetDescription,
    ciffile_GetDetDlls,
};

static BOOL copy_string(char **dest, const char *source)
{
    if (!source)
    {
        *dest = NULL;
        return TRUE;
    }

    *dest = strdupA(source);
    if (!dest) return FALSE;
    return TRUE;
}

static BOOL section_get_str(struct inf_section *inf_sec, const char *key, char **value, const char *def)
{
    struct inf_value *inf_val;

    inf_val = inf_get_value(inf_sec, key);
    if (!inf_val) return copy_string(value, def);

    *value = inf_value_get_value(inf_val);
    if (!*value) return FALSE;

    return TRUE;
}

static char *next_part(char **str, BOOL strip_quotes)
{
    char *start = *str;
    char *next = *str;

    while (*next && *next != ',')
        next++;

    if (!*next)
    {
        *str = trim(start, NULL, strip_quotes);
        return NULL;
    }

    *next = 0;
    *str = trim(start, NULL, strip_quotes);
    return ++next;
}

static BOOL value_get_str_field(struct inf_value *inf_val, int field, char **value, const char *def)
{
    char *line, *str, *next;
    int i = 0;

    line = inf_value_get_value(inf_val);
    if (!line) return FALSE;

    str = line;
    do
    {
        i++;
        next = next_part(&str, TRUE);

        if (field == i)
        {
            BOOL ret = copy_string(value, str);
            heap_free(line);
            return ret;
        }

        str = next;
    } while (str);

    return copy_string(value, def);
}

/*
static BOOL section_get_str_field(struct inf_section *inf_sec, const char *key, int field, char **value, const char *def)
{
    struct inf_value *inf_val;

    inf_val = inf_get_value(inf_sec, key);
    if (!inf_val) return copy_string(value, def);

    return value_get_str_field(inf_val, field, value, def);
}
*/

static BOOL section_get_dword(struct inf_section *inf_sec, const char *key, DWORD *value, DWORD def)
{
    struct inf_value *inf_val;
    char *str;

    inf_val = inf_get_value(inf_sec, key);
    if (!inf_val)
    {
        *value = def;
        return TRUE;
    }

    str = inf_value_get_value(inf_val);
    if (!str) return FALSE;

    *value = atoi(str);
    heap_free(str);

    return TRUE;
}

static BOOL value_get_dword_field(struct inf_value *inf_val, int field, DWORD *value, DWORD def)
{
    char *value_str;
    BOOL ret;

    ret = value_get_str_field(inf_val, field, &value_str, NULL);
    if (!ret) return FALSE;
    if (!value_str)
    {
        *value = def;
        return TRUE;
    }

    *value = atoi(value_str);
    heap_free(value_str);

    return TRUE;
}

static BOOL section_get_dword_field(struct inf_section *inf_sec, const char *key, int field, DWORD *value, DWORD def)
{
    struct inf_value *inf_val;

    inf_val = inf_get_value(inf_sec, key);
    if (!inf_val)
    {
        *value = def;
        return TRUE;
    }

    return value_get_dword_field(inf_val, field, value, def);
}

static HRESULT process_version(struct ciffile *file, struct inf_section *section)
{
    if (!section_get_str(section, "DisplayName", &file->name, DEFAULT_INSTALLER_DESC))
        return E_OUTOFMEMORY;

    return S_OK;
}

static BOOL read_version_entry(struct inf_section *section, DWORD *ret_ver, DWORD *ret_build)
{
    DWORD version = 0;
    DWORD build = 0;
    char *line, *str, *next;

    if (!section_get_str(section, "Version", &line, NULL))
        return FALSE;
    if (!line) goto done;

    str = line;

    next = next_part(&str, TRUE);
    version |= atoi(str) << 16;
    if (!next) goto done;
    str = next;

    next = next_part(&str, TRUE);
    version |= atoi(str) & 0xffff;
    if (!next) goto done;
    str = next;

    next = next_part(&str, TRUE);
    build |= atoi(str) << 16;
    if (!next) goto done;
    str = next;

    next_part(&str, TRUE);
    build |= atoi(str) & 0xffff;

done:
    heap_free(line);
    *ret_ver = version;
    *ret_build = build;
    return TRUE;
}

static BOOL read_platform_entry(struct inf_section *section, DWORD *ret_platform)
{
    DWORD platform = PLATFORM_ALL;
    char *line, *str, *next;

    if (!section_get_str(section, "Platform", &line, NULL))
        return FALSE;
    if (!line) goto done;

    platform = 0;
    str = line;
    do
    {
        next = next_part(&str, TRUE);

        if (strcasecmp(str, "Win95") == 0)
            platform |= PLATFORM_WIN98;
        else if (strcasecmp(str, "Win98") == 0)
            platform |= PLATFORM_WIN98;
        else if (strcasecmp(str, "NT4") == 0)
            platform |= PLATFORM_NT4;
        else if (strcasecmp(str, "NT5") == 0)
            platform |= PLATFORM_NT5;
        else if (strcasecmp(str, "NT4Alpha") == 0)
            platform |= PLATFORM_NT4;
        else if (strcasecmp(str, "NT5Alpha") == 0)
            platform |= PLATFORM_NT5;
        else if (strcasecmp(str, "Millen") == 0)
            platform |= PLATFORM_MILLEN;
        else
            FIXME("Unknown platform: %s\n", debugstr_a(str));

        str = next;
    } while (str);

done:
    heap_free(line);
    *ret_platform = platform;
    return TRUE;
}

static BOOL read_dependencies(struct cifcomponent *component, struct inf_section *section)
{
    struct dependency_info *dependency;
    char *line, *str, *next;
    BOOL ret = TRUE;

    if (!section_get_str(section, "Dependencies", &line, NULL))
        return E_OUTOFMEMORY;
    if (!line) goto done;

    ret = FALSE;
    str = line;
    do
    {
        next = next_part(&str, TRUE);

        dependency = heap_alloc_zero(sizeof(*dependency));
        if (!dependency) goto done;

        dependency->id = strdupA(str);
        if (!dependency->id)
        {
            heap_free(dependency);
            goto done;
        }

        dependency->type = strstr(dependency->id, ":");
        if (dependency->type) *dependency->type++ = 0;

        list_add_tail(&component->dependencies, &dependency->entry);

        str = next;
    } while (str);

    ret = TRUE;

done:
    heap_free(line);
    return ret;
}

static BOOL read_urls(struct cifcomponent *component, struct inf_section *section)
{
    struct inf_value *inf_value = NULL;
    struct url_info *url_entry;
    char *str, *next;
    int index;

    while (inf_section_next_value(section, &inf_value))
    {
        str = inf_value_get_key(inf_value);
        if (!str) return E_OUTOFMEMORY;

        if (strncasecmp(str, "URL", 3))
            goto next;

        if (!str[3])
            goto next;

        index = strtol(str+3, &next, 10);
        if (next == str+3 || *next != 0 || index < 1)
            goto next;
        index--;

        url_entry = heap_alloc_zero(sizeof(*url_entry));
        if (!url_entry) goto error;

        url_entry->index = index;

        if (!value_get_str_field(inf_value, 1, &url_entry->url, NULL))
            goto error;
        if (!url_entry->url || !*url_entry->url)
        {
            url_entry_free(url_entry);
            goto next;
        }

        if (!value_get_dword_field(inf_value, 2, &url_entry->flags, 0))
            goto error;

        list_add_tail(&component->urls, &url_entry->entry);

    next:
        heap_free(str);
    }

    return TRUE;

error:
    heap_free(str);
    url_entry_free(url_entry);
    return FALSE;
};

void add_component_by_priority(struct ciffile *file, struct cifcomponent *component)
{
    struct cifcomponent *entry;

    LIST_FOR_EACH_ENTRY(entry, &file->components, struct cifcomponent, entry)
    {
        if (entry->priority > component->priority)
            continue;

        list_add_before(&entry->entry, &component->entry);
        return;
    }

    list_add_tail(&file->components, &component->entry);
}

static HRESULT process_component(struct ciffile *file, struct inf_section *section, const char *section_name)
{
    struct cifcomponent *component;
    HRESULT hr = E_OUTOFMEMORY;

    component = heap_alloc_zero(sizeof(*component));
    if (!component) return E_OUTOFMEMORY;

    component->ICifComponent_iface.lpVtbl = &cifcomponentVtbl;
    component->parent = &file->ICifFile_iface;

    list_init(&component->urls);
    list_init(&component->dependencies);

    component->queue_state = ActionNone;

    component->id = strdupA(section_name);
    if (!component->id) goto error;

    if (!section_get_str(section, "DisplayName", &component->description, NULL))
        goto error;
    if (!section_get_str(section, "GUID", &component->guid, NULL))
        goto error;
    if (!section_get_str(section, "Details", &component->details, NULL))
        goto error;
    if (!section_get_str(section, "Group", &component->group, NULL))
        goto error;
    if (!section_get_str(section, "Locale", &component->locale, "en"))
        goto error;
    if (!section_get_str(section, "PatchID", &component->patchid, NULL))
        goto error;

    if (!section_get_dword_field(section, "Size", 1, &component->size_download, 0))
        goto error;
    if (!section_get_dword_field(section, "Size", 2, &component->size_extracted, 0))
        goto error;
    if (!section_get_dword_field(section, "InstalledSize", 1, &component->size_app, 0))
        goto error;
    if (!section_get_dword_field(section, "InstalledSize", 2, &component->size_win, 0))
        goto error;

    if (!section_get_str(section, "SuccessKey", &component->key_success, NULL))
        goto error;
    if (!section_get_str(section, "CancelKey", &component->key_cancel, NULL))
        goto error;
    if (!section_get_str(section, "ProgressKey", &component->key_progress, NULL))
        goto error;
    if (!section_get_str(section, "UninstallKey", &component->key_uninstall, NULL))
        goto error;
    if (!section_get_dword(section, "Reboot", &component->reboot, 0))
        goto error;
    if (!section_get_dword(section, "AdminCheck", &component->admin, 0))
        goto error;
    if (!section_get_dword(section, "UIVisible", &component->visibleui, 1))
        goto error;
    if (!section_get_dword(section, "ActiveSetupAware", &component->as_aware, 0))
        goto error;
    if (!section_get_dword(section, "Priority", &component->priority, 0))
        goto error;

    if (!read_version_entry(section, &component->version, &component->build))
        goto error;
    if (!read_platform_entry(section, &component->platform))
        goto error;
    if (!read_urls(component, section))
        goto error;
    if (!read_dependencies(component, section))
        goto error;

    component->current_priority = component->priority;

    add_component_by_priority(file, component);
    return S_OK;

error:
    component_free(component);
    return hr;
}

static HRESULT process_group(struct ciffile *file, struct inf_section *section, const char *section_name)
{
    struct cifgroup *group;
    HRESULT hr = E_OUTOFMEMORY;

    group = heap_alloc_zero(sizeof(*group));
    if (!group) return E_OUTOFMEMORY;

    group->ICifGroup_iface.lpVtbl = &cifgroupVtbl;
    group->parent = &file->ICifFile_iface;

    group->id = strdupA(section_name);
    if (!group->id) goto error;

    if (!section_get_str(section, "DisplayName", &group->description, NULL))
        goto error;
    if (!section_get_dword(section, "Priority", &group->priority, 0))
        goto error;

    list_add_head(&file->groups, &group->entry);
    return S_OK;

error:
    group_free(group);
    return hr;
}

static HRESULT process_section(struct ciffile *file, struct inf_section *section, const char *section_name)
{
    HRESULT hr;
    char *type;

    if (!section_get_str(section, "SectionType", &type, "Component"))
        return E_OUTOFMEMORY;

    if (!strcasecmp(type, "Component"))
        hr = process_component(file, section, section_name);
    else if (strcasecmp(type, "Group") == 0)
        hr = process_group(file, section, section_name);
    else
        FIXME("Don't know how to process %s\n", debugstr_a(type));

    heap_free(type);
    return hr;
}

static HRESULT process_inf(struct ciffile *file, struct inf_file *inf)
{
    struct inf_section *section = NULL;
    char *section_name;
    HRESULT hr = S_OK;

    while (SUCCEEDED(hr) && inf_next_section(inf, &section))
    {
        section_name = inf_section_get_name(section);
        if (!section_name) return E_OUTOFMEMORY;

        TRACE("start processing section %s\n", debugstr_a(section_name));

        if (!strcasecmp(section_name, "Strings") ||
            !strncasecmp(section_name, "Strings.", strlen("Strings.")))
        {
            /* Ignore string sections */
        }
        else if (strcasecmp(section_name, "Version") == 0)
            hr = process_version(file, section);
        else
            hr = process_section(file, section, section_name);

        TRACE("finished processing section %s (%x)\n", debugstr_a(section_name), hr);
        heap_free(section_name);
    }

    /* In case there was no version section, set the default installer description */
    if (SUCCEEDED(hr) && !file->name)
    {
        file->name = strdupA(DEFAULT_INSTALLER_DESC);
        if (!file->name) hr = E_OUTOFMEMORY;
    }

    return hr;
}

static HRESULT load_ciffile(const char *path, ICifFile **icif)
{
    struct inf_file *inf = NULL;
    struct ciffile *file;
    HRESULT hr = E_FAIL;

    file = heap_alloc_zero(sizeof(*file));
    if(!file) return E_OUTOFMEMORY;

    file->ICifFile_iface.lpVtbl = &ciffileVtbl;
    file->ref = 1;

    list_init(&file->components);
    list_init(&file->groups);

    hr = inf_load(path, &inf);
    if (FAILED(hr)) goto error;

    hr = process_inf(file, inf);
    if (FAILED(hr)) goto error;

    *icif = &file->ICifFile_iface;
    return S_OK;

error:
    if (inf) inf_free(inf);
    ICifFile_Release(&file->ICifFile_iface);
    return hr;
}

HRESULT WINAPI GetICifFileFromFile(ICifFile **icif, const char *path)
{
    TRACE("(%p, %s)\n", icif, debugstr_a(path));

    return load_ciffile(path, icif);
}


HRESULT WINAPI GetICifRWFileFromFile(ICifRWFile **icif, const char *path)
{
    FIXME("(%p, %s): stub\n", icif, debugstr_a(path));

    return E_NOTIMPL;
}