mirror of
https://github.com/reactos/wine.git
synced 2024-12-05 10:17:57 +00:00
1741 lines
49 KiB
C
1741 lines
49 KiB
C
/*
|
|
* 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_PerformUIAction( package, szAction, SCRIPT_NONE );
|
|
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( LPCWSTR str, awstring *awbuf, DWORD *sz )
|
|
{
|
|
UINT len, r = ERROR_SUCCESS;
|
|
|
|
if (awbuf->str.w && !sz )
|
|
return ERROR_INVALID_PARAMETER;
|
|
|
|
if (!sz)
|
|
return r;
|
|
|
|
if (awbuf->unicode)
|
|
{
|
|
len = lstrlenW( str );
|
|
if (awbuf->str.w)
|
|
lstrcpynW( awbuf->str.w, str, *sz );
|
|
}
|
|
else
|
|
{
|
|
len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL );
|
|
if (len)
|
|
len--;
|
|
WideCharToMultiByte( CP_ACP, 0, str, -1, awbuf->str.a, *sz, NULL, NULL );
|
|
if ( awbuf->str.a && *sz && (len >= *sz) )
|
|
awbuf->str.a[*sz - 1] = 0;
|
|
}
|
|
|
|
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, 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;
|
|
|
|
r = msi_strcpy_to_awstring( path, szPathBuf, pcchPathBuf );
|
|
return r;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* 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, 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, 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 );
|
|
|
|
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 || (comp->assembly && !comp->assembly->application)) 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->scheduled_action_running;
|
|
break;
|
|
|
|
case MSIRUNMODE_ROLLBACK:
|
|
r = package->rollback_action_running;
|
|
break;
|
|
|
|
case MSIRUNMODE_COMMIT:
|
|
r = package->commit_action_running;
|
|
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;
|
|
MSICOMPONENT *comp;
|
|
|
|
LIST_FOR_EACH_ENTRY( comp, &feature->Components, MSICOMPONENT, entry )
|
|
{
|
|
cost += comp->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];
|
|
UINT r;
|
|
|
|
TRACE("%p %i\n", package, iInstallLevel);
|
|
|
|
if (iInstallLevel > 32767)
|
|
return ERROR_INVALID_PARAMETER;
|
|
|
|
if (iInstallLevel < 1)
|
|
return MSI_SetFeatureStates( package );
|
|
|
|
sprintfW( level, fmt, iInstallLevel );
|
|
r = msi_set_property( package->db, szInstallLevel, level );
|
|
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;
|
|
}
|