/* * 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 #include #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; }