| /* |
| * Implementation of the Microsoft Installer (msi.dll) |
| * |
| * Copyright 2005 Aric Stewart for CodeWeavers |
| * |
| * 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 |
| */ |
| |
| /* Msi top level apis directly related to installs */ |
| |
| #define COBJMACROS |
| |
| #include <stdarg.h> |
| |
| #include "windef.h" |
| #include "winbase.h" |
| #include "winerror.h" |
| #include "wine/debug.h" |
| #include "msi.h" |
| #include "msidefs.h" |
| #include "objbase.h" |
| #include "oleauto.h" |
| |
| #include "msipriv.h" |
| #include "msiserver.h" |
| #include "wine/unicode.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(msi); |
| |
| /*********************************************************************** |
| * MsiDoActionA (MSI.@) |
| */ |
| UINT WINAPI MsiDoActionA( MSIHANDLE hInstall, LPCSTR szAction ) |
| { |
| LPWSTR szwAction; |
| UINT ret; |
| |
| TRACE("%s\n", debugstr_a(szAction)); |
| |
| szwAction = strdupAtoW(szAction); |
| if (szAction && !szwAction) |
| return ERROR_FUNCTION_FAILED; |
| |
| ret = MsiDoActionW( hInstall, szwAction ); |
| msi_free( szwAction ); |
| return ret; |
| } |
| |
| /*********************************************************************** |
| * MsiDoActionW (MSI.@) |
| */ |
| UINT WINAPI MsiDoActionW( MSIHANDLE hInstall, LPCWSTR szAction ) |
| { |
| MSIPACKAGE *package; |
| UINT ret; |
| |
| TRACE("%s\n",debugstr_w(szAction)); |
| |
| if (!szAction) |
| return ERROR_INVALID_PARAMETER; |
| |
| package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE ); |
| if (!package) |
| { |
| HRESULT hr; |
| BSTR action; |
| IWineMsiRemotePackage *remote_package; |
| |
| remote_package = (IWineMsiRemotePackage *)msi_get_remote( hInstall ); |
| if (!remote_package) |
| return ERROR_INVALID_HANDLE; |
| |
| action = SysAllocString( szAction ); |
| if (!action) |
| { |
| IWineMsiRemotePackage_Release( remote_package ); |
| return ERROR_OUTOFMEMORY; |
| } |
| |
| hr = IWineMsiRemotePackage_DoAction( remote_package, action ); |
| |
| SysFreeString( action ); |
| IWineMsiRemotePackage_Release( remote_package ); |
| |
| if (FAILED(hr)) |
| { |
| if (HRESULT_FACILITY(hr) == FACILITY_WIN32) |
| return HRESULT_CODE(hr); |
| |
| return ERROR_FUNCTION_FAILED; |
| } |
| |
| return ERROR_SUCCESS; |
| } |
| |
| ret = ACTION_PerformAction( package, szAction ); |
| msiobj_release( &package->hdr ); |
| |
| return ret; |
| } |
| |
| /*********************************************************************** |
| * MsiSequenceA (MSI.@) |
| */ |
| UINT WINAPI MsiSequenceA( MSIHANDLE hInstall, LPCSTR szTable, INT iSequenceMode ) |
| { |
| LPWSTR szwTable; |
| UINT ret; |
| |
| TRACE("%s, %d\n", debugstr_a(szTable), iSequenceMode); |
| |
| szwTable = strdupAtoW(szTable); |
| if (szTable && !szwTable) |
| return ERROR_FUNCTION_FAILED; |
| |
| ret = MsiSequenceW( hInstall, szwTable, iSequenceMode ); |
| msi_free( szwTable ); |
| return ret; |
| } |
| |
| /*********************************************************************** |
| * MsiSequenceW (MSI.@) |
| */ |
| UINT WINAPI MsiSequenceW( MSIHANDLE hInstall, LPCWSTR szTable, INT iSequenceMode ) |
| { |
| MSIPACKAGE *package; |
| UINT ret; |
| |
| TRACE("%s, %d\n", debugstr_w(szTable), iSequenceMode); |
| |
| package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE ); |
| if (!package) |
| { |
| HRESULT hr; |
| BSTR table; |
| IWineMsiRemotePackage *remote_package; |
| |
| remote_package = (IWineMsiRemotePackage *)msi_get_remote( hInstall ); |
| if (!remote_package) |
| return ERROR_INVALID_HANDLE; |
| |
| table = SysAllocString( szTable ); |
| if (!table) |
| { |
| IWineMsiRemotePackage_Release( remote_package ); |
| return ERROR_OUTOFMEMORY; |
| } |
| |
| hr = IWineMsiRemotePackage_Sequence( remote_package, table, iSequenceMode ); |
| |
| SysFreeString( table ); |
| IWineMsiRemotePackage_Release( remote_package ); |
| |
| if (FAILED(hr)) |
| { |
| if (HRESULT_FACILITY(hr) == FACILITY_WIN32) |
| return HRESULT_CODE(hr); |
| |
| return ERROR_FUNCTION_FAILED; |
| } |
| |
| return ERROR_SUCCESS; |
| } |
| ret = MSI_Sequence( package, szTable ); |
| msiobj_release( &package->hdr ); |
| return ret; |
| } |
| |
| UINT msi_strcpy_to_awstring( const WCHAR *str, int len, awstring *awbuf, DWORD *sz ) |
| { |
| UINT r = ERROR_SUCCESS; |
| |
| if (awbuf->str.w && !sz) |
| return ERROR_INVALID_PARAMETER; |
| if (!sz) |
| return ERROR_SUCCESS; |
| |
| if (len < 0) len = strlenW( str ); |
| |
| if (awbuf->unicode && awbuf->str.w) |
| memcpy( awbuf->str.w, str, min(len + 1, *sz) * sizeof(WCHAR) ); |
| else |
| { |
| int lenA = WideCharToMultiByte( CP_ACP, 0, str, len + 1, NULL, 0, NULL, NULL ); |
| if (lenA) lenA--; |
| WideCharToMultiByte( CP_ACP, 0, str, len + 1, awbuf->str.a, *sz, NULL, NULL ); |
| if (awbuf->str.a && *sz && lenA >= *sz) |
| awbuf->str.a[*sz - 1] = 0; |
| len = lenA; |
| } |
| if (awbuf->str.w && len >= *sz) |
| r = ERROR_MORE_DATA; |
| *sz = len; |
| return r; |
| } |
| |
| const WCHAR *msi_get_target_folder( MSIPACKAGE *package, const WCHAR *name ) |
| { |
| MSIFOLDER *folder = msi_get_loaded_folder( package, name ); |
| |
| if (!folder) return NULL; |
| if (!folder->ResolvedTarget) |
| { |
| MSIFOLDER *parent = folder; |
| while (parent->Parent && strcmpW( parent->Parent, parent->Directory )) |
| { |
| parent = msi_get_loaded_folder( package, parent->Parent ); |
| } |
| msi_resolve_target_folder( package, parent->Directory, TRUE ); |
| } |
| return folder->ResolvedTarget; |
| } |
| |
| /*********************************************************************** |
| * MsiGetTargetPath (internal) |
| */ |
| static UINT MSI_GetTargetPath( MSIHANDLE hInstall, LPCWSTR szFolder, |
| awstring *szPathBuf, LPDWORD pcchPathBuf ) |
| { |
| MSIPACKAGE *package; |
| const WCHAR *path; |
| UINT r = ERROR_FUNCTION_FAILED; |
| |
| if (!szFolder) |
| return ERROR_INVALID_PARAMETER; |
| |
| package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE ); |
| if (!package) |
| { |
| HRESULT hr; |
| IWineMsiRemotePackage *remote_package; |
| LPWSTR value = NULL; |
| BSTR folder; |
| DWORD len; |
| |
| remote_package = (IWineMsiRemotePackage *)msi_get_remote( hInstall ); |
| if (!remote_package) |
| return ERROR_INVALID_HANDLE; |
| |
| folder = SysAllocString( szFolder ); |
| if (!folder) |
| { |
| IWineMsiRemotePackage_Release( remote_package ); |
| return ERROR_OUTOFMEMORY; |
| } |
| |
| len = 0; |
| hr = IWineMsiRemotePackage_GetTargetPath( remote_package, folder, NULL, &len ); |
| if (FAILED(hr)) |
| goto done; |
| |
| len++; |
| value = msi_alloc(len * sizeof(WCHAR)); |
| if (!value) |
| { |
| r = ERROR_OUTOFMEMORY; |
| goto done; |
| } |
| |
| hr = IWineMsiRemotePackage_GetTargetPath( remote_package, folder, value, &len ); |
| if (FAILED(hr)) |
| goto done; |
| |
| r = msi_strcpy_to_awstring( value, len, szPathBuf, pcchPathBuf ); |
| |
| done: |
| IWineMsiRemotePackage_Release( remote_package ); |
| SysFreeString( folder ); |
| msi_free( value ); |
| |
| if (FAILED(hr)) |
| { |
| if (HRESULT_FACILITY(hr) == FACILITY_WIN32) |
| return HRESULT_CODE(hr); |
| |
| return ERROR_FUNCTION_FAILED; |
| } |
| |
| return r; |
| } |
| |
| path = msi_get_target_folder( package, szFolder ); |
| msiobj_release( &package->hdr ); |
| |
| if (!path) |
| return ERROR_DIRECTORY; |
| |
| return msi_strcpy_to_awstring( path, -1, szPathBuf, pcchPathBuf ); |
| } |
| |
| /*********************************************************************** |
| * MsiGetTargetPathA (MSI.@) |
| */ |
| UINT WINAPI MsiGetTargetPathA( MSIHANDLE hInstall, LPCSTR szFolder, |
| LPSTR szPathBuf, LPDWORD pcchPathBuf ) |
| { |
| LPWSTR szwFolder; |
| awstring path; |
| UINT r; |
| |
| TRACE("%s %p %p\n", debugstr_a(szFolder), szPathBuf, pcchPathBuf); |
| |
| szwFolder = strdupAtoW(szFolder); |
| if (szFolder && !szwFolder) |
| return ERROR_FUNCTION_FAILED; |
| |
| path.unicode = FALSE; |
| path.str.a = szPathBuf; |
| |
| r = MSI_GetTargetPath( hInstall, szwFolder, &path, pcchPathBuf ); |
| |
| msi_free( szwFolder ); |
| |
| return r; |
| } |
| |
| /*********************************************************************** |
| * MsiGetTargetPathW (MSI.@) |
| */ |
| UINT WINAPI MsiGetTargetPathW( MSIHANDLE hInstall, LPCWSTR szFolder, |
| LPWSTR szPathBuf, LPDWORD pcchPathBuf ) |
| { |
| awstring path; |
| |
| TRACE("%s %p %p\n", debugstr_w(szFolder), szPathBuf, pcchPathBuf); |
| |
| path.unicode = TRUE; |
| path.str.w = szPathBuf; |
| |
| return MSI_GetTargetPath( hInstall, szFolder, &path, pcchPathBuf ); |
| } |
| |
| static WCHAR *get_source_root( MSIPACKAGE *package ) |
| { |
| msi_set_sourcedir_props( package, FALSE ); |
| return msi_dup_property( package->db, szSourceDir ); |
| } |
| |
| WCHAR *msi_resolve_source_folder( MSIPACKAGE *package, const WCHAR *name, MSIFOLDER **folder ) |
| { |
| MSIFOLDER *f; |
| LPWSTR p, path = NULL, parent; |
| |
| TRACE("working to resolve %s\n", debugstr_w(name)); |
| |
| if (!strcmpW( name, szSourceDir )) name = szTargetDir; |
| if (!(f = msi_get_loaded_folder( package, name ))) return NULL; |
| |
| /* special resolving for root dir */ |
| if (!strcmpW( name, szTargetDir ) && !f->ResolvedSource) |
| { |
| f->ResolvedSource = get_source_root( package ); |
| } |
| if (folder) *folder = f; |
| if (f->ResolvedSource) |
| { |
| path = strdupW( f->ResolvedSource ); |
| TRACE(" already resolved to %s\n", debugstr_w(path)); |
| return path; |
| } |
| if (!f->Parent) return path; |
| parent = f->Parent; |
| TRACE(" ! parent is %s\n", debugstr_w(parent)); |
| |
| p = msi_resolve_source_folder( package, parent, NULL ); |
| |
| if (package->WordCount & msidbSumInfoSourceTypeCompressed) |
| path = get_source_root( package ); |
| else if (package->WordCount & msidbSumInfoSourceTypeSFN) |
| path = msi_build_directory_name( 3, p, f->SourceShortPath, NULL ); |
| else |
| path = msi_build_directory_name( 3, p, f->SourceLongPath, NULL ); |
| |
| TRACE("-> %s\n", debugstr_w(path)); |
| f->ResolvedSource = strdupW( path ); |
| msi_free( p ); |
| |
| return path; |
| } |
| |
| /*********************************************************************** |
| * MSI_GetSourcePath (internal) |
| */ |
| static UINT MSI_GetSourcePath( MSIHANDLE hInstall, LPCWSTR szFolder, |
| awstring *szPathBuf, LPDWORD pcchPathBuf ) |
| { |
| MSIPACKAGE *package; |
| LPWSTR path; |
| UINT r = ERROR_FUNCTION_FAILED; |
| |
| TRACE("%s %p %p\n", debugstr_w(szFolder), szPathBuf, pcchPathBuf ); |
| |
| if (!szFolder) |
| return ERROR_INVALID_PARAMETER; |
| |
| package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE ); |
| if (!package) |
| { |
| HRESULT hr; |
| IWineMsiRemotePackage *remote_package; |
| LPWSTR value = NULL; |
| BSTR folder; |
| DWORD len; |
| |
| remote_package = (IWineMsiRemotePackage *)msi_get_remote( hInstall ); |
| if (!remote_package) |
| return ERROR_INVALID_HANDLE; |
| |
| folder = SysAllocString( szFolder ); |
| if (!folder) |
| { |
| IWineMsiRemotePackage_Release( remote_package ); |
| return ERROR_OUTOFMEMORY; |
| } |
| |
| len = 0; |
| hr = IWineMsiRemotePackage_GetSourcePath( remote_package, folder, NULL, &len ); |
| if (FAILED(hr)) |
| goto done; |
| |
| len++; |
| value = msi_alloc(len * sizeof(WCHAR)); |
| if (!value) |
| { |
| r = ERROR_OUTOFMEMORY; |
| goto done; |
| } |
| |
| hr = IWineMsiRemotePackage_GetSourcePath( remote_package, folder, value, &len ); |
| if (FAILED(hr)) |
| goto done; |
| |
| r = msi_strcpy_to_awstring( value, len, szPathBuf, pcchPathBuf ); |
| |
| done: |
| IWineMsiRemotePackage_Release( remote_package ); |
| SysFreeString( folder ); |
| msi_free( value ); |
| |
| if (FAILED(hr)) |
| { |
| if (HRESULT_FACILITY(hr) == FACILITY_WIN32) |
| return HRESULT_CODE(hr); |
| |
| return ERROR_FUNCTION_FAILED; |
| } |
| |
| return r; |
| } |
| |
| if (szPathBuf->str.w && !pcchPathBuf ) |
| { |
| msiobj_release( &package->hdr ); |
| return ERROR_INVALID_PARAMETER; |
| } |
| |
| path = msi_resolve_source_folder( package, szFolder, NULL ); |
| msiobj_release( &package->hdr ); |
| |
| TRACE("path = %s\n", debugstr_w(path)); |
| if (!path) |
| return ERROR_DIRECTORY; |
| |
| r = msi_strcpy_to_awstring( path, -1, szPathBuf, pcchPathBuf ); |
| msi_free( path ); |
| return r; |
| } |
| |
| /*********************************************************************** |
| * MsiGetSourcePathA (MSI.@) |
| */ |
| UINT WINAPI MsiGetSourcePathA( MSIHANDLE hInstall, LPCSTR szFolder, |
| LPSTR szPathBuf, LPDWORD pcchPathBuf ) |
| { |
| LPWSTR folder; |
| awstring str; |
| UINT r; |
| |
| TRACE("%s %p %p\n", debugstr_a(szFolder), szPathBuf, pcchPathBuf); |
| |
| str.unicode = FALSE; |
| str.str.a = szPathBuf; |
| |
| folder = strdupAtoW( szFolder ); |
| r = MSI_GetSourcePath( hInstall, folder, &str, pcchPathBuf ); |
| msi_free( folder ); |
| |
| return r; |
| } |
| |
| /*********************************************************************** |
| * MsiGetSourcePathW (MSI.@) |
| */ |
| UINT WINAPI MsiGetSourcePathW( MSIHANDLE hInstall, LPCWSTR szFolder, |
| LPWSTR szPathBuf, LPDWORD pcchPathBuf ) |
| { |
| awstring str; |
| |
| TRACE("%s %p %p\n", debugstr_w(szFolder), szPathBuf, pcchPathBuf ); |
| |
| str.unicode = TRUE; |
| str.str.w = szPathBuf; |
| |
| return MSI_GetSourcePath( hInstall, szFolder, &str, pcchPathBuf ); |
| } |
| |
| /*********************************************************************** |
| * MsiSetTargetPathA (MSI.@) |
| */ |
| UINT WINAPI MsiSetTargetPathA( MSIHANDLE hInstall, LPCSTR szFolder, |
| LPCSTR szFolderPath ) |
| { |
| LPWSTR szwFolder = NULL, szwFolderPath = NULL; |
| UINT rc = ERROR_OUTOFMEMORY; |
| |
| if ( !szFolder || !szFolderPath ) |
| return ERROR_INVALID_PARAMETER; |
| |
| szwFolder = strdupAtoW(szFolder); |
| szwFolderPath = strdupAtoW(szFolderPath); |
| if (!szwFolder || !szwFolderPath) |
| goto end; |
| |
| rc = MsiSetTargetPathW( hInstall, szwFolder, szwFolderPath ); |
| |
| end: |
| msi_free(szwFolder); |
| msi_free(szwFolderPath); |
| |
| return rc; |
| } |
| |
| static void set_target_path( MSIPACKAGE *package, MSIFOLDER *folder, const WCHAR *path ) |
| { |
| FolderList *fl; |
| MSIFOLDER *child; |
| WCHAR *target_path; |
| |
| if (!(target_path = msi_normalize_path( path ))) return; |
| if (strcmpW( target_path, folder->ResolvedTarget )) |
| { |
| msi_free( folder->ResolvedTarget ); |
| folder->ResolvedTarget = target_path; |
| msi_set_property( package->db, folder->Directory, folder->ResolvedTarget, -1 ); |
| |
| LIST_FOR_EACH_ENTRY( fl, &folder->children, FolderList, entry ) |
| { |
| child = fl->folder; |
| msi_resolve_target_folder( package, child->Directory, FALSE ); |
| } |
| } |
| else msi_free( target_path ); |
| } |
| |
| UINT MSI_SetTargetPathW( MSIPACKAGE *package, LPCWSTR szFolder, LPCWSTR szFolderPath ) |
| { |
| DWORD attrib; |
| MSIFOLDER *folder; |
| MSIFILE *file; |
| |
| TRACE("%p %s %s\n", package, debugstr_w(szFolder), debugstr_w(szFolderPath)); |
| |
| attrib = GetFileAttributesW(szFolderPath); |
| /* native MSI tests writeability by making temporary files at each drive */ |
| if (attrib != INVALID_FILE_ATTRIBUTES && |
| (attrib & FILE_ATTRIBUTE_OFFLINE || attrib & FILE_ATTRIBUTE_READONLY)) |
| { |
| return ERROR_FUNCTION_FAILED; |
| } |
| if (!(folder = msi_get_loaded_folder( package, szFolder ))) return ERROR_DIRECTORY; |
| |
| set_target_path( package, folder, szFolderPath ); |
| |
| LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry ) |
| { |
| const WCHAR *dir; |
| MSICOMPONENT *comp = file->Component; |
| |
| if (!comp->Enabled || msi_is_global_assembly( comp )) continue; |
| |
| dir = msi_get_target_folder( package, comp->Directory ); |
| msi_free( file->TargetPath ); |
| file->TargetPath = msi_build_directory_name( 2, dir, file->FileName ); |
| } |
| return ERROR_SUCCESS; |
| } |
| |
| /*********************************************************************** |
| * MsiSetTargetPathW (MSI.@) |
| */ |
| UINT WINAPI MsiSetTargetPathW(MSIHANDLE hInstall, LPCWSTR szFolder, |
| LPCWSTR szFolderPath) |
| { |
| MSIPACKAGE *package; |
| UINT ret; |
| |
| TRACE("%s %s\n",debugstr_w(szFolder),debugstr_w(szFolderPath)); |
| |
| if ( !szFolder || !szFolderPath ) |
| return ERROR_INVALID_PARAMETER; |
| |
| package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE); |
| if (!package) |
| { |
| HRESULT hr; |
| BSTR folder, path; |
| IWineMsiRemotePackage *remote_package; |
| |
| remote_package = (IWineMsiRemotePackage *)msi_get_remote( hInstall ); |
| if (!remote_package) |
| return ERROR_INVALID_HANDLE; |
| |
| folder = SysAllocString( szFolder ); |
| path = SysAllocString( szFolderPath ); |
| if (!folder || !path) |
| { |
| SysFreeString(folder); |
| SysFreeString(path); |
| IWineMsiRemotePackage_Release( remote_package ); |
| return ERROR_OUTOFMEMORY; |
| } |
| |
| hr = IWineMsiRemotePackage_SetTargetPath( remote_package, folder, path ); |
| |
| SysFreeString(folder); |
| SysFreeString(path); |
| IWineMsiRemotePackage_Release( remote_package ); |
| |
| if (FAILED(hr)) |
| { |
| if (HRESULT_FACILITY(hr) == FACILITY_WIN32) |
| return HRESULT_CODE(hr); |
| |
| return ERROR_FUNCTION_FAILED; |
| } |
| |
| return ERROR_SUCCESS; |
| } |
| |
| ret = MSI_SetTargetPathW( package, szFolder, szFolderPath ); |
| msiobj_release( &package->hdr ); |
| return ret; |
| } |
| |
| /*********************************************************************** |
| * MsiGetMode (MSI.@) |
| * |
| * Returns an internal installer state (if it is running in a mode iRunMode) |
| * |
| * PARAMS |
| * hInstall [I] Handle to the installation |
| * hRunMode [I] Checking run mode |
| * MSIRUNMODE_ADMIN Administrative mode |
| * MSIRUNMODE_ADVERTISE Advertisement mode |
| * MSIRUNMODE_MAINTENANCE Maintenance mode |
| * MSIRUNMODE_ROLLBACKENABLED Rollback is enabled |
| * MSIRUNMODE_LOGENABLED Log file is writing |
| * MSIRUNMODE_OPERATIONS Operations in progress?? |
| * MSIRUNMODE_REBOOTATEND We need to reboot after installation completed |
| * MSIRUNMODE_REBOOTNOW We need to reboot to continue the installation |
| * MSIRUNMODE_CABINET Files from cabinet are installed |
| * MSIRUNMODE_SOURCESHORTNAMES Long names in source files is suppressed |
| * MSIRUNMODE_TARGETSHORTNAMES Long names in destination files is suppressed |
| * MSIRUNMODE_RESERVED11 Reserved |
| * MSIRUNMODE_WINDOWS9X Running under Windows95/98 |
| * MSIRUNMODE_ZAWENABLED Demand installation is supported |
| * MSIRUNMODE_RESERVED14 Reserved |
| * MSIRUNMODE_RESERVED15 Reserved |
| * MSIRUNMODE_SCHEDULED called from install script |
| * MSIRUNMODE_ROLLBACK called from rollback script |
| * MSIRUNMODE_COMMIT called from commit script |
| * |
| * RETURNS |
| * In the state: TRUE |
| * Not in the state: FALSE |
| * |
| */ |
| BOOL WINAPI MsiGetMode(MSIHANDLE hInstall, MSIRUNMODE iRunMode) |
| { |
| MSIPACKAGE *package; |
| BOOL r = FALSE; |
| |
| TRACE("%d %d\n", hInstall, iRunMode); |
| |
| package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE); |
| if (!package) |
| { |
| BOOL ret; |
| HRESULT hr; |
| IWineMsiRemotePackage *remote_package; |
| |
| remote_package = (IWineMsiRemotePackage *)msi_get_remote(hInstall); |
| if (!remote_package) |
| return FALSE; |
| |
| hr = IWineMsiRemotePackage_GetMode(remote_package, iRunMode, &ret); |
| IWineMsiRemotePackage_Release(remote_package); |
| |
| if (hr == S_OK) |
| return ret; |
| |
| return FALSE; |
| } |
| |
| switch (iRunMode) |
| { |
| case MSIRUNMODE_ADMIN: |
| FIXME("no support for administrative installs\n"); |
| break; |
| |
| case MSIRUNMODE_ADVERTISE: |
| FIXME("no support for advertised installs\n"); |
| break; |
| |
| case MSIRUNMODE_WINDOWS9X: |
| if (GetVersion() & 0x80000000) |
| r = TRUE; |
| break; |
| |
| case MSIRUNMODE_OPERATIONS: |
| case MSIRUNMODE_RESERVED11: |
| case MSIRUNMODE_RESERVED14: |
| case MSIRUNMODE_RESERVED15: |
| break; |
| |
| case MSIRUNMODE_SCHEDULED: |
| r = (package->script == SCRIPT_INSTALL); |
| break; |
| |
| case MSIRUNMODE_ROLLBACK: |
| r = (package->script == SCRIPT_ROLLBACK); |
| break; |
| |
| case MSIRUNMODE_COMMIT: |
| r = (package->script == SCRIPT_COMMIT); |
| break; |
| |
| case MSIRUNMODE_MAINTENANCE: |
| r = msi_get_property_int( package->db, szInstalled, 0 ) != 0; |
| break; |
| |
| case MSIRUNMODE_ROLLBACKENABLED: |
| r = msi_get_property_int( package->db, szRollbackDisabled, 0 ) == 0; |
| break; |
| |
| case MSIRUNMODE_REBOOTATEND: |
| r = package->need_reboot_at_end; |
| break; |
| |
| case MSIRUNMODE_REBOOTNOW: |
| r = package->need_reboot_now; |
| break; |
| |
| case MSIRUNMODE_LOGENABLED: |
| r = (package->log_file != INVALID_HANDLE_VALUE); |
| break; |
| |
| default: |
| FIXME("unimplemented run mode: %d\n", iRunMode); |
| r = TRUE; |
| } |
| |
| msiobj_release( &package->hdr ); |
| return r; |
| } |
| |
| /*********************************************************************** |
| * MsiSetMode (MSI.@) |
| */ |
| UINT WINAPI MsiSetMode(MSIHANDLE hInstall, MSIRUNMODE iRunMode, BOOL fState) |
| { |
| MSIPACKAGE *package; |
| UINT r; |
| |
| TRACE("%d %d %d\n", hInstall, iRunMode, fState); |
| |
| package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE ); |
| if (!package) |
| { |
| HRESULT hr; |
| IWineMsiRemotePackage *remote_package; |
| |
| remote_package = (IWineMsiRemotePackage *)msi_get_remote( hInstall ); |
| if (!remote_package) |
| return FALSE; |
| |
| hr = IWineMsiRemotePackage_SetMode( remote_package, iRunMode, fState ); |
| IWineMsiRemotePackage_Release( remote_package ); |
| |
| if (FAILED(hr)) |
| { |
| if (HRESULT_FACILITY(hr) == FACILITY_WIN32) |
| return HRESULT_CODE(hr); |
| |
| return ERROR_FUNCTION_FAILED; |
| } |
| |
| return ERROR_SUCCESS; |
| } |
| |
| switch (iRunMode) |
| { |
| case MSIRUNMODE_REBOOTATEND: |
| package->need_reboot_at_end = (fState != 0); |
| r = ERROR_SUCCESS; |
| break; |
| |
| case MSIRUNMODE_REBOOTNOW: |
| package->need_reboot_now = (fState != 0); |
| r = ERROR_SUCCESS; |
| break; |
| |
| default: |
| r = ERROR_ACCESS_DENIED; |
| } |
| |
| msiobj_release( &package->hdr ); |
| return r; |
| } |
| |
| /*********************************************************************** |
| * MsiSetFeatureStateA (MSI.@) |
| * |
| * According to the docs, when this is called it immediately recalculates |
| * all the component states as well |
| */ |
| UINT WINAPI MsiSetFeatureStateA(MSIHANDLE hInstall, LPCSTR szFeature, |
| INSTALLSTATE iState) |
| { |
| LPWSTR szwFeature = NULL; |
| UINT rc; |
| |
| szwFeature = strdupAtoW(szFeature); |
| |
| if (!szwFeature) |
| return ERROR_FUNCTION_FAILED; |
| |
| rc = MsiSetFeatureStateW(hInstall,szwFeature, iState); |
| |
| msi_free(szwFeature); |
| |
| return rc; |
| } |
| |
| /* update component state based on a feature change */ |
| void ACTION_UpdateComponentStates( MSIPACKAGE *package, MSIFEATURE *feature ) |
| { |
| INSTALLSTATE newstate; |
| ComponentList *cl; |
| |
| newstate = feature->ActionRequest; |
| if (newstate == INSTALLSTATE_ABSENT) newstate = INSTALLSTATE_UNKNOWN; |
| |
| LIST_FOR_EACH_ENTRY(cl, &feature->Components, ComponentList, entry) |
| { |
| MSICOMPONENT *component = cl->component; |
| |
| if (!component->Enabled) continue; |
| |
| TRACE("Modifying (%d): Component %s (Installed %d, Action %d, Request %d)\n", |
| newstate, debugstr_w(component->Component), component->Installed, |
| component->Action, component->ActionRequest); |
| |
| if (newstate == INSTALLSTATE_LOCAL) |
| { |
| component->Action = INSTALLSTATE_LOCAL; |
| component->ActionRequest = INSTALLSTATE_LOCAL; |
| } |
| else |
| { |
| ComponentList *clist; |
| MSIFEATURE *f; |
| |
| component->hasLocalFeature = FALSE; |
| |
| component->Action = newstate; |
| component->ActionRequest = newstate; |
| /* if any other feature wants it local we need to set it local */ |
| LIST_FOR_EACH_ENTRY(f, &package->features, MSIFEATURE, entry) |
| { |
| if ( f->ActionRequest != INSTALLSTATE_LOCAL && |
| f->ActionRequest != INSTALLSTATE_SOURCE ) |
| { |
| continue; |
| } |
| LIST_FOR_EACH_ENTRY(clist, &f->Components, ComponentList, entry) |
| { |
| if (clist->component == component && |
| (f->ActionRequest == INSTALLSTATE_LOCAL || |
| f->ActionRequest == INSTALLSTATE_SOURCE)) |
| { |
| TRACE("Saved by %s\n", debugstr_w(f->Feature)); |
| component->hasLocalFeature = TRUE; |
| |
| if (component->Attributes & msidbComponentAttributesOptional) |
| { |
| if (f->Attributes & msidbFeatureAttributesFavorSource) |
| { |
| component->Action = INSTALLSTATE_SOURCE; |
| component->ActionRequest = INSTALLSTATE_SOURCE; |
| } |
| else |
| { |
| component->Action = INSTALLSTATE_LOCAL; |
| component->ActionRequest = INSTALLSTATE_LOCAL; |
| } |
| } |
| else if (component->Attributes & msidbComponentAttributesSourceOnly) |
| { |
| component->Action = INSTALLSTATE_SOURCE; |
| component->ActionRequest = INSTALLSTATE_SOURCE; |
| } |
| else |
| { |
| component->Action = INSTALLSTATE_LOCAL; |
| component->ActionRequest = INSTALLSTATE_LOCAL; |
| } |
| } |
| } |
| } |
| } |
| TRACE("Result (%d): Component %s (Installed %d, Action %d, Request %d)\n", |
| newstate, debugstr_w(component->Component), component->Installed, |
| component->Action, component->ActionRequest); |
| } |
| } |
| |
| UINT MSI_SetFeatureStateW( MSIPACKAGE *package, LPCWSTR szFeature, INSTALLSTATE iState ) |
| { |
| UINT rc = ERROR_SUCCESS; |
| MSIFEATURE *feature, *child; |
| |
| TRACE("%s %i\n", debugstr_w(szFeature), iState); |
| |
| feature = msi_get_loaded_feature( package, szFeature ); |
| if (!feature) |
| return ERROR_UNKNOWN_FEATURE; |
| |
| if (iState == INSTALLSTATE_ADVERTISED && |
| feature->Attributes & msidbFeatureAttributesDisallowAdvertise) |
| return ERROR_FUNCTION_FAILED; |
| |
| feature->ActionRequest = iState; |
| |
| ACTION_UpdateComponentStates( package, feature ); |
| |
| /* update all the features that are children of this feature */ |
| LIST_FOR_EACH_ENTRY( child, &package->features, MSIFEATURE, entry ) |
| { |
| if (child->Feature_Parent && !strcmpW( szFeature, child->Feature_Parent )) |
| MSI_SetFeatureStateW(package, child->Feature, iState); |
| } |
| |
| return rc; |
| } |
| |
| /*********************************************************************** |
| * MsiSetFeatureStateW (MSI.@) |
| */ |
| UINT WINAPI MsiSetFeatureStateW(MSIHANDLE hInstall, LPCWSTR szFeature, |
| INSTALLSTATE iState) |
| { |
| MSIPACKAGE* package; |
| UINT rc = ERROR_SUCCESS; |
| |
| TRACE("%s %i\n",debugstr_w(szFeature), iState); |
| |
| package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE); |
| if (!package) |
| { |
| HRESULT hr; |
| BSTR feature; |
| IWineMsiRemotePackage *remote_package; |
| |
| remote_package = (IWineMsiRemotePackage *)msi_get_remote(hInstall); |
| if (!remote_package) |
| return ERROR_INVALID_HANDLE; |
| |
| feature = SysAllocString(szFeature); |
| if (!feature) |
| { |
| IWineMsiRemotePackage_Release(remote_package); |
| return ERROR_OUTOFMEMORY; |
| } |
| |
| hr = IWineMsiRemotePackage_SetFeatureState(remote_package, feature, iState); |
| |
| SysFreeString(feature); |
| IWineMsiRemotePackage_Release(remote_package); |
| |
| if (FAILED(hr)) |
| { |
| if (HRESULT_FACILITY(hr) == FACILITY_WIN32) |
| return HRESULT_CODE(hr); |
| |
| return ERROR_FUNCTION_FAILED; |
| } |
| |
| return ERROR_SUCCESS; |
| } |
| |
| rc = MSI_SetFeatureStateW(package,szFeature,iState); |
| |
| msiobj_release( &package->hdr ); |
| return rc; |
| } |
| |
| /*********************************************************************** |
| * MsiSetFeatureAttributesA (MSI.@) |
| */ |
| UINT WINAPI MsiSetFeatureAttributesA( MSIHANDLE handle, LPCSTR feature, DWORD attrs ) |
| { |
| UINT r; |
| WCHAR *featureW = NULL; |
| |
| TRACE("%u, %s, 0x%08x\n", handle, debugstr_a(feature), attrs); |
| |
| if (feature && !(featureW = strdupAtoW( feature ))) return ERROR_OUTOFMEMORY; |
| |
| r = MsiSetFeatureAttributesW( handle, featureW, attrs ); |
| msi_free( featureW ); |
| return r; |
| } |
| |
| static DWORD unmap_feature_attributes( DWORD attrs ) |
| { |
| DWORD ret = 0; |
| |
| if (attrs & INSTALLFEATUREATTRIBUTE_FAVORLOCAL) ret = msidbFeatureAttributesFavorLocal; |
| if (attrs & INSTALLFEATUREATTRIBUTE_FAVORSOURCE) ret |= msidbFeatureAttributesFavorSource; |
| if (attrs & INSTALLFEATUREATTRIBUTE_FOLLOWPARENT) ret |= msidbFeatureAttributesFollowParent; |
| if (attrs & INSTALLFEATUREATTRIBUTE_FAVORADVERTISE) ret |= msidbFeatureAttributesFavorAdvertise; |
| if (attrs & INSTALLFEATUREATTRIBUTE_DISALLOWADVERTISE) ret |= msidbFeatureAttributesDisallowAdvertise; |
| if (attrs & INSTALLFEATUREATTRIBUTE_NOUNSUPPORTEDADVERTISE) ret |= msidbFeatureAttributesNoUnsupportedAdvertise; |
| return ret; |
| } |
| |
| /*********************************************************************** |
| * MsiSetFeatureAttributesW (MSI.@) |
| */ |
| UINT WINAPI MsiSetFeatureAttributesW( MSIHANDLE handle, LPCWSTR name, DWORD attrs ) |
| { |
| MSIPACKAGE *package; |
| MSIFEATURE *feature; |
| WCHAR *costing; |
| |
| TRACE("%u, %s, 0x%08x\n", handle, debugstr_w(name), attrs); |
| |
| if (!name || !name[0]) return ERROR_UNKNOWN_FEATURE; |
| |
| if (!(package = msihandle2msiinfo( handle, MSIHANDLETYPE_PACKAGE ))) |
| return ERROR_INVALID_HANDLE; |
| |
| costing = msi_dup_property( package->db, szCostingComplete ); |
| if (!costing || !strcmpW( costing, szOne )) |
| { |
| msi_free( costing ); |
| msiobj_release( &package->hdr ); |
| return ERROR_FUNCTION_FAILED; |
| } |
| msi_free( costing ); |
| if (!(feature = msi_get_loaded_feature( package, name ))) |
| { |
| msiobj_release( &package->hdr ); |
| return ERROR_UNKNOWN_FEATURE; |
| } |
| feature->Attributes = unmap_feature_attributes( attrs ); |
| msiobj_release( &package->hdr ); |
| return ERROR_SUCCESS; |
| } |
| |
| /*********************************************************************** |
| * MsiGetFeatureStateA (MSI.@) |
| */ |
| UINT WINAPI MsiGetFeatureStateA(MSIHANDLE hInstall, LPCSTR szFeature, |
| INSTALLSTATE *piInstalled, INSTALLSTATE *piAction) |
| { |
| LPWSTR szwFeature = NULL; |
| UINT rc; |
| |
| if (szFeature && !(szwFeature = strdupAtoW(szFeature))) return ERROR_OUTOFMEMORY; |
| |
| rc = MsiGetFeatureStateW(hInstall, szwFeature, piInstalled, piAction); |
| msi_free( szwFeature); |
| return rc; |
| } |
| |
| UINT MSI_GetFeatureStateW(MSIPACKAGE *package, LPCWSTR szFeature, |
| INSTALLSTATE *piInstalled, INSTALLSTATE *piAction) |
| { |
| MSIFEATURE *feature; |
| |
| feature = msi_get_loaded_feature(package,szFeature); |
| if (!feature) |
| return ERROR_UNKNOWN_FEATURE; |
| |
| if (piInstalled) |
| *piInstalled = feature->Installed; |
| |
| if (piAction) |
| *piAction = feature->ActionRequest; |
| |
| TRACE("returning %i %i\n", feature->Installed, feature->ActionRequest); |
| |
| return ERROR_SUCCESS; |
| } |
| |
| /*********************************************************************** |
| * MsiGetFeatureStateW (MSI.@) |
| */ |
| UINT WINAPI MsiGetFeatureStateW(MSIHANDLE hInstall, LPCWSTR szFeature, |
| INSTALLSTATE *piInstalled, INSTALLSTATE *piAction) |
| { |
| MSIPACKAGE* package; |
| UINT ret; |
| |
| TRACE("%d %s %p %p\n", hInstall, debugstr_w(szFeature), piInstalled, piAction); |
| |
| package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE); |
| if (!package) |
| { |
| HRESULT hr; |
| BSTR feature; |
| IWineMsiRemotePackage *remote_package; |
| |
| remote_package = (IWineMsiRemotePackage *)msi_get_remote(hInstall); |
| if (!remote_package) |
| return ERROR_INVALID_HANDLE; |
| |
| feature = SysAllocString(szFeature); |
| if (!feature) |
| { |
| IWineMsiRemotePackage_Release(remote_package); |
| return ERROR_OUTOFMEMORY; |
| } |
| |
| hr = IWineMsiRemotePackage_GetFeatureState(remote_package, feature, |
| piInstalled, piAction); |
| |
| SysFreeString(feature); |
| IWineMsiRemotePackage_Release(remote_package); |
| |
| if (FAILED(hr)) |
| { |
| if (HRESULT_FACILITY(hr) == FACILITY_WIN32) |
| return HRESULT_CODE(hr); |
| |
| return ERROR_FUNCTION_FAILED; |
| } |
| |
| return ERROR_SUCCESS; |
| } |
| |
| ret = MSI_GetFeatureStateW(package, szFeature, piInstalled, piAction); |
| msiobj_release( &package->hdr ); |
| return ret; |
| } |
| |
| /*********************************************************************** |
| * MsiGetFeatureCostA (MSI.@) |
| */ |
| UINT WINAPI MsiGetFeatureCostA(MSIHANDLE hInstall, LPCSTR szFeature, |
| MSICOSTTREE iCostTree, INSTALLSTATE iState, LPINT piCost) |
| { |
| LPWSTR szwFeature = NULL; |
| UINT rc; |
| |
| szwFeature = strdupAtoW(szFeature); |
| |
| rc = MsiGetFeatureCostW(hInstall, szwFeature, iCostTree, iState, piCost); |
| |
| msi_free(szwFeature); |
| |
| return rc; |
| } |
| |
| static INT feature_cost( MSIFEATURE *feature ) |
| { |
| INT cost = 0; |
| ComponentList *cl; |
| |
| LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry ) |
| { |
| cost += cl->component->Cost; |
| } |
| return cost; |
| } |
| |
| UINT MSI_GetFeatureCost( MSIPACKAGE *package, MSIFEATURE *feature, MSICOSTTREE tree, |
| INSTALLSTATE state, LPINT cost ) |
| { |
| TRACE("%s, %u, %d, %p\n", debugstr_w(feature->Feature), tree, state, cost); |
| |
| *cost = 0; |
| switch (tree) |
| { |
| case MSICOSTTREE_CHILDREN: |
| { |
| MSIFEATURE *child; |
| |
| LIST_FOR_EACH_ENTRY( child, &feature->Children, MSIFEATURE, entry ) |
| { |
| if (child->ActionRequest == state) |
| *cost += feature_cost( child ); |
| } |
| break; |
| } |
| case MSICOSTTREE_PARENTS: |
| { |
| const WCHAR *feature_parent = feature->Feature_Parent; |
| for (;;) |
| { |
| MSIFEATURE *parent = msi_get_loaded_feature( package, feature_parent ); |
| if (!parent) |
| break; |
| |
| if (parent->ActionRequest == state) |
| *cost += feature_cost( parent ); |
| |
| feature_parent = parent->Feature_Parent; |
| } |
| break; |
| } |
| case MSICOSTTREE_SELFONLY: |
| if (feature->ActionRequest == state) |
| *cost = feature_cost( feature ); |
| break; |
| |
| default: |
| WARN("unhandled cost tree %u\n", tree); |
| break; |
| } |
| |
| *cost /= 512; |
| return ERROR_SUCCESS; |
| } |
| |
| /*********************************************************************** |
| * MsiGetFeatureCostW (MSI.@) |
| */ |
| UINT WINAPI MsiGetFeatureCostW(MSIHANDLE hInstall, LPCWSTR szFeature, |
| MSICOSTTREE iCostTree, INSTALLSTATE iState, LPINT piCost) |
| { |
| MSIPACKAGE *package; |
| MSIFEATURE *feature; |
| UINT ret; |
| |
| TRACE("(%d %s %i %i %p)\n", hInstall, debugstr_w(szFeature), |
| iCostTree, iState, piCost); |
| |
| package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE); |
| if (!package) |
| { |
| HRESULT hr; |
| BSTR feature; |
| IWineMsiRemotePackage *remote_package; |
| |
| remote_package = (IWineMsiRemotePackage *)msi_get_remote(hInstall); |
| if (!remote_package) |
| return ERROR_INVALID_HANDLE; |
| |
| feature = SysAllocString(szFeature); |
| if (!feature) |
| { |
| IWineMsiRemotePackage_Release(remote_package); |
| return ERROR_OUTOFMEMORY; |
| } |
| |
| hr = IWineMsiRemotePackage_GetFeatureCost(remote_package, feature, |
| iCostTree, iState, piCost); |
| |
| SysFreeString(feature); |
| IWineMsiRemotePackage_Release(remote_package); |
| |
| if (FAILED(hr)) |
| { |
| if (HRESULT_FACILITY(hr) == FACILITY_WIN32) |
| return HRESULT_CODE(hr); |
| |
| return ERROR_FUNCTION_FAILED; |
| } |
| |
| return ERROR_SUCCESS; |
| } |
| |
| feature = msi_get_loaded_feature(package, szFeature); |
| |
| if (feature) |
| ret = MSI_GetFeatureCost(package, feature, iCostTree, iState, piCost); |
| else |
| ret = ERROR_UNKNOWN_FEATURE; |
| |
| msiobj_release( &package->hdr ); |
| return ret; |
| } |
| |
| /*********************************************************************** |
| * MsiGetFeatureInfoA (MSI.@) |
| */ |
| UINT WINAPI MsiGetFeatureInfoA( MSIHANDLE handle, LPCSTR feature, LPDWORD attrs, |
| LPSTR title, LPDWORD title_len, LPSTR help, LPDWORD help_len ) |
| { |
| UINT r; |
| WCHAR *titleW = NULL, *helpW = NULL, *featureW = NULL; |
| |
| TRACE("%u, %s, %p, %p, %p, %p, %p\n", handle, debugstr_a(feature), attrs, title, |
| title_len, help, help_len); |
| |
| if (feature && !(featureW = strdupAtoW( feature ))) return ERROR_OUTOFMEMORY; |
| |
| if (title && title_len && !(titleW = msi_alloc( *title_len * sizeof(WCHAR) ))) |
| { |
| msi_free( featureW ); |
| return ERROR_OUTOFMEMORY; |
| } |
| if (help && help_len && !(helpW = msi_alloc( *help_len * sizeof(WCHAR) ))) |
| { |
| msi_free( featureW ); |
| msi_free( titleW ); |
| return ERROR_OUTOFMEMORY; |
| } |
| r = MsiGetFeatureInfoW( handle, featureW, attrs, titleW, title_len, helpW, help_len ); |
| if (r == ERROR_SUCCESS) |
| { |
| if (titleW) WideCharToMultiByte( CP_ACP, 0, titleW, -1, title, *title_len + 1, NULL, NULL ); |
| if (helpW) WideCharToMultiByte( CP_ACP, 0, helpW, -1, help, *help_len + 1, NULL, NULL ); |
| } |
| msi_free( titleW ); |
| msi_free( helpW ); |
| msi_free( featureW ); |
| return r; |
| } |
| |
| static DWORD map_feature_attributes( DWORD attrs ) |
| { |
| DWORD ret = 0; |
| |
| if (attrs == msidbFeatureAttributesFavorLocal) ret |= INSTALLFEATUREATTRIBUTE_FAVORLOCAL; |
| if (attrs & msidbFeatureAttributesFavorSource) ret |= INSTALLFEATUREATTRIBUTE_FAVORSOURCE; |
| if (attrs & msidbFeatureAttributesFollowParent) ret |= INSTALLFEATUREATTRIBUTE_FOLLOWPARENT; |
| if (attrs & msidbFeatureAttributesFavorAdvertise) ret |= INSTALLFEATUREATTRIBUTE_FAVORADVERTISE; |
| if (attrs & msidbFeatureAttributesDisallowAdvertise) ret |= INSTALLFEATUREATTRIBUTE_DISALLOWADVERTISE; |
| if (attrs & msidbFeatureAttributesNoUnsupportedAdvertise) ret |= INSTALLFEATUREATTRIBUTE_NOUNSUPPORTEDADVERTISE; |
| return ret; |
| } |
| |
| static UINT MSI_GetFeatureInfo( MSIPACKAGE *package, LPCWSTR name, LPDWORD attrs, |
| LPWSTR title, LPDWORD title_len, LPWSTR help, LPDWORD help_len ) |
| { |
| UINT r = ERROR_SUCCESS; |
| MSIFEATURE *feature = msi_get_loaded_feature( package, name ); |
| int len; |
| |
| if (!feature) return ERROR_UNKNOWN_FEATURE; |
| if (attrs) *attrs = map_feature_attributes( feature->Attributes ); |
| if (title_len) |
| { |
| if (feature->Title) len = strlenW( feature->Title ); |
| else len = 0; |
| if (*title_len <= len) |
| { |
| *title_len = len; |
| if (title) r = ERROR_MORE_DATA; |
| } |
| else if (title) |
| { |
| if (feature->Title) strcpyW( title, feature->Title ); |
| else *title = 0; |
| *title_len = len; |
| } |
| } |
| if (help_len) |
| { |
| if (feature->Description) len = strlenW( feature->Description ); |
| else len = 0; |
| if (*help_len <= len) |
| { |
| *help_len = len; |
| if (help) r = ERROR_MORE_DATA; |
| } |
| else if (help) |
| { |
| if (feature->Description) strcpyW( help, feature->Description ); |
| else *help = 0; |
| *help_len = len; |
| } |
| } |
| return r; |
| } |
| |
| /*********************************************************************** |
| * MsiGetFeatureInfoW (MSI.@) |
| */ |
| UINT WINAPI MsiGetFeatureInfoW( MSIHANDLE handle, LPCWSTR feature, LPDWORD attrs, |
| LPWSTR title, LPDWORD title_len, LPWSTR help, LPDWORD help_len ) |
| { |
| UINT r; |
| MSIPACKAGE *package; |
| |
| TRACE("%u, %s, %p, %p, %p, %p, %p\n", handle, debugstr_w(feature), attrs, title, |
| title_len, help, help_len); |
| |
| if (!feature) return ERROR_INVALID_PARAMETER; |
| |
| if (!(package = msihandle2msiinfo( handle, MSIHANDLETYPE_PACKAGE ))) |
| return ERROR_INVALID_HANDLE; |
| |
| /* features may not have been loaded yet */ |
| msi_load_all_components( package ); |
| msi_load_all_features( package ); |
| |
| r = MSI_GetFeatureInfo( package, feature, attrs, title, title_len, help, help_len ); |
| msiobj_release( &package->hdr ); |
| return r; |
| } |
| |
| /*********************************************************************** |
| * MsiSetComponentStateA (MSI.@) |
| */ |
| UINT WINAPI MsiSetComponentStateA(MSIHANDLE hInstall, LPCSTR szComponent, |
| INSTALLSTATE iState) |
| { |
| UINT rc; |
| LPWSTR szwComponent = strdupAtoW(szComponent); |
| |
| rc = MsiSetComponentStateW(hInstall, szwComponent, iState); |
| |
| msi_free(szwComponent); |
| |
| return rc; |
| } |
| |
| /*********************************************************************** |
| * MsiGetComponentStateA (MSI.@) |
| */ |
| UINT WINAPI MsiGetComponentStateA(MSIHANDLE hInstall, LPCSTR szComponent, |
| INSTALLSTATE *piInstalled, INSTALLSTATE *piAction) |
| { |
| LPWSTR szwComponent= NULL; |
| UINT rc; |
| |
| szwComponent= strdupAtoW(szComponent); |
| |
| rc = MsiGetComponentStateW(hInstall,szwComponent,piInstalled, piAction); |
| |
| msi_free( szwComponent); |
| |
| return rc; |
| } |
| |
| static UINT MSI_SetComponentStateW(MSIPACKAGE *package, LPCWSTR szComponent, |
| INSTALLSTATE iState) |
| { |
| MSICOMPONENT *comp; |
| |
| TRACE("%p %s %d\n", package, debugstr_w(szComponent), iState); |
| |
| comp = msi_get_loaded_component(package, szComponent); |
| if (!comp) |
| return ERROR_UNKNOWN_COMPONENT; |
| |
| if (comp->Enabled) |
| comp->Action = iState; |
| |
| return ERROR_SUCCESS; |
| } |
| |
| UINT MSI_GetComponentStateW(MSIPACKAGE *package, LPCWSTR szComponent, |
| INSTALLSTATE *piInstalled, INSTALLSTATE *piAction) |
| { |
| MSICOMPONENT *comp; |
| |
| TRACE("%p %s %p %p\n", package, debugstr_w(szComponent), |
| piInstalled, piAction); |
| |
| comp = msi_get_loaded_component(package,szComponent); |
| if (!comp) |
| return ERROR_UNKNOWN_COMPONENT; |
| |
| if (piInstalled) |
| { |
| if (comp->Enabled) |
| *piInstalled = comp->Installed; |
| else |
| *piInstalled = INSTALLSTATE_UNKNOWN; |
| } |
| |
| if (piAction) |
| { |
| if (comp->Enabled) |
| *piAction = comp->Action; |
| else |
| *piAction = INSTALLSTATE_UNKNOWN; |
| } |
| |
| TRACE("states (%i, %i)\n", comp->Installed, comp->Action ); |
| return ERROR_SUCCESS; |
| } |
| |
| /*********************************************************************** |
| * MsiSetComponentStateW (MSI.@) |
| */ |
| UINT WINAPI MsiSetComponentStateW(MSIHANDLE hInstall, LPCWSTR szComponent, |
| INSTALLSTATE iState) |
| { |
| MSIPACKAGE* package; |
| UINT ret; |
| |
| package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE); |
| if (!package) |
| { |
| HRESULT hr; |
| BSTR component; |
| IWineMsiRemotePackage *remote_package; |
| |
| remote_package = (IWineMsiRemotePackage *)msi_get_remote(hInstall); |
| if (!remote_package) |
| return ERROR_INVALID_HANDLE; |
| |
| component = SysAllocString(szComponent); |
| if (!component) |
| { |
| IWineMsiRemotePackage_Release(remote_package); |
| return ERROR_OUTOFMEMORY; |
| } |
| |
| hr = IWineMsiRemotePackage_SetComponentState(remote_package, component, iState); |
| |
| SysFreeString(component); |
| IWineMsiRemotePackage_Release(remote_package); |
| |
| if (FAILED(hr)) |
| { |
| if (HRESULT_FACILITY(hr) == FACILITY_WIN32) |
| return HRESULT_CODE(hr); |
| |
| return ERROR_FUNCTION_FAILED; |
| } |
| |
| return ERROR_SUCCESS; |
| } |
| |
| ret = MSI_SetComponentStateW(package, szComponent, iState); |
| msiobj_release(&package->hdr); |
| return ret; |
| } |
| |
| /*********************************************************************** |
| * MsiGetComponentStateW (MSI.@) |
| */ |
| UINT WINAPI MsiGetComponentStateW(MSIHANDLE hInstall, LPCWSTR szComponent, |
| INSTALLSTATE *piInstalled, INSTALLSTATE *piAction) |
| { |
| MSIPACKAGE* package; |
| UINT ret; |
| |
| TRACE("%d %s %p %p\n", hInstall, debugstr_w(szComponent), |
| piInstalled, piAction); |
| |
| package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE); |
| if (!package) |
| { |
| HRESULT hr; |
| BSTR component; |
| IWineMsiRemotePackage *remote_package; |
| |
| remote_package = (IWineMsiRemotePackage *)msi_get_remote(hInstall); |
| if (!remote_package) |
| return ERROR_INVALID_HANDLE; |
| |
| component = SysAllocString(szComponent); |
| if (!component) |
| { |
| IWineMsiRemotePackage_Release(remote_package); |
| return ERROR_OUTOFMEMORY; |
| } |
| |
| hr = IWineMsiRemotePackage_GetComponentState(remote_package, component, |
| piInstalled, piAction); |
| |
| SysFreeString(component); |
| IWineMsiRemotePackage_Release(remote_package); |
| |
| if (FAILED(hr)) |
| { |
| if (HRESULT_FACILITY(hr) == FACILITY_WIN32) |
| return HRESULT_CODE(hr); |
| |
| return ERROR_FUNCTION_FAILED; |
| } |
| |
| return ERROR_SUCCESS; |
| } |
| |
| ret = MSI_GetComponentStateW( package, szComponent, piInstalled, piAction); |
| msiobj_release( &package->hdr ); |
| return ret; |
| } |
| |
| /*********************************************************************** |
| * MsiGetLanguage (MSI.@) |
| */ |
| LANGID WINAPI MsiGetLanguage(MSIHANDLE hInstall) |
| { |
| MSIPACKAGE* package; |
| LANGID langid; |
| |
| package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE); |
| if (!package) |
| { |
| HRESULT hr; |
| LANGID lang; |
| IWineMsiRemotePackage *remote_package; |
| |
| remote_package = (IWineMsiRemotePackage *)msi_get_remote(hInstall); |
| if (!remote_package) |
| return ERROR_INVALID_HANDLE; |
| |
| hr = IWineMsiRemotePackage_GetLanguage(remote_package, &lang); |
| |
| if (SUCCEEDED(hr)) |
| return lang; |
| |
| return 0; |
| } |
| |
| langid = msi_get_property_int( package->db, szProductLanguage, 0 ); |
| msiobj_release( &package->hdr ); |
| return langid; |
| } |
| |
| UINT MSI_SetInstallLevel( MSIPACKAGE *package, int iInstallLevel ) |
| { |
| static const WCHAR fmt[] = { '%','d',0 }; |
| WCHAR level[6]; |
| int len; |
| UINT r; |
| |
| TRACE("%p %i\n", package, iInstallLevel); |
| |
| if (iInstallLevel > 32767) |
| return ERROR_INVALID_PARAMETER; |
| |
| if (iInstallLevel < 1) |
| return MSI_SetFeatureStates( package ); |
| |
| len = sprintfW( level, fmt, iInstallLevel ); |
| r = msi_set_property( package->db, szInstallLevel, level, len ); |
| if ( r == ERROR_SUCCESS ) |
| r = MSI_SetFeatureStates( package ); |
| |
| return r; |
| } |
| |
| /*********************************************************************** |
| * MsiSetInstallLevel (MSI.@) |
| */ |
| UINT WINAPI MsiSetInstallLevel(MSIHANDLE hInstall, int iInstallLevel) |
| { |
| MSIPACKAGE* package; |
| UINT r; |
| |
| TRACE("%d %i\n", hInstall, iInstallLevel); |
| |
| package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE); |
| if (!package) |
| { |
| HRESULT hr; |
| IWineMsiRemotePackage *remote_package; |
| |
| remote_package = (IWineMsiRemotePackage *)msi_get_remote(hInstall); |
| if (!remote_package) |
| return ERROR_INVALID_HANDLE; |
| |
| hr = IWineMsiRemotePackage_SetInstallLevel(remote_package, iInstallLevel); |
| |
| IWineMsiRemotePackage_Release(remote_package); |
| |
| if (FAILED(hr)) |
| { |
| if (HRESULT_FACILITY(hr) == FACILITY_WIN32) |
| return HRESULT_CODE(hr); |
| |
| return ERROR_FUNCTION_FAILED; |
| } |
| |
| return ERROR_SUCCESS; |
| } |
| |
| r = MSI_SetInstallLevel( package, iInstallLevel ); |
| |
| msiobj_release( &package->hdr ); |
| |
| return r; |
| } |
| |
| /*********************************************************************** |
| * MsiGetFeatureValidStatesW (MSI.@) |
| */ |
| UINT WINAPI MsiGetFeatureValidStatesW(MSIHANDLE hInstall, LPCWSTR szFeature, |
| LPDWORD pInstallState) |
| { |
| if(pInstallState) *pInstallState = 1<<INSTALLSTATE_LOCAL; |
| FIXME("%d %s %p stub returning %d\n", |
| hInstall, debugstr_w(szFeature), pInstallState, pInstallState ? *pInstallState : 0); |
| |
| return ERROR_SUCCESS; |
| } |
| |
| /*********************************************************************** |
| * MsiGetFeatureValidStatesA (MSI.@) |
| */ |
| UINT WINAPI MsiGetFeatureValidStatesA(MSIHANDLE hInstall, LPCSTR szFeature, |
| LPDWORD pInstallState) |
| { |
| UINT ret; |
| LPWSTR szwFeature = strdupAtoW(szFeature); |
| |
| ret = MsiGetFeatureValidStatesW(hInstall, szwFeature, pInstallState); |
| |
| msi_free(szwFeature); |
| |
| return ret; |
| } |
