package.c File Reference

#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winreg.h"
#include "winnls.h"
#include "shlwapi.h"
#include "wingdi.h"
#include "wine/debug.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 "wine/unicode.h"
#include "objbase.h"
#include "msidefs.h"
#include "sddl.h"
#include "msipriv.h"
#include "msiserver.h"
#include "resource.h"

Include dependency graph for package.c:

Go to the source code of this file.

Classes
struct	tagLANGANDCODEPAGE
struct	_msi_remote_package_impl

Macros
#define	NONAMELESSUNION
#define	NONAMELESSSTRUCT
#define	COBJMACROS

Typedefs
typedef struct tagLANGANDCODEPAGE	LANGANDCODEPAGE
typedef struct _msi_remote_package_impl	msi_remote_package_impl

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (msi)
static void	free_feature (MSIFEATURE *feature)
static void	free_folder (MSIFOLDER *folder)
static void	free_extension (MSIEXTENSION *ext)
static void	free_assembly (MSIASSEMBLY *assembly)
void	msi_free_action_script (MSIPACKAGE *package, UINT script)
static void	free_package_structures (MSIPACKAGE *package)
static void	MSI_FreePackage (MSIOBJECTHDR *arg)
static UINT	create_temp_property_table (MSIPACKAGE *package)
UINT	msi_clone_properties (MSIDATABASE *db)
static UINT	set_installed_prop (MSIPACKAGE *package)
static UINT	set_user_sid_prop (MSIPACKAGE *package)
static LPWSTR	get_fusion_filename (MSIPACKAGE *package)
static void	set_msi_assembly_prop (MSIPACKAGE *package)
static VOID	set_installer_properties (MSIPACKAGE *package)
static MSIPACKAGE *	msi_alloc_package (void)
static UINT	msi_load_admin_properties (MSIPACKAGE *package)
void	msi_adjust_privilege_properties (MSIPACKAGE *package)
MSIPACKAGE *	MSI_CreatePackage (MSIDATABASE *db, LPCWSTR base_url)
UINT	msi_download_file (LPCWSTR szUrl, LPWSTR filename)
UINT	msi_create_empty_local_file (LPWSTR path, LPCWSTR suffix)
static enum platform	parse_platform (const WCHAR *str)
static UINT	parse_suminfo (MSISUMMARYINFO *si, MSIPACKAGE *package)
static UINT	validate_package (MSIPACKAGE *package)
static WCHAR *	get_product_code (MSIDATABASE *db)
static UINT	get_registered_local_package (const WCHAR *product, const WCHAR *package, WCHAR *localfile)
static WCHAR *	get_package_code (MSIDATABASE *db)
static UINT	get_local_package (const WCHAR *filename, WCHAR *localfile)
UINT	msi_set_original_database_property (MSIDATABASE *db, const WCHAR *package)
UINT	MSI_OpenPackageW (LPCWSTR szPackage, MSIPACKAGE **pPackage)
UINT WINAPI	MsiOpenPackageExW (LPCWSTR szPackage, DWORD dwOptions, MSIHANDLE *phPackage)
UINT WINAPI	MsiOpenPackageW (LPCWSTR szPackage, MSIHANDLE *phPackage)
UINT WINAPI	MsiOpenPackageExA (LPCSTR szPackage, DWORD dwOptions, MSIHANDLE *phPackage)
UINT WINAPI	MsiOpenPackageA (LPCSTR szPackage, MSIHANDLE *phPackage)
MSIHANDLE WINAPI	MsiGetActiveDatabase (MSIHANDLE hInstall)
static INT	internal_ui_handler (MSIPACKAGE *package, INSTALLMESSAGE eMessageType, MSIRECORD *record, LPCWSTR message)
static LPCWSTR	get_internal_error_message (int error)
LPWSTR	msi_get_error_message (MSIDATABASE *db, int error)
INT	MSI_ProcessMessageVerbatim (MSIPACKAGE *package, INSTALLMESSAGE eMessageType, MSIRECORD *record)
INT	MSI_ProcessMessage (MSIPACKAGE *package, INSTALLMESSAGE eMessageType, MSIRECORD *record)
INT WINAPI	MsiProcessMessage (MSIHANDLE hInstall, INSTALLMESSAGE eMessageType, MSIHANDLE hRecord)
UINT WINAPI	MsiSetPropertyA (MSIHANDLE hInstall, LPCSTR szName, LPCSTR szValue)
void	msi_reset_folders (MSIPACKAGE *package, BOOL source)
UINT	msi_set_property (MSIDATABASE *db, const WCHAR *name, const WCHAR *value, int len)
UINT WINAPI	MsiSetPropertyW (MSIHANDLE hInstall, LPCWSTR szName, LPCWSTR szValue)
static MSIRECORD *	msi_get_property_row (MSIDATABASE *db, LPCWSTR name)
UINT	msi_get_property (MSIDATABASE *db, LPCWSTR szName, LPWSTR szValueBuf, LPDWORD pchValueBuf)
LPWSTR	msi_dup_property (MSIDATABASE *db, LPCWSTR prop)
int	msi_get_property_int (MSIDATABASE *db, LPCWSTR prop, int def)
static UINT	MSI_GetProperty (MSIHANDLE handle, LPCWSTR name, awstring *szValueBuf, LPDWORD pchValueBuf)
UINT WINAPI	MsiGetPropertyA (MSIHANDLE hInstall, LPCSTR szName, LPSTR szValueBuf, LPDWORD pchValueBuf)
UINT WINAPI	MsiGetPropertyW (MSIHANDLE hInstall, LPCWSTR szName, LPWSTR szValueBuf, LPDWORD pchValueBuf)
static msi_remote_package_impl *	impl_from_IWineMsiRemotePackage (IWineMsiRemotePackage *iface)
static HRESULT WINAPI	mrp_QueryInterface (IWineMsiRemotePackage *iface, REFIID riid, LPVOID *ppobj)
static ULONG WINAPI	mrp_AddRef (IWineMsiRemotePackage *iface)
static ULONG WINAPI	mrp_Release (IWineMsiRemotePackage *iface)
static HRESULT WINAPI	mrp_SetMsiHandle (IWineMsiRemotePackage *iface, MSIHANDLE handle)
static HRESULT WINAPI	mrp_GetActiveDatabase (IWineMsiRemotePackage *iface, MSIHANDLE *handle)
static HRESULT WINAPI	mrp_GetProperty (IWineMsiRemotePackage *iface, BSTR property, BSTR value, DWORD *size)
static HRESULT WINAPI	mrp_SetProperty (IWineMsiRemotePackage *iface, BSTR property, BSTR value)
static HRESULT WINAPI	mrp_ProcessMessage (IWineMsiRemotePackage *iface, INSTALLMESSAGE message, MSIHANDLE record)
static HRESULT WINAPI	mrp_DoAction (IWineMsiRemotePackage *iface, BSTR action)
static HRESULT WINAPI	mrp_Sequence (IWineMsiRemotePackage *iface, BSTR table, int sequence)
static HRESULT WINAPI	mrp_GetTargetPath (IWineMsiRemotePackage *iface, BSTR folder, BSTR value, DWORD *size)
static HRESULT WINAPI	mrp_SetTargetPath (IWineMsiRemotePackage *iface, BSTR folder, BSTR value)
static HRESULT WINAPI	mrp_GetSourcePath (IWineMsiRemotePackage *iface, BSTR folder, BSTR value, DWORD *size)
static HRESULT WINAPI	mrp_GetMode (IWineMsiRemotePackage *iface, MSIRUNMODE mode, BOOL *ret)
static HRESULT WINAPI	mrp_SetMode (IWineMsiRemotePackage *iface, MSIRUNMODE mode, BOOL state)
static HRESULT WINAPI	mrp_GetFeatureState (IWineMsiRemotePackage *iface, BSTR feature, INSTALLSTATE *installed, INSTALLSTATE *action)
static HRESULT WINAPI	mrp_SetFeatureState (IWineMsiRemotePackage *iface, BSTR feature, INSTALLSTATE state)
static HRESULT WINAPI	mrp_GetComponentState (IWineMsiRemotePackage *iface, BSTR component, INSTALLSTATE *installed, INSTALLSTATE *action)
static HRESULT WINAPI	mrp_SetComponentState (IWineMsiRemotePackage *iface, BSTR component, INSTALLSTATE state)
static HRESULT WINAPI	mrp_GetLanguage (IWineMsiRemotePackage *iface, LANGID *language)
static HRESULT WINAPI	mrp_SetInstallLevel (IWineMsiRemotePackage *iface, int level)
static HRESULT WINAPI	mrp_FormatRecord (IWineMsiRemotePackage *iface, MSIHANDLE record, BSTR *value)
static HRESULT WINAPI	mrp_EvaluateCondition (IWineMsiRemotePackage *iface, BSTR condition)
static HRESULT WINAPI	mrp_GetFeatureCost (IWineMsiRemotePackage *iface, BSTR feature, INT cost_tree, INSTALLSTATE state, INT *cost)
static HRESULT WINAPI	mrp_EnumComponentCosts (IWineMsiRemotePackage *iface, BSTR component, DWORD index, INSTALLSTATE state, BSTR drive, DWORD *buflen, INT *cost, INT *temp)
HRESULT	create_msi_remote_package (IUnknown *pOuter, LPVOID *ppObj)
UINT	msi_package_add_info (MSIPACKAGE *package, DWORD context, DWORD options, LPCWSTR property, LPWSTR value)
UINT	msi_package_add_media_disk (MSIPACKAGE *package, DWORD context, DWORD options, DWORD disk_id, LPWSTR volume_label, LPWSTR disk_prompt)

Variables
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}
struct {
int   id
const WCHAR *   text
}	internal_errors []
static const IWineMsiRemotePackageVtbl	msi_remote_package_vtbl

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 23 of file package.c.

NONAMELESSSTRUCT

#define NONAMELESSSTRUCT

Definition at line 22 of file package.c.

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 21 of file package.c.

Typedef Documentation

LANGANDCODEPAGE

typedef struct tagLANGANDCODEPAGE LANGANDCODEPAGE

msi_remote_package_impl

typedef struct _msi_remote_package_impl msi_remote_package_impl

Function Documentation

create_msi_remote_package()

HRESULT create_msi_remote_package	(	IUnknown *	pOuter,
		LPVOID *	ppObj
	)

Definition at line 2783 of file package.c.

{
    msi_remote_package_impl* This;

    This = msi_alloc( sizeof *This );
    if (!This)
        return E_OUTOFMEMORY;

    This->IWineMsiRemotePackage_iface.lpVtbl = &msi_remote_package_vtbl;
    This->package = 0;
    This->refs = 1;

    *ppObj = &This->IWineMsiRemotePackage_iface;

    return S_OK;
}

Referenced by mcr_GetActionInfo().

create_temp_property_table()

static UINT create_temp_property_table ( MSIPACKAGE *  package )

static

Definition at line 352 of file package.c.

{
    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;
    UINT rc;

    rc = MSI_DatabaseOpenViewW(package->db, query, &view);
    if (rc != ERROR_SUCCESS)
        return rc;

    rc = MSI_ViewExecute(view, 0);
    MSI_ViewClose(view);
    msiobj_release(&view->hdr);
    return rc;
}

Referenced by MSI_CreatePackage().

free_assembly()

static void free_assembly ( MSIASSEMBLY *  assembly )

static

Definition at line 118 of file package.c.

{
    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 );
}

Referenced by free_package_structures().

free_extension()

static void free_extension ( MSIEXTENSION *  ext )

static

Definition at line 98 of file package.c.

{
    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 );
}

Referenced by free_package_structures().

free_feature()

static void free_feature ( MSIFEATURE *  feature )

static

Definition at line 53 of file package.c.

{
    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 );
}

Referenced by free_package_structures().

free_folder()

static void free_folder ( MSIFOLDER *  folder )

static

Definition at line 78 of file package.c.

{
    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 );
}

Referenced by free_package_structures().

free_package_structures()

static void free_package_structures ( MSIPACKAGE *  package )

static

Definition at line 140 of file package.c.

{
    struct list *item, *cursor;
    int i;

    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 );
        free_folder( folder );
    }

    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 );
    }

    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 );
        if (comp->assembly) free_assembly( comp->assembly );
        msi_free( comp );
    }

    LIST_FOR_EACH_SAFE( item, cursor, &package->filepatches )
    {
        MSIFILEPATCH *patch = LIST_ENTRY( item, MSIFILEPATCH, entry );

        list_remove( &patch->entry );
        msi_free( patch->path );
        msi_free( patch );
    }

    /* 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 );
        msi_free( mt->suffix );
        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 );
    }

    for (i = 0; i < SCRIPT_MAX; i++)
        msi_free_action_script( package, i );

    for (i = 0; i < package->unique_actions_count; i++)
        msi_free( package->unique_actions[i] );
    msi_free( package->unique_actions);

    LIST_FOR_EACH_SAFE( item, cursor, &package->binaries )
    {
        MSIBINARY *binary = LIST_ENTRY( item, MSIBINARY, entry );

        list_remove( &binary->entry );
        if (binary->module)
            FreeLibrary( binary->module );
        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 );
    }

    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 );
    }

    msi_free( package->BaseURL );
    msi_free( package->PackagePath );
    msi_free( package->ProductCode );
    msi_free( package->ActionFormat );
    msi_free( package->LastAction );
    msi_free( package->LastActionTemplate );
    msi_free( package->langids );

    /* cleanup control event subscriptions */
    msi_event_cleanup_all_subscriptions( package );
}

Referenced by MSI_FreePackage().

get_fusion_filename()

static LPWSTR get_fusion_filename ( MSIPACKAGE *  package )

static

Definition at line 529 of file package.c.

{
    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;
    LONG res;
    DWORD size, len, type;
    WCHAR windir[MAX_PATH], path[MAX_PATH], *filename = NULL;

    res = RegOpenKeyExW(HKEY_LOCAL_MACHINE, subkey, 0, KEY_CREATE_SUB_KEY, &netsetup);
    if (res != ERROR_SUCCESS)
        return NULL;

    if (!RegCreateKeyExW(netsetup, v4client, 0, NULL, 0, KEY_QUERY_VALUE, NULL, &hkey, NULL))
    {
        size = sizeof(path)/sizeof(path[0]);
        if (!RegQueryValueExW(hkey, installpath, NULL, &type, (BYTE *)path, &size))
        {
            len = strlenW(path) + strlenW(fusion) + 2;
            if (!(filename = msi_alloc(len * sizeof(WCHAR)))) return NULL;

            strcpyW(filename, path);
            strcatW(filename, szBackSlash);
            strcatW(filename, fusion);
            if (GetFileAttributesW(filename) != INVALID_FILE_ATTRIBUTES)
            {
                TRACE( "found %s\n", debugstr_w(filename) );
                RegCloseKey(hkey);
                RegCloseKey(netsetup);
                return filename;
            }
        }
        RegCloseKey(hkey);
    }

    if (!RegCreateKeyExW(netsetup, v2050727, 0, NULL, 0, KEY_QUERY_VALUE, NULL, &hkey, NULL))
    {
        RegCloseKey(hkey);
        GetWindowsDirectoryW(windir, MAX_PATH);
        len = strlenW(windir) + strlenW(subdir) + strlenW(v2050727) + strlenW(fusion) + 3;
        if (!(filename = msi_alloc(len * sizeof(WCHAR)))) return NULL;

        strcpyW(filename, windir);
        strcatW(filename, szBackSlash);
        strcatW(filename, subdir);
        strcatW(filename, v2050727);
        strcatW(filename, szBackSlash);
        strcatW(filename, fusion);
        if (GetFileAttributesW(filename) != INVALID_FILE_ATTRIBUTES)
        {
            TRACE( "found %s\n", debugstr_w(filename) );
            RegCloseKey(netsetup);
            return filename;
        }
    }

    RegCloseKey(netsetup);
    return filename;
}

Referenced by set_msi_assembly_prop().

get_internal_error_message()

static LPCWSTR get_internal_error_message ( int  error )

static

Definition at line 1835 of file package.c.

{
    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;
}

Referenced by MSI_ProcessMessage().

get_local_package()

static UINT get_local_package ( const WCHAR *  filename, WCHAR *  localfile  )

static

Definition at line 1389 of file package.c.

{
    WCHAR *product_code, *package_code;
    MSIDATABASE *db;
    UINT r;

    if ((r = MSI_OpenDatabaseW( filename, MSIDBOPEN_READONLY, &db )) != ERROR_SUCCESS)
    {
        if (GetFileAttributesW( filename ) == INVALID_FILE_ATTRIBUTES)
            return ERROR_FILE_NOT_FOUND;
        return r;
    }
    if (!(product_code = get_product_code( db )))
    {
        msiobj_release( &db->hdr );
        return ERROR_INSTALL_PACKAGE_INVALID;
    }
    if (!(package_code = get_package_code( db )))
    {
        msi_free( product_code );
        msiobj_release( &db->hdr );
        return ERROR_INSTALL_PACKAGE_INVALID;
    }
    r = get_registered_local_package( product_code, package_code, localfile );
    msi_free( package_code );
    msi_free( product_code );
    msiobj_release( &db->hdr );
    return r;
}

Referenced by MSI_OpenPackageW().

get_package_code()

static WCHAR* get_package_code ( MSIDATABASE *  db )

static

Definition at line 1368 of file package.c.

{
    WCHAR *ret;
    MSISUMMARYINFO *si;
    UINT r;

    r = msi_get_suminfo( db->storage, 0, &si );
    if (r != ERROR_SUCCESS)
    {
        r = msi_get_db_suminfo( db, 0, &si );
        if (r != ERROR_SUCCESS)
        {
            WARN("failed to load summary info %u\n", r);
            return NULL;
        }
    }
    ret = msi_suminfo_dup_string( si, PID_REVNUMBER );
    msiobj_release( &si->hdr );
    return ret;
}

Referenced by get_local_package().

get_product_code()

static WCHAR* get_product_code ( MSIDATABASE *  db )

static

Definition at line 1293 of file package.c.

{
    static const WCHAR query[] = {
        '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','`','=',
        '\'','P','r','o','d','u','c','t','C','o','d','e','\'',0};
    MSIQUERY *view;
    MSIRECORD *rec;
    WCHAR *ret = NULL;

    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;
}

Referenced by get_local_package().

get_registered_local_package()

static UINT get_registered_local_package ( const WCHAR *  product, const WCHAR *  package, WCHAR *  localfile  )

static

Definition at line 1324 of file package.c.

{
    MSIINSTALLCONTEXT context;
    HKEY product_key, props_key;
    WCHAR *registered_package = NULL, unsquashed[GUID_SIZE];
    UINT r;

    r = msi_locate_product( product, &context );
    if (r != ERROR_SUCCESS)
        return r;

    r = MSIREG_OpenProductKey( product, NULL, context, &product_key, FALSE );
    if (r != ERROR_SUCCESS)
        return r;

    r = MSIREG_OpenInstallProps( product, context, NULL, &props_key, FALSE );
    if (r != ERROR_SUCCESS)
    {
        RegCloseKey( product_key );
        return r;
    }
    r = ERROR_FUNCTION_FAILED;
    registered_package = msi_reg_get_val_str( product_key, INSTALLPROPERTY_PACKAGECODEW );
    if (!registered_package)
        goto done;

    unsquash_guid( registered_package, unsquashed );
    if (!strcmpiW( package, unsquashed ))
    {
        WCHAR *filename = msi_reg_get_val_str( props_key, INSTALLPROPERTY_LOCALPACKAGEW );
        if (!filename)
            goto done;

        strcpyW( localfile, filename );
        msi_free( filename );
        r = ERROR_SUCCESS;
    }
done:
    msi_free( registered_package );
    RegCloseKey( props_key );
    RegCloseKey( product_key );
    return r;
}

Referenced by get_local_package().

impl_from_IWineMsiRemotePackage()

static msi_remote_package_impl* impl_from_IWineMsiRemotePackage ( IWineMsiRemotePackage *  iface )

inlinestatic

Definition at line 2524 of file package.c.

{
    return CONTAINING_RECORD(iface, msi_remote_package_impl, IWineMsiRemotePackage_iface);
}

Referenced by mrp_AddRef(), mrp_DoAction(), mrp_EnumComponentCosts(), mrp_EvaluateCondition(), mrp_FormatRecord(), mrp_GetActiveDatabase(), mrp_GetComponentState(), mrp_GetFeatureCost(), mrp_GetFeatureState(), mrp_GetLanguage(), mrp_GetMode(), mrp_GetProperty(), mrp_GetSourcePath(), mrp_GetTargetPath(), mrp_ProcessMessage(), mrp_Release(), mrp_Sequence(), mrp_SetComponentState(), mrp_SetFeatureState(), mrp_SetInstallLevel(), mrp_SetMode(), mrp_SetMsiHandle(), mrp_SetProperty(), and mrp_SetTargetPath().

internal_ui_handler()

static INT internal_ui_handler ( MSIPACKAGE *  package, INSTALLMESSAGE  eMessageType, MSIRECORD *  record, LPCWSTR  message  )

static

Definition at line 1725 of file package.c.

{
    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};
    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:
    case INSTALLMESSAGE_INSTALLSTART:
    case INSTALLMESSAGE_INSTALLEND:
        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;
    }
}

Referenced by MSI_ProcessMessageVerbatim().

mrp_AddRef()

static ULONG WINAPI mrp_AddRef ( IWineMsiRemotePackage *  iface )

static

Definition at line 2543 of file package.c.

{
    msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );

    return InterlockedIncrement( &This->refs );
}

mrp_DoAction()

static HRESULT WINAPI mrp_DoAction ( IWineMsiRemotePackage *  iface, BSTR  action  )

static

Definition at line 2620 of file package.c.

{
    msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
    UINT r = MsiDoActionW(This->package, action);
    return HRESULT_FROM_WIN32(r);
}

mrp_EnumComponentCosts()

static HRESULT WINAPI mrp_EnumComponentCosts ( IWineMsiRemotePackage *  iface, BSTR  component, DWORD  index, INSTALLSTATE  state, BSTR  drive, DWORD *  buflen, INT *  cost, INT *  temp  )

static

Definition at line 2745 of file package.c.

{
    msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
    UINT r = MsiEnumComponentCostsW(This->package, component, index, state, drive, buflen, cost, temp);
    return HRESULT_FROM_WIN32(r);
}

mrp_EvaluateCondition()

static HRESULT WINAPI mrp_EvaluateCondition ( IWineMsiRemotePackage *  iface, BSTR  condition  )

static

Definition at line 2730 of file package.c.

{
    msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
    UINT r = MsiEvaluateConditionW(This->package, condition);
    return HRESULT_FROM_WIN32(r);
}

mrp_FormatRecord()

static HRESULT WINAPI mrp_FormatRecord ( IWineMsiRemotePackage *  iface, MSIHANDLE  record, BSTR *  value  )

static

Definition at line 2713 of file package.c.

{
    DWORD size = 0;
    msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
    UINT r = MsiFormatRecordW(This->package, record, NULL, &size);
    if (r == ERROR_SUCCESS)
    {
        *value = SysAllocStringLen(NULL, size);
        if (!*value)
            return E_OUTOFMEMORY;
        size++;
        r = MsiFormatRecordW(This->package, record, *value, &size);
    }
    return HRESULT_FROM_WIN32(r);
}

mrp_GetActiveDatabase()

static HRESULT WINAPI mrp_GetActiveDatabase ( IWineMsiRemotePackage *  iface, MSIHANDLE *  handle  )

static

Definition at line 2571 of file package.c.

{
    msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
    IWineMsiRemoteDatabase *rdb = NULL;
    HRESULT hr;
    MSIHANDLE hdb;

    hr = create_msi_remote_database( NULL, (LPVOID *)&rdb );
    if (FAILED(hr) || !rdb)
    {
        ERR("Failed to create remote database\n");
        return hr;
    }

    hdb = MsiGetActiveDatabase(This->package);

    hr = IWineMsiRemoteDatabase_SetMsiHandle( rdb, hdb );
    if (FAILED(hr))
    {
        ERR("Failed to set the database handle\n");
        return hr;
    }

    *handle = alloc_msi_remote_handle( (IUnknown *)rdb );
    return S_OK;
}

mrp_GetComponentState()

static HRESULT WINAPI mrp_GetComponentState ( IWineMsiRemotePackage *  iface, BSTR  component, INSTALLSTATE *  installed, INSTALLSTATE *  action  )

static

Definition at line 2684 of file package.c.

{
    msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
    UINT r = MsiGetComponentStateW(This->package, component, installed, action);
    return HRESULT_FROM_WIN32(r);
}

mrp_GetFeatureCost()

static HRESULT WINAPI mrp_GetFeatureCost ( IWineMsiRemotePackage *  iface, BSTR  feature, INT  cost_tree, INSTALLSTATE  state, INT *  cost  )

static

Definition at line 2737 of file package.c.

{
    msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
    UINT r = MsiGetFeatureCostW(This->package, feature, cost_tree, state, cost);
    return HRESULT_FROM_WIN32(r);
}

mrp_GetFeatureState()

static HRESULT WINAPI mrp_GetFeatureState ( IWineMsiRemotePackage *  iface, BSTR  feature, INSTALLSTATE *  installed, INSTALLSTATE *  action  )

static

Definition at line 2669 of file package.c.

{
    msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
    UINT r = MsiGetFeatureStateW(This->package, feature, installed, action);
    return HRESULT_FROM_WIN32(r);
}

mrp_GetLanguage()

static HRESULT WINAPI mrp_GetLanguage ( IWineMsiRemotePackage *  iface, LANGID *  language  )

static

Definition at line 2699 of file package.c.

{
    msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
    *language = MsiGetLanguage(This->package);
    return S_OK;
}

mrp_GetMode()

static HRESULT WINAPI mrp_GetMode ( IWineMsiRemotePackage *  iface, MSIRUNMODE  mode, BOOL *  ret  )

static

Definition at line 2655 of file package.c.

{
    msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
    *ret = MsiGetMode(This->package, mode);
    return S_OK;
}

mrp_GetProperty()

static HRESULT WINAPI mrp_GetProperty ( IWineMsiRemotePackage *  iface, BSTR  property, BSTR  value, DWORD *  size  )

static

Definition at line 2598 of file package.c.

{
    msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
    UINT r = MsiGetPropertyW(This->package, property, value, size);
    if (r != ERROR_SUCCESS) return HRESULT_FROM_WIN32(r);
    return S_OK;
}

mrp_GetSourcePath()

static HRESULT WINAPI mrp_GetSourcePath ( IWineMsiRemotePackage *  iface, BSTR  folder, BSTR  value, DWORD *  size  )

static

Definition at line 2648 of file package.c.

{
    msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
    UINT r = MsiGetSourcePathW(This->package, folder, value, size);
    return HRESULT_FROM_WIN32(r);
}

mrp_GetTargetPath()

static HRESULT WINAPI mrp_GetTargetPath ( IWineMsiRemotePackage *  iface, BSTR  folder, BSTR  value, DWORD *  size  )

static

Definition at line 2634 of file package.c.

{
    msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
    UINT r = MsiGetTargetPathW(This->package, folder, value, size);
    return HRESULT_FROM_WIN32(r);
}

mrp_ProcessMessage()

static HRESULT WINAPI mrp_ProcessMessage ( IWineMsiRemotePackage *  iface, INSTALLMESSAGE  message, MSIHANDLE  record  )

static

Definition at line 2613 of file package.c.

{
    msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
    UINT r = MsiProcessMessage(This->package, message, record);
    return HRESULT_FROM_WIN32(r);
}

mrp_QueryInterface()

static HRESULT WINAPI mrp_QueryInterface ( IWineMsiRemotePackage *  iface, REFIID  riid, LPVOID *  ppobj  )

static

Definition at line 2529 of file package.c.

{
    if( IsEqualCLSID( riid, &IID_IUnknown ) ||
        IsEqualCLSID( riid, &IID_IWineMsiRemotePackage ) )
    {
        IWineMsiRemotePackage_AddRef( iface );
        *ppobj = iface;
        return S_OK;
    }

    return E_NOINTERFACE;
}

mrp_Release()

static ULONG WINAPI mrp_Release ( IWineMsiRemotePackage *  iface )

static

Definition at line 2550 of file package.c.

{
    msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
    ULONG r;

    r = InterlockedDecrement( &This->refs );
    if (r == 0)
    {
        MsiCloseHandle( This->package );
        msi_free( This );
    }
    return r;
}

mrp_Sequence()

static HRESULT WINAPI mrp_Sequence ( IWineMsiRemotePackage *  iface, BSTR  table, int  sequence  )

static

Definition at line 2627 of file package.c.

{
    msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
    UINT r = MsiSequenceW(This->package, table, sequence);
    return HRESULT_FROM_WIN32(r);
}

mrp_SetComponentState()

static HRESULT WINAPI mrp_SetComponentState ( IWineMsiRemotePackage *  iface, BSTR  component, INSTALLSTATE  state  )

static

Definition at line 2692 of file package.c.

{
    msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
    UINT r = MsiSetComponentStateW(This->package, component, state);
    return HRESULT_FROM_WIN32(r);
}

mrp_SetFeatureState()

static HRESULT WINAPI mrp_SetFeatureState ( IWineMsiRemotePackage *  iface, BSTR  feature, INSTALLSTATE  state  )

static

Definition at line 2677 of file package.c.

{
    msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
    UINT r = MsiSetFeatureStateW(This->package, feature, state);
    return HRESULT_FROM_WIN32(r);
}

mrp_SetInstallLevel()

static HRESULT WINAPI mrp_SetInstallLevel ( IWineMsiRemotePackage *  iface, int  level  )

static

Definition at line 2706 of file package.c.

{
    msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
    UINT r = MsiSetInstallLevel(This->package, level);
    return HRESULT_FROM_WIN32(r);
}

mrp_SetMode()

static HRESULT WINAPI mrp_SetMode ( IWineMsiRemotePackage *  iface, MSIRUNMODE  mode, BOOL  state  )

static

Definition at line 2662 of file package.c.

{
    msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
    UINT r = MsiSetMode(This->package, mode, state);
    return HRESULT_FROM_WIN32(r);
}

mrp_SetMsiHandle()

static HRESULT WINAPI mrp_SetMsiHandle ( IWineMsiRemotePackage *  iface, MSIHANDLE  handle  )

static

Definition at line 2564 of file package.c.

{
    msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
    This->package = handle;
    return S_OK;
}

mrp_SetProperty()

static HRESULT WINAPI mrp_SetProperty ( IWineMsiRemotePackage *  iface, BSTR  property, BSTR  value  )

static

Definition at line 2606 of file package.c.

{
    msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
    UINT r = MsiSetPropertyW(This->package, property, value);
    return HRESULT_FROM_WIN32(r);
}

mrp_SetTargetPath()

static HRESULT WINAPI mrp_SetTargetPath ( IWineMsiRemotePackage *  iface, BSTR  folder, BSTR  value  )

static

Definition at line 2641 of file package.c.

{
    msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
    UINT r = MsiSetTargetPathW(This->package, folder, value);
    return HRESULT_FROM_WIN32(r);
}

msi_adjust_privilege_properties()

void msi_adjust_privilege_properties

(

MSIPACKAGE *

package

)

Definition at line 1046 of file package.c.

{
    /* FIXME: this should depend on the user's privileges */
    if (msi_get_property_int( package->db, szAllUsers, 0 ) == 2)
    {
        TRACE("resetting ALLUSERS property from 2 to 1\n");
        msi_set_property( package->db, szAllUsers, szOne, -1 );
    }
    msi_set_property( package->db, szAdminUser, szOne, -1 );
}

Referenced by MSI_CreatePackage(), MSI_InstallPackage(), and MSI_OpenPackageW().

msi_alloc_package()

static MSIPACKAGE* msi_alloc_package ( void  )

static

Definition at line 998 of file package.c.

{
    MSIPACKAGE *package;

    package = alloc_msiobject( MSIHANDLETYPE_PACKAGE, sizeof (MSIPACKAGE),
                               MSI_FreePackage );
    if( package )
    {
        list_init( &package->components );
        list_init( &package->features );
        list_init( &package->files );
        list_init( &package->filepatches );
        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 );
        list_init( &package->sourcelist_info );
        list_init( &package->sourcelist_media );
        list_init( &package->patches );
        list_init( &package->binaries );
        list_init( &package->cabinet_streams );
    }

    return package;
}

msi_clone_properties()

UINT msi_clone_properties

(

MSIDATABASE *

db

)

Definition at line 377 of file package.c.

{
    static const WCHAR query_select[] = {
        'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
        '`','P','r','o','p','e','r','t','y','`',0};
    static const WCHAR query_insert[] = {
        '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 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};
    MSIQUERY *view_select;
    UINT rc;

    rc = MSI_DatabaseOpenViewW( db, query_select, &view_select );
    if (rc != ERROR_SUCCESS)
        return rc;

    rc = MSI_ViewExecute( view_select, 0 );
    if (rc != ERROR_SUCCESS)
    {
        MSI_ViewClose( view_select );
        msiobj_release( &view_select->hdr );
        return rc;
    }

    while (1)
    {
        MSIQUERY *view_insert, *view_update;
        MSIRECORD *rec_select;

        rc = MSI_ViewFetch( view_select, &rec_select );
        if (rc != ERROR_SUCCESS)
            break;

        rc = MSI_DatabaseOpenViewW( db, query_insert, &view_insert );
        if (rc != ERROR_SUCCESS)
        {
            msiobj_release( &rec_select->hdr );
            continue;
        }

        rc = MSI_ViewExecute( view_insert, rec_select );
        MSI_ViewClose( view_insert );
        msiobj_release( &view_insert->hdr );
        if (rc != ERROR_SUCCESS)
        {
            MSIRECORD *rec_update;

            TRACE("insert failed, trying update\n");

            rc = MSI_DatabaseOpenViewW( db, query_update, &view_update );
            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 );
        }

        msiobj_release( &rec_select->hdr );
    }

    MSI_ViewClose( view_select );
    msiobj_release( &view_select->hdr );
    return rc;
}

Referenced by MSI_CreatePackage(), and msi_table_apply_transform().

msi_create_empty_local_file()

UINT msi_create_empty_local_file	(	LPWSTR	path,
		LPCWSTR	suffix
	)

Definition at line 1143 of file package.c.

{
    static const WCHAR szInstaller[] = {
        '\\','I','n','s','t','a','l','l','e','r','\\',0};
    static const WCHAR fmt[] = {'%','x',0};
    DWORD time, len, i, offset;
    HANDLE handle;

    time = GetTickCount();
    GetWindowsDirectoryW( path, MAX_PATH );
    strcatW( path, szInstaller );
    CreateDirectoryW( path, NULL );

    len = strlenW(path);
    for (i = 0; i < 0x10000; i++)
    {
        offset = snprintfW( path + len, MAX_PATH - len, fmt, (time + i) & 0xffff );
        memcpy( path + len + offset, suffix, (strlenW( suffix ) + 1) * sizeof(WCHAR) );
        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;
}

Referenced by msi_apply_patch_package(), and MSI_OpenPackageW().

MSI_CreatePackage()

MSIPACKAGE* MSI_CreatePackage	(	MSIDATABASE *	db,
		LPCWSTR	base_url
	)

Definition at line 1057 of file package.c.

{
    static const WCHAR fmtW[] = {'%','u',0};
    MSIPACKAGE *package;
    WCHAR uilevel[11];
    int len;
    UINT r;

    TRACE("%p\n", db);

    package = msi_alloc_package();
    if (package)
    {
        msiobj_addref( &db->hdr );
        package->db = db;

        package->LastAction = NULL;
        package->LastActionTemplate = NULL;
        package->LastActionResult = MSI_NULL_INTEGER;
        package->WordCount = 0;
        package->PackagePath = strdupW( db->path );
        package->BaseURL = strdupW( base_url );

        create_temp_property_table( package );
        msi_clone_properties( package->db );
        msi_adjust_privilege_properties( package );

        package->ProductCode = msi_dup_property( package->db, szProductCode );

        set_installer_properties( package );

        package->ui_level = gUILevel;
        len = sprintfW( uilevel, fmtW, gUILevel & INSTALLUILEVEL_MASK );
        msi_set_property( package->db, szUILevel, uilevel, len );

        r = msi_load_suminfo_properties( package );
        if (r != ERROR_SUCCESS)
        {
            msiobj_release( &package->hdr );
            return NULL;
        }

        if (package->WordCount & msidbSumInfoSourceTypeAdminImage)
            msi_load_admin_properties( package );

        package->log_file = INVALID_HANDLE_VALUE;
    }
    return package;
}

msi_download_file()

UINT msi_download_file	(	LPCWSTR	szUrl,
		LPWSTR	filename
	)

Definition at line 1107 of file package.c.

{
    LPINTERNET_CACHE_ENTRY_INFOW cache_entry;
    DWORD size = 0;
    HRESULT hr;

    /* call will always fail, because size is 0,
     * but will return ERROR_FILE_NOT_FOUND first
     * if the file doesn't exist
     */
    GetUrlCacheEntryInfoW( szUrl, NULL, &size );
    if ( GetLastError() != ERROR_FILE_NOT_FOUND )
    {
        cache_entry = msi_alloc( size );
        if ( !GetUrlCacheEntryInfoW( szUrl, cache_entry, &size ) )
        {
            UINT error = GetLastError();
            msi_free( cache_entry );
            return error;
        }

        lstrcpyW( filename, cache_entry->lpszLocalFileName );
        msi_free( cache_entry );
        return ERROR_SUCCESS;
    }

    hr = URLDownloadToCacheFileW( NULL, szUrl, filename, MAX_PATH, 0, NULL );
    if ( FAILED(hr) )
    {
        WARN("failed to download %s to cache file\n", debugstr_w(szUrl));
        return ERROR_FUNCTION_FAILED;
    }

    return ERROR_SUCCESS;
}

Referenced by MSI_OpenPackageW(), and ready_media().

msi_dup_property()

LPWSTR msi_dup_property	(	MSIDATABASE *	db,
		LPCWSTR	prop
	)

Definition at line 2370 of file package.c.

{
    DWORD sz = 0;
    LPWSTR str;
    UINT r;

    r = msi_get_property(db, prop, NULL, &sz);
    if (r != ERROR_SUCCESS && r != ERROR_MORE_DATA)
        return NULL;

    sz++;
    str = msi_alloc(sz * sizeof(WCHAR));
    r = msi_get_property(db, prop, str, &sz);
    if (r != ERROR_SUCCESS)
    {
        msi_free(str);
        str = NULL;
    }

    return str;
}

Referenced by ACTION_CostFinalize(), ACTION_CustomAction(), ACTION_ExecuteAction(), ACTION_RegisterProduct(), ACTION_RegisterUser(), append_productcode(), check_transform_applicable(), defer_custom_action(), event_set_target_path(), get_duplicate_filename(), get_ini_file_name(), get_source_root(), HANDLE_CustomType23(), HANDLE_CustomType50(), HANDLE_CustomType53_54(), ITERATE_MoveFiles(), ITERATE_RemoveExistingProducts(), ITERATE_RemoveFiles(), MSI_ApplicablePatchXML(), msi_apply_patches(), msi_apply_transforms(), msi_build_icon_path(), msi_change_media(), msi_check_patch_applicable(), MSI_CreatePackage(), msi_dialog_combobox_update(), msi_dialog_dup_property(), msi_dialog_edit_control(), msi_dialog_maskedit_control(), msi_dialog_oncreate(), msi_dialog_radiogroup_control(), msi_get_checkbox_value(), msi_get_property_int(), MSI_InstallPackage(), msi_load_media_info(), MSI_OpenPackageW(), msi_publish_install_properties(), msi_publish_product_properties(), msi_publish_upgrade_code(), msi_resolve_target_folder(), msi_set_sourcedir_props(), msi_validate_product_id(), MsiSetFeatureAttributesW(), patch_set_media_source_prop(), process_state_property(), ready_media(), remove_product_upgrade_code(), set_installer_properties(), and yyparse().

msi_free_action_script()

void msi_free_action_script	(	MSIPACKAGE *	package,
		UINT	script
	)

Definition at line 129 of file package.c.

{
    UINT i;
    for (i = 0; i < package->script_actions_count[script]; i++)
        msi_free( package->script_actions[script][i] );

    msi_free( package->script_actions[script] );
    package->script_actions[script] = NULL;
    package->script_actions_count[script] = 0;
}

Referenced by execute_script(), and free_package_structures().

MSI_FreePackage()

static void MSI_FreePackage ( MSIOBJECTHDR *  arg )

static

Definition at line 334 of file package.c.

{
    MSIPACKAGE *package = (MSIPACKAGE *)arg;

    msi_destroy_assembly_caches( package );

    if( package->dialog )
        msi_dialog_destroy( package->dialog );

    msiobj_release( &package->db->hdr );
    free_package_structures(package);
    CloseHandle( package->log_file );

    if (package->delete_on_close) DeleteFileW( package->localfile );
    msi_free( package->localfile );
    MSI_ProcessMessage(NULL, INSTALLMESSAGE_TERMINATE, 0);
}

msi_get_error_message()

LPWSTR msi_get_error_message	(	MSIDATABASE *	db,
		int	error
	)

Definition at line 1851 of file package.c.

{
    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;
}

Referenced by ACTION_ExecuteAction(), MSI_OpenPackageW(), MSI_ProcessMessage(), and ui_actioninfo().

msi_get_property()

UINT msi_get_property	(	MSIDATABASE *	db,
		LPCWSTR	szName,
		LPWSTR	szValueBuf,
		LPDWORD	pchValueBuf
	)

Definition at line 2336 of file package.c.

{
    MSIRECORD *row;
    UINT rc = ERROR_FUNCTION_FAILED;

    TRACE("%p %s %p %p\n", db, debugstr_w(szName), szValueBuf, pchValueBuf);

    row = msi_get_property_row( db, szName );

    if (*pchValueBuf > 0)
        szValueBuf[0] = 0;

    if (row)
    {
        rc = MSI_RecordGetStringW(row, 1, szValueBuf, pchValueBuf);
        msiobj_release(&row->hdr);
    }

    if (rc == ERROR_SUCCESS)
        TRACE("returning %s for property %s\n", debugstr_wn(szValueBuf, *pchValueBuf),
            debugstr_w(szName));
    else if (rc == ERROR_MORE_DATA)
        TRACE("need %d sized buffer for %s\n", *pchValueBuf,
            debugstr_w(szName));
    else
    {
        *pchValueBuf = 0;
        TRACE("property %s not found\n", debugstr_w(szName));
    }

    return rc;
}

Referenced by create_temp_dir(), deformat_property(), msi_create_temp_file(), msi_dialog_get_checkbox_state(), msi_dup_property(), MSI_InstallPackage(), and msi_set_property().

msi_get_property_int()

int msi_get_property_int	(	MSIDATABASE *	db,
		LPCWSTR	prop,
		int	def
	)

Definition at line 2392 of file package.c.

{
    LPWSTR str = msi_dup_property( db, prop );
    int val = str ? atoiW(str) : def;
    msi_free(str);
    return val;
}

Referenced by ACTION_AllocateRegistrySpace(), ACTION_CostFinalize(), ACTION_FindRelatedProducts(), ACTION_InstallFiles(), ACTION_MigrateFeatureStates(), get_root_key(), is_obsoleted_by_patch(), msi_adjust_privilege_properties(), msi_dialog_adjust_dialog_pos(), MSI_InstallPackage(), msi_publish_install_properties(), msi_publish_product_properties(), msi_set_context(), MSI_SetFeatureStates(), MsiEnumComponentCostsW(), MsiGetLanguage(), and MsiGetMode().

msi_get_property_row()

static MSIRECORD* msi_get_property_row ( MSIDATABASE *  db, LPCWSTR  name  )

static

Definition at line 2262 of file package.c.

{
    static const WCHAR query[]= {
        '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','`','=','?',0};
    MSIRECORD *rec, *row = NULL;
    MSIQUERY *view;
    UINT r;

    static const WCHAR szDate[] = {'D','a','t','e',0};
    static const WCHAR szTime[] = {'T','i','m','e',0};
    WCHAR *buffer;
    int length;

    if (!name || !*name)
        return NULL;

    if (!strcmpW(name, szDate))
    {
        length = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, NULL, NULL, NULL, 0);
        if (!length)
            return NULL;
        buffer = msi_alloc(length * sizeof(WCHAR));
        GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, NULL, NULL, buffer, length);

        row = MSI_CreateRecord(1);
        if (!row)
        {
            msi_free(buffer);
            return NULL;
        }
        MSI_RecordSetStringW(row, 1, buffer);
        msi_free(buffer);
        return row;
    }
    else if (!strcmpW(name, szTime))
    {
        length = GetTimeFormatW(LOCALE_USER_DEFAULT, TIME_NOTIMEMARKER, NULL, NULL, NULL, 0);
        if (!length)
            return NULL;
        buffer = msi_alloc(length * sizeof(WCHAR));
        GetTimeFormatW(LOCALE_USER_DEFAULT, TIME_NOTIMEMARKER, NULL, NULL, buffer, length);

        row = MSI_CreateRecord(1);
        if (!row)
        {
            msi_free(buffer);
            return NULL;
        }
        MSI_RecordSetStringW(row, 1, buffer);
        msi_free(buffer);
        return row;
    }

    rec = MSI_CreateRecord(1);
    if (!rec)
        return NULL;

    MSI_RecordSetStringW(rec, 1, name);

    r = MSI_DatabaseOpenViewW(db, query, &view);
    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;
}

Referenced by msi_get_property(), and MSI_GetProperty().

MSI_GetProperty()

static UINT MSI_GetProperty ( MSIHANDLE  handle, LPCWSTR  name, awstring *  szValueBuf, LPDWORD  pchValueBuf  )

static

Definition at line 2400 of file package.c.

{
    MSIPACKAGE *package;
    MSIRECORD *row = NULL;
    UINT r = ERROR_FUNCTION_FAILED;
    LPCWSTR val = NULL;
    DWORD len = 0;

    TRACE("%u %s %p %p\n", handle, debugstr_w(name),
          szValueBuf->str.w, pchValueBuf );

    if (!name)
        return ERROR_INVALID_PARAMETER;

    package = msihandle2msiinfo( handle, MSIHANDLETYPE_PACKAGE );
    if (!package)
    {
        HRESULT hr;
        IWineMsiRemotePackage *remote_package;
        LPWSTR value = NULL;
        BSTR bname;

        remote_package = (IWineMsiRemotePackage *)msi_get_remote( handle );
        if (!remote_package)
            return ERROR_INVALID_HANDLE;

        bname = SysAllocString( name );
        if (!bname)
        {
            IWineMsiRemotePackage_Release( remote_package );
            return ERROR_OUTOFMEMORY;
        }

        hr = IWineMsiRemotePackage_GetProperty( remote_package, bname, NULL, &len );
        if (FAILED(hr))
            goto done;

        len++;
        value = msi_alloc(len * sizeof(WCHAR));
        if (!value)
        {
            r = ERROR_OUTOFMEMORY;
            goto done;
        }

        hr = IWineMsiRemotePackage_GetProperty( remote_package, bname, value, &len );
        if (FAILED(hr))
            goto done;

        r = msi_strcpy_to_awstring( value, len, szValueBuf, pchValueBuf );

        /* Bug required by Adobe installers */
        if (!szValueBuf->unicode && !szValueBuf->str.a)
            *pchValueBuf *= sizeof(WCHAR);

done:
        IWineMsiRemotePackage_Release(remote_package);
        SysFreeString(bname);
        msi_free(value);

        if (FAILED(hr))
        {
            if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
                return HRESULT_CODE(hr);

            return ERROR_FUNCTION_FAILED;
        }

        return r;
    }

    row = msi_get_property_row( package->db, name );
    if (row)
        val = msi_record_get_string( row, 1, (int *)&len );

    if (!val)
        val = szEmpty;

    r = msi_strcpy_to_awstring( val, len, szValueBuf, pchValueBuf );

    if (row)
        msiobj_release( &row->hdr );
    msiobj_release( &package->hdr );

    return r;
}

Referenced by MsiGetPropertyA(), and MsiGetPropertyW().

msi_load_admin_properties()

static UINT msi_load_admin_properties ( MSIPACKAGE *  package )

static

Definition at line 1029 of file package.c.

{
    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};

    r = read_stream_data(package->db->storage, stmname, FALSE, &data, &sz);
    if (r != ERROR_SUCCESS)
        return r;

    r = msi_parse_command_line(package, (WCHAR *)data, TRUE);

    msi_free(data);
    return r;
}

Referenced by MSI_CreatePackage().

MSI_OpenPackageW()

UINT MSI_OpenPackageW	(	LPCWSTR	szPackage,
		MSIPACKAGE **	pPackage
	)

Definition at line 1441 of file package.c.

{
    static const WCHAR dotmsi[] = {'.','m','s','i',0};
    MSIDATABASE *db;
    MSIPACKAGE *package;
    MSIHANDLE handle;
    MSIRECORD *data_row, *info_row;
    LPWSTR ptr, base_url = NULL;
    UINT r;
    WCHAR localfile[MAX_PATH], cachefile[MAX_PATH];
    LPCWSTR file = szPackage;
    DWORD index = 0;
    MSISUMMARYINFO *si;
    BOOL delete_on_close = FALSE;
    LPWSTR productname;
    WCHAR *info_template;

    TRACE("%s %p\n", debugstr_w(szPackage), pPackage);

    MSI_ProcessMessage(NULL, INSTALLMESSAGE_INITIALIZE, 0);

    localfile[0] = 0;
    if( szPackage[0] == '#' )
    {
        handle = atoiW(&szPackage[1]);
        db = msihandle2msiinfo( handle, MSIHANDLETYPE_DATABASE );
        if( !db )
        {
            IWineMsiRemoteDatabase *remote_database;

            remote_database = (IWineMsiRemoteDatabase *)msi_get_remote( handle );
            if ( !remote_database )
                return ERROR_INVALID_HANDLE;

            IWineMsiRemoteDatabase_Release( remote_database );
            WARN("MsiOpenPackage not allowed during a custom action!\n");

            return ERROR_FUNCTION_FAILED;
        }
    }
    else
    {
        if ( UrlIsW( szPackage, URLIS_URL ) )
        {
            r = msi_download_file( szPackage, cachefile );
            if (r != ERROR_SUCCESS)
                return r;

            file = cachefile;

            base_url = strdupW( szPackage );
            if (!base_url)
                return ERROR_OUTOFMEMORY;

            ptr = strrchrW( base_url, '/' );
            if (ptr) *(ptr + 1) = '\0';
        }
        r = get_local_package( file, localfile );
        if (r != ERROR_SUCCESS || GetFileAttributesW( localfile ) == INVALID_FILE_ATTRIBUTES)
        {
            r = msi_create_empty_local_file( localfile, dotmsi );
            if (r != ERROR_SUCCESS)
            {
                msi_free ( base_url );
                return r;
            }

            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 );
                msi_free ( base_url );
                return r;
            }
            delete_on_close = TRUE;
        }
        TRACE("opening package %s\n", debugstr_w( localfile ));
        r = MSI_OpenDatabaseW( localfile, MSIDBOPEN_TRANSACT, &db );
        if (r != ERROR_SUCCESS)
        {
            msi_free ( base_url );
            return r;
        }
    }
    package = MSI_CreatePackage( db, base_url );
    msi_free( base_url );
    msiobj_release( &db->hdr );
    if (!package) return ERROR_INSTALL_PACKAGE_INVALID;
    package->localfile = strdupW( localfile );
    package->delete_on_close = delete_on_close;

    r = msi_get_suminfo( db->storage, 0, &si );
    if (r != ERROR_SUCCESS)
    {
        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;
        }
    }
    r = parse_suminfo( si, package );
    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;
    }
    msi_set_property( package->db, szDatabase, db->path, -1 );
    set_installed_prop( package );
    msi_set_context( package );

    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));

        r = msi_apply_registered_patch( package, patch_code );
        if (r != ERROR_SUCCESS)
        {
            ERR("registered patch failed to apply %u\n", r);
            msiobj_release( &package->hdr );
            return r;
        }
        index++;
    }
    if (index) msi_adjust_privilege_properties( package );

    r = msi_set_original_database_property( package->db, szPackage );
    if (r != ERROR_SUCCESS)
    {
        msiobj_release( &package->hdr );
        return r;
    }
    if (gszLogFile)
        package->log_file = CreateFileW( gszLogFile, GENERIC_WRITE, FILE_SHARE_WRITE, NULL,
                                         OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );

    /* 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);

    *pPackage = package;
    return ERROR_SUCCESS;
}

Referenced by MSI_OpenProductW(), MsiDetermineApplicablePatchesW(), MsiInstallProductW(), MsiOpenPackageExW(), MsiReinstallFeatureW(), and open_package().

msi_package_add_info()

UINT msi_package_add_info	(	MSIPACKAGE *	package,
		DWORD	context,
		DWORD	options,
		LPCWSTR	property,
		LPWSTR	value
	)

Definition at line 2800 of file package.c.

{
    MSISOURCELISTINFO *info;

    LIST_FOR_EACH_ENTRY( info, &package->sourcelist_info, MSISOURCELISTINFO, entry )
    {
        if (!strcmpW( info->value, value )) return ERROR_SUCCESS;
    }

    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;
}

Referenced by msi_load_media_info().

msi_package_add_media_disk()

UINT msi_package_add_media_disk	(	MSIPACKAGE *	package,
		DWORD	context,
		DWORD	options,
		DWORD	disk_id,
		LPWSTR	volume_label,
		LPWSTR	disk_prompt
	)

Definition at line 2823 of file package.c.

{
    MSIMEDIADISK *disk;

    LIST_FOR_EACH_ENTRY( disk, &package->sourcelist_media, MSIMEDIADISK, entry )
    {
        if (disk->disk_id == disk_id) return ERROR_SUCCESS;
    }

    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;
}

Referenced by msi_load_media_info().

MSI_ProcessMessage()

INT MSI_ProcessMessage	(	MSIPACKAGE *	package,
		INSTALLMESSAGE	eMessageType,
		MSIRECORD *	record
	)

Definition at line 1946 of file package.c.

{
    switch (eMessageType & 0xff000000)
    {
    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 */

            LPWSTR template;
            LPWSTR template_rec = NULL, template_prefix = NULL;
            int error = MSI_RecordGetInteger(record, 1);

            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);

            template_prefix = msi_get_error_message(package->db, eMessageType >> 24);
            if (!template_prefix) template_prefix = strdupW(szEmpty);

            if (!template_rec)
            {
                /* always returns 0 */
                MSI_RecordSetStringW(record, 0, template_prefix);
                MSI_ProcessMessageVerbatim(package, eMessageType, record);
                msi_free(template_prefix);
                return 0;
            }

            template = msi_alloc((strlenW(template_rec) + strlenW(template_prefix) + 1) * sizeof(WCHAR));
            if (!template) return ERROR_OUTOFMEMORY;

            strcpyW(template, template_prefix);
            strcatW(template, template_rec);
            MSI_RecordSetStringW(record, 0, template);

            msi_free(template_prefix);
            msi_free(template_rec);
            msi_free(template);
        }
        break;
    case INSTALLMESSAGE_ACTIONSTART:
    {
        WCHAR *template = msi_get_error_message(package->db, MSIERR_ACTIONSTART);
        MSI_RecordSetStringW(record, 0, template);
        msi_free(template);

        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};
            WCHAR *template;

            template = msi_alloc((strlenW(package->LastAction) + strlenW(package->LastActionTemplate) + 7) * sizeof(WCHAR));
            if (!template) return ERROR_OUTOFMEMORY;
            sprintfW(template, template_s, package->LastAction, package->LastActionTemplate);
            MSI_RecordSetStringW(record, 0, template);
            msi_free(template);
        }
        break;
    case INSTALLMESSAGE_COMMONDATA:
    {
        WCHAR *template = msi_get_error_message(package->db, MSIERR_COMMONDATA);
        MSI_RecordSetStringW(record, 0, template);
        msi_free(template);
    }
    break;
    }

    return MSI_ProcessMessageVerbatim(package, eMessageType, record);
}

Referenced by ACTION_AllocateRegistrySpace(), ACTION_ExecuteAction(), ACTION_MsiPublishAssemblies(), ACTION_MsiUnpublishAssemblies(), ACTION_ProcessComponents(), ACTION_PublishFeatures(), ACTION_PublishProduct(), ACTION_RegisterClassInfo(), ACTION_RegisterExtensionInfo(), ACTION_RegisterMIMEInfo(), ACTION_RegisterProduct(), ACTION_RegisterProgIdInfo(), ACTION_RegisterUser(), ACTION_RemoveFiles(), ACTION_ResolveSource(), ACTION_ShowDialog(), ACTION_UnregisterClassInfo(), ACTION_UnregisterExtensionInfo(), ACTION_UnregisterMIMEInfo(), ACTION_UnregisterProgIdInfo(), dialog_create(), iterate_appsearch(), ITERATE_CreateFolders(), ITERATE_CreateShortcuts(), ITERATE_DeleteService(), ITERATE_DuplicateFiles(), ITERATE_FindRelatedProducts(), ITERATE_InstallODBCDataSource(), ITERATE_InstallODBCDriver(), ITERATE_InstallODBCTranslator(), ITERATE_MoveFiles(), iterate_properties(), ITERATE_PublishComponent(), ITERATE_RegisterFonts(), ITERATE_RegisterTypeLibraries(), ITERATE_RemoveDuplicateFiles(), ITERATE_RemoveEnvironmentString(), ITERATE_RemoveFiles(), ITERATE_RemoveFolders(), ITERATE_RemoveIniValuesOnInstall(), ITERATE_RemoveIniValuesOnUninstall(), ITERATE_RemoveODBCDataSource(), ITERATE_RemoveODBCDriver(), ITERATE_RemoveODBCTranslator(), ITERATE_RemoveRegistryValuesOnInstall(), ITERATE_RemoveRegistryValuesOnUninstall(), ITERATE_RemoveShortcuts(), ITERATE_SelfRegModules(), ITERATE_SelfUnregModules(), ITERATE_StartService(), ITERATE_StopService(), ITERATE_UnpublishComponent(), ITERATE_UnregisterFonts(), ITERATE_UnregisterTypeLibraries(), ITERATE_WriteEnvironmentString(), ITERATE_WriteIniValues(), ITERATE_WriteRegistryValues(), msi_change_media(), msi_file_update_ui(), MSI_FreePackage(), MSI_OpenPackageW(), msi_ui_progress(), msi_unpublish_feature(), MsiOpenPackageExW(), MsiProcessMessage(), ui_actioninfo(), and ui_actionstart().

MSI_ProcessMessageVerbatim()

INT MSI_ProcessMessageVerbatim	(	MSIPACKAGE *	package,
		INSTALLMESSAGE	eMessageType,
		MSIRECORD *	record
	)

Definition at line 1880 of file package.c.

{
    LPWSTR message = {0};
    DWORD len;
    DWORD log_type = 1 << (eMessageType >> 24);
    UINT res;
    INT rc = 0;
    char *msg;

    TRACE("%x\n", eMessageType);
    if (TRACE_ON(msi)) dump_record(record);

    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);
    }

    /* convert it to ASCII */
    len = WideCharToMultiByte( CP_ACP, 0, message, -1, NULL, 0, NULL, NULL );
    msg = msi_alloc( len );
    WideCharToMultiByte( CP_ACP, 0, message, -1, msg, len, NULL, NULL );

    if (gUIHandlerRecord && (gUIFilterRecord & log_type))
    {
        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 );
    }
    if (!rc && gUIHandlerW && (gUIFilter & log_type))
    {
        TRACE("Calling UI handler %p(pvContext=%p, iMessageType=%08x, szMessage=%s)\n",
              gUIHandlerW, gUIContext, eMessageType, debugstr_w(message));
        rc = gUIHandlerW( gUIContext, eMessageType, message );
    }
    else if (!rc && gUIHandlerA && (gUIFilter & log_type))
    {
        TRACE("Calling UI handler %p(pvContext=%p, iMessageType=%08x, szMessage=%s)\n",
              gUIHandlerA, gUIContext, eMessageType, debugstr_a(msg));
        rc = gUIHandlerA( gUIContext, eMessageType, msg );
    }

    if (!rc)
        rc = internal_ui_handler(package, eMessageType, record, message);

    if (!rc && package && package->log_file != INVALID_HANDLE_VALUE &&
        (eMessageType & 0xff000000) != INSTALLMESSAGE_PROGRESS)
    {
        DWORD written;
        WriteFile( package->log_file, msg, len - 1, &written, NULL );
        WriteFile( package->log_file, "\n", 1, &written, NULL );
    }
    msi_free( msg );
    msi_free( message );

    return rc;
}