mirror of
https://github.com/reactos/reactos.git
synced 2024-08-23 03:42:40 +00:00
1746 lines
43 KiB
C
1746 lines
43 KiB
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 <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, §ion))
|
|
{
|
|
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;
|
|
}
|