2006-02-17 00:04:10 +00:00
|
|
|
/*
|
|
|
|
* Implementation of the Microsoft Installer (msi.dll)
|
|
|
|
*
|
|
|
|
* Copyright 2004 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
|
2006-08-01 23:12:11 +00:00
|
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
2006-02-17 00:04:10 +00:00
|
|
|
*/
|
|
|
|
|
2018-03-04 23:30:58 +00:00
|
|
|
#define NONAMELESSUNION
|
|
|
|
#define NONAMELESSSTRUCT
|
|
|
|
#define COBJMACROS
|
2022-03-13 18:08:27 +00:00
|
|
|
#ifdef __REACTOS__
|
|
|
|
#define WIN32_NO_STATUS
|
|
|
|
#endif
|
2018-03-04 23:30:58 +00:00
|
|
|
|
|
|
|
#include <stdarg.h>
|
|
|
|
#include "windef.h"
|
|
|
|
#include "winbase.h"
|
|
|
|
#include "winreg.h"
|
|
|
|
#include "winnls.h"
|
2022-03-13 18:08:27 +00:00
|
|
|
#ifdef __REACTOS__
|
|
|
|
#include <ndk/rtlfuncs.h>
|
|
|
|
#else
|
|
|
|
#include "winternl.h"
|
|
|
|
#endif
|
2018-03-04 23:30:58 +00:00
|
|
|
#include "shlwapi.h"
|
|
|
|
#include "wingdi.h"
|
|
|
|
#include "msi.h"
|
|
|
|
#include "msiquery.h"
|
|
|
|
#include "objidl.h"
|
|
|
|
#include "wincrypt.h"
|
|
|
|
#include "winuser.h"
|
|
|
|
#include "wininet.h"
|
|
|
|
#include "winver.h"
|
|
|
|
#include "urlmon.h"
|
|
|
|
#include "shlobj.h"
|
|
|
|
#include "objbase.h"
|
|
|
|
#include "msidefs.h"
|
|
|
|
#include "sddl.h"
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2022-03-12 14:11:46 +00:00
|
|
|
#include "wine/heap.h"
|
|
|
|
#include "wine/debug.h"
|
2022-03-12 22:54:40 +00:00
|
|
|
#include "wine/exception.h"
|
2022-03-12 14:11:46 +00:00
|
|
|
|
2018-03-04 23:30:58 +00:00
|
|
|
#include "msipriv.h"
|
2022-03-12 14:12:08 +00:00
|
|
|
#include "winemsi_s.h"
|
2018-03-04 23:30:58 +00:00
|
|
|
#include "resource.h"
|
2006-02-17 00:04:10 +00:00
|
|
|
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(msi);
|
|
|
|
|
2010-02-06 21:28:28 +00:00
|
|
|
static void free_feature( MSIFEATURE *feature )
|
|
|
|
{
|
|
|
|
struct list *item, *cursor;
|
|
|
|
|
|
|
|
LIST_FOR_EACH_SAFE( item, cursor, &feature->Children )
|
|
|
|
{
|
|
|
|
FeatureList *fl = LIST_ENTRY( item, FeatureList, entry );
|
|
|
|
list_remove( &fl->entry );
|
|
|
|
msi_free( fl );
|
|
|
|
}
|
|
|
|
|
|
|
|
LIST_FOR_EACH_SAFE( item, cursor, &feature->Components )
|
|
|
|
{
|
|
|
|
ComponentList *cl = LIST_ENTRY( item, ComponentList, entry );
|
|
|
|
list_remove( &cl->entry );
|
|
|
|
msi_free( cl );
|
|
|
|
}
|
|
|
|
msi_free( feature->Feature );
|
|
|
|
msi_free( feature->Feature_Parent );
|
|
|
|
msi_free( feature->Directory );
|
|
|
|
msi_free( feature->Description );
|
|
|
|
msi_free( feature->Title );
|
|
|
|
msi_free( feature );
|
|
|
|
}
|
|
|
|
|
2012-01-21 17:19:12 +00:00
|
|
|
static void free_folder( MSIFOLDER *folder )
|
|
|
|
{
|
|
|
|
struct list *item, *cursor;
|
|
|
|
|
|
|
|
LIST_FOR_EACH_SAFE( item, cursor, &folder->children )
|
|
|
|
{
|
|
|
|
FolderList *fl = LIST_ENTRY( item, FolderList, entry );
|
|
|
|
list_remove( &fl->entry );
|
|
|
|
msi_free( fl );
|
|
|
|
}
|
|
|
|
msi_free( folder->Parent );
|
|
|
|
msi_free( folder->Directory );
|
|
|
|
msi_free( folder->TargetDefault );
|
|
|
|
msi_free( folder->SourceLongPath );
|
|
|
|
msi_free( folder->SourceShortPath );
|
|
|
|
msi_free( folder->ResolvedTarget );
|
|
|
|
msi_free( folder->ResolvedSource );
|
|
|
|
msi_free( folder );
|
|
|
|
}
|
|
|
|
|
2010-02-06 21:28:28 +00:00
|
|
|
static void free_extension( MSIEXTENSION *ext )
|
|
|
|
{
|
|
|
|
struct list *item, *cursor;
|
|
|
|
|
|
|
|
LIST_FOR_EACH_SAFE( item, cursor, &ext->verbs )
|
|
|
|
{
|
|
|
|
MSIVERB *verb = LIST_ENTRY( item, MSIVERB, entry );
|
|
|
|
|
|
|
|
list_remove( &verb->entry );
|
|
|
|
msi_free( verb->Verb );
|
|
|
|
msi_free( verb->Command );
|
|
|
|
msi_free( verb->Argument );
|
|
|
|
msi_free( verb );
|
|
|
|
}
|
|
|
|
|
|
|
|
msi_free( ext->Extension );
|
|
|
|
msi_free( ext->ProgIDText );
|
|
|
|
msi_free( ext );
|
|
|
|
}
|
|
|
|
|
2011-03-20 08:47:41 +00:00
|
|
|
static void free_assembly( MSIASSEMBLY *assembly )
|
|
|
|
{
|
|
|
|
msi_free( assembly->feature );
|
|
|
|
msi_free( assembly->manifest );
|
|
|
|
msi_free( assembly->application );
|
|
|
|
msi_free( assembly->display_name );
|
|
|
|
if (assembly->tempdir) RemoveDirectoryW( assembly->tempdir );
|
|
|
|
msi_free( assembly->tempdir );
|
|
|
|
msi_free( assembly );
|
|
|
|
}
|
|
|
|
|
2012-01-21 17:19:12 +00:00
|
|
|
void msi_free_action_script( MSIPACKAGE *package, UINT script )
|
|
|
|
{
|
|
|
|
UINT i;
|
2018-01-20 11:29:30 +00:00
|
|
|
for (i = 0; i < package->script_actions_count[script]; i++)
|
|
|
|
msi_free( package->script_actions[script][i] );
|
2012-01-21 17:19:12 +00:00
|
|
|
|
2018-01-20 11:29:30 +00:00
|
|
|
msi_free( package->script_actions[script] );
|
|
|
|
package->script_actions[script] = NULL;
|
|
|
|
package->script_actions_count[script] = 0;
|
2012-01-21 17:19:12 +00:00
|
|
|
}
|
|
|
|
|
2010-02-06 21:28:28 +00:00
|
|
|
static void free_package_structures( MSIPACKAGE *package )
|
|
|
|
{
|
|
|
|
struct list *item, *cursor;
|
2018-01-20 11:29:30 +00:00
|
|
|
int i;
|
2010-02-06 21:28:28 +00:00
|
|
|
|
|
|
|
LIST_FOR_EACH_SAFE( item, cursor, &package->features )
|
|
|
|
{
|
|
|
|
MSIFEATURE *feature = LIST_ENTRY( item, MSIFEATURE, entry );
|
|
|
|
list_remove( &feature->entry );
|
|
|
|
free_feature( feature );
|
|
|
|
}
|
|
|
|
|
|
|
|
LIST_FOR_EACH_SAFE( item, cursor, &package->folders )
|
|
|
|
{
|
|
|
|
MSIFOLDER *folder = LIST_ENTRY( item, MSIFOLDER, entry );
|
|
|
|
list_remove( &folder->entry );
|
2012-01-21 17:19:12 +00:00
|
|
|
free_folder( folder );
|
2010-02-06 21:28:28 +00:00
|
|
|
}
|
|
|
|
|
2015-07-19 23:04:25 +00:00
|
|
|
LIST_FOR_EACH_SAFE( item, cursor, &package->files )
|
|
|
|
{
|
|
|
|
MSIFILE *file = LIST_ENTRY( item, MSIFILE, entry );
|
|
|
|
|
|
|
|
list_remove( &file->entry );
|
|
|
|
msi_free( file->File );
|
|
|
|
msi_free( file->FileName );
|
|
|
|
msi_free( file->ShortName );
|
|
|
|
msi_free( file->LongName );
|
|
|
|
msi_free( file->Version );
|
|
|
|
msi_free( file->Language );
|
|
|
|
if (msi_is_global_assembly( file->Component )) DeleteFileW( file->TargetPath );
|
|
|
|
msi_free( file->TargetPath );
|
|
|
|
msi_free( file );
|
|
|
|
}
|
|
|
|
|
2010-02-06 21:28:28 +00:00
|
|
|
LIST_FOR_EACH_SAFE( item, cursor, &package->components )
|
|
|
|
{
|
|
|
|
MSICOMPONENT *comp = LIST_ENTRY( item, MSICOMPONENT, entry );
|
|
|
|
|
|
|
|
list_remove( &comp->entry );
|
|
|
|
msi_free( comp->Component );
|
|
|
|
msi_free( comp->ComponentId );
|
|
|
|
msi_free( comp->Directory );
|
|
|
|
msi_free( comp->Condition );
|
|
|
|
msi_free( comp->KeyPath );
|
|
|
|
msi_free( comp->FullKeypath );
|
2011-03-20 08:47:41 +00:00
|
|
|
if (comp->assembly) free_assembly( comp->assembly );
|
2010-02-06 21:28:28 +00:00
|
|
|
msi_free( comp );
|
|
|
|
}
|
|
|
|
|
2015-07-19 23:04:25 +00:00
|
|
|
LIST_FOR_EACH_SAFE( item, cursor, &package->filepatches )
|
2010-02-06 21:28:28 +00:00
|
|
|
{
|
2015-07-19 23:04:25 +00:00
|
|
|
MSIFILEPATCH *patch = LIST_ENTRY( item, MSIFILEPATCH, entry );
|
2010-02-06 21:28:28 +00:00
|
|
|
|
2015-07-19 23:04:25 +00:00
|
|
|
list_remove( &patch->entry );
|
|
|
|
msi_free( patch->path );
|
|
|
|
msi_free( patch );
|
2010-02-06 21:28:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* clean up extension, progid, class and verb structures */
|
|
|
|
LIST_FOR_EACH_SAFE( item, cursor, &package->classes )
|
|
|
|
{
|
|
|
|
MSICLASS *cls = LIST_ENTRY( item, MSICLASS, entry );
|
|
|
|
|
|
|
|
list_remove( &cls->entry );
|
|
|
|
msi_free( cls->clsid );
|
|
|
|
msi_free( cls->Context );
|
|
|
|
msi_free( cls->Description );
|
|
|
|
msi_free( cls->FileTypeMask );
|
|
|
|
msi_free( cls->IconPath );
|
|
|
|
msi_free( cls->DefInprocHandler );
|
|
|
|
msi_free( cls->DefInprocHandler32 );
|
|
|
|
msi_free( cls->Argument );
|
|
|
|
msi_free( cls->ProgIDText );
|
|
|
|
msi_free( cls );
|
|
|
|
}
|
|
|
|
|
|
|
|
LIST_FOR_EACH_SAFE( item, cursor, &package->extensions )
|
|
|
|
{
|
|
|
|
MSIEXTENSION *ext = LIST_ENTRY( item, MSIEXTENSION, entry );
|
|
|
|
|
|
|
|
list_remove( &ext->entry );
|
|
|
|
free_extension( ext );
|
|
|
|
}
|
|
|
|
|
|
|
|
LIST_FOR_EACH_SAFE( item, cursor, &package->progids )
|
|
|
|
{
|
|
|
|
MSIPROGID *progid = LIST_ENTRY( item, MSIPROGID, entry );
|
|
|
|
|
|
|
|
list_remove( &progid->entry );
|
|
|
|
msi_free( progid->ProgID );
|
|
|
|
msi_free( progid->Description );
|
|
|
|
msi_free( progid->IconPath );
|
|
|
|
msi_free( progid );
|
|
|
|
}
|
|
|
|
|
|
|
|
LIST_FOR_EACH_SAFE( item, cursor, &package->mimes )
|
|
|
|
{
|
|
|
|
MSIMIME *mt = LIST_ENTRY( item, MSIMIME, entry );
|
|
|
|
|
|
|
|
list_remove( &mt->entry );
|
2010-05-29 08:55:43 +00:00
|
|
|
msi_free( mt->suffix );
|
2010-02-06 21:28:28 +00:00
|
|
|
msi_free( mt->clsid );
|
|
|
|
msi_free( mt->ContentType );
|
|
|
|
msi_free( mt );
|
|
|
|
}
|
|
|
|
|
|
|
|
LIST_FOR_EACH_SAFE( item, cursor, &package->appids )
|
|
|
|
{
|
|
|
|
MSIAPPID *appid = LIST_ENTRY( item, MSIAPPID, entry );
|
|
|
|
|
|
|
|
list_remove( &appid->entry );
|
|
|
|
msi_free( appid->AppID );
|
|
|
|
msi_free( appid->RemoteServerName );
|
|
|
|
msi_free( appid->LocalServer );
|
|
|
|
msi_free( appid->ServiceParameters );
|
|
|
|
msi_free( appid->DllSurrogate );
|
|
|
|
msi_free( appid );
|
|
|
|
}
|
|
|
|
|
|
|
|
LIST_FOR_EACH_SAFE( item, cursor, &package->sourcelist_info )
|
|
|
|
{
|
|
|
|
MSISOURCELISTINFO *info = LIST_ENTRY( item, MSISOURCELISTINFO, entry );
|
|
|
|
|
|
|
|
list_remove( &info->entry );
|
|
|
|
msi_free( info->value );
|
|
|
|
msi_free( info );
|
|
|
|
}
|
|
|
|
|
|
|
|
LIST_FOR_EACH_SAFE( item, cursor, &package->sourcelist_media )
|
|
|
|
{
|
|
|
|
MSIMEDIADISK *info = LIST_ENTRY( item, MSIMEDIADISK, entry );
|
|
|
|
|
|
|
|
list_remove( &info->entry );
|
|
|
|
msi_free( info->volume_label );
|
|
|
|
msi_free( info->disk_prompt );
|
|
|
|
msi_free( info );
|
|
|
|
}
|
|
|
|
|
2018-01-20 11:29:30 +00:00
|
|
|
for (i = 0; i < SCRIPT_MAX; i++)
|
|
|
|
msi_free_action_script( package, i );
|
2010-02-06 21:28:28 +00:00
|
|
|
|
2018-01-20 11:29:30 +00:00
|
|
|
for (i = 0; i < package->unique_actions_count; i++)
|
|
|
|
msi_free( package->unique_actions[i] );
|
|
|
|
msi_free( package->unique_actions);
|
2010-02-06 21:28:28 +00:00
|
|
|
|
2011-03-20 08:47:41 +00:00
|
|
|
LIST_FOR_EACH_SAFE( item, cursor, &package->binaries )
|
|
|
|
{
|
|
|
|
MSIBINARY *binary = LIST_ENTRY( item, MSIBINARY, entry );
|
|
|
|
|
|
|
|
list_remove( &binary->entry );
|
|
|
|
if (!DeleteFileW( binary->tmpfile ))
|
|
|
|
ERR("failed to delete %s (%u)\n", debugstr_w(binary->tmpfile), GetLastError());
|
|
|
|
msi_free( binary->source );
|
|
|
|
msi_free( binary->tmpfile );
|
|
|
|
msi_free( binary );
|
|
|
|
}
|
|
|
|
|
2012-01-21 17:19:12 +00:00
|
|
|
LIST_FOR_EACH_SAFE( item, cursor, &package->cabinet_streams )
|
|
|
|
{
|
|
|
|
MSICABINETSTREAM *cab = LIST_ENTRY( item, MSICABINETSTREAM, entry );
|
|
|
|
|
|
|
|
list_remove( &cab->entry );
|
|
|
|
IStorage_Release( cab->storage );
|
|
|
|
msi_free( cab->stream );
|
|
|
|
msi_free( cab );
|
|
|
|
}
|
|
|
|
|
|
|
|
LIST_FOR_EACH_SAFE( item, cursor, &package->patches )
|
|
|
|
{
|
|
|
|
MSIPATCHINFO *patch = LIST_ENTRY( item, MSIPATCHINFO, entry );
|
|
|
|
|
|
|
|
list_remove( &patch->entry );
|
|
|
|
if (patch->delete_on_close && !DeleteFileW( patch->localfile ))
|
|
|
|
{
|
|
|
|
ERR("failed to delete %s (%u)\n", debugstr_w(patch->localfile), GetLastError());
|
|
|
|
}
|
|
|
|
msi_free_patchinfo( patch );
|
|
|
|
}
|
|
|
|
|
2010-02-06 21:28:28 +00:00
|
|
|
msi_free( package->PackagePath );
|
|
|
|
msi_free( package->ProductCode );
|
|
|
|
msi_free( package->ActionFormat );
|
|
|
|
msi_free( package->LastAction );
|
2017-10-08 08:14:40 +00:00
|
|
|
msi_free( package->LastActionTemplate );
|
2010-10-22 13:18:11 +00:00
|
|
|
msi_free( package->langids );
|
2010-02-06 21:28:28 +00:00
|
|
|
|
|
|
|
/* cleanup control event subscriptions */
|
2013-09-22 16:30:18 +00:00
|
|
|
msi_event_cleanup_all_subscriptions( package );
|
2010-02-06 21:28:28 +00:00
|
|
|
}
|
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
static void MSI_FreePackage( MSIOBJECTHDR *arg)
|
|
|
|
{
|
2011-03-20 08:47:41 +00:00
|
|
|
MSIPACKAGE *package = (MSIPACKAGE *)arg;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2012-08-13 16:17:18 +00:00
|
|
|
msi_destroy_assembly_caches( package );
|
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
if( package->dialog )
|
|
|
|
msi_dialog_destroy( package->dialog );
|
2008-01-16 10:11:22 +00:00
|
|
|
|
|
|
|
msiobj_release( &package->db->hdr );
|
2010-02-06 21:28:28 +00:00
|
|
|
free_package_structures(package);
|
2011-03-20 08:47:41 +00:00
|
|
|
CloseHandle( package->log_file );
|
2022-03-12 16:01:10 +00:00
|
|
|
if (package->rpc_server_started)
|
|
|
|
RpcServerUnregisterIf(s_IWineMsiRemote_v0_0_s_ifspec, NULL, FALSE);
|
2022-03-12 22:22:08 +00:00
|
|
|
if (rpc_handle)
|
|
|
|
RpcBindingFree(&rpc_handle);
|
2022-03-12 22:22:09 +00:00
|
|
|
if (package->custom_server_32_process)
|
|
|
|
custom_stop_server(package->custom_server_32_process, package->custom_server_32_pipe);
|
|
|
|
if (package->custom_server_64_process)
|
|
|
|
custom_stop_server(package->custom_server_64_process, package->custom_server_64_pipe);
|
2011-03-20 08:47:41 +00:00
|
|
|
|
2012-01-21 17:19:12 +00:00
|
|
|
if (package->delete_on_close) DeleteFileW( package->localfile );
|
|
|
|
msi_free( package->localfile );
|
2017-10-08 08:14:40 +00:00
|
|
|
MSI_ProcessMessage(NULL, INSTALLMESSAGE_TERMINATE, 0);
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2008-01-16 10:11:22 +00:00
|
|
|
static UINT create_temp_property_table(MSIPACKAGE *package)
|
|
|
|
{
|
2012-01-21 17:19:12 +00:00
|
|
|
static const WCHAR query[] = {
|
|
|
|
'C','R','E','A','T','E',' ','T','A','B','L','E',' ',
|
|
|
|
'`','_','P','r','o','p','e','r','t','y','`',' ','(',' ',
|
|
|
|
'`','_','P','r','o','p','e','r','t','y','`',' ',
|
|
|
|
'C','H','A','R','(','5','6',')',' ','N','O','T',' ','N','U','L','L',' ',
|
|
|
|
'T','E','M','P','O','R','A','R','Y',',',' ',
|
|
|
|
'`','V','a','l','u','e','`',' ','C','H','A','R','(','9','8',')',' ',
|
|
|
|
'N','O','T',' ','N','U','L','L',' ','T','E','M','P','O','R','A','R','Y',
|
|
|
|
' ','P','R','I','M','A','R','Y',' ','K','E','Y',' ',
|
|
|
|
'`','_','P','r','o','p','e','r','t','y','`',')',' ','H','O','L','D',0};
|
|
|
|
MSIQUERY *view;
|
2008-01-16 10:11:22 +00:00
|
|
|
UINT rc;
|
2006-08-30 19:24:26 +00:00
|
|
|
|
2012-01-21 17:19:12 +00:00
|
|
|
rc = MSI_DatabaseOpenViewW(package->db, query, &view);
|
2008-01-16 10:11:22 +00:00
|
|
|
if (rc != ERROR_SUCCESS)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
rc = MSI_ViewExecute(view, 0);
|
|
|
|
MSI_ViewClose(view);
|
|
|
|
msiobj_release(&view->hdr);
|
|
|
|
return rc;
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
2015-03-09 20:28:19 +00:00
|
|
|
UINT msi_clone_properties( MSIDATABASE *db )
|
2006-02-17 00:04:10 +00:00
|
|
|
{
|
Finish the Wine sync. These components are not just rc file changes
atl, comctl32, comdlg32, dwmapi, fusion, gdiplus, jscript, mpr, mshtml, msi, msimtf, msxml3, ole32, oleaut32, riched20, shdocvw, shlwapi, urlmon, usp10, version and windowscodecs
Seems to build and boot. /me hides
svn path=/trunk/; revision=48273
2010-07-26 02:26:04 +00:00
|
|
|
static const WCHAR query_select[] = {
|
2012-01-21 17:19:12 +00:00
|
|
|
'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
|
|
|
|
'`','P','r','o','p','e','r','t','y','`',0};
|
Finish the Wine sync. These components are not just rc file changes
atl, comctl32, comdlg32, dwmapi, fusion, gdiplus, jscript, mpr, mshtml, msi, msimtf, msxml3, ole32, oleaut32, riched20, shdocvw, shlwapi, urlmon, usp10, version and windowscodecs
Seems to build and boot. /me hides
svn path=/trunk/; revision=48273
2010-07-26 02:26:04 +00:00
|
|
|
static const WCHAR query_insert[] = {
|
2012-01-21 17:19:12 +00:00
|
|
|
'I','N','S','E','R','T',' ','I','N','T','O',' ',
|
|
|
|
'`','_','P','r','o','p','e','r','t','y','`',' ',
|
|
|
|
'(','`','_','P','r','o','p','e','r','t','y','`',',','`','V','a','l','u','e','`',')',' ',
|
|
|
|
'V','A','L','U','E','S',' ','(','?',',','?',')',0};
|
Finish the Wine sync. These components are not just rc file changes
atl, comctl32, comdlg32, dwmapi, fusion, gdiplus, jscript, mpr, mshtml, msi, msimtf, msxml3, ole32, oleaut32, riched20, shdocvw, shlwapi, urlmon, usp10, version and windowscodecs
Seems to build and boot. /me hides
svn path=/trunk/; revision=48273
2010-07-26 02:26:04 +00:00
|
|
|
static const WCHAR query_update[] = {
|
|
|
|
'U','P','D','A','T','E',' ','`','_','P','r','o','p','e','r','t','y','`',' ',
|
|
|
|
'S','E','T',' ','`','V','a','l','u','e','`',' ','=',' ','?',' ',
|
|
|
|
'W','H','E','R','E',' ','`','_','P','r','o','p','e','r','t','y','`',' ','=',' ','?',0};
|
2012-01-21 17:19:12 +00:00
|
|
|
MSIQUERY *view_select;
|
|
|
|
UINT rc;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2015-03-09 20:28:19 +00:00
|
|
|
rc = MSI_DatabaseOpenViewW( db, query_select, &view_select );
|
2006-02-17 00:04:10 +00:00
|
|
|
if (rc != ERROR_SUCCESS)
|
|
|
|
return rc;
|
|
|
|
|
Finish the Wine sync. These components are not just rc file changes
atl, comctl32, comdlg32, dwmapi, fusion, gdiplus, jscript, mpr, mshtml, msi, msimtf, msxml3, ole32, oleaut32, riched20, shdocvw, shlwapi, urlmon, usp10, version and windowscodecs
Seems to build and boot. /me hides
svn path=/trunk/; revision=48273
2010-07-26 02:26:04 +00:00
|
|
|
rc = MSI_ViewExecute( view_select, 0 );
|
2006-02-17 00:04:10 +00:00
|
|
|
if (rc != ERROR_SUCCESS)
|
|
|
|
{
|
Finish the Wine sync. These components are not just rc file changes
atl, comctl32, comdlg32, dwmapi, fusion, gdiplus, jscript, mpr, mshtml, msi, msimtf, msxml3, ole32, oleaut32, riched20, shdocvw, shlwapi, urlmon, usp10, version and windowscodecs
Seems to build and boot. /me hides
svn path=/trunk/; revision=48273
2010-07-26 02:26:04 +00:00
|
|
|
MSI_ViewClose( view_select );
|
|
|
|
msiobj_release( &view_select->hdr );
|
2006-02-17 00:04:10 +00:00
|
|
|
return rc;
|
|
|
|
}
|
2008-01-16 10:11:22 +00:00
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
while (1)
|
|
|
|
{
|
Finish the Wine sync. These components are not just rc file changes
atl, comctl32, comdlg32, dwmapi, fusion, gdiplus, jscript, mpr, mshtml, msi, msimtf, msxml3, ole32, oleaut32, riched20, shdocvw, shlwapi, urlmon, usp10, version and windowscodecs
Seems to build and boot. /me hides
svn path=/trunk/; revision=48273
2010-07-26 02:26:04 +00:00
|
|
|
MSIQUERY *view_insert, *view_update;
|
|
|
|
MSIRECORD *rec_select;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
Finish the Wine sync. These components are not just rc file changes
atl, comctl32, comdlg32, dwmapi, fusion, gdiplus, jscript, mpr, mshtml, msi, msimtf, msxml3, ole32, oleaut32, riched20, shdocvw, shlwapi, urlmon, usp10, version and windowscodecs
Seems to build and boot. /me hides
svn path=/trunk/; revision=48273
2010-07-26 02:26:04 +00:00
|
|
|
rc = MSI_ViewFetch( view_select, &rec_select );
|
2006-02-17 00:04:10 +00:00
|
|
|
if (rc != ERROR_SUCCESS)
|
|
|
|
break;
|
|
|
|
|
2015-03-09 20:28:19 +00:00
|
|
|
rc = MSI_DatabaseOpenViewW( db, query_insert, &view_insert );
|
2008-01-16 10:11:22 +00:00
|
|
|
if (rc != ERROR_SUCCESS)
|
|
|
|
{
|
Finish the Wine sync. These components are not just rc file changes
atl, comctl32, comdlg32, dwmapi, fusion, gdiplus, jscript, mpr, mshtml, msi, msimtf, msxml3, ole32, oleaut32, riched20, shdocvw, shlwapi, urlmon, usp10, version and windowscodecs
Seems to build and boot. /me hides
svn path=/trunk/; revision=48273
2010-07-26 02:26:04 +00:00
|
|
|
msiobj_release( &rec_select->hdr );
|
2008-01-16 10:11:22 +00:00
|
|
|
continue;
|
|
|
|
}
|
2006-08-30 19:24:26 +00:00
|
|
|
|
Finish the Wine sync. These components are not just rc file changes
atl, comctl32, comdlg32, dwmapi, fusion, gdiplus, jscript, mpr, mshtml, msi, msimtf, msxml3, ole32, oleaut32, riched20, shdocvw, shlwapi, urlmon, usp10, version and windowscodecs
Seems to build and boot. /me hides
svn path=/trunk/; revision=48273
2010-07-26 02:26:04 +00:00
|
|
|
rc = MSI_ViewExecute( view_insert, rec_select );
|
|
|
|
MSI_ViewClose( view_insert );
|
|
|
|
msiobj_release( &view_insert->hdr );
|
|
|
|
if (rc != ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
MSIRECORD *rec_update;
|
2008-01-16 10:11:22 +00:00
|
|
|
|
Finish the Wine sync. These components are not just rc file changes
atl, comctl32, comdlg32, dwmapi, fusion, gdiplus, jscript, mpr, mshtml, msi, msimtf, msxml3, ole32, oleaut32, riched20, shdocvw, shlwapi, urlmon, usp10, version and windowscodecs
Seems to build and boot. /me hides
svn path=/trunk/; revision=48273
2010-07-26 02:26:04 +00:00
|
|
|
TRACE("insert failed, trying update\n");
|
|
|
|
|
2015-03-09 20:28:19 +00:00
|
|
|
rc = MSI_DatabaseOpenViewW( db, query_update, &view_update );
|
Finish the Wine sync. These components are not just rc file changes
atl, comctl32, comdlg32, dwmapi, fusion, gdiplus, jscript, mpr, mshtml, msi, msimtf, msxml3, ole32, oleaut32, riched20, shdocvw, shlwapi, urlmon, usp10, version and windowscodecs
Seems to build and boot. /me hides
svn path=/trunk/; revision=48273
2010-07-26 02:26:04 +00:00
|
|
|
if (rc != ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
WARN("open view failed %u\n", rc);
|
|
|
|
msiobj_release( &rec_select->hdr );
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
rec_update = MSI_CreateRecord( 2 );
|
|
|
|
MSI_RecordCopyField( rec_select, 1, rec_update, 2 );
|
|
|
|
MSI_RecordCopyField( rec_select, 2, rec_update, 1 );
|
|
|
|
rc = MSI_ViewExecute( view_update, rec_update );
|
|
|
|
if (rc != ERROR_SUCCESS)
|
|
|
|
WARN("update failed %u\n", rc);
|
|
|
|
|
|
|
|
MSI_ViewClose( view_update );
|
|
|
|
msiobj_release( &view_update->hdr );
|
|
|
|
msiobj_release( &rec_update->hdr );
|
|
|
|
}
|
2006-08-30 19:24:26 +00:00
|
|
|
|
Finish the Wine sync. These components are not just rc file changes
atl, comctl32, comdlg32, dwmapi, fusion, gdiplus, jscript, mpr, mshtml, msi, msimtf, msxml3, ole32, oleaut32, riched20, shdocvw, shlwapi, urlmon, usp10, version and windowscodecs
Seems to build and boot. /me hides
svn path=/trunk/; revision=48273
2010-07-26 02:26:04 +00:00
|
|
|
msiobj_release( &rec_select->hdr );
|
|
|
|
}
|
|
|
|
|
|
|
|
MSI_ViewClose( view_select );
|
|
|
|
msiobj_release( &view_select->hdr );
|
2006-02-17 00:04:10 +00:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* set_installed_prop
|
|
|
|
*
|
|
|
|
* Sets the "Installed" property to indicate that
|
|
|
|
* the product is installed for the current user.
|
|
|
|
*/
|
|
|
|
static UINT set_installed_prop( MSIPACKAGE *package )
|
|
|
|
{
|
2012-01-21 17:19:12 +00:00
|
|
|
HKEY hkey;
|
2006-02-17 00:04:10 +00:00
|
|
|
UINT r;
|
|
|
|
|
2012-01-21 17:19:12 +00:00
|
|
|
if (!package->ProductCode) return ERROR_FUNCTION_FAILED;
|
|
|
|
|
|
|
|
r = MSIREG_OpenUninstallKey( package->ProductCode, package->platform, &hkey, FALSE );
|
2006-02-17 00:04:10 +00:00
|
|
|
if (r == ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
RegCloseKey( hkey );
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szInstalled, szOne, -1 );
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2008-01-16 10:11:22 +00:00
|
|
|
static UINT set_user_sid_prop( MSIPACKAGE *package )
|
|
|
|
{
|
|
|
|
SID_NAME_USE use;
|
|
|
|
LPWSTR user_name;
|
|
|
|
LPWSTR sid_str = NULL, dom = NULL;
|
|
|
|
DWORD size, dom_size;
|
|
|
|
PSID psid = NULL;
|
|
|
|
UINT r = ERROR_FUNCTION_FAILED;
|
|
|
|
|
|
|
|
size = 0;
|
|
|
|
GetUserNameW( NULL, &size );
|
|
|
|
|
|
|
|
user_name = msi_alloc( (size + 1) * sizeof(WCHAR) );
|
|
|
|
if (!user_name)
|
|
|
|
return ERROR_OUTOFMEMORY;
|
|
|
|
|
|
|
|
if (!GetUserNameW( user_name, &size ))
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
size = 0;
|
|
|
|
dom_size = 0;
|
|
|
|
LookupAccountNameW( NULL, user_name, NULL, &size, NULL, &dom_size, &use );
|
|
|
|
|
|
|
|
psid = msi_alloc( size );
|
|
|
|
dom = msi_alloc( dom_size*sizeof (WCHAR) );
|
|
|
|
if (!psid || !dom)
|
|
|
|
{
|
|
|
|
r = ERROR_OUTOFMEMORY;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!LookupAccountNameW( NULL, user_name, psid, &size, dom, &dom_size, &use ))
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
if (!ConvertSidToStringSidW( psid, &sid_str ))
|
|
|
|
goto done;
|
|
|
|
|
2012-12-09 19:43:59 +00:00
|
|
|
r = msi_set_property( package->db, szUserSID, sid_str, -1 );
|
2008-01-16 10:11:22 +00:00
|
|
|
|
|
|
|
done:
|
|
|
|
LocalFree( sid_str );
|
|
|
|
msi_free( dom );
|
|
|
|
msi_free( psid );
|
|
|
|
msi_free( user_name );
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static LPWSTR get_fusion_filename(MSIPACKAGE *package)
|
|
|
|
{
|
2018-03-04 23:30:58 +00:00
|
|
|
static const WCHAR fusion[] =
|
|
|
|
{'f','u','s','i','o','n','.','d','l','l',0};
|
|
|
|
static const WCHAR subkey[] =
|
|
|
|
{'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
|
|
|
|
'N','E','T',' ','F','r','a','m','e','w','o','r','k',' ','S','e','t','u','p','\\','N','D','P',0};
|
|
|
|
static const WCHAR subdir[] =
|
|
|
|
{'M','i','c','r','o','s','o','f','t','.','N','E','T','\\','F','r','a','m','e','w','o','r','k','\\',0};
|
|
|
|
static const WCHAR v2050727[] =
|
|
|
|
{'v','2','.','0','.','5','0','7','2','7',0};
|
|
|
|
static const WCHAR v4client[] =
|
|
|
|
{'v','4','\\','C','l','i','e','n','t',0};
|
|
|
|
static const WCHAR installpath[] =
|
|
|
|
{'I','n','s','t','a','l','l','P','a','t','h',0};
|
|
|
|
HKEY netsetup, hkey;
|
2008-01-16 10:11:22 +00:00
|
|
|
LONG res;
|
2018-03-04 23:30:58 +00:00
|
|
|
DWORD size, len, type;
|
|
|
|
WCHAR windir[MAX_PATH], path[MAX_PATH], *filename = NULL;
|
2008-01-16 10:11:22 +00:00
|
|
|
|
2018-03-04 23:30:58 +00:00
|
|
|
res = RegOpenKeyExW(HKEY_LOCAL_MACHINE, subkey, 0, KEY_CREATE_SUB_KEY, &netsetup);
|
2008-01-16 10:11:22 +00:00
|
|
|
if (res != ERROR_SUCCESS)
|
|
|
|
return NULL;
|
|
|
|
|
2018-03-04 23:30:58 +00:00
|
|
|
if (!RegCreateKeyExW(netsetup, v4client, 0, NULL, 0, KEY_QUERY_VALUE, NULL, &hkey, NULL))
|
2008-01-16 10:11:22 +00:00
|
|
|
{
|
2022-03-12 22:54:36 +00:00
|
|
|
size = ARRAY_SIZE(path);
|
2018-03-04 23:30:58 +00:00
|
|
|
if (!RegQueryValueExW(hkey, installpath, NULL, &type, (BYTE *)path, &size))
|
2009-05-20 12:59:23 +00:00
|
|
|
{
|
2022-03-13 00:35:24 +00:00
|
|
|
len = lstrlenW(path) + lstrlenW(fusion) + 2;
|
2018-03-04 23:30:58 +00:00
|
|
|
if (!(filename = msi_alloc(len * sizeof(WCHAR)))) return NULL;
|
2008-01-16 10:11:22 +00:00
|
|
|
|
2022-03-13 00:35:24 +00:00
|
|
|
lstrcpyW(filename, path);
|
|
|
|
lstrcatW(filename, szBackSlash);
|
|
|
|
lstrcatW(filename, fusion);
|
2018-03-04 23:30:58 +00:00
|
|
|
if (GetFileAttributesW(filename) != INVALID_FILE_ATTRIBUTES)
|
2009-05-20 12:59:23 +00:00
|
|
|
{
|
2018-03-04 23:30:58 +00:00
|
|
|
TRACE( "found %s\n", debugstr_w(filename) );
|
|
|
|
RegCloseKey(hkey);
|
|
|
|
RegCloseKey(netsetup);
|
|
|
|
return filename;
|
2009-05-20 12:59:23 +00:00
|
|
|
}
|
2018-03-04 23:30:58 +00:00
|
|
|
}
|
|
|
|
RegCloseKey(hkey);
|
|
|
|
}
|
2008-01-16 10:11:22 +00:00
|
|
|
|
2018-03-04 23:30:58 +00:00
|
|
|
if (!RegCreateKeyExW(netsetup, v2050727, 0, NULL, 0, KEY_QUERY_VALUE, NULL, &hkey, NULL))
|
|
|
|
{
|
|
|
|
RegCloseKey(hkey);
|
|
|
|
GetWindowsDirectoryW(windir, MAX_PATH);
|
2022-03-13 00:35:24 +00:00
|
|
|
len = lstrlenW(windir) + lstrlenW(subdir) + lstrlenW(v2050727) + lstrlenW(fusion) + 3;
|
2018-03-04 23:30:58 +00:00
|
|
|
if (!(filename = msi_alloc(len * sizeof(WCHAR)))) return NULL;
|
|
|
|
|
2022-03-13 00:35:24 +00:00
|
|
|
lstrcpyW(filename, windir);
|
|
|
|
lstrcatW(filename, szBackSlash);
|
|
|
|
lstrcatW(filename, subdir);
|
|
|
|
lstrcatW(filename, v2050727);
|
|
|
|
lstrcatW(filename, szBackSlash);
|
|
|
|
lstrcatW(filename, fusion);
|
2018-03-04 23:30:58 +00:00
|
|
|
if (GetFileAttributesW(filename) != INVALID_FILE_ATTRIBUTES)
|
|
|
|
{
|
|
|
|
TRACE( "found %s\n", debugstr_w(filename) );
|
|
|
|
RegCloseKey(netsetup);
|
|
|
|
return filename;
|
2009-05-20 12:59:23 +00:00
|
|
|
}
|
|
|
|
}
|
2008-01-16 10:11:22 +00:00
|
|
|
|
2009-05-20 12:59:23 +00:00
|
|
|
RegCloseKey(netsetup);
|
2018-03-04 23:30:58 +00:00
|
|
|
return filename;
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
typedef struct tagLANGANDCODEPAGE
|
|
|
|
{
|
|
|
|
WORD wLanguage;
|
|
|
|
WORD wCodePage;
|
|
|
|
} LANGANDCODEPAGE;
|
|
|
|
|
|
|
|
static void set_msi_assembly_prop(MSIPACKAGE *package)
|
|
|
|
{
|
|
|
|
UINT val_len;
|
|
|
|
DWORD size, handle;
|
|
|
|
LPVOID version = NULL;
|
|
|
|
WCHAR buf[MAX_PATH];
|
|
|
|
LPWSTR fusion, verstr;
|
|
|
|
LANGANDCODEPAGE *translate;
|
|
|
|
|
|
|
|
static const WCHAR netasm[] = {
|
|
|
|
'M','s','i','N','e','t','A','s','s','e','m','b','l','y','S','u','p','p','o','r','t',0
|
|
|
|
};
|
|
|
|
static const WCHAR translation[] = {
|
|
|
|
'\\','V','a','r','F','i','l','e','I','n','f','o',
|
|
|
|
'\\','T','r','a','n','s','l','a','t','i','o','n',0
|
|
|
|
};
|
|
|
|
static const WCHAR verfmt[] = {
|
|
|
|
'\\','S','t','r','i','n','g','F','i','l','e','I','n','f','o',
|
|
|
|
'\\','%','0','4','x','%','0','4','x',
|
|
|
|
'\\','P','r','o','d','u','c','t','V','e','r','s','i','o','n',0
|
|
|
|
};
|
|
|
|
|
|
|
|
fusion = get_fusion_filename(package);
|
|
|
|
if (!fusion)
|
|
|
|
return;
|
|
|
|
|
|
|
|
size = GetFileVersionInfoSizeW(fusion, &handle);
|
2012-12-09 19:43:59 +00:00
|
|
|
if (!size)
|
|
|
|
goto done;
|
2008-01-16 10:11:22 +00:00
|
|
|
|
|
|
|
version = msi_alloc(size);
|
2012-12-09 19:43:59 +00:00
|
|
|
if (!version)
|
|
|
|
goto done;
|
2008-01-16 10:11:22 +00:00
|
|
|
|
|
|
|
if (!GetFileVersionInfoW(fusion, handle, size, version))
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
if (!VerQueryValueW(version, translation, (LPVOID *)&translate, &val_len))
|
|
|
|
goto done;
|
|
|
|
|
2022-03-13 00:35:24 +00:00
|
|
|
swprintf(buf, ARRAY_SIZE(buf), verfmt, translate[0].wLanguage, translate[0].wCodePage);
|
2008-01-16 10:11:22 +00:00
|
|
|
|
|
|
|
if (!VerQueryValueW(version, buf, (LPVOID *)&verstr, &val_len))
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
if (!val_len || !verstr)
|
|
|
|
goto done;
|
|
|
|
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, netasm, verstr, -1 );
|
2008-01-16 10:11:22 +00:00
|
|
|
|
|
|
|
done:
|
|
|
|
msi_free(fusion);
|
|
|
|
msi_free(version);
|
|
|
|
}
|
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
static VOID set_installer_properties(MSIPACKAGE *package)
|
|
|
|
{
|
|
|
|
WCHAR *ptr;
|
2022-03-13 18:08:27 +00:00
|
|
|
RTL_OSVERSIONINFOEXW OSVersion;
|
2006-02-17 00:04:10 +00:00
|
|
|
MEMORYSTATUSEX msex;
|
2022-03-12 14:12:11 +00:00
|
|
|
DWORD verval, len, type;
|
2012-08-13 16:17:18 +00:00
|
|
|
WCHAR pth[MAX_PATH], verstr[11], bufstr[22];
|
2006-02-17 00:04:10 +00:00
|
|
|
HDC dc;
|
2006-10-22 20:23:59 +00:00
|
|
|
HKEY hkey;
|
2008-04-04 13:43:40 +00:00
|
|
|
LPWSTR username, companyname;
|
2008-01-16 10:11:22 +00:00
|
|
|
SYSTEM_INFO sys_info;
|
2008-04-04 13:43:40 +00:00
|
|
|
LANGID langid;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2010-10-22 13:18:11 +00:00
|
|
|
static const WCHAR szCommonFilesFolder[] = {'C','o','m','m','o','n','F','i','l','e','s','F','o','l','d','e','r',0};
|
|
|
|
static const WCHAR szProgramFilesFolder[] = {'P','r','o','g','r','a','m','F','i','l','e','s','F','o','l','d','e','r',0};
|
|
|
|
static const WCHAR szCommonAppDataFolder[] = {'C','o','m','m','o','n','A','p','p','D','a','t','a','F','o','l','d','e','r',0};
|
|
|
|
static const WCHAR szFavoritesFolder[] = {'F','a','v','o','r','i','t','e','s','F','o','l','d','e','r',0};
|
|
|
|
static const WCHAR szFontsFolder[] = {'F','o','n','t','s','F','o','l','d','e','r',0};
|
|
|
|
static const WCHAR szSendToFolder[] = {'S','e','n','d','T','o','F','o','l','d','e','r',0};
|
|
|
|
static const WCHAR szStartMenuFolder[] = {'S','t','a','r','t','M','e','n','u','F','o','l','d','e','r',0};
|
|
|
|
static const WCHAR szStartupFolder[] = {'S','t','a','r','t','u','p','F','o','l','d','e','r',0};
|
|
|
|
static const WCHAR szTemplateFolder[] = {'T','e','m','p','l','a','t','e','F','o','l','d','e','r',0};
|
|
|
|
static const WCHAR szDesktopFolder[] = {'D','e','s','k','t','o','p','F','o','l','d','e','r',0};
|
|
|
|
static const WCHAR szProgramMenuFolder[] = {'P','r','o','g','r','a','m','M','e','n','u','F','o','l','d','e','r',0};
|
|
|
|
static const WCHAR szAdminToolsFolder[] = {'A','d','m','i','n','T','o','o','l','s','F','o','l','d','e','r',0};
|
|
|
|
static const WCHAR szSystemFolder[] = {'S','y','s','t','e','m','F','o','l','d','e','r',0};
|
|
|
|
static const WCHAR szSystem16Folder[] = {'S','y','s','t','e','m','1','6','F','o','l','d','e','r',0};
|
|
|
|
static const WCHAR szLocalAppDataFolder[] = {'L','o','c','a','l','A','p','p','D','a','t','a','F','o','l','d','e','r',0};
|
|
|
|
static const WCHAR szMyPicturesFolder[] = {'M','y','P','i','c','t','u','r','e','s','F','o','l','d','e','r',0};
|
|
|
|
static const WCHAR szPersonalFolder[] = {'P','e','r','s','o','n','a','l','F','o','l','d','e','r',0};
|
|
|
|
static const WCHAR szWindowsVolume[] = {'W','i','n','d','o','w','s','V','o','l','u','m','e',0};
|
|
|
|
static const WCHAR szPrivileged[] = {'P','r','i','v','i','l','e','g','e','d',0};
|
|
|
|
static const WCHAR szVersion9x[] = {'V','e','r','s','i','o','n','9','X',0};
|
|
|
|
static const WCHAR szVersionNT[] = {'V','e','r','s','i','o','n','N','T',0};
|
|
|
|
static const WCHAR szMsiNTProductType[] = {'M','s','i','N','T','P','r','o','d','u','c','t','T','y','p','e',0};
|
2012-08-13 16:17:18 +00:00
|
|
|
static const WCHAR szFormat[] = {'%','u',0};
|
|
|
|
static const WCHAR szFormat2[] = {'%','u','.','%','u',0};
|
2010-10-22 13:18:11 +00:00
|
|
|
static const WCHAR szWindowsBuild[] = {'W','i','n','d','o','w','s','B','u','i','l','d',0};
|
|
|
|
static const WCHAR szServicePackLevel[] = {'S','e','r','v','i','c','e','P','a','c','k','L','e','v','e','l',0};
|
2006-02-17 00:04:10 +00:00
|
|
|
static const WCHAR szVersionMsi[] = { 'V','e','r','s','i','o','n','M','s','i',0 };
|
2008-01-16 10:11:22 +00:00
|
|
|
static const WCHAR szVersionDatabase[] = { 'V','e','r','s','i','o','n','D','a','t','a','b','a','s','e',0 };
|
2006-02-17 00:04:10 +00:00
|
|
|
static const WCHAR szPhysicalMemory[] = { 'P','h','y','s','i','c','a','l','M','e','m','o','r','y',0 };
|
|
|
|
static const WCHAR szScreenX[] = {'S','c','r','e','e','n','X',0};
|
|
|
|
static const WCHAR szScreenY[] = {'S','c','r','e','e','n','Y',0};
|
|
|
|
static const WCHAR szColorBits[] = {'C','o','l','o','r','B','i','t','s',0};
|
2008-04-04 13:43:40 +00:00
|
|
|
static const WCHAR szIntFormat[] = {'%','d',0};
|
2010-10-22 13:18:11 +00:00
|
|
|
static const WCHAR szMsiAMD64[] = { 'M','s','i','A','M','D','6','4',0 };
|
|
|
|
static const WCHAR szMsix64[] = { 'M','s','i','x','6','4',0 };
|
|
|
|
static const WCHAR szSystem64Folder[] = { 'S','y','s','t','e','m','6','4','F','o','l','d','e','r',0 };
|
|
|
|
static const WCHAR szCommonFiles64Folder[] = { 'C','o','m','m','o','n','F','i','l','e','s','6','4','F','o','l','d','e','r',0 };
|
|
|
|
static const WCHAR szProgramFiles64Folder[] = { 'P','r','o','g','r','a','m','F','i','l','e','s','6','4','F','o','l','d','e','r',0 };
|
2022-03-12 14:12:11 +00:00
|
|
|
static const WCHAR szProgramFilesDir[] = {'P','r','o','g','r','a','m','F','i','l','e','s','D','i','r',0};
|
|
|
|
static const WCHAR szProgramFilesDirx86[] = {'P','r','o','g','r','a','m','F','i','l','e','s','D','i','r',' ','(','x','8','6',')',0};
|
|
|
|
static const WCHAR szCommonFilesDir[] = {'C','o','m','m','o','n','F','i','l','e','s','D','i','r',0};
|
|
|
|
static const WCHAR szCommonFilesDirx86[] = {'C','o','m','m','o','n','F','i','l','e','s','D','i','r',' ','(','x','8','6',')',0};
|
2010-10-22 13:18:11 +00:00
|
|
|
static const WCHAR szVersionNT64[] = { 'V','e','r','s','i','o','n','N','T','6','4',0 };
|
2008-04-04 13:43:40 +00:00
|
|
|
static const WCHAR szUserInfo[] = {
|
|
|
|
'S','O','F','T','W','A','R','E','\\',
|
|
|
|
'M','i','c','r','o','s','o','f','t','\\',
|
|
|
|
'M','S',' ','S','e','t','u','p',' ','(','A','C','M','E',')','\\',
|
|
|
|
'U','s','e','r',' ','I','n','f','o',0
|
|
|
|
};
|
|
|
|
static const WCHAR szDefName[] = { 'D','e','f','N','a','m','e',0 };
|
|
|
|
static const WCHAR szDefCompany[] = { 'D','e','f','C','o','m','p','a','n','y',0 };
|
2006-10-22 20:23:59 +00:00
|
|
|
static const WCHAR szCurrentVersion[] = {
|
2022-03-12 14:12:11 +00:00
|
|
|
'S','O','F','T','W','A','R','E','\\',
|
|
|
|
'M','i','c','r','o','s','o','f','t','\\',
|
|
|
|
'W','i','n','d','o','w','s','\\',
|
|
|
|
'C','u','r','r','e','n','t','V','e','r','s','i','o','n',0
|
|
|
|
};
|
|
|
|
static const WCHAR szCurrentVersionNT[] = {
|
2006-10-22 20:23:59 +00:00
|
|
|
'S','O','F','T','W','A','R','E','\\',
|
|
|
|
'M','i','c','r','o','s','o','f','t','\\',
|
|
|
|
'W','i','n','d','o','w','s',' ','N','T','\\',
|
|
|
|
'C','u','r','r','e','n','t','V','e','r','s','i','o','n',0
|
|
|
|
};
|
2022-03-13 00:24:01 +00:00
|
|
|
static const WCHAR szRegisteredOwner[] = {'R','e','g','i','s','t','e','r','e','d','O','w','n','e','r',0};
|
2010-10-22 13:18:11 +00:00
|
|
|
static const WCHAR szRegisteredOrganization[] = {
|
2006-10-22 20:23:59 +00:00
|
|
|
'R','e','g','i','s','t','e','r','e','d','O','r','g','a','n','i','z','a','t','i','o','n',0
|
|
|
|
};
|
|
|
|
static const WCHAR szUSERNAME[] = {'U','S','E','R','N','A','M','E',0};
|
|
|
|
static const WCHAR szCOMPANYNAME[] = {'C','O','M','P','A','N','Y','N','A','M','E',0};
|
2010-10-22 13:18:11 +00:00
|
|
|
static const WCHAR szUserLanguageID[] = {'U','s','e','r','L','a','n','g','u','a','g','e','I','D',0};
|
2009-05-20 12:59:23 +00:00
|
|
|
static const WCHAR szSystemLangID[] = {'S','y','s','t','e','m','L','a','n','g','u','a','g','e','I','D',0};
|
2009-10-17 21:16:57 +00:00
|
|
|
static const WCHAR szProductState[] = {'P','r','o','d','u','c','t','S','t','a','t','e',0};
|
2009-12-06 14:55:00 +00:00
|
|
|
static const WCHAR szLogonUser[] = {'L','o','g','o','n','U','s','e','r',0};
|
2010-10-22 13:18:11 +00:00
|
|
|
static const WCHAR szNetHoodFolder[] = {'N','e','t','H','o','o','d','F','o','l','d','e','r',0};
|
|
|
|
static const WCHAR szPrintHoodFolder[] = {'P','r','i','n','t','H','o','o','d','F','o','l','d','e','r',0};
|
|
|
|
static const WCHAR szRecentFolder[] = {'R','e','c','e','n','t','F','o','l','d','e','r',0};
|
2012-01-21 17:19:12 +00:00
|
|
|
static const WCHAR szComputerName[] = {'C','o','m','p','u','t','e','r','N','a','m','e',0};
|
2006-02-17 00:04:10 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Other things that probably should be set:
|
|
|
|
*
|
2012-01-21 17:19:12 +00:00
|
|
|
* VirtualMemory ShellAdvSupport DefaultUIFont PackagecodeChanging
|
|
|
|
* CaptionHeight BorderTop BorderSide TextHeight RedirectedDllSupport
|
2006-02-17 00:04:10 +00:00
|
|
|
*/
|
|
|
|
|
2010-10-22 13:18:11 +00:00
|
|
|
SHGetFolderPathW(NULL, CSIDL_COMMON_APPDATA, NULL, 0, pth);
|
2022-03-13 00:35:24 +00:00
|
|
|
lstrcatW(pth, szBackSlash);
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szCommonAppDataFolder, pth, -1 );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2010-10-22 13:18:11 +00:00
|
|
|
SHGetFolderPathW(NULL, CSIDL_FAVORITES, NULL, 0, pth);
|
2022-03-13 00:35:24 +00:00
|
|
|
lstrcatW(pth, szBackSlash);
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szFavoritesFolder, pth, -1 );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2010-10-22 13:18:11 +00:00
|
|
|
SHGetFolderPathW(NULL, CSIDL_FONTS, NULL, 0, pth);
|
2022-03-13 00:35:24 +00:00
|
|
|
lstrcatW(pth, szBackSlash);
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szFontsFolder, pth, -1 );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2010-10-22 13:18:11 +00:00
|
|
|
SHGetFolderPathW(NULL, CSIDL_SENDTO, NULL, 0, pth);
|
2022-03-13 00:35:24 +00:00
|
|
|
lstrcatW(pth, szBackSlash);
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szSendToFolder, pth, -1 );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2010-10-22 13:18:11 +00:00
|
|
|
SHGetFolderPathW(NULL, CSIDL_STARTMENU, NULL, 0, pth);
|
2022-03-13 00:35:24 +00:00
|
|
|
lstrcatW(pth, szBackSlash);
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szStartMenuFolder, pth, -1 );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2010-10-22 13:18:11 +00:00
|
|
|
SHGetFolderPathW(NULL, CSIDL_STARTUP, NULL, 0, pth);
|
2022-03-13 00:35:24 +00:00
|
|
|
lstrcatW(pth, szBackSlash);
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szStartupFolder, pth, -1 );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2010-10-22 13:18:11 +00:00
|
|
|
SHGetFolderPathW(NULL, CSIDL_TEMPLATES, NULL, 0, pth);
|
2022-03-13 00:35:24 +00:00
|
|
|
lstrcatW(pth, szBackSlash);
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szTemplateFolder, pth, -1 );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2010-10-22 13:18:11 +00:00
|
|
|
SHGetFolderPathW(NULL, CSIDL_DESKTOP, NULL, 0, pth);
|
2022-03-13 00:35:24 +00:00
|
|
|
lstrcatW(pth, szBackSlash);
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szDesktopFolder, pth, -1 );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2010-10-22 13:18:11 +00:00
|
|
|
/* FIXME: set to AllUsers profile path if ALLUSERS is set */
|
|
|
|
SHGetFolderPathW(NULL, CSIDL_PROGRAMS, NULL, 0, pth);
|
2022-03-13 00:35:24 +00:00
|
|
|
lstrcatW(pth, szBackSlash);
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szProgramMenuFolder, pth, -1 );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2010-10-22 13:18:11 +00:00
|
|
|
SHGetFolderPathW(NULL, CSIDL_ADMINTOOLS, NULL, 0, pth);
|
2022-03-13 00:35:24 +00:00
|
|
|
lstrcatW(pth, szBackSlash);
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szAdminToolsFolder, pth, -1 );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2010-10-22 13:18:11 +00:00
|
|
|
SHGetFolderPathW(NULL, CSIDL_APPDATA, NULL, 0, pth);
|
2022-03-13 00:35:24 +00:00
|
|
|
lstrcatW(pth, szBackSlash);
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szAppDataFolder, pth, -1 );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2010-10-22 13:18:11 +00:00
|
|
|
SHGetFolderPathW(NULL, CSIDL_SYSTEM, NULL, 0, pth);
|
2022-03-13 00:35:24 +00:00
|
|
|
lstrcatW(pth, szBackSlash);
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szSystemFolder, pth, -1 );
|
|
|
|
msi_set_property( package->db, szSystem16Folder, pth, -1 );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2010-10-22 13:18:11 +00:00
|
|
|
SHGetFolderPathW(NULL, CSIDL_LOCAL_APPDATA, NULL, 0, pth);
|
2022-03-13 00:35:24 +00:00
|
|
|
lstrcatW(pth, szBackSlash);
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szLocalAppDataFolder, pth, -1 );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2010-10-22 13:18:11 +00:00
|
|
|
SHGetFolderPathW(NULL, CSIDL_MYPICTURES, NULL, 0, pth);
|
2022-03-13 00:35:24 +00:00
|
|
|
lstrcatW(pth, szBackSlash);
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szMyPicturesFolder, pth, -1 );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2010-10-22 13:18:11 +00:00
|
|
|
SHGetFolderPathW(NULL, CSIDL_PERSONAL, NULL, 0, pth);
|
2022-03-13 00:35:24 +00:00
|
|
|
lstrcatW(pth, szBackSlash);
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szPersonalFolder, pth, -1 );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2010-10-22 13:18:11 +00:00
|
|
|
SHGetFolderPathW(NULL, CSIDL_WINDOWS, NULL, 0, pth);
|
2022-03-13 00:35:24 +00:00
|
|
|
lstrcatW(pth, szBackSlash);
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szWindowsFolder, pth, -1 );
|
2010-10-22 13:18:11 +00:00
|
|
|
|
|
|
|
SHGetFolderPathW(NULL, CSIDL_PRINTHOOD, NULL, 0, pth);
|
2022-03-13 00:35:24 +00:00
|
|
|
lstrcatW(pth, szBackSlash);
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szPrintHoodFolder, pth, -1 );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2010-10-22 13:18:11 +00:00
|
|
|
SHGetFolderPathW(NULL, CSIDL_NETHOOD, NULL, 0, pth);
|
2022-03-13 00:35:24 +00:00
|
|
|
lstrcatW(pth, szBackSlash);
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szNetHoodFolder, pth, -1 );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2010-10-22 13:18:11 +00:00
|
|
|
SHGetFolderPathW(NULL, CSIDL_RECENT, NULL, 0, pth);
|
2022-03-13 00:35:24 +00:00
|
|
|
lstrcatW(pth, szBackSlash);
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szRecentFolder, pth, -1 );
|
2010-10-22 13:18:11 +00:00
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
/* Physical Memory is specified in MB. Using total amount. */
|
|
|
|
msex.dwLength = sizeof(msex);
|
|
|
|
GlobalMemoryStatusEx( &msex );
|
2022-03-13 00:35:24 +00:00
|
|
|
len = swprintf( bufstr, ARRAY_SIZE(bufstr), szIntFormat, (int)(msex.ullTotalPhys / 1024 / 1024) );
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szPhysicalMemory, bufstr, len );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2010-10-22 13:18:11 +00:00
|
|
|
SHGetFolderPathW(NULL, CSIDL_WINDOWS, NULL, 0, pth);
|
2022-03-13 00:35:24 +00:00
|
|
|
ptr = wcschr(pth,'\\');
|
2010-10-22 13:18:11 +00:00
|
|
|
if (ptr) *(ptr + 1) = 0;
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szWindowsVolume, pth, -1 );
|
2008-01-16 10:11:22 +00:00
|
|
|
|
2012-12-09 19:43:59 +00:00
|
|
|
len = GetTempPathW(MAX_PATH, pth);
|
|
|
|
msi_set_property( package->db, szTempFolder, pth, len );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
|
|
|
/* in a wine environment the user is always admin and privileged */
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szAdminUser, szOne, -1 );
|
|
|
|
msi_set_property( package->db, szPrivileged, szOne, -1 );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
|
|
|
/* set the os things */
|
2022-03-13 18:08:27 +00:00
|
|
|
OSVersion.dwOSVersionInfoSize = sizeof(OSVersion);
|
|
|
|
RtlGetVersion((PRTL_OSVERSIONINFOW)&OSVersion);
|
2010-10-22 13:18:11 +00:00
|
|
|
verval = OSVersion.dwMinorVersion + OSVersion.dwMajorVersion * 100;
|
2022-03-13 18:08:27 +00:00
|
|
|
if (verval > 603)
|
|
|
|
{
|
|
|
|
verval = 603;
|
|
|
|
OSVersion.dwBuildNumber = 9600;
|
|
|
|
}
|
2022-03-13 00:35:24 +00:00
|
|
|
len = swprintf( verstr, ARRAY_SIZE(verstr), szFormat, verval );
|
2006-02-17 00:04:10 +00:00
|
|
|
switch (OSVersion.dwPlatformId)
|
|
|
|
{
|
2008-01-16 10:11:22 +00:00
|
|
|
case VER_PLATFORM_WIN32_WINDOWS:
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szVersion9x, verstr, len );
|
2006-02-17 00:04:10 +00:00
|
|
|
break;
|
|
|
|
case VER_PLATFORM_WIN32_NT:
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szVersionNT, verstr, len );
|
2022-03-13 00:35:24 +00:00
|
|
|
len = swprintf( bufstr, ARRAY_SIZE(bufstr), szFormat,OSVersion.wProductType );
|
2013-09-22 16:30:18 +00:00
|
|
|
msi_set_property( package->db, szMsiNTProductType, bufstr, len );
|
2006-02-17 00:04:10 +00:00
|
|
|
break;
|
|
|
|
}
|
2022-03-13 00:35:24 +00:00
|
|
|
len = swprintf( bufstr, ARRAY_SIZE(bufstr), szFormat, OSVersion.dwBuildNumber );
|
2013-09-22 16:30:18 +00:00
|
|
|
msi_set_property( package->db, szWindowsBuild, bufstr, len );
|
2022-03-13 00:35:24 +00:00
|
|
|
len = swprintf( bufstr, ARRAY_SIZE(bufstr), szFormat, OSVersion.wServicePackMajor );
|
2013-09-22 16:30:18 +00:00
|
|
|
msi_set_property( package->db, szServicePackLevel, bufstr, len );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2022-03-13 00:35:24 +00:00
|
|
|
len = swprintf( bufstr, ARRAY_SIZE(bufstr), szFormat2, MSI_MAJORVERSION, MSI_MINORVERSION );
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szVersionMsi, bufstr, len );
|
2022-03-13 00:35:24 +00:00
|
|
|
len = swprintf( bufstr, ARRAY_SIZE(bufstr), szFormat, MSI_MAJORVERSION * 100 );
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szVersionDatabase, bufstr, len );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2022-03-12 14:12:11 +00:00
|
|
|
RegOpenKeyExW(HKEY_LOCAL_MACHINE, szCurrentVersion, 0,
|
|
|
|
KEY_QUERY_VALUE | KEY_WOW64_64KEY, &hkey);
|
|
|
|
|
2010-10-22 13:18:11 +00:00
|
|
|
GetNativeSystemInfo( &sys_info );
|
2022-03-13 00:35:24 +00:00
|
|
|
len = swprintf( bufstr, ARRAY_SIZE(bufstr), szIntFormat, sys_info.wProcessorLevel );
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szIntel, bufstr, len );
|
2006-02-17 00:04:10 +00:00
|
|
|
if (sys_info.u.s.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL)
|
|
|
|
{
|
2010-10-22 13:18:11 +00:00
|
|
|
GetSystemDirectoryW( pth, MAX_PATH );
|
|
|
|
PathAddBackslashW( pth );
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szSystemFolder, pth, -1 );
|
2010-10-22 13:18:11 +00:00
|
|
|
|
2022-03-12 14:12:11 +00:00
|
|
|
len = MAX_PATH;
|
|
|
|
RegQueryValueExW(hkey, szProgramFilesDir, 0, &type, (BYTE *)pth, &len);
|
2010-10-22 13:18:11 +00:00
|
|
|
PathAddBackslashW( pth );
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szProgramFilesFolder, pth, -1 );
|
2010-10-22 13:18:11 +00:00
|
|
|
|
2022-03-12 14:12:11 +00:00
|
|
|
len = MAX_PATH;
|
|
|
|
RegQueryValueExW(hkey, szCommonFilesDir, 0, &type, (BYTE *)pth, &len);
|
2010-10-22 13:18:11 +00:00
|
|
|
PathAddBackslashW( pth );
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szCommonFilesFolder, pth, -1 );
|
2010-10-22 13:18:11 +00:00
|
|
|
}
|
|
|
|
else if (sys_info.u.s.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
|
|
|
|
{
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szMsiAMD64, bufstr, -1 );
|
|
|
|
msi_set_property( package->db, szMsix64, bufstr, -1 );
|
|
|
|
msi_set_property( package->db, szVersionNT64, verstr, -1 );
|
2010-10-22 13:18:11 +00:00
|
|
|
|
|
|
|
GetSystemDirectoryW( pth, MAX_PATH );
|
|
|
|
PathAddBackslashW( pth );
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szSystem64Folder, pth, -1 );
|
2010-10-22 13:18:11 +00:00
|
|
|
|
|
|
|
GetSystemWow64DirectoryW( pth, MAX_PATH );
|
|
|
|
PathAddBackslashW( pth );
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szSystemFolder, pth, -1 );
|
2010-10-22 13:18:11 +00:00
|
|
|
|
2022-03-12 14:12:11 +00:00
|
|
|
len = MAX_PATH;
|
|
|
|
RegQueryValueExW(hkey, szProgramFilesDir, 0, &type, (BYTE *)pth, &len);
|
2010-10-22 13:18:11 +00:00
|
|
|
PathAddBackslashW( pth );
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szProgramFiles64Folder, pth, -1 );
|
2010-10-22 13:18:11 +00:00
|
|
|
|
2022-03-12 14:12:11 +00:00
|
|
|
len = MAX_PATH;
|
|
|
|
RegQueryValueExW(hkey, szProgramFilesDirx86, 0, &type, (BYTE *)pth, &len);
|
2010-10-22 13:18:11 +00:00
|
|
|
PathAddBackslashW( pth );
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szProgramFilesFolder, pth, -1 );
|
2010-10-22 13:18:11 +00:00
|
|
|
|
2022-03-12 14:12:11 +00:00
|
|
|
len = MAX_PATH;
|
|
|
|
RegQueryValueExW(hkey, szCommonFilesDir, 0, &type, (BYTE *)pth, &len);
|
2010-10-22 13:18:11 +00:00
|
|
|
PathAddBackslashW( pth );
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szCommonFiles64Folder, pth, -1 );
|
2010-10-22 13:18:11 +00:00
|
|
|
|
2022-03-12 14:12:11 +00:00
|
|
|
len = MAX_PATH;
|
|
|
|
RegQueryValueExW(hkey, szCommonFilesDirx86, 0, &type, (BYTE *)pth, &len);
|
2010-10-22 13:18:11 +00:00
|
|
|
PathAddBackslashW( pth );
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szCommonFilesFolder, pth, -1 );
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
2022-03-12 14:12:11 +00:00
|
|
|
RegCloseKey(hkey);
|
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
/* Screen properties. */
|
|
|
|
dc = GetDC(0);
|
2022-03-13 00:35:24 +00:00
|
|
|
len = swprintf( bufstr, ARRAY_SIZE(bufstr), szIntFormat, GetDeviceCaps(dc, HORZRES) );
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szScreenX, bufstr, len );
|
2022-03-13 00:35:24 +00:00
|
|
|
len = swprintf( bufstr, ARRAY_SIZE(bufstr), szIntFormat, GetDeviceCaps(dc, VERTRES) );
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szScreenY, bufstr, len );
|
2022-03-13 00:35:24 +00:00
|
|
|
len = swprintf( bufstr, ARRAY_SIZE(bufstr), szIntFormat, GetDeviceCaps(dc, BITSPIXEL) );
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szColorBits, bufstr, len );
|
2006-02-17 00:04:10 +00:00
|
|
|
ReleaseDC(0, dc);
|
2006-10-22 20:23:59 +00:00
|
|
|
|
|
|
|
/* USERNAME and COMPANYNAME */
|
2010-05-29 08:55:43 +00:00
|
|
|
username = msi_dup_property( package->db, szUSERNAME );
|
|
|
|
companyname = msi_dup_property( package->db, szCOMPANYNAME );
|
2006-10-22 20:23:59 +00:00
|
|
|
|
2008-04-04 13:43:40 +00:00
|
|
|
if ((!username || !companyname) &&
|
|
|
|
RegOpenKeyW( HKEY_CURRENT_USER, szUserInfo, &hkey ) == ERROR_SUCCESS)
|
2006-10-22 20:23:59 +00:00
|
|
|
{
|
2008-04-04 13:43:40 +00:00
|
|
|
if (!username &&
|
|
|
|
(username = msi_reg_get_val_str( hkey, szDefName )))
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szUSERNAME, username, -1 );
|
2008-04-04 13:43:40 +00:00
|
|
|
if (!companyname &&
|
|
|
|
(companyname = msi_reg_get_val_str( hkey, szDefCompany )))
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szCOMPANYNAME, companyname, -1 );
|
2008-04-04 13:43:40 +00:00
|
|
|
CloseHandle( hkey );
|
2006-10-22 20:23:59 +00:00
|
|
|
}
|
2008-04-04 13:43:40 +00:00
|
|
|
if ((!username || !companyname) &&
|
2022-03-13 00:24:01 +00:00
|
|
|
RegOpenKeyExW( HKEY_LOCAL_MACHINE, szCurrentVersionNT, 0, KEY_QUERY_VALUE|KEY_WOW64_64KEY,
|
|
|
|
&hkey ) == ERROR_SUCCESS)
|
2006-10-22 20:23:59 +00:00
|
|
|
{
|
2008-04-04 13:43:40 +00:00
|
|
|
if (!username &&
|
2022-03-13 00:24:01 +00:00
|
|
|
(username = msi_reg_get_val_str( hkey, szRegisteredOwner )))
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szUSERNAME, username, -1 );
|
2008-04-04 13:43:40 +00:00
|
|
|
if (!companyname &&
|
2010-10-22 13:18:11 +00:00
|
|
|
(companyname = msi_reg_get_val_str( hkey, szRegisteredOrganization )))
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szCOMPANYNAME, companyname, -1 );
|
2008-04-04 13:43:40 +00:00
|
|
|
CloseHandle( hkey );
|
2006-10-22 20:23:59 +00:00
|
|
|
}
|
2008-04-04 13:43:40 +00:00
|
|
|
msi_free( username );
|
|
|
|
msi_free( companyname );
|
2006-10-22 20:23:59 +00:00
|
|
|
|
2008-01-16 10:11:22 +00:00
|
|
|
if ( set_user_sid_prop( package ) != ERROR_SUCCESS)
|
|
|
|
ERR("Failed to set the UserSID property\n");
|
|
|
|
|
|
|
|
set_msi_assembly_prop( package );
|
|
|
|
|
2008-04-04 13:43:40 +00:00
|
|
|
langid = GetUserDefaultLangID();
|
2022-03-13 00:35:24 +00:00
|
|
|
len = swprintf( bufstr, ARRAY_SIZE(bufstr), szIntFormat, langid );
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szUserLanguageID, bufstr, len );
|
2009-05-20 12:59:23 +00:00
|
|
|
|
|
|
|
langid = GetSystemDefaultLangID();
|
2022-03-13 00:35:24 +00:00
|
|
|
len = swprintf( bufstr, ARRAY_SIZE(bufstr), szIntFormat, langid );
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szSystemLangID, bufstr, len );
|
2009-10-17 21:16:57 +00:00
|
|
|
|
2022-03-13 00:35:24 +00:00
|
|
|
len = swprintf( bufstr, ARRAY_SIZE(bufstr), szIntFormat, MsiQueryProductStateW(package->ProductCode) );
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szProductState, bufstr, len );
|
2009-12-06 14:55:00 +00:00
|
|
|
|
|
|
|
len = 0;
|
2012-01-21 17:19:12 +00:00
|
|
|
if (!GetUserNameW( NULL, &len ) && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
|
2009-12-06 14:55:00 +00:00
|
|
|
{
|
|
|
|
WCHAR *username;
|
2010-05-29 08:55:43 +00:00
|
|
|
if ((username = msi_alloc( len * sizeof(WCHAR) )))
|
2009-12-06 14:55:00 +00:00
|
|
|
{
|
|
|
|
if (GetUserNameW( username, &len ))
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szLogonUser, username, len - 1 );
|
2010-05-29 08:55:43 +00:00
|
|
|
msi_free( username );
|
2009-12-06 14:55:00 +00:00
|
|
|
}
|
|
|
|
}
|
2012-01-21 17:19:12 +00:00
|
|
|
len = 0;
|
|
|
|
if (!GetComputerNameW( NULL, &len ) && GetLastError() == ERROR_BUFFER_OVERFLOW)
|
|
|
|
{
|
|
|
|
WCHAR *computername;
|
|
|
|
if ((computername = msi_alloc( len * sizeof(WCHAR) )))
|
|
|
|
{
|
|
|
|
if (GetComputerNameW( computername, &len ))
|
2013-09-22 16:30:18 +00:00
|
|
|
msi_set_property( package->db, szComputerName, computername, len );
|
2012-01-21 17:19:12 +00:00
|
|
|
msi_free( computername );
|
|
|
|
}
|
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
2008-01-16 10:11:22 +00:00
|
|
|
static MSIPACKAGE *msi_alloc_package( void )
|
2006-02-17 00:04:10 +00:00
|
|
|
{
|
2008-01-16 10:11:22 +00:00
|
|
|
MSIPACKAGE *package;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
|
|
|
package = alloc_msiobject( MSIHANDLETYPE_PACKAGE, sizeof (MSIPACKAGE),
|
|
|
|
MSI_FreePackage );
|
|
|
|
if( package )
|
|
|
|
{
|
|
|
|
list_init( &package->components );
|
|
|
|
list_init( &package->features );
|
|
|
|
list_init( &package->files );
|
2012-01-21 17:19:12 +00:00
|
|
|
list_init( &package->filepatches );
|
2006-02-17 00:04:10 +00:00
|
|
|
list_init( &package->tempfiles );
|
|
|
|
list_init( &package->folders );
|
|
|
|
list_init( &package->subscriptions );
|
|
|
|
list_init( &package->appids );
|
|
|
|
list_init( &package->classes );
|
|
|
|
list_init( &package->mimes );
|
|
|
|
list_init( &package->extensions );
|
|
|
|
list_init( &package->progids );
|
|
|
|
list_init( &package->RunningActions );
|
2008-01-16 10:11:22 +00:00
|
|
|
list_init( &package->sourcelist_info );
|
|
|
|
list_init( &package->sourcelist_media );
|
2010-05-29 08:55:43 +00:00
|
|
|
list_init( &package->patches );
|
2011-03-20 08:47:41 +00:00
|
|
|
list_init( &package->binaries );
|
2012-01-21 17:19:12 +00:00
|
|
|
list_init( &package->cabinet_streams );
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return package;
|
|
|
|
}
|
|
|
|
|
|
|
|
static UINT msi_load_admin_properties(MSIPACKAGE *package)
|
|
|
|
{
|
|
|
|
BYTE *data;
|
|
|
|
UINT r, sz;
|
|
|
|
|
|
|
|
static const WCHAR stmname[] = {'A','d','m','i','n','P','r','o','p','e','r','t','i','e','s',0};
|
2006-08-30 19:24:26 +00:00
|
|
|
|
2008-01-16 10:11:22 +00:00
|
|
|
r = read_stream_data(package->db->storage, stmname, FALSE, &data, &sz);
|
|
|
|
if (r != ERROR_SUCCESS)
|
|
|
|
return r;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2008-12-27 15:10:14 +00:00
|
|
|
r = msi_parse_command_line(package, (WCHAR *)data, TRUE);
|
2006-08-30 19:24:26 +00:00
|
|
|
|
2008-01-16 10:11:22 +00:00
|
|
|
msi_free(data);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2010-10-22 13:18:11 +00:00
|
|
|
void msi_adjust_privilege_properties( MSIPACKAGE *package )
|
2009-12-22 09:28:03 +00:00
|
|
|
{
|
|
|
|
/* FIXME: this should depend on the user's privileges */
|
2010-05-29 08:55:43 +00:00
|
|
|
if (msi_get_property_int( package->db, szAllUsers, 0 ) == 2)
|
2009-12-22 09:28:03 +00:00
|
|
|
{
|
|
|
|
TRACE("resetting ALLUSERS property from 2 to 1\n");
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szAllUsers, szOne, -1 );
|
2009-12-22 09:28:03 +00:00
|
|
|
}
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szAdminUser, szOne, -1 );
|
2009-12-22 09:28:03 +00:00
|
|
|
}
|
|
|
|
|
2022-03-12 14:11:49 +00:00
|
|
|
MSIPACKAGE *MSI_CreatePackage( MSIDATABASE *db )
|
2008-01-16 10:11:22 +00:00
|
|
|
{
|
2012-05-14 21:41:31 +00:00
|
|
|
static const WCHAR fmtW[] = {'%','u',0};
|
2008-01-16 10:11:22 +00:00
|
|
|
MSIPACKAGE *package;
|
2012-05-14 21:41:31 +00:00
|
|
|
WCHAR uilevel[11];
|
2012-12-09 19:43:59 +00:00
|
|
|
int len;
|
2008-01-16 10:11:22 +00:00
|
|
|
UINT r;
|
|
|
|
|
|
|
|
TRACE("%p\n", db);
|
|
|
|
|
|
|
|
package = msi_alloc_package();
|
|
|
|
if (package)
|
|
|
|
{
|
|
|
|
msiobj_addref( &db->hdr );
|
|
|
|
package->db = db;
|
|
|
|
|
2017-10-08 08:14:40 +00:00
|
|
|
package->LastAction = NULL;
|
|
|
|
package->LastActionTemplate = NULL;
|
|
|
|
package->LastActionResult = MSI_NULL_INTEGER;
|
2008-01-16 10:11:22 +00:00
|
|
|
package->WordCount = 0;
|
|
|
|
package->PackagePath = strdupW( db->path );
|
|
|
|
|
|
|
|
create_temp_property_table( package );
|
2015-03-09 20:28:19 +00:00
|
|
|
msi_clone_properties( package->db );
|
2010-10-22 13:18:11 +00:00
|
|
|
msi_adjust_privilege_properties( package );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2010-05-29 08:55:43 +00:00
|
|
|
package->ProductCode = msi_dup_property( package->db, szProductCode );
|
|
|
|
|
2009-10-17 21:16:57 +00:00
|
|
|
set_installer_properties( package );
|
|
|
|
|
2012-05-14 21:41:31 +00:00
|
|
|
package->ui_level = gUILevel;
|
2022-03-13 00:35:24 +00:00
|
|
|
len = swprintf( uilevel, ARRAY_SIZE(uilevel), fmtW, gUILevel & INSTALLUILEVEL_MASK );
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szUILevel, uilevel, len );
|
2009-10-17 21:16:57 +00:00
|
|
|
|
2015-07-19 23:04:25 +00:00
|
|
|
r = msi_load_suminfo_properties( package );
|
2008-01-16 10:11:22 +00:00
|
|
|
if (r != ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
msiobj_release( &package->hdr );
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-09-21 15:24:30 +00:00
|
|
|
if (package->WordCount & msidbSumInfoSourceTypeAdminImage)
|
2008-01-16 10:11:22 +00:00
|
|
|
msi_load_admin_properties( package );
|
2011-03-20 08:47:41 +00:00
|
|
|
|
|
|
|
package->log_file = INVALID_HANDLE_VALUE;
|
2022-03-12 15:34:06 +00:00
|
|
|
package->script = SCRIPT_NONE;
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
return package;
|
|
|
|
}
|
|
|
|
|
2009-12-22 09:28:03 +00:00
|
|
|
UINT msi_download_file( LPCWSTR szUrl, LPWSTR filename )
|
2006-08-01 23:12:11 +00:00
|
|
|
{
|
|
|
|
LPINTERNET_CACHE_ENTRY_INFOW cache_entry;
|
|
|
|
DWORD size = 0;
|
|
|
|
HRESULT hr;
|
|
|
|
|
2012-01-21 17:19:12 +00:00
|
|
|
/* call will always fail, because size is 0,
|
2006-08-01 23:12:11 +00:00
|
|
|
* but will return ERROR_FILE_NOT_FOUND first
|
|
|
|
* if the file doesn't exist
|
|
|
|
*/
|
|
|
|
GetUrlCacheEntryInfoW( szUrl, NULL, &size );
|
|
|
|
if ( GetLastError() != ERROR_FILE_NOT_FOUND )
|
|
|
|
{
|
2010-05-29 08:55:43 +00:00
|
|
|
cache_entry = msi_alloc( size );
|
2006-08-01 23:12:11 +00:00
|
|
|
if ( !GetUrlCacheEntryInfoW( szUrl, cache_entry, &size ) )
|
|
|
|
{
|
2009-12-22 09:28:03 +00:00
|
|
|
UINT error = GetLastError();
|
2010-05-29 08:55:43 +00:00
|
|
|
msi_free( cache_entry );
|
2009-12-22 09:28:03 +00:00
|
|
|
return error;
|
2006-08-01 23:12:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
lstrcpyW( filename, cache_entry->lpszLocalFileName );
|
2010-05-29 08:55:43 +00:00
|
|
|
msi_free( cache_entry );
|
2009-12-22 09:28:03 +00:00
|
|
|
return ERROR_SUCCESS;
|
2006-08-01 23:12:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
hr = URLDownloadToCacheFileW( NULL, szUrl, filename, MAX_PATH, 0, NULL );
|
|
|
|
if ( FAILED(hr) )
|
2009-12-22 09:28:03 +00:00
|
|
|
{
|
|
|
|
WARN("failed to download %s to cache file\n", debugstr_w(szUrl));
|
|
|
|
return ERROR_FUNCTION_FAILED;
|
|
|
|
}
|
2006-08-01 23:12:11 +00:00
|
|
|
|
2009-12-22 09:28:03 +00:00
|
|
|
return ERROR_SUCCESS;
|
2006-08-01 23:12:11 +00:00
|
|
|
}
|
|
|
|
|
2012-01-21 17:19:12 +00:00
|
|
|
UINT msi_create_empty_local_file( LPWSTR path, LPCWSTR suffix )
|
2009-10-25 11:06:09 +00:00
|
|
|
{
|
|
|
|
static const WCHAR szInstaller[] = {
|
|
|
|
'\\','I','n','s','t','a','l','l','e','r','\\',0};
|
2010-05-29 08:55:43 +00:00
|
|
|
static const WCHAR fmt[] = {'%','x',0};
|
|
|
|
DWORD time, len, i, offset;
|
2009-10-25 11:06:09 +00:00
|
|
|
HANDLE handle;
|
|
|
|
|
|
|
|
time = GetTickCount();
|
|
|
|
GetWindowsDirectoryW( path, MAX_PATH );
|
2022-03-13 00:35:24 +00:00
|
|
|
lstrcatW( path, szInstaller );
|
2009-10-25 11:06:09 +00:00
|
|
|
CreateDirectoryW( path, NULL );
|
|
|
|
|
2022-03-13 00:35:24 +00:00
|
|
|
len = lstrlenW(path);
|
2009-10-25 11:06:09 +00:00
|
|
|
for (i = 0; i < 0x10000; i++)
|
|
|
|
{
|
2022-03-13 00:35:24 +00:00
|
|
|
offset = swprintf( path + len, MAX_PATH - len, fmt, (time + i) & 0xffff );
|
|
|
|
memcpy( path + len + offset, suffix, (lstrlenW( suffix ) + 1) * sizeof(WCHAR) );
|
2009-10-25 11:06:09 +00:00
|
|
|
handle = CreateFileW( path, GENERIC_WRITE, 0, NULL,
|
|
|
|
CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0 );
|
|
|
|
if (handle != INVALID_HANDLE_VALUE)
|
|
|
|
{
|
|
|
|
CloseHandle(handle);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (GetLastError() != ERROR_FILE_EXISTS &&
|
|
|
|
GetLastError() != ERROR_SHARING_VIOLATION)
|
|
|
|
return ERROR_FUNCTION_FAILED;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ERROR_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2016-11-22 12:25:27 +00:00
|
|
|
static enum platform parse_platform( const WCHAR *str )
|
2013-04-03 21:58:03 +00:00
|
|
|
{
|
2022-03-13 00:35:24 +00:00
|
|
|
if (!str[0] || !wcscmp( str, szIntel )) return PLATFORM_INTEL;
|
|
|
|
else if (!wcscmp( str, szIntel64 )) return PLATFORM_INTEL64;
|
|
|
|
else if (!wcscmp( str, szX64 ) || !wcscmp( str, szAMD64 )) return PLATFORM_X64;
|
|
|
|
else if (!wcscmp( str, szARM )) return PLATFORM_ARM;
|
|
|
|
else if (!wcscmp( str, szARM64 )) return PLATFORM_ARM64;
|
2022-03-13 18:08:14 +00:00
|
|
|
return PLATFORM_UNRECOGNIZED;
|
2013-04-03 21:58:03 +00:00
|
|
|
}
|
|
|
|
|
2015-07-19 23:04:25 +00:00
|
|
|
static UINT parse_suminfo( MSISUMMARYINFO *si, MSIPACKAGE *package )
|
2010-10-22 13:18:11 +00:00
|
|
|
{
|
2013-04-03 21:58:03 +00:00
|
|
|
WCHAR *template, *p, *q, *platform;
|
2010-10-22 13:18:11 +00:00
|
|
|
DWORD i, count;
|
|
|
|
|
|
|
|
package->version = msi_suminfo_get_int32( si, PID_PAGECOUNT );
|
|
|
|
TRACE("version: %d\n", package->version);
|
|
|
|
|
|
|
|
template = msi_suminfo_dup_string( si, PID_TEMPLATE );
|
|
|
|
if (!template)
|
|
|
|
return ERROR_SUCCESS; /* native accepts missing template property */
|
|
|
|
|
|
|
|
TRACE("template: %s\n", debugstr_w(template));
|
|
|
|
|
2022-03-13 00:35:24 +00:00
|
|
|
p = wcschr( template, ';' );
|
2010-10-22 13:18:11 +00:00
|
|
|
if (!p)
|
|
|
|
{
|
|
|
|
WARN("invalid template string %s\n", debugstr_w(template));
|
|
|
|
msi_free( template );
|
|
|
|
return ERROR_PATCH_PACKAGE_INVALID;
|
|
|
|
}
|
|
|
|
*p = 0;
|
2013-04-03 21:58:03 +00:00
|
|
|
platform = template;
|
2022-03-13 00:35:24 +00:00
|
|
|
if ((q = wcschr( platform, ',' ))) *q = 0;
|
2013-04-03 21:58:03 +00:00
|
|
|
package->platform = parse_platform( platform );
|
2022-03-13 18:08:14 +00:00
|
|
|
while (package->platform == PLATFORM_UNRECOGNIZED && q)
|
2013-04-03 21:58:03 +00:00
|
|
|
{
|
|
|
|
platform = q + 1;
|
2022-03-13 00:35:24 +00:00
|
|
|
if ((q = wcschr( platform, ',' ))) *q = 0;
|
2013-04-03 21:58:03 +00:00
|
|
|
package->platform = parse_platform( platform );
|
|
|
|
}
|
2022-03-13 18:08:14 +00:00
|
|
|
if (package->platform == PLATFORM_UNRECOGNIZED)
|
2010-10-22 13:18:11 +00:00
|
|
|
{
|
|
|
|
WARN("unknown platform %s\n", debugstr_w(template));
|
|
|
|
msi_free( template );
|
|
|
|
return ERROR_INSTALL_PLATFORM_UNSUPPORTED;
|
|
|
|
}
|
2011-03-20 08:47:41 +00:00
|
|
|
p++;
|
|
|
|
if (!*p)
|
|
|
|
{
|
|
|
|
msi_free( template );
|
|
|
|
return ERROR_SUCCESS;
|
|
|
|
}
|
2010-10-22 13:18:11 +00:00
|
|
|
count = 1;
|
2022-03-13 00:35:24 +00:00
|
|
|
for (q = p; (q = wcschr( q, ',' )); q++) count++;
|
2010-10-22 13:18:11 +00:00
|
|
|
|
|
|
|
package->langids = msi_alloc( count * sizeof(LANGID) );
|
|
|
|
if (!package->langids)
|
|
|
|
{
|
|
|
|
msi_free( template );
|
|
|
|
return ERROR_OUTOFMEMORY;
|
|
|
|
}
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
while (*p)
|
|
|
|
{
|
2022-03-13 00:35:24 +00:00
|
|
|
q = wcschr( p, ',' );
|
2010-10-22 13:18:11 +00:00
|
|
|
if (q) *q = 0;
|
2022-03-13 00:35:24 +00:00
|
|
|
package->langids[i] = wcstol( p, NULL, 10 );
|
2010-10-22 13:18:11 +00:00
|
|
|
if (!q) break;
|
|
|
|
p = q + 1;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
package->num_langids = i + 1;
|
|
|
|
|
|
|
|
msi_free( template );
|
|
|
|
return ERROR_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
static UINT validate_package( MSIPACKAGE *package )
|
|
|
|
{
|
|
|
|
UINT i;
|
|
|
|
|
2012-01-21 17:19:12 +00:00
|
|
|
if (package->platform == PLATFORM_INTEL64)
|
|
|
|
return ERROR_INSTALL_PLATFORM_UNSUPPORTED;
|
2012-05-14 21:41:31 +00:00
|
|
|
#ifndef __arm__
|
|
|
|
if (package->platform == PLATFORM_ARM)
|
|
|
|
return ERROR_INSTALL_PLATFORM_UNSUPPORTED;
|
2022-03-12 23:16:15 +00:00
|
|
|
#endif
|
|
|
|
#ifndef __aarch64__
|
|
|
|
if (package->platform == PLATFORM_ARM64)
|
|
|
|
return ERROR_INSTALL_PLATFORM_UNSUPPORTED;
|
2012-05-14 21:41:31 +00:00
|
|
|
#endif
|
2010-10-22 13:18:11 +00:00
|
|
|
if (package->platform == PLATFORM_X64)
|
|
|
|
{
|
|
|
|
if (!is_64bit && !is_wow64)
|
|
|
|
return ERROR_INSTALL_PLATFORM_UNSUPPORTED;
|
|
|
|
if (package->version < 200)
|
|
|
|
return ERROR_INSTALL_PACKAGE_INVALID;
|
|
|
|
}
|
|
|
|
if (!package->num_langids)
|
|
|
|
{
|
|
|
|
return ERROR_SUCCESS;
|
|
|
|
}
|
|
|
|
for (i = 0; i < package->num_langids; i++)
|
|
|
|
{
|
2011-03-20 08:47:41 +00:00
|
|
|
LANGID langid = package->langids[i];
|
|
|
|
|
|
|
|
if (PRIMARYLANGID( langid ) == LANG_NEUTRAL)
|
|
|
|
{
|
|
|
|
langid = MAKELANGID( PRIMARYLANGID( GetSystemDefaultLangID() ), SUBLANGID( langid ) );
|
|
|
|
}
|
|
|
|
if (SUBLANGID( langid ) == SUBLANG_NEUTRAL)
|
|
|
|
{
|
|
|
|
langid = MAKELANGID( PRIMARYLANGID( langid ), SUBLANGID( GetSystemDefaultLangID() ) );
|
|
|
|
}
|
|
|
|
if (IsValidLocale( langid, LCID_INSTALLED ))
|
2010-10-22 13:18:11 +00:00
|
|
|
return ERROR_SUCCESS;
|
|
|
|
}
|
|
|
|
return ERROR_INSTALL_LANGUAGE_UNSUPPORTED;
|
|
|
|
}
|
|
|
|
|
2022-03-12 15:34:12 +00:00
|
|
|
static WCHAR *get_property( MSIDATABASE *db, const WCHAR *prop )
|
2012-01-21 17:19:12 +00:00
|
|
|
{
|
2022-03-12 15:34:12 +00:00
|
|
|
static const WCHAR select_query[] = {
|
2012-01-21 17:19:12 +00:00
|
|
|
'S','E','L','E','C','T',' ','`','V','a','l','u','e','`',' ',
|
|
|
|
'F','R','O','M',' ','`','P','r','o','p','e','r','t','y','`',' ',
|
|
|
|
'W','H','E','R','E',' ','`','P','r','o','p','e','r','t','y','`','=',
|
2022-03-12 15:34:12 +00:00
|
|
|
'\'','%','s','\'',0};
|
|
|
|
WCHAR query[MAX_PATH];
|
2012-01-21 17:19:12 +00:00
|
|
|
MSIQUERY *view;
|
|
|
|
MSIRECORD *rec;
|
|
|
|
WCHAR *ret = NULL;
|
|
|
|
|
2022-03-13 00:35:24 +00:00
|
|
|
swprintf(query, ARRAY_SIZE(query), select_query, prop);
|
2012-01-21 17:19:12 +00:00
|
|
|
if (MSI_DatabaseOpenViewW( db, query, &view ) != ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (MSI_ViewExecute( view, 0 ) != ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
MSI_ViewClose( view );
|
|
|
|
msiobj_release( &view->hdr );
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (MSI_ViewFetch( view, &rec ) == ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
ret = strdupW( MSI_RecordGetString( rec, 1 ) );
|
|
|
|
msiobj_release( &rec->hdr );
|
|
|
|
}
|
|
|
|
MSI_ViewClose( view );
|
|
|
|
msiobj_release( &view->hdr );
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-03-12 15:34:12 +00:00
|
|
|
static WCHAR *get_product_code( MSIDATABASE *db )
|
|
|
|
{
|
|
|
|
return get_property( db, szProductCode );
|
|
|
|
}
|
|
|
|
|
|
|
|
static WCHAR *get_product_version( MSIDATABASE *db )
|
|
|
|
{
|
|
|
|
return get_property( db, szProductVersion );
|
|
|
|
}
|
|
|
|
|
|
|
|
static UINT get_registered_local_package( const WCHAR *product, WCHAR *localfile )
|
2012-01-21 17:19:12 +00:00
|
|
|
{
|
|
|
|
MSIINSTALLCONTEXT context;
|
2022-03-12 15:34:12 +00:00
|
|
|
WCHAR *filename;
|
|
|
|
HKEY props_key;
|
2012-01-21 17:19:12 +00:00
|
|
|
UINT r;
|
|
|
|
|
|
|
|
r = msi_locate_product( product, &context );
|
|
|
|
if (r != ERROR_SUCCESS)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = MSIREG_OpenInstallProps( product, context, NULL, &props_key, FALSE );
|
|
|
|
if (r != ERROR_SUCCESS)
|
|
|
|
return r;
|
|
|
|
|
2022-03-12 15:34:12 +00:00
|
|
|
filename = msi_reg_get_val_str( props_key, INSTALLPROPERTY_LOCALPACKAGEW );
|
2012-01-21 17:19:12 +00:00
|
|
|
RegCloseKey( props_key );
|
2022-03-12 15:34:12 +00:00
|
|
|
if (!filename)
|
|
|
|
return ERROR_FUNCTION_FAILED;
|
|
|
|
|
2022-03-13 00:35:24 +00:00
|
|
|
lstrcpyW( localfile, filename );
|
2022-03-12 15:34:12 +00:00
|
|
|
msi_free( filename );
|
|
|
|
return ERROR_SUCCESS;
|
2012-01-21 17:19:12 +00:00
|
|
|
}
|
|
|
|
|
2022-03-12 15:34:11 +00:00
|
|
|
WCHAR *msi_get_package_code( MSIDATABASE *db )
|
2012-01-21 17:19:12 +00:00
|
|
|
{
|
|
|
|
WCHAR *ret;
|
|
|
|
MSISUMMARYINFO *si;
|
2015-07-19 23:04:25 +00:00
|
|
|
UINT r;
|
2012-01-21 17:19:12 +00:00
|
|
|
|
2015-07-19 23:04:25 +00:00
|
|
|
r = msi_get_suminfo( db->storage, 0, &si );
|
|
|
|
if (r != ERROR_SUCCESS)
|
2012-01-21 17:19:12 +00:00
|
|
|
{
|
2015-07-19 23:04:25 +00:00
|
|
|
r = msi_get_db_suminfo( db, 0, &si );
|
|
|
|
if (r != ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
WARN("failed to load summary info %u\n", r);
|
|
|
|
return NULL;
|
|
|
|
}
|
2012-01-21 17:19:12 +00:00
|
|
|
}
|
|
|
|
ret = msi_suminfo_dup_string( si, PID_REVNUMBER );
|
|
|
|
msiobj_release( &si->hdr );
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-03-12 15:34:12 +00:00
|
|
|
static UINT get_local_package( MSIDATABASE *db, WCHAR *localfile )
|
2012-01-21 17:19:12 +00:00
|
|
|
{
|
2022-03-12 15:34:12 +00:00
|
|
|
WCHAR *product_code;
|
2012-01-21 17:19:12 +00:00
|
|
|
UINT r;
|
|
|
|
|
|
|
|
if (!(product_code = get_product_code( db )))
|
|
|
|
return ERROR_INSTALL_PACKAGE_INVALID;
|
2022-03-12 15:34:12 +00:00
|
|
|
r = get_registered_local_package( product_code, localfile );
|
2012-01-21 17:19:12 +00:00
|
|
|
msi_free( product_code );
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2013-04-03 21:58:03 +00:00
|
|
|
UINT msi_set_original_database_property( MSIDATABASE *db, const WCHAR *package )
|
|
|
|
{
|
|
|
|
UINT r;
|
|
|
|
|
|
|
|
if (UrlIsW( package, URLIS_URL ))
|
|
|
|
r = msi_set_property( db, szOriginalDatabase, package, -1 );
|
|
|
|
else if (package[0] == '#')
|
|
|
|
r = msi_set_property( db, szOriginalDatabase, db->path, -1 );
|
|
|
|
else
|
|
|
|
{
|
|
|
|
DWORD len;
|
|
|
|
WCHAR *path;
|
|
|
|
|
|
|
|
if (!(len = GetFullPathNameW( package, 0, NULL, NULL ))) return GetLastError();
|
|
|
|
if (!(path = msi_alloc( len * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
|
|
|
|
len = GetFullPathNameW( package, len, path, NULL );
|
|
|
|
r = msi_set_property( db, szOriginalDatabase, path, len );
|
|
|
|
msi_free( path );
|
|
|
|
}
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2022-03-12 15:57:00 +00:00
|
|
|
UINT MSI_OpenPackageW(LPCWSTR szPackage, DWORD dwOptions, MSIPACKAGE **pPackage)
|
2006-02-17 00:04:10 +00:00
|
|
|
{
|
2010-05-29 08:55:43 +00:00
|
|
|
static const WCHAR dotmsi[] = {'.','m','s','i',0};
|
2012-01-21 17:19:12 +00:00
|
|
|
MSIDATABASE *db;
|
2006-02-17 00:04:10 +00:00
|
|
|
MSIPACKAGE *package;
|
|
|
|
MSIHANDLE handle;
|
2017-10-08 08:14:40 +00:00
|
|
|
MSIRECORD *data_row, *info_row;
|
2006-02-17 00:04:10 +00:00
|
|
|
UINT r;
|
2012-01-21 17:19:12 +00:00
|
|
|
WCHAR localfile[MAX_PATH], cachefile[MAX_PATH];
|
2008-01-16 10:11:22 +00:00
|
|
|
LPCWSTR file = szPackage;
|
2010-05-29 08:55:43 +00:00
|
|
|
DWORD index = 0;
|
2010-10-22 13:18:11 +00:00
|
|
|
MSISUMMARYINFO *si;
|
2012-01-21 17:19:12 +00:00
|
|
|
BOOL delete_on_close = FALSE;
|
2022-03-12 15:34:11 +00:00
|
|
|
WCHAR *info_template, *productname, *product_code;
|
|
|
|
MSIINSTALLCONTEXT context;
|
2006-10-22 20:23:59 +00:00
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
TRACE("%s %p\n", debugstr_w(szPackage), pPackage);
|
|
|
|
|
2017-10-08 08:14:40 +00:00
|
|
|
MSI_ProcessMessage(NULL, INSTALLMESSAGE_INITIALIZE, 0);
|
|
|
|
|
2012-01-21 17:19:12 +00:00
|
|
|
localfile[0] = 0;
|
2006-02-17 00:04:10 +00:00
|
|
|
if( szPackage[0] == '#' )
|
|
|
|
{
|
2022-03-13 00:35:24 +00:00
|
|
|
handle = wcstol(&szPackage[1], NULL, 10);
|
2022-03-13 00:21:42 +00:00
|
|
|
if (!(db = msihandle2msiinfo(handle, MSIHANDLETYPE_DATABASE)))
|
|
|
|
return ERROR_INVALID_HANDLE;
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2022-03-12 15:34:12 +00:00
|
|
|
WCHAR *product_version = NULL;
|
|
|
|
|
2006-08-01 23:12:11 +00:00
|
|
|
if ( UrlIsW( szPackage, URLIS_URL ) )
|
2006-11-28 11:21:39 +00:00
|
|
|
{
|
2009-12-22 09:28:03 +00:00
|
|
|
r = msi_download_file( szPackage, cachefile );
|
2012-01-21 17:19:12 +00:00
|
|
|
if (r != ERROR_SUCCESS)
|
2009-12-22 09:28:03 +00:00
|
|
|
return r;
|
|
|
|
|
2012-01-21 17:19:12 +00:00
|
|
|
file = cachefile;
|
2006-11-28 11:21:39 +00:00
|
|
|
}
|
2022-03-12 15:34:12 +00:00
|
|
|
r = MSI_OpenDatabaseW( file, MSIDBOPEN_READONLY, &db );
|
|
|
|
if (r != ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
if (GetFileAttributesW( file ) == INVALID_FILE_ATTRIBUTES)
|
|
|
|
return ERROR_FILE_NOT_FOUND;
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
r = get_local_package( db, localfile );
|
2012-01-21 17:19:12 +00:00
|
|
|
if (r != ERROR_SUCCESS || GetFileAttributesW( localfile ) == INVALID_FILE_ATTRIBUTES)
|
2009-12-22 09:28:03 +00:00
|
|
|
{
|
2021-02-12 13:46:56 +00:00
|
|
|
DWORD localfile_attr;
|
|
|
|
|
2012-01-21 17:19:12 +00:00
|
|
|
r = msi_create_empty_local_file( localfile, dotmsi );
|
|
|
|
if (r != ERROR_SUCCESS)
|
2022-03-12 15:34:12 +00:00
|
|
|
{
|
|
|
|
msiobj_release( &db->hdr );
|
2009-12-22 09:28:03 +00:00
|
|
|
return r;
|
2022-03-12 15:34:12 +00:00
|
|
|
}
|
2009-12-22 09:28:03 +00:00
|
|
|
|
2012-01-21 17:19:12 +00:00
|
|
|
if (!CopyFileW( file, localfile, FALSE ))
|
|
|
|
{
|
|
|
|
r = GetLastError();
|
|
|
|
WARN("unable to copy package %s to %s (%u)\n", debugstr_w(file), debugstr_w(localfile), r);
|
|
|
|
DeleteFileW( localfile );
|
2022-03-12 15:34:12 +00:00
|
|
|
msiobj_release( &db->hdr );
|
2012-01-21 17:19:12 +00:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
delete_on_close = TRUE;
|
2021-02-12 13:46:56 +00:00
|
|
|
|
|
|
|
/* Remove read-only bit, we are opening it with write access in MSI_OpenDatabaseW below. */
|
|
|
|
localfile_attr = GetFileAttributesW( localfile );
|
|
|
|
if (localfile_attr & FILE_ATTRIBUTE_READONLY)
|
|
|
|
SetFileAttributesW( localfile, localfile_attr & ~FILE_ATTRIBUTE_READONLY);
|
2009-12-22 09:28:03 +00:00
|
|
|
}
|
2022-03-12 15:57:00 +00:00
|
|
|
else if (dwOptions & WINE_OPENPACKAGEFLAGS_RECACHE)
|
|
|
|
{
|
|
|
|
if (!CopyFileW( file, localfile, FALSE ))
|
|
|
|
{
|
|
|
|
r = GetLastError();
|
|
|
|
WARN("unable to update cached package (%u)\n", r);
|
|
|
|
msiobj_release( &db->hdr );
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
}
|
2022-03-12 15:34:12 +00:00
|
|
|
else
|
|
|
|
product_version = get_product_version( db );
|
|
|
|
msiobj_release( &db->hdr );
|
2012-01-21 17:19:12 +00:00
|
|
|
TRACE("opening package %s\n", debugstr_w( localfile ));
|
|
|
|
r = MSI_OpenDatabaseW( localfile, MSIDBOPEN_TRANSACT, &db );
|
2009-10-25 11:06:09 +00:00
|
|
|
if (r != ERROR_SUCCESS)
|
|
|
|
return r;
|
2022-03-12 15:34:12 +00:00
|
|
|
|
|
|
|
if (product_version)
|
|
|
|
{
|
|
|
|
WCHAR *cache_version = get_product_version( db );
|
|
|
|
if (!product_version != !cache_version ||
|
2022-03-13 00:35:24 +00:00
|
|
|
(product_version && wcscmp(product_version, cache_version)))
|
2022-03-12 15:34:12 +00:00
|
|
|
{
|
|
|
|
msiobj_release( &db->hdr );
|
|
|
|
msi_free(product_version);
|
|
|
|
msi_free(cache_version);
|
|
|
|
return ERROR_PRODUCT_VERSION;
|
|
|
|
}
|
|
|
|
msi_free(product_version);
|
|
|
|
msi_free(cache_version);
|
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
2022-03-12 14:11:49 +00:00
|
|
|
package = MSI_CreatePackage( db );
|
2006-02-17 00:04:10 +00:00
|
|
|
msiobj_release( &db->hdr );
|
2012-01-21 17:19:12 +00:00
|
|
|
if (!package) return ERROR_INSTALL_PACKAGE_INVALID;
|
|
|
|
package->localfile = strdupW( localfile );
|
|
|
|
package->delete_on_close = delete_on_close;
|
2008-01-16 10:11:22 +00:00
|
|
|
|
2015-07-19 23:04:25 +00:00
|
|
|
r = msi_get_suminfo( db->storage, 0, &si );
|
|
|
|
if (r != ERROR_SUCCESS)
|
2010-10-22 13:18:11 +00:00
|
|
|
{
|
2015-07-19 23:04:25 +00:00
|
|
|
r = msi_get_db_suminfo( db, 0, &si );
|
|
|
|
if (r != ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
WARN("failed to load summary info\n");
|
|
|
|
msiobj_release( &package->hdr );
|
|
|
|
return ERROR_INSTALL_PACKAGE_INVALID;
|
|
|
|
}
|
2010-10-22 13:18:11 +00:00
|
|
|
}
|
2015-07-19 23:04:25 +00:00
|
|
|
r = parse_suminfo( si, package );
|
2010-10-22 13:18:11 +00:00
|
|
|
msiobj_release( &si->hdr );
|
|
|
|
if (r != ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
WARN("failed to parse summary info %u\n", r);
|
|
|
|
msiobj_release( &package->hdr );
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
r = validate_package( package );
|
|
|
|
if (r != ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
msiobj_release( &package->hdr );
|
|
|
|
return r;
|
|
|
|
}
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_set_property( package->db, szDatabase, db->path, -1 );
|
2014-09-23 18:32:48 +00:00
|
|
|
set_installed_prop( package );
|
2010-05-29 08:55:43 +00:00
|
|
|
msi_set_context( package );
|
|
|
|
|
2022-03-12 15:34:11 +00:00
|
|
|
product_code = get_product_code( db );
|
|
|
|
if (msi_locate_product( product_code, &context ) == ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
TRACE("product already registered\n");
|
|
|
|
msi_set_property( package->db, szProductToBeRegistered, szOne, -1 );
|
|
|
|
}
|
|
|
|
msi_free(product_code);
|
|
|
|
|
2010-05-29 08:55:43 +00:00
|
|
|
while (1)
|
|
|
|
{
|
|
|
|
WCHAR patch_code[GUID_SIZE];
|
|
|
|
r = MsiEnumPatchesExW( package->ProductCode, NULL, package->Context,
|
|
|
|
MSIPATCHSTATE_APPLIED, index, patch_code, NULL, NULL, NULL, NULL );
|
|
|
|
if (r != ERROR_SUCCESS)
|
|
|
|
break;
|
|
|
|
|
|
|
|
TRACE("found registered patch %s\n", debugstr_w(patch_code));
|
|
|
|
|
2012-01-21 17:19:12 +00:00
|
|
|
r = msi_apply_registered_patch( package, patch_code );
|
2010-05-29 08:55:43 +00:00
|
|
|
if (r != ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
ERR("registered patch failed to apply %u\n", r);
|
2010-10-22 13:18:11 +00:00
|
|
|
msiobj_release( &package->hdr );
|
2010-05-29 08:55:43 +00:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
index++;
|
|
|
|
}
|
2015-03-09 20:28:19 +00:00
|
|
|
if (index) msi_adjust_privilege_properties( package );
|
|
|
|
|
2013-04-03 21:58:03 +00:00
|
|
|
r = msi_set_original_database_property( package->db, szPackage );
|
|
|
|
if (r != ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
msiobj_release( &package->hdr );
|
|
|
|
return r;
|
|
|
|
}
|
2011-03-20 08:47:41 +00:00
|
|
|
if (gszLogFile)
|
|
|
|
package->log_file = CreateFileW( gszLogFile, GENERIC_WRITE, FILE_SHARE_WRITE, NULL,
|
|
|
|
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
|
2017-10-08 08:14:40 +00:00
|
|
|
|
2022-03-13 00:17:50 +00:00
|
|
|
if (!msi_init_assembly_caches( package ))
|
|
|
|
{
|
|
|
|
ERR("can't initialize assembly caches\n");
|
|
|
|
msiobj_release( &package->hdr );
|
|
|
|
return ERROR_FUNCTION_FAILED;
|
|
|
|
}
|
|
|
|
|
2017-10-08 08:14:40 +00:00
|
|
|
/* FIXME: when should these messages be sent? */
|
|
|
|
data_row = MSI_CreateRecord(3);
|
|
|
|
if (!data_row)
|
|
|
|
return ERROR_OUTOFMEMORY;
|
|
|
|
MSI_RecordSetStringW(data_row, 0, NULL);
|
|
|
|
MSI_RecordSetInteger(data_row, 1, 0);
|
|
|
|
MSI_RecordSetInteger(data_row, 2, package->num_langids ? package->langids[0] : 0);
|
|
|
|
MSI_RecordSetInteger(data_row, 3, msi_get_string_table_codepage(package->db->strings));
|
|
|
|
MSI_ProcessMessageVerbatim(package, INSTALLMESSAGE_COMMONDATA, data_row);
|
|
|
|
|
|
|
|
info_row = MSI_CreateRecord(0);
|
|
|
|
if (!info_row)
|
|
|
|
{
|
|
|
|
msiobj_release(&data_row->hdr);
|
|
|
|
return ERROR_OUTOFMEMORY;
|
|
|
|
}
|
|
|
|
info_template = msi_get_error_message(package->db, MSIERR_INFO_LOGGINGSTART);
|
|
|
|
MSI_RecordSetStringW(info_row, 0, info_template);
|
|
|
|
msi_free(info_template);
|
|
|
|
MSI_ProcessMessage(package, INSTALLMESSAGE_INFO|MB_ICONHAND, info_row);
|
|
|
|
|
|
|
|
MSI_ProcessMessage(package, INSTALLMESSAGE_COMMONDATA, data_row);
|
|
|
|
|
|
|
|
productname = msi_dup_property(package->db, INSTALLPROPERTY_PRODUCTNAMEW);
|
|
|
|
MSI_RecordSetInteger(data_row, 1, 1);
|
|
|
|
MSI_RecordSetStringW(data_row, 2, productname);
|
|
|
|
MSI_RecordSetStringW(data_row, 3, NULL);
|
|
|
|
MSI_ProcessMessage(package, INSTALLMESSAGE_COMMONDATA, data_row);
|
|
|
|
|
|
|
|
msi_free(productname);
|
|
|
|
msiobj_release(&info_row->hdr);
|
|
|
|
msiobj_release(&data_row->hdr);
|
|
|
|
|
2010-05-29 08:55:43 +00:00
|
|
|
*pPackage = package;
|
2006-02-17 00:04:10 +00:00
|
|
|
return ERROR_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
UINT WINAPI MsiOpenPackageExW(LPCWSTR szPackage, DWORD dwOptions, MSIHANDLE *phPackage)
|
|
|
|
{
|
|
|
|
MSIPACKAGE *package = NULL;
|
|
|
|
UINT ret;
|
|
|
|
|
2006-10-22 20:23:59 +00:00
|
|
|
TRACE("%s %08x %p\n", debugstr_w(szPackage), dwOptions, phPackage );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2008-01-16 10:11:22 +00:00
|
|
|
if( !szPackage || !phPackage )
|
2006-08-01 23:12:11 +00:00
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
|
|
|
2008-01-16 10:11:22 +00:00
|
|
|
if ( !*szPackage )
|
|
|
|
{
|
|
|
|
FIXME("Should create an empty database and package\n");
|
|
|
|
return ERROR_FUNCTION_FAILED;
|
|
|
|
}
|
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
if( dwOptions )
|
2006-10-22 20:23:59 +00:00
|
|
|
FIXME("dwOptions %08x not supported\n", dwOptions);
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2022-03-12 15:57:00 +00:00
|
|
|
ret = MSI_OpenPackageW( szPackage, 0, &package );
|
2006-02-17 00:04:10 +00:00
|
|
|
if( ret == ERROR_SUCCESS )
|
|
|
|
{
|
|
|
|
*phPackage = alloc_msihandle( &package->hdr );
|
2006-08-30 19:24:26 +00:00
|
|
|
if (! *phPackage)
|
|
|
|
ret = ERROR_NOT_ENOUGH_MEMORY;
|
2006-02-17 00:04:10 +00:00
|
|
|
msiobj_release( &package->hdr );
|
|
|
|
}
|
2017-10-08 08:14:40 +00:00
|
|
|
else
|
|
|
|
MSI_ProcessMessage(NULL, INSTALLMESSAGE_TERMINATE, 0);
|
2006-02-17 00:04:10 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
UINT WINAPI MsiOpenPackageW(LPCWSTR szPackage, MSIHANDLE *phPackage)
|
|
|
|
{
|
|
|
|
return MsiOpenPackageExW( szPackage, 0, phPackage );
|
|
|
|
}
|
|
|
|
|
|
|
|
UINT WINAPI MsiOpenPackageExA(LPCSTR szPackage, DWORD dwOptions, MSIHANDLE *phPackage)
|
|
|
|
{
|
|
|
|
LPWSTR szwPack = NULL;
|
|
|
|
UINT ret;
|
|
|
|
|
|
|
|
if( szPackage )
|
|
|
|
{
|
|
|
|
szwPack = strdupAtoW( szPackage );
|
|
|
|
if( !szwPack )
|
|
|
|
return ERROR_OUTOFMEMORY;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = MsiOpenPackageExW( szwPack, dwOptions, phPackage );
|
|
|
|
|
|
|
|
msi_free( szwPack );
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
UINT WINAPI MsiOpenPackageA(LPCSTR szPackage, MSIHANDLE *phPackage)
|
|
|
|
{
|
|
|
|
return MsiOpenPackageExA( szPackage, 0, phPackage );
|
|
|
|
}
|
|
|
|
|
|
|
|
MSIHANDLE WINAPI MsiGetActiveDatabase(MSIHANDLE hInstall)
|
|
|
|
{
|
|
|
|
MSIPACKAGE *package;
|
|
|
|
MSIHANDLE handle = 0;
|
2022-03-12 14:11:45 +00:00
|
|
|
MSIHANDLE remote;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-18 12:52:01 +00:00
|
|
|
TRACE("(%d)\n",hInstall);
|
2006-02-17 00:04:10 +00:00
|
|
|
|
|
|
|
package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE);
|
|
|
|
if( package)
|
|
|
|
{
|
|
|
|
handle = alloc_msihandle( &package->db->hdr );
|
|
|
|
msiobj_release( &package->hdr );
|
|
|
|
}
|
2022-03-12 14:11:45 +00:00
|
|
|
else if ((remote = msi_get_remote(hInstall)))
|
2008-01-16 10:11:22 +00:00
|
|
|
{
|
2022-03-12 22:54:40 +00:00
|
|
|
__TRY
|
|
|
|
{
|
2022-03-12 22:57:41 +00:00
|
|
|
handle = remote_GetActiveDatabase(remote);
|
2022-03-12 22:54:40 +00:00
|
|
|
handle = alloc_msi_remote_handle(handle);
|
|
|
|
}
|
|
|
|
__EXCEPT(rpc_filter)
|
|
|
|
{
|
|
|
|
handle = 0;
|
|
|
|
}
|
|
|
|
__ENDTRY
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
|
|
|
|
return handle;
|
|
|
|
}
|
|
|
|
|
2017-10-08 08:14:40 +00:00
|
|
|
static INT internal_ui_handler(MSIPACKAGE *package, INSTALLMESSAGE eMessageType, MSIRECORD *record, LPCWSTR message)
|
2006-02-17 00:04:10 +00:00
|
|
|
{
|
2012-05-14 21:41:31 +00:00
|
|
|
static const WCHAR szActionData[] = {'A','c','t','i','o','n','D','a','t','a',0};
|
|
|
|
static const WCHAR szActionText[] = {'A','c','t','i','o','n','T','e','x','t',0};
|
2017-10-08 08:14:40 +00:00
|
|
|
static const WCHAR szSetProgress[] = {'S','e','t','P','r','o','g','r','e','s','s',0};
|
|
|
|
static const WCHAR szWindows_Installer[] =
|
|
|
|
{'W','i','n','d','o','w','s',' ','I','n','s','t','a','l','l','e','r',0};
|
|
|
|
|
|
|
|
if (!package || (package->ui_level & INSTALLUILEVEL_MASK) == INSTALLUILEVEL_NONE)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* todo: check if message needs additional styles (topmost/foreground/modality?) */
|
|
|
|
|
|
|
|
switch (eMessageType & 0xff000000)
|
|
|
|
{
|
|
|
|
case INSTALLMESSAGE_FATALEXIT:
|
|
|
|
case INSTALLMESSAGE_ERROR:
|
|
|
|
case INSTALLMESSAGE_OUTOFDISKSPACE:
|
|
|
|
if (package->ui_level & INSTALLUILEVEL_PROGRESSONLY) return 0;
|
|
|
|
if (!(eMessageType & MB_ICONMASK))
|
|
|
|
eMessageType |= MB_ICONEXCLAMATION;
|
|
|
|
return MessageBoxW(gUIhwnd, message, szWindows_Installer, eMessageType & 0x00ffffff);
|
|
|
|
case INSTALLMESSAGE_WARNING:
|
|
|
|
if (package->ui_level & INSTALLUILEVEL_PROGRESSONLY) return 0;
|
|
|
|
if (!(eMessageType & MB_ICONMASK))
|
|
|
|
eMessageType |= MB_ICONASTERISK;
|
|
|
|
return MessageBoxW(gUIhwnd, message, szWindows_Installer, eMessageType & 0x00ffffff);
|
|
|
|
case INSTALLMESSAGE_USER:
|
|
|
|
if (package->ui_level & INSTALLUILEVEL_PROGRESSONLY) return 0;
|
|
|
|
if (!(eMessageType & MB_ICONMASK))
|
|
|
|
eMessageType |= MB_USERICON;
|
|
|
|
return MessageBoxW(gUIhwnd, message, szWindows_Installer, eMessageType & 0x00ffffff);
|
|
|
|
case INSTALLMESSAGE_INFO:
|
|
|
|
case INSTALLMESSAGE_INITIALIZE:
|
|
|
|
case INSTALLMESSAGE_TERMINATE:
|
2018-01-20 11:29:30 +00:00
|
|
|
case INSTALLMESSAGE_INSTALLSTART:
|
|
|
|
case INSTALLMESSAGE_INSTALLEND:
|
2017-10-08 08:14:40 +00:00
|
|
|
return 0;
|
|
|
|
case INSTALLMESSAGE_SHOWDIALOG:
|
|
|
|
{
|
|
|
|
LPWSTR dialog = msi_dup_record_field(record, 0);
|
|
|
|
INT rc = ACTION_DialogBox(package, dialog);
|
|
|
|
msi_free(dialog);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
case INSTALLMESSAGE_ACTIONSTART:
|
|
|
|
{
|
|
|
|
LPWSTR deformatted;
|
|
|
|
MSIRECORD *uirow = MSI_CreateRecord(1);
|
|
|
|
if (!uirow) return -1;
|
|
|
|
deformat_string(package, MSI_RecordGetString(record, 2), &deformatted);
|
|
|
|
MSI_RecordSetStringW(uirow, 1, deformatted);
|
|
|
|
msi_event_fire(package, szActionText, uirow);
|
|
|
|
|
|
|
|
msi_free(deformatted);
|
|
|
|
msiobj_release(&uirow->hdr);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
case INSTALLMESSAGE_ACTIONDATA:
|
|
|
|
{
|
|
|
|
MSIRECORD *uirow = MSI_CreateRecord(1);
|
|
|
|
if (!uirow) return -1;
|
|
|
|
MSI_RecordSetStringW(uirow, 1, message);
|
|
|
|
msi_event_fire(package, szActionData, uirow);
|
|
|
|
msiobj_release(&uirow->hdr);
|
|
|
|
|
|
|
|
if (package->action_progress_increment)
|
|
|
|
{
|
|
|
|
uirow = MSI_CreateRecord(2);
|
|
|
|
if (!uirow) return -1;
|
|
|
|
MSI_RecordSetInteger(uirow, 1, 2);
|
|
|
|
MSI_RecordSetInteger(uirow, 2, package->action_progress_increment);
|
|
|
|
msi_event_fire(package, szSetProgress, uirow);
|
|
|
|
msiobj_release(&uirow->hdr);
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
case INSTALLMESSAGE_PROGRESS:
|
|
|
|
msi_event_fire(package, szSetProgress, record);
|
|
|
|
return 1;
|
|
|
|
case INSTALLMESSAGE_COMMONDATA:
|
|
|
|
switch (MSI_RecordGetInteger(record, 1))
|
|
|
|
{
|
|
|
|
case 0:
|
|
|
|
case 1:
|
|
|
|
/* do nothing */
|
|
|
|
return 0;
|
|
|
|
default:
|
|
|
|
/* fall through */
|
|
|
|
;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
FIXME("internal UI not implemented for message 0x%08x (UI level = %x)\n", eMessageType, package->ui_level);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static const WCHAR szActionNotFound[] = {'D','E','B','U','G',':',' ','E','r','r','o','r',' ','[','1',']',':',' ',' ','A','c','t','i','o','n',' ','n','o','t',' ','f','o','u','n','d',':',' ','[','2',']',0};
|
|
|
|
|
|
|
|
static const struct
|
|
|
|
{
|
|
|
|
int id;
|
|
|
|
const WCHAR *text;
|
|
|
|
}
|
|
|
|
internal_errors[] =
|
|
|
|
{
|
|
|
|
{2726, szActionNotFound},
|
|
|
|
{0}
|
|
|
|
};
|
|
|
|
|
|
|
|
static LPCWSTR get_internal_error_message(int error)
|
|
|
|
{
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
while (internal_errors[i].id != 0)
|
|
|
|
{
|
|
|
|
if (internal_errors[i].id == error)
|
|
|
|
return internal_errors[i].text;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
|
|
|
FIXME("missing error message %d\n", error);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Returned string must be freed */
|
|
|
|
LPWSTR msi_get_error_message(MSIDATABASE *db, int error)
|
|
|
|
{
|
|
|
|
static const WCHAR query[] =
|
|
|
|
{'S','E','L','E','C','T',' ','`','M','e','s','s','a','g','e','`',' ',
|
|
|
|
'F','R','O','M',' ','`','E','r','r','o','r','`',' ','W','H','E','R','E',' ',
|
|
|
|
'`','E','r','r','o','r','`',' ','=',' ','%','i',0};
|
|
|
|
MSIRECORD *record;
|
|
|
|
LPWSTR ret = NULL;
|
|
|
|
|
|
|
|
if ((record = MSI_QueryGetRecord(db, query, error)))
|
|
|
|
{
|
|
|
|
ret = msi_dup_record_field(record, 1);
|
|
|
|
msiobj_release(&record->hdr);
|
|
|
|
}
|
|
|
|
else if (error < 2000)
|
|
|
|
{
|
|
|
|
int len = LoadStringW(msi_hInstance, IDS_ERROR_BASE + error, (LPWSTR) &ret, 0);
|
|
|
|
if (len)
|
|
|
|
{
|
|
|
|
ret = msi_alloc((len + 1) * sizeof(WCHAR));
|
|
|
|
LoadStringW(msi_hInstance, IDS_ERROR_BASE + error, ret, len + 1);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
ret = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
INT MSI_ProcessMessageVerbatim(MSIPACKAGE *package, INSTALLMESSAGE eMessageType, MSIRECORD *record)
|
|
|
|
{
|
|
|
|
LPWSTR message = {0};
|
2018-01-20 11:29:30 +00:00
|
|
|
DWORD len;
|
|
|
|
DWORD log_type = 1 << (eMessageType >> 24);
|
2017-10-08 08:14:40 +00:00
|
|
|
UINT res;
|
2012-01-21 17:19:12 +00:00
|
|
|
INT rc = 0;
|
2006-02-17 00:04:10 +00:00
|
|
|
char *msg;
|
|
|
|
|
|
|
|
TRACE("%x\n", eMessageType);
|
2017-10-08 08:14:40 +00:00
|
|
|
if (TRACE_ON(msi)) dump_record(record);
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2017-10-08 08:14:40 +00:00
|
|
|
if (!package || !record)
|
|
|
|
message = NULL;
|
|
|
|
else {
|
|
|
|
res = MSI_FormatRecordW(package, record, message, &len);
|
|
|
|
if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA)
|
|
|
|
return res;
|
|
|
|
len++;
|
|
|
|
message = msi_alloc(len * sizeof(WCHAR));
|
|
|
|
if (!message) return ERROR_OUTOFMEMORY;
|
|
|
|
MSI_FormatRecordW(package, record, message, &len);
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* convert it to ASCII */
|
2009-11-16 01:13:42 +00:00
|
|
|
len = WideCharToMultiByte( CP_ACP, 0, message, -1, NULL, 0, NULL, NULL );
|
2006-02-17 00:04:10 +00:00
|
|
|
msg = msi_alloc( len );
|
2009-11-16 01:13:42 +00:00
|
|
|
WideCharToMultiByte( CP_ACP, 0, message, -1, msg, len, NULL, NULL );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2017-10-08 08:14:40 +00:00
|
|
|
if (gUIHandlerRecord && (gUIFilterRecord & log_type))
|
2006-02-17 00:04:10 +00:00
|
|
|
{
|
2017-10-08 08:14:40 +00:00
|
|
|
MSIHANDLE rec = alloc_msihandle(&record->hdr);
|
|
|
|
TRACE("Calling UI handler %p(pvContext=%p, iMessageType=%08x, hRecord=%u)\n",
|
|
|
|
gUIHandlerRecord, gUIContextRecord, eMessageType, rec);
|
|
|
|
rc = gUIHandlerRecord( gUIContextRecord, eMessageType, rec );
|
|
|
|
MsiCloseHandle( rec );
|
2009-11-16 01:13:42 +00:00
|
|
|
}
|
2017-10-08 08:14:40 +00:00
|
|
|
if (!rc && gUIHandlerW && (gUIFilter & log_type))
|
2009-11-16 01:13:42 +00:00
|
|
|
{
|
2017-10-08 08:14:40 +00:00
|
|
|
TRACE("Calling UI handler %p(pvContext=%p, iMessageType=%08x, szMessage=%s)\n",
|
|
|
|
gUIHandlerW, gUIContext, eMessageType, debugstr_w(message));
|
|
|
|
rc = gUIHandlerW( gUIContext, eMessageType, message );
|
2009-11-16 01:13:42 +00:00
|
|
|
}
|
2017-10-08 08:14:40 +00:00
|
|
|
else if (!rc && gUIHandlerA && (gUIFilter & log_type))
|
2009-11-16 01:13:42 +00:00
|
|
|
{
|
2017-10-08 08:14:40 +00:00
|
|
|
TRACE("Calling UI handler %p(pvContext=%p, iMessageType=%08x, szMessage=%s)\n",
|
|
|
|
gUIHandlerA, gUIContext, eMessageType, debugstr_a(msg));
|
|
|
|
rc = gUIHandlerA( gUIContext, eMessageType, msg );
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
2017-10-08 08:14:40 +00:00
|
|
|
if (!rc)
|
|
|
|
rc = internal_ui_handler(package, eMessageType, record, message);
|
|
|
|
|
|
|
|
if (!rc && package && package->log_file != INVALID_HANDLE_VALUE &&
|
2011-03-20 08:47:41 +00:00
|
|
|
(eMessageType & 0xff000000) != INSTALLMESSAGE_PROGRESS)
|
2006-02-17 00:04:10 +00:00
|
|
|
{
|
2011-03-20 08:47:41 +00:00
|
|
|
DWORD written;
|
|
|
|
WriteFile( package->log_file, msg, len - 1, &written, NULL );
|
|
|
|
WriteFile( package->log_file, "\n", 1, &written, NULL );
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
msi_free( msg );
|
2009-11-16 01:13:42 +00:00
|
|
|
msi_free( message );
|
2006-08-01 23:12:11 +00:00
|
|
|
|
2017-10-08 08:14:40 +00:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
INT MSI_ProcessMessage( MSIPACKAGE *package, INSTALLMESSAGE eMessageType, MSIRECORD *record )
|
|
|
|
{
|
2006-08-01 23:12:11 +00:00
|
|
|
switch (eMessageType & 0xff000000)
|
|
|
|
{
|
2017-10-08 08:14:40 +00:00
|
|
|
case INSTALLMESSAGE_FATALEXIT:
|
|
|
|
case INSTALLMESSAGE_ERROR:
|
|
|
|
case INSTALLMESSAGE_WARNING:
|
|
|
|
case INSTALLMESSAGE_USER:
|
|
|
|
case INSTALLMESSAGE_INFO:
|
|
|
|
case INSTALLMESSAGE_OUTOFDISKSPACE:
|
|
|
|
if (MSI_RecordGetInteger(record, 1) != MSI_NULL_INTEGER)
|
|
|
|
{
|
|
|
|
/* error message */
|
2012-05-14 21:41:31 +00:00
|
|
|
|
2017-10-08 08:14:40 +00:00
|
|
|
LPWSTR template;
|
|
|
|
LPWSTR template_rec = NULL, template_prefix = NULL;
|
|
|
|
int error = MSI_RecordGetInteger(record, 1);
|
2012-08-13 16:17:18 +00:00
|
|
|
|
2017-10-08 08:14:40 +00:00
|
|
|
if (MSI_RecordIsNull(record, 0))
|
|
|
|
{
|
|
|
|
if (error >= 32)
|
|
|
|
{
|
|
|
|
template_rec = msi_get_error_message(package->db, error);
|
|
|
|
|
|
|
|
if (!template_rec && error >= 2000)
|
|
|
|
{
|
|
|
|
/* internal error, not localized */
|
|
|
|
if ((template_rec = (LPWSTR) get_internal_error_message(error)))
|
|
|
|
{
|
|
|
|
MSI_RecordSetStringW(record, 0, template_rec);
|
|
|
|
MSI_ProcessMessageVerbatim(package, INSTALLMESSAGE_INFO, record);
|
|
|
|
}
|
|
|
|
template_rec = msi_get_error_message(package->db, MSIERR_INSTALLERROR);
|
|
|
|
MSI_RecordSetStringW(record, 0, template_rec);
|
|
|
|
MSI_ProcessMessageVerbatim(package, eMessageType, record);
|
|
|
|
msi_free(template_rec);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
template_rec = msi_dup_record_field(record, 0);
|
2006-08-01 23:12:11 +00:00
|
|
|
|
2017-10-08 08:14:40 +00:00
|
|
|
template_prefix = msi_get_error_message(package->db, eMessageType >> 24);
|
|
|
|
if (!template_prefix) template_prefix = strdupW(szEmpty);
|
2006-08-01 23:12:11 +00:00
|
|
|
|
2017-10-08 08:14:40 +00:00
|
|
|
if (!template_rec)
|
|
|
|
{
|
|
|
|
/* always returns 0 */
|
|
|
|
MSI_RecordSetStringW(record, 0, template_prefix);
|
|
|
|
MSI_ProcessMessageVerbatim(package, eMessageType, record);
|
|
|
|
msi_free(template_prefix);
|
|
|
|
return 0;
|
|
|
|
}
|
2006-08-01 23:12:11 +00:00
|
|
|
|
2022-03-13 00:35:24 +00:00
|
|
|
template = msi_alloc((lstrlenW(template_rec) + lstrlenW(template_prefix) + 1) * sizeof(WCHAR));
|
2017-10-08 08:14:40 +00:00
|
|
|
if (!template) return ERROR_OUTOFMEMORY;
|
|
|
|
|
2022-03-13 00:35:24 +00:00
|
|
|
lstrcpyW(template, template_prefix);
|
|
|
|
lstrcatW(template, template_rec);
|
2017-10-08 08:14:40 +00:00
|
|
|
MSI_RecordSetStringW(record, 0, template);
|
|
|
|
|
|
|
|
msi_free(template_prefix);
|
|
|
|
msi_free(template_rec);
|
|
|
|
msi_free(template);
|
|
|
|
}
|
2006-08-01 23:12:11 +00:00
|
|
|
break;
|
2017-10-08 08:14:40 +00:00
|
|
|
case INSTALLMESSAGE_ACTIONSTART:
|
|
|
|
{
|
|
|
|
WCHAR *template = msi_get_error_message(package->db, MSIERR_ACTIONSTART);
|
|
|
|
MSI_RecordSetStringW(record, 0, template);
|
|
|
|
msi_free(template);
|
2012-05-14 21:41:31 +00:00
|
|
|
|
2017-10-08 08:14:40 +00:00
|
|
|
msi_free(package->LastAction);
|
|
|
|
msi_free(package->LastActionTemplate);
|
|
|
|
package->LastAction = msi_dup_record_field(record, 1);
|
|
|
|
if (!package->LastAction) package->LastAction = strdupW(szEmpty);
|
|
|
|
package->LastActionTemplate = msi_dup_record_field(record, 3);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case INSTALLMESSAGE_ACTIONDATA:
|
|
|
|
if (package->LastAction && package->LastActionTemplate)
|
|
|
|
{
|
|
|
|
static const WCHAR template_s[] =
|
|
|
|
{'{','{','%','s',':',' ','}','}','%','s',0};
|
2022-03-13 00:35:24 +00:00
|
|
|
size_t len = lstrlenW(package->LastAction) + lstrlenW(package->LastActionTemplate) + 7;
|
|
|
|
WCHAR *template = msi_alloc(len * sizeof(WCHAR));
|
2017-10-08 08:14:40 +00:00
|
|
|
if (!template) return ERROR_OUTOFMEMORY;
|
2022-03-13 00:35:24 +00:00
|
|
|
swprintf(template, len, template_s, package->LastAction, package->LastActionTemplate);
|
2017-10-08 08:14:40 +00:00
|
|
|
MSI_RecordSetStringW(record, 0, template);
|
|
|
|
msi_free(template);
|
|
|
|
}
|
2006-08-01 23:12:11 +00:00
|
|
|
break;
|
2017-10-08 08:14:40 +00:00
|
|
|
case INSTALLMESSAGE_COMMONDATA:
|
|
|
|
{
|
|
|
|
WCHAR *template = msi_get_error_message(package->db, MSIERR_COMMONDATA);
|
|
|
|
MSI_RecordSetStringW(record, 0, template);
|
|
|
|
msi_free(template);
|
|
|
|
}
|
|
|
|
break;
|
2006-08-01 23:12:11 +00:00
|
|
|
}
|
|
|
|
|
2017-10-08 08:14:40 +00:00
|
|
|
return MSI_ProcessMessageVerbatim(package, eMessageType, record);
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
INT WINAPI MsiProcessMessage( MSIHANDLE hInstall, INSTALLMESSAGE eMessageType,
|
|
|
|
MSIHANDLE hRecord)
|
|
|
|
{
|
|
|
|
UINT ret = ERROR_INVALID_HANDLE;
|
|
|
|
MSIPACKAGE *package = NULL;
|
|
|
|
MSIRECORD *record = NULL;
|
|
|
|
|
2017-10-08 08:14:40 +00:00
|
|
|
if ((eMessageType & 0xff000000) == INSTALLMESSAGE_INITIALIZE ||
|
|
|
|
(eMessageType & 0xff000000) == INSTALLMESSAGE_TERMINATE)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if ((eMessageType & 0xff000000) == INSTALLMESSAGE_COMMONDATA &&
|
|
|
|
MsiRecordGetInteger(hRecord, 1) != 2)
|
|
|
|
return -1;
|
|
|
|
|
2022-03-12 14:11:49 +00:00
|
|
|
record = msihandle2msiinfo(hRecord, MSIHANDLETYPE_RECORD);
|
|
|
|
if (!record)
|
|
|
|
return ERROR_INVALID_HANDLE;
|
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
|
|
|
|
if( !package )
|
2008-01-16 10:11:22 +00:00
|
|
|
{
|
2022-03-12 14:11:45 +00:00
|
|
|
MSIHANDLE remote;
|
2008-01-16 10:11:22 +00:00
|
|
|
|
2022-03-12 14:11:45 +00:00
|
|
|
if (!(remote = msi_get_remote(hInstall)))
|
2008-01-16 10:11:22 +00:00
|
|
|
return ERROR_INVALID_HANDLE;
|
|
|
|
|
2022-03-12 22:54:40 +00:00
|
|
|
__TRY
|
|
|
|
{
|
|
|
|
ret = remote_ProcessMessage(remote, eMessageType, (struct wire_record *)&record->count);
|
|
|
|
}
|
|
|
|
__EXCEPT(rpc_filter)
|
|
|
|
{
|
|
|
|
ret = GetExceptionCode();
|
|
|
|
}
|
|
|
|
__ENDTRY
|
2008-01-16 10:11:22 +00:00
|
|
|
|
2022-03-12 14:11:49 +00:00
|
|
|
msiobj_release(&record->hdr);
|
|
|
|
return ret;
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
|
|
|
|
ret = MSI_ProcessMessage( package, eMessageType, record );
|
|
|
|
|
2022-03-12 23:04:00 +00:00
|
|
|
msiobj_release( &record->hdr );
|
2006-02-17 00:04:10 +00:00
|
|
|
msiobj_release( &package->hdr );
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* property code */
|
2006-08-30 19:24:26 +00:00
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
UINT WINAPI MsiSetPropertyA( MSIHANDLE hInstall, LPCSTR szName, LPCSTR szValue )
|
|
|
|
{
|
|
|
|
LPWSTR szwName = NULL, szwValue = NULL;
|
|
|
|
UINT r = ERROR_OUTOFMEMORY;
|
|
|
|
|
|
|
|
szwName = strdupAtoW( szName );
|
|
|
|
if( szName && !szwName )
|
|
|
|
goto end;
|
|
|
|
|
|
|
|
szwValue = strdupAtoW( szValue );
|
|
|
|
if( szValue && !szwValue )
|
|
|
|
goto end;
|
|
|
|
|
|
|
|
r = MsiSetPropertyW( hInstall, szwName, szwValue);
|
|
|
|
|
|
|
|
end:
|
|
|
|
msi_free( szwName );
|
|
|
|
msi_free( szwValue );
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2022-03-12 23:08:16 +00:00
|
|
|
void msi_reset_source_folders( MSIPACKAGE *package )
|
2010-03-06 09:05:09 +00:00
|
|
|
{
|
|
|
|
MSIFOLDER *folder;
|
|
|
|
|
|
|
|
LIST_FOR_EACH_ENTRY( folder, &package->folders, MSIFOLDER, entry )
|
|
|
|
{
|
2022-03-12 23:08:16 +00:00
|
|
|
msi_free( folder->ResolvedSource );
|
|
|
|
folder->ResolvedSource = NULL;
|
2010-03-06 09:05:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-09 19:43:59 +00:00
|
|
|
UINT msi_set_property( MSIDATABASE *db, const WCHAR *name, const WCHAR *value, int len )
|
2006-02-17 00:04:10 +00:00
|
|
|
{
|
2012-01-21 17:19:12 +00:00
|
|
|
static const WCHAR insert_query[] = {
|
|
|
|
'I','N','S','E','R','T',' ','I','N','T','O',' ',
|
|
|
|
'`','_','P','r','o','p','e','r','t','y','`',' ',
|
|
|
|
'(','`','_','P','r','o','p','e','r','t','y','`',',','`','V','a','l','u','e','`',')',' ',
|
|
|
|
'V','A','L','U','E','S',' ','(','?',',','?',')',0};
|
|
|
|
static const WCHAR update_query[] = {
|
|
|
|
'U','P','D','A','T','E',' ','`','_','P','r','o','p','e','r','t','y','`',' ',
|
|
|
|
'S','E','T',' ','`','V','a','l','u','e','`',' ','=',' ','?',' ','W','H','E','R','E',' ',
|
|
|
|
'`','_','P','r','o','p','e','r','t','y','`',' ','=',' ','\'','%','s','\'',0};
|
|
|
|
static const WCHAR delete_query[] = {
|
2008-01-16 10:11:22 +00:00
|
|
|
'D','E','L','E','T','E',' ','F','R','O','M',' ',
|
|
|
|
'`','_','P','r','o','p','e','r','t','y','`',' ','W','H','E','R','E',' ',
|
|
|
|
'`','_','P','r','o','p','e','r','t','y','`',' ','=',' ','\'','%','s','\'',0};
|
2012-01-21 17:19:12 +00:00
|
|
|
MSIQUERY *view;
|
|
|
|
MSIRECORD *row = NULL;
|
|
|
|
DWORD sz = 0;
|
|
|
|
WCHAR query[1024];
|
|
|
|
UINT rc;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2012-12-09 19:43:59 +00:00
|
|
|
TRACE("%p %s %s %d\n", db, debugstr_w(name), debugstr_wn(value, len), len);
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2012-12-09 19:43:59 +00:00
|
|
|
if (!name)
|
2006-02-17 00:04:10 +00:00
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
|
|
|
|
|
|
/* this one is weird... */
|
2012-12-09 19:43:59 +00:00
|
|
|
if (!name[0])
|
|
|
|
return value ? ERROR_FUNCTION_FAILED : ERROR_SUCCESS;
|
|
|
|
|
2022-03-13 00:35:24 +00:00
|
|
|
if (value && len < 0) len = lstrlenW( value );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2012-12-09 19:43:59 +00:00
|
|
|
rc = msi_get_property( db, name, 0, &sz );
|
|
|
|
if (!value || (!*value && !len))
|
2008-01-16 10:11:22 +00:00
|
|
|
{
|
2022-03-13 00:35:24 +00:00
|
|
|
swprintf( query, ARRAY_SIZE(query), delete_query, name );
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
|
|
|
else if (rc == ERROR_MORE_DATA || rc == ERROR_SUCCESS)
|
|
|
|
{
|
2022-03-13 00:35:24 +00:00
|
|
|
swprintf( query, ARRAY_SIZE(query), update_query, name );
|
2008-01-16 10:11:22 +00:00
|
|
|
row = MSI_CreateRecord(1);
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_record_set_string( row, 1, value, len );
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2022-03-13 00:35:24 +00:00
|
|
|
lstrcpyW( query, insert_query );
|
2008-01-16 10:11:22 +00:00
|
|
|
row = MSI_CreateRecord(2);
|
2012-12-09 19:43:59 +00:00
|
|
|
msi_record_set_string( row, 1, name, -1 );
|
|
|
|
msi_record_set_string( row, 2, value, len );
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
|
|
|
|
2012-01-21 17:19:12 +00:00
|
|
|
rc = MSI_DatabaseOpenViewW(db, query, &view);
|
2008-01-16 10:11:22 +00:00
|
|
|
if (rc == ERROR_SUCCESS)
|
2006-02-17 00:04:10 +00:00
|
|
|
{
|
2008-01-16 10:11:22 +00:00
|
|
|
rc = MSI_ViewExecute(view, row);
|
|
|
|
MSI_ViewClose(view);
|
|
|
|
msiobj_release(&view->hdr);
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
2012-01-21 17:19:12 +00:00
|
|
|
if (row) msiobj_release(&row->hdr);
|
2008-01-16 10:11:22 +00:00
|
|
|
return rc;
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
UINT WINAPI MsiSetPropertyW( MSIHANDLE hInstall, LPCWSTR szName, LPCWSTR szValue)
|
|
|
|
{
|
|
|
|
MSIPACKAGE *package;
|
|
|
|
UINT ret;
|
|
|
|
|
|
|
|
package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE);
|
|
|
|
if( !package )
|
2008-01-16 10:11:22 +00:00
|
|
|
{
|
2022-03-12 14:11:45 +00:00
|
|
|
MSIHANDLE remote;
|
2008-01-16 10:11:22 +00:00
|
|
|
|
2022-03-12 14:11:45 +00:00
|
|
|
if (!(remote = msi_get_remote(hInstall)))
|
2008-01-16 10:11:22 +00:00
|
|
|
return ERROR_INVALID_HANDLE;
|
|
|
|
|
2022-03-12 22:54:40 +00:00
|
|
|
__TRY
|
|
|
|
{
|
|
|
|
ret = remote_SetProperty(remote, szName, szValue);
|
|
|
|
}
|
|
|
|
__EXCEPT(rpc_filter)
|
|
|
|
{
|
|
|
|
ret = GetExceptionCode();
|
|
|
|
}
|
|
|
|
__ENDTRY
|
|
|
|
|
|
|
|
return ret;
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
|
|
|
|
2012-12-09 19:43:59 +00:00
|
|
|
ret = msi_set_property( package->db, szName, szValue, -1 );
|
2022-03-13 00:35:24 +00:00
|
|
|
if (ret == ERROR_SUCCESS && !wcscmp( szName, szSourceDir ))
|
2022-03-12 23:08:16 +00:00
|
|
|
msi_reset_source_folders( package );
|
2010-05-29 08:55:43 +00:00
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
msiobj_release( &package->hdr );
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-05-29 08:55:43 +00:00
|
|
|
static MSIRECORD *msi_get_property_row( MSIDATABASE *db, LPCWSTR name )
|
2008-01-16 10:11:22 +00:00
|
|
|
{
|
|
|
|
static const WCHAR query[]= {
|
|
|
|
'S','E','L','E','C','T',' ','`','V','a','l','u','e','`',' ',
|
2012-01-21 17:19:12 +00:00
|
|
|
'F','R','O','M',' ' ,'`','_','P','r','o','p','e','r','t','y','`',' ',
|
|
|
|
'W','H','E','R','E',' ' ,'`','_','P','r','o','p','e','r','t','y','`','=','?',0};
|
|
|
|
MSIRECORD *rec, *row = NULL;
|
|
|
|
MSIQUERY *view;
|
|
|
|
UINT r;
|
2008-01-16 10:11:22 +00:00
|
|
|
|
2017-10-08 08:14:40 +00:00
|
|
|
static const WCHAR szDate[] = {'D','a','t','e',0};
|
|
|
|
static const WCHAR szTime[] = {'T','i','m','e',0};
|
|
|
|
WCHAR *buffer;
|
|
|
|
int length;
|
|
|
|
|
2008-01-16 10:11:22 +00:00
|
|
|
if (!name || !*name)
|
|
|
|
return NULL;
|
|
|
|
|
2022-03-13 00:35:24 +00:00
|
|
|
if (!wcscmp(name, szDate))
|
2017-10-08 08:14:40 +00:00
|
|
|
{
|
|
|
|
length = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, NULL, NULL, NULL, 0);
|
|
|
|
if (!length)
|
|
|
|
return NULL;
|
|
|
|
buffer = msi_alloc(length * sizeof(WCHAR));
|
2017-10-20 17:40:15 +00:00
|
|
|
GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, NULL, NULL, buffer, length);
|
2017-10-08 08:14:40 +00:00
|
|
|
|
|
|
|
row = MSI_CreateRecord(1);
|
|
|
|
if (!row)
|
2018-01-20 11:29:30 +00:00
|
|
|
{
|
|
|
|
msi_free(buffer);
|
2017-10-08 08:14:40 +00:00
|
|
|
return NULL;
|
2018-01-20 11:29:30 +00:00
|
|
|
}
|
2017-10-08 08:14:40 +00:00
|
|
|
MSI_RecordSetStringW(row, 1, buffer);
|
|
|
|
msi_free(buffer);
|
|
|
|
return row;
|
|
|
|
}
|
2022-03-13 00:35:24 +00:00
|
|
|
else if (!wcscmp(name, szTime))
|
2017-10-08 08:14:40 +00:00
|
|
|
{
|
|
|
|
length = GetTimeFormatW(LOCALE_USER_DEFAULT, TIME_NOTIMEMARKER, NULL, NULL, NULL, 0);
|
|
|
|
if (!length)
|
|
|
|
return NULL;
|
|
|
|
buffer = msi_alloc(length * sizeof(WCHAR));
|
2017-10-20 17:40:15 +00:00
|
|
|
GetTimeFormatW(LOCALE_USER_DEFAULT, TIME_NOTIMEMARKER, NULL, NULL, buffer, length);
|
2017-10-08 08:14:40 +00:00
|
|
|
|
|
|
|
row = MSI_CreateRecord(1);
|
|
|
|
if (!row)
|
2018-01-20 11:29:30 +00:00
|
|
|
{
|
|
|
|
msi_free(buffer);
|
2017-10-08 08:14:40 +00:00
|
|
|
return NULL;
|
2018-01-20 11:29:30 +00:00
|
|
|
}
|
2017-10-08 08:14:40 +00:00
|
|
|
MSI_RecordSetStringW(row, 1, buffer);
|
|
|
|
msi_free(buffer);
|
|
|
|
return row;
|
|
|
|
}
|
|
|
|
|
2009-05-20 12:59:23 +00:00
|
|
|
rec = MSI_CreateRecord(1);
|
|
|
|
if (!rec)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
MSI_RecordSetStringW(rec, 1, name);
|
|
|
|
|
2010-05-29 08:55:43 +00:00
|
|
|
r = MSI_DatabaseOpenViewW(db, query, &view);
|
2009-05-20 12:59:23 +00:00
|
|
|
if (r == ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
MSI_ViewExecute(view, rec);
|
|
|
|
MSI_ViewFetch(view, &row);
|
|
|
|
MSI_ViewClose(view);
|
|
|
|
msiobj_release(&view->hdr);
|
|
|
|
}
|
|
|
|
msiobj_release(&rec->hdr);
|
|
|
|
return row;
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
/* internal function, not compatible with MsiGetPropertyW */
|
2010-05-29 08:55:43 +00:00
|
|
|
UINT msi_get_property( MSIDATABASE *db, LPCWSTR szName,
|
2008-01-16 10:11:22 +00:00
|
|
|
LPWSTR szValueBuf, LPDWORD pchValueBuf )
|
2006-02-17 00:04:10 +00:00
|
|
|
{
|
2008-01-16 10:11:22 +00:00
|
|
|
MSIRECORD *row;
|
|
|
|
UINT rc = ERROR_FUNCTION_FAILED;
|
|
|
|
|
2015-11-21 16:44:38 +00:00
|
|
|
TRACE("%p %s %p %p\n", db, debugstr_w(szName), szValueBuf, pchValueBuf);
|
|
|
|
|
2010-05-29 08:55:43 +00:00
|
|
|
row = msi_get_property_row( db, szName );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
|
|
|
if (*pchValueBuf > 0)
|
|
|
|
szValueBuf[0] = 0;
|
|
|
|
|
2008-01-16 10:11:22 +00:00
|
|
|
if (row)
|
2006-02-17 00:04:10 +00:00
|
|
|
{
|
2008-01-16 10:11:22 +00:00
|
|
|
rc = MSI_RecordGetStringW(row, 1, szValueBuf, pchValueBuf);
|
|
|
|
msiobj_release(&row->hdr);
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
2008-01-16 10:11:22 +00:00
|
|
|
if (rc == ERROR_SUCCESS)
|
2012-12-09 19:43:59 +00:00
|
|
|
TRACE("returning %s for property %s\n", debugstr_wn(szValueBuf, *pchValueBuf),
|
2008-01-16 10:11:22 +00:00
|
|
|
debugstr_w(szName));
|
|
|
|
else if (rc == ERROR_MORE_DATA)
|
|
|
|
TRACE("need %d sized buffer for %s\n", *pchValueBuf,
|
|
|
|
debugstr_w(szName));
|
2006-02-17 00:04:10 +00:00
|
|
|
else
|
|
|
|
{
|
2008-01-16 10:11:22 +00:00
|
|
|
*pchValueBuf = 0;
|
|
|
|
TRACE("property %s not found\n", debugstr_w(szName));
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
2008-01-16 10:11:22 +00:00
|
|
|
return rc;
|
2006-08-30 19:24:26 +00:00
|
|
|
}
|
|
|
|
|
2010-05-29 08:55:43 +00:00
|
|
|
LPWSTR msi_dup_property(MSIDATABASE *db, LPCWSTR prop)
|
2006-08-30 19:24:26 +00:00
|
|
|
{
|
2008-01-16 10:11:22 +00:00
|
|
|
DWORD sz = 0;
|
|
|
|
LPWSTR str;
|
|
|
|
UINT r;
|
2006-08-30 19:24:26 +00:00
|
|
|
|
2010-05-29 08:55:43 +00:00
|
|
|
r = msi_get_property(db, prop, NULL, &sz);
|
2008-01-16 10:11:22 +00:00
|
|
|
if (r != ERROR_SUCCESS && r != ERROR_MORE_DATA)
|
|
|
|
return NULL;
|
2006-08-30 19:24:26 +00:00
|
|
|
|
2008-01-16 10:11:22 +00:00
|
|
|
sz++;
|
|
|
|
str = msi_alloc(sz * sizeof(WCHAR));
|
2010-05-29 08:55:43 +00:00
|
|
|
r = msi_get_property(db, prop, str, &sz);
|
2008-01-16 10:11:22 +00:00
|
|
|
if (r != ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
msi_free(str);
|
|
|
|
str = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return str;
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
2010-05-29 08:55:43 +00:00
|
|
|
int msi_get_property_int( MSIDATABASE *db, LPCWSTR prop, int def )
|
2006-08-30 19:24:26 +00:00
|
|
|
{
|
2010-05-29 08:55:43 +00:00
|
|
|
LPWSTR str = msi_dup_property( db, prop );
|
2022-03-13 00:35:24 +00:00
|
|
|
int val = str ? wcstol(str, NULL, 10) : def;
|
2008-01-16 10:11:22 +00:00
|
|
|
msi_free(str);
|
|
|
|
return val;
|
2006-08-30 19:24:26 +00:00
|
|
|
}
|
|
|
|
|
2022-03-12 14:12:16 +00:00
|
|
|
UINT WINAPI MsiGetPropertyA(MSIHANDLE hinst, const char *name, char *buf, DWORD *sz)
|
2006-02-17 00:04:10 +00:00
|
|
|
{
|
2022-03-12 14:12:16 +00:00
|
|
|
const WCHAR *value = szEmpty;
|
2006-02-17 00:04:10 +00:00
|
|
|
MSIPACKAGE *package;
|
2022-03-12 14:12:16 +00:00
|
|
|
MSIRECORD *row;
|
|
|
|
WCHAR *nameW;
|
|
|
|
int len = 0;
|
|
|
|
UINT r;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
|
|
|
if (!name)
|
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
|
|
|
2022-03-12 14:12:16 +00:00
|
|
|
if (!(nameW = strdupAtoW(name)))
|
|
|
|
return ERROR_OUTOFMEMORY;
|
|
|
|
|
|
|
|
package = msihandle2msiinfo(hinst, MSIHANDLETYPE_PACKAGE);
|
2006-02-17 00:04:10 +00:00
|
|
|
if (!package)
|
2008-01-16 10:11:22 +00:00
|
|
|
{
|
2022-03-12 14:12:16 +00:00
|
|
|
WCHAR *value = NULL, *tmp;
|
2022-03-12 14:11:45 +00:00
|
|
|
MSIHANDLE remote;
|
2022-03-12 14:12:16 +00:00
|
|
|
DWORD len;
|
2008-01-16 10:11:22 +00:00
|
|
|
|
2022-03-12 14:12:16 +00:00
|
|
|
if (!(remote = msi_get_remote(hinst)))
|
2022-03-12 14:12:17 +00:00
|
|
|
{
|
|
|
|
heap_free(nameW);
|
2008-01-16 10:11:22 +00:00
|
|
|
return ERROR_INVALID_HANDLE;
|
2022-03-12 14:12:17 +00:00
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2022-03-12 22:54:40 +00:00
|
|
|
__TRY
|
|
|
|
{
|
|
|
|
r = remote_GetProperty(remote, nameW, &value, &len);
|
|
|
|
}
|
|
|
|
__EXCEPT(rpc_filter)
|
|
|
|
{
|
|
|
|
r = GetExceptionCode();
|
|
|
|
}
|
|
|
|
__ENDTRY
|
|
|
|
|
2022-03-12 14:12:17 +00:00
|
|
|
heap_free(nameW);
|
|
|
|
|
2022-03-12 14:12:16 +00:00
|
|
|
if (!r)
|
2008-01-16 10:11:22 +00:00
|
|
|
{
|
2022-03-12 14:12:16 +00:00
|
|
|
/* String might contain embedded nulls.
|
|
|
|
* Native returns the correct size but truncates the string. */
|
|
|
|
tmp = heap_alloc_zero((len + 1) * sizeof(WCHAR));
|
|
|
|
if (!tmp)
|
|
|
|
{
|
|
|
|
midl_user_free(value);
|
|
|
|
return ERROR_OUTOFMEMORY;
|
|
|
|
}
|
2022-03-13 00:35:24 +00:00
|
|
|
lstrcpyW(tmp, value);
|
2008-01-16 10:11:22 +00:00
|
|
|
|
2022-03-12 14:12:16 +00:00
|
|
|
r = msi_strncpyWtoA(tmp, len, buf, sz, TRUE);
|
2008-01-16 10:11:22 +00:00
|
|
|
|
2022-03-12 14:12:16 +00:00
|
|
|
heap_free(tmp);
|
|
|
|
}
|
2022-03-12 14:11:46 +00:00
|
|
|
midl_user_free(value);
|
2008-01-16 10:11:22 +00:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2022-03-12 14:12:16 +00:00
|
|
|
row = msi_get_property_row(package->db, nameW);
|
2008-01-16 10:11:22 +00:00
|
|
|
if (row)
|
2022-03-12 14:12:16 +00:00
|
|
|
value = msi_record_get_string(row, 1, &len);
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2022-03-12 14:12:16 +00:00
|
|
|
r = msi_strncpyWtoA(value, len, buf, sz, FALSE);
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2022-03-12 14:12:16 +00:00
|
|
|
heap_free(nameW);
|
|
|
|
if (row) msiobj_release(&row->hdr);
|
|
|
|
msiobj_release(&package->hdr);
|
2006-02-17 00:04:10 +00:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2022-03-12 14:12:16 +00:00
|
|
|
UINT WINAPI MsiGetPropertyW(MSIHANDLE hinst, const WCHAR *name, WCHAR *buf, DWORD *sz)
|
2006-02-17 00:04:10 +00:00
|
|
|
{
|
2022-03-12 14:12:16 +00:00
|
|
|
const WCHAR *value = szEmpty;
|
2022-03-12 14:12:16 +00:00
|
|
|
MSIPACKAGE *package;
|
2022-03-12 14:12:16 +00:00
|
|
|
MSIRECORD *row;
|
|
|
|
int len = 0;
|
2006-02-17 00:04:10 +00:00
|
|
|
UINT r;
|
|
|
|
|
2022-03-12 14:12:16 +00:00
|
|
|
if (!name)
|
|
|
|
return ERROR_INVALID_PARAMETER;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2022-03-12 14:12:16 +00:00
|
|
|
package = msihandle2msiinfo(hinst, MSIHANDLETYPE_PACKAGE);
|
|
|
|
if (!package)
|
|
|
|
{
|
|
|
|
WCHAR *value = NULL, *tmp;
|
|
|
|
MSIHANDLE remote;
|
|
|
|
DWORD len;
|
|
|
|
|
|
|
|
if (!(remote = msi_get_remote(hinst)))
|
|
|
|
return ERROR_INVALID_HANDLE;
|
|
|
|
|
2022-03-12 22:54:40 +00:00
|
|
|
__TRY
|
|
|
|
{
|
|
|
|
r = remote_GetProperty(remote, name, &value, &len);
|
|
|
|
}
|
|
|
|
__EXCEPT(rpc_filter)
|
|
|
|
{
|
|
|
|
r = GetExceptionCode();
|
|
|
|
}
|
|
|
|
__ENDTRY
|
|
|
|
|
2022-03-12 14:12:16 +00:00
|
|
|
if (!r)
|
|
|
|
{
|
|
|
|
/* String might contain embedded nulls.
|
|
|
|
* Native returns the correct size but truncates the string. */
|
|
|
|
tmp = heap_alloc_zero((len + 1) * sizeof(WCHAR));
|
|
|
|
if (!tmp)
|
|
|
|
{
|
|
|
|
midl_user_free(value);
|
|
|
|
return ERROR_OUTOFMEMORY;
|
|
|
|
}
|
2022-03-13 00:35:24 +00:00
|
|
|
lstrcpyW(tmp, value);
|
2022-03-12 14:12:16 +00:00
|
|
|
|
2022-03-12 14:12:16 +00:00
|
|
|
r = msi_strncpyW(tmp, len, buf, sz);
|
2022-03-12 14:12:16 +00:00
|
|
|
|
|
|
|
heap_free(tmp);
|
|
|
|
}
|
|
|
|
midl_user_free(value);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2022-03-12 14:12:16 +00:00
|
|
|
row = msi_get_property_row(package->db, name);
|
|
|
|
if (row)
|
|
|
|
value = msi_record_get_string(row, 1, &len);
|
2022-03-12 14:12:16 +00:00
|
|
|
|
2022-03-12 14:12:16 +00:00
|
|
|
r = msi_strncpyW(value, len, buf, sz);
|
2022-03-12 14:12:16 +00:00
|
|
|
|
2022-03-12 14:12:16 +00:00
|
|
|
if (row) msiobj_release(&row->hdr);
|
2022-03-12 14:12:16 +00:00
|
|
|
msiobj_release(&package->hdr);
|
2006-02-17 00:04:10 +00:00
|
|
|
return r;
|
|
|
|
}
|
2006-08-30 19:24:26 +00:00
|
|
|
|
2022-03-12 14:12:08 +00:00
|
|
|
MSIHANDLE __cdecl s_remote_GetActiveDatabase(MSIHANDLE hinst)
|
2008-01-16 10:11:22 +00:00
|
|
|
{
|
2022-03-12 14:11:51 +00:00
|
|
|
return MsiGetActiveDatabase(hinst);
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
|
|
|
|
2022-03-12 14:12:08 +00:00
|
|
|
UINT __cdecl s_remote_GetProperty(MSIHANDLE hinst, LPCWSTR property, LPWSTR *value, DWORD *size)
|
2008-01-16 10:11:22 +00:00
|
|
|
{
|
2022-03-12 14:11:46 +00:00
|
|
|
WCHAR empty[1];
|
|
|
|
UINT r;
|
|
|
|
|
|
|
|
*size = 0;
|
|
|
|
r = MsiGetPropertyW(hinst, property, empty, size);
|
|
|
|
if (r == ERROR_MORE_DATA)
|
|
|
|
{
|
|
|
|
++*size;
|
|
|
|
*value = midl_user_allocate(*size * sizeof(WCHAR));
|
|
|
|
if (!*value)
|
|
|
|
return ERROR_OUTOFMEMORY;
|
|
|
|
r = MsiGetPropertyW(hinst, property, *value, size);
|
|
|
|
}
|
|
|
|
return r;
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
|
|
|
|
2022-03-12 14:12:08 +00:00
|
|
|
UINT __cdecl s_remote_SetProperty(MSIHANDLE hinst, LPCWSTR property, LPCWSTR value)
|
2008-01-16 10:11:22 +00:00
|
|
|
{
|
2022-03-12 14:11:46 +00:00
|
|
|
return MsiSetPropertyW(hinst, property, value);
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
|
|
|
|
2022-03-12 14:12:08 +00:00
|
|
|
int __cdecl s_remote_ProcessMessage(MSIHANDLE hinst, INSTALLMESSAGE message, struct wire_record *remote_rec)
|
2008-01-16 10:11:22 +00:00
|
|
|
{
|
2022-03-12 14:11:49 +00:00
|
|
|
MSIHANDLE rec;
|
|
|
|
int ret;
|
|
|
|
UINT r;
|
|
|
|
|
|
|
|
if ((r = unmarshal_record(remote_rec, &rec)))
|
|
|
|
return r;
|
|
|
|
|
|
|
|
ret = MsiProcessMessage(hinst, message, rec);
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
return ret;
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
|
|
|
|
2022-03-12 14:12:08 +00:00
|
|
|
UINT __cdecl s_remote_DoAction(MSIHANDLE hinst, LPCWSTR action)
|
2008-01-16 10:11:22 +00:00
|
|
|
{
|
2022-03-12 14:11:57 +00:00
|
|
|
return MsiDoActionW(hinst, action);
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
|
|
|
|
2022-03-12 14:12:08 +00:00
|
|
|
UINT __cdecl s_remote_Sequence(MSIHANDLE hinst, LPCWSTR table, int sequence)
|
2008-01-16 10:11:22 +00:00
|
|
|
{
|
2022-03-12 14:11:58 +00:00
|
|
|
return MsiSequenceW(hinst, table, sequence);
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
|
|
|
|
2022-03-12 14:12:08 +00:00
|
|
|
UINT __cdecl s_remote_GetTargetPath(MSIHANDLE hinst, LPCWSTR folder, LPWSTR *value)
|
2008-01-16 10:11:22 +00:00
|
|
|
{
|
2022-03-12 14:11:58 +00:00
|
|
|
WCHAR empty[1];
|
|
|
|
DWORD size = 0;
|
|
|
|
UINT r;
|
|
|
|
|
|
|
|
r = MsiGetTargetPathW(hinst, folder, empty, &size);
|
|
|
|
if (r == ERROR_MORE_DATA)
|
|
|
|
{
|
|
|
|
*value = midl_user_allocate(++size * sizeof(WCHAR));
|
|
|
|
if (!*value)
|
|
|
|
return ERROR_OUTOFMEMORY;
|
|
|
|
r = MsiGetTargetPathW(hinst, folder, *value, &size);
|
|
|
|
}
|
|
|
|
return r;
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
|
|
|
|
2022-03-12 14:12:08 +00:00
|
|
|
UINT __cdecl s_remote_SetTargetPath(MSIHANDLE hinst, LPCWSTR folder, LPCWSTR value)
|
2008-01-16 10:11:22 +00:00
|
|
|
{
|
2022-03-12 14:11:59 +00:00
|
|
|
return MsiSetTargetPathW(hinst, folder, value);
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
|
|
|
|
2022-03-12 14:12:08 +00:00
|
|
|
UINT __cdecl s_remote_GetSourcePath(MSIHANDLE hinst, LPCWSTR folder, LPWSTR *value)
|
2008-01-16 10:11:22 +00:00
|
|
|
{
|
2022-03-12 14:11:59 +00:00
|
|
|
WCHAR empty[1];
|
|
|
|
DWORD size = 1;
|
|
|
|
UINT r;
|
|
|
|
|
|
|
|
r = MsiGetSourcePathW(hinst, folder, empty, &size);
|
|
|
|
if (r == ERROR_MORE_DATA)
|
|
|
|
{
|
|
|
|
*value = midl_user_allocate(++size * sizeof(WCHAR));
|
|
|
|
if (!*value)
|
|
|
|
return ERROR_OUTOFMEMORY;
|
|
|
|
r = MsiGetSourcePathW(hinst, folder, *value, &size);
|
|
|
|
}
|
|
|
|
return r;
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
|
|
|
|
2022-03-12 14:12:08 +00:00
|
|
|
BOOL __cdecl s_remote_GetMode(MSIHANDLE hinst, MSIRUNMODE mode)
|
2008-01-16 10:11:22 +00:00
|
|
|
{
|
2022-03-12 14:12:00 +00:00
|
|
|
return MsiGetMode(hinst, mode);
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
|
|
|
|
2022-03-12 14:12:08 +00:00
|
|
|
UINT __cdecl s_remote_SetMode(MSIHANDLE hinst, MSIRUNMODE mode, BOOL state)
|
2010-03-01 12:01:30 +00:00
|
|
|
{
|
2022-03-12 14:12:01 +00:00
|
|
|
return MsiSetMode(hinst, mode, state);
|
2010-03-01 12:01:30 +00:00
|
|
|
}
|
|
|
|
|
2022-03-12 14:12:08 +00:00
|
|
|
UINT __cdecl s_remote_GetFeatureState(MSIHANDLE hinst, LPCWSTR feature,
|
2022-03-12 14:11:45 +00:00
|
|
|
INSTALLSTATE *installed, INSTALLSTATE *action)
|
2008-01-16 10:11:22 +00:00
|
|
|
{
|
2022-03-12 14:12:01 +00:00
|
|
|
return MsiGetFeatureStateW(hinst, feature, installed, action);
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
|
|
|
|
2022-03-12 14:12:08 +00:00
|
|
|
UINT __cdecl s_remote_SetFeatureState(MSIHANDLE hinst, LPCWSTR feature, INSTALLSTATE state)
|
2008-01-16 10:11:22 +00:00
|
|
|
{
|
2022-03-12 14:12:02 +00:00
|
|
|
return MsiSetFeatureStateW(hinst, feature, state);
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
|
|
|
|
2022-03-12 14:12:08 +00:00
|
|
|
UINT __cdecl s_remote_GetComponentState(MSIHANDLE hinst, LPCWSTR component,
|
2022-03-12 14:11:45 +00:00
|
|
|
INSTALLSTATE *installed, INSTALLSTATE *action)
|
2008-01-16 10:11:22 +00:00
|
|
|
{
|
2022-03-12 14:12:02 +00:00
|
|
|
return MsiGetComponentStateW(hinst, component, installed, action);
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
|
|
|
|
2022-03-12 14:12:08 +00:00
|
|
|
UINT __cdecl s_remote_SetComponentState(MSIHANDLE hinst, LPCWSTR component, INSTALLSTATE state)
|
2008-01-16 10:11:22 +00:00
|
|
|
{
|
2022-03-12 14:12:03 +00:00
|
|
|
return MsiSetComponentStateW(hinst, component, state);
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
|
|
|
|
2022-03-12 14:12:08 +00:00
|
|
|
LANGID __cdecl s_remote_GetLanguage(MSIHANDLE hinst)
|
2008-01-16 10:11:22 +00:00
|
|
|
{
|
2022-03-12 14:12:04 +00:00
|
|
|
return MsiGetLanguage(hinst);
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
|
|
|
|
2022-03-12 14:12:08 +00:00
|
|
|
UINT __cdecl s_remote_SetInstallLevel(MSIHANDLE hinst, int level)
|
2008-01-16 10:11:22 +00:00
|
|
|
{
|
2022-03-12 14:12:04 +00:00
|
|
|
return MsiSetInstallLevel(hinst, level);
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
|
|
|
|
2022-03-12 14:12:08 +00:00
|
|
|
UINT __cdecl s_remote_FormatRecord(MSIHANDLE hinst, struct wire_record *remote_rec, LPWSTR *value)
|
2008-01-16 10:11:22 +00:00
|
|
|
{
|
2022-03-12 14:12:05 +00:00
|
|
|
WCHAR empty[1];
|
2008-05-17 19:46:01 +00:00
|
|
|
DWORD size = 0;
|
2022-03-12 14:12:05 +00:00
|
|
|
MSIHANDLE rec;
|
|
|
|
UINT r;
|
|
|
|
|
|
|
|
if ((r = unmarshal_record(remote_rec, &rec)))
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = MsiFormatRecordW(hinst, rec, empty, &size);
|
|
|
|
if (r == ERROR_MORE_DATA)
|
2008-05-17 19:46:01 +00:00
|
|
|
{
|
2022-03-12 14:12:05 +00:00
|
|
|
*value = midl_user_allocate(++size * sizeof(WCHAR));
|
2008-05-17 19:46:01 +00:00
|
|
|
if (!*value)
|
2022-03-12 23:04:00 +00:00
|
|
|
{
|
|
|
|
MsiCloseHandle(rec);
|
2022-03-12 14:12:05 +00:00
|
|
|
return ERROR_OUTOFMEMORY;
|
2022-03-12 23:04:00 +00:00
|
|
|
}
|
2022-03-12 14:12:05 +00:00
|
|
|
r = MsiFormatRecordW(hinst, rec, *value, &size);
|
2008-05-17 19:46:01 +00:00
|
|
|
}
|
2022-03-12 14:12:05 +00:00
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
return r;
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
|
|
|
|
2022-03-12 14:12:08 +00:00
|
|
|
MSICONDITION __cdecl s_remote_EvaluateCondition(MSIHANDLE hinst, LPCWSTR condition)
|
2008-01-16 10:11:22 +00:00
|
|
|
{
|
2022-03-12 14:12:05 +00:00
|
|
|
return MsiEvaluateConditionW(hinst, condition);
|
2008-01-16 10:11:22 +00:00
|
|
|
}
|
|
|
|
|
2022-03-12 14:12:08 +00:00
|
|
|
UINT __cdecl s_remote_GetFeatureCost(MSIHANDLE hinst, LPCWSTR feature,
|
2022-03-12 14:12:06 +00:00
|
|
|
MSICOSTTREE cost_tree, INSTALLSTATE state, INT *cost)
|
2009-11-16 01:13:42 +00:00
|
|
|
{
|
2022-03-12 14:12:06 +00:00
|
|
|
return MsiGetFeatureCostW(hinst, feature, cost_tree, state, cost);
|
2009-11-16 01:13:42 +00:00
|
|
|
}
|
|
|
|
|
2022-03-12 14:12:08 +00:00
|
|
|
UINT __cdecl s_remote_EnumComponentCosts(MSIHANDLE hinst, LPCWSTR component,
|
2022-03-12 14:12:07 +00:00
|
|
|
DWORD index, INSTALLSTATE state, LPWSTR drive, INT *cost, INT *temp)
|
2012-01-21 17:19:12 +00:00
|
|
|
{
|
2022-03-12 14:12:07 +00:00
|
|
|
DWORD size = 3;
|
|
|
|
return MsiEnumComponentCostsW(hinst, component, index, state, drive, &size, cost, temp);
|
2012-01-21 17:19:12 +00:00
|
|
|
}
|
|
|
|
|
2008-01-16 10:11:22 +00:00
|
|
|
UINT msi_package_add_info(MSIPACKAGE *package, DWORD context, DWORD options,
|
|
|
|
LPCWSTR property, LPWSTR value)
|
|
|
|
{
|
|
|
|
MSISOURCELISTINFO *info;
|
|
|
|
|
2011-03-20 08:47:41 +00:00
|
|
|
LIST_FOR_EACH_ENTRY( info, &package->sourcelist_info, MSISOURCELISTINFO, entry )
|
|
|
|
{
|
2022-03-13 00:35:24 +00:00
|
|
|
if (!wcscmp( info->value, value )) return ERROR_SUCCESS;
|
2011-03-20 08:47:41 +00:00
|
|
|
}
|
|
|
|
|
2008-01-16 10:11:22 +00:00
|
|
|
info = msi_alloc(sizeof(MSISOURCELISTINFO));
|
|
|
|
if (!info)
|
|
|
|
return ERROR_OUTOFMEMORY;
|
|
|
|
|
|
|
|
info->context = context;
|
|
|
|
info->options = options;
|
|
|
|
info->property = property;
|
|
|
|
info->value = strdupW(value);
|
|
|
|
list_add_head(&package->sourcelist_info, &info->entry);
|
|
|
|
|
|
|
|
return ERROR_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
UINT msi_package_add_media_disk(MSIPACKAGE *package, DWORD context, DWORD options,
|
|
|
|
DWORD disk_id, LPWSTR volume_label, LPWSTR disk_prompt)
|
|
|
|
{
|
|
|
|
MSIMEDIADISK *disk;
|
|
|
|
|
2011-03-20 08:47:41 +00:00
|
|
|
LIST_FOR_EACH_ENTRY( disk, &package->sourcelist_media, MSIMEDIADISK, entry )
|
|
|
|
{
|
|
|
|
if (disk->disk_id == disk_id) return ERROR_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2008-01-16 10:11:22 +00:00
|
|
|
disk = msi_alloc(sizeof(MSIMEDIADISK));
|
|
|
|
if (!disk)
|
|
|
|
return ERROR_OUTOFMEMORY;
|
|
|
|
|
|
|
|
disk->context = context;
|
|
|
|
disk->options = options;
|
|
|
|
disk->disk_id = disk_id;
|
|
|
|
disk->volume_label = strdupW(volume_label);
|
|
|
|
disk->disk_prompt = strdupW(disk_prompt);
|
|
|
|
list_add_head(&package->sourcelist_media, &disk->entry);
|
|
|
|
|
|
|
|
return ERROR_SUCCESS;
|
|
|
|
}
|