install.c File Reference

#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "msi.h"
#include "msidefs.h"
#include "objbase.h"
#include "oleauto.h"
#include "msipriv.h"
#include "winemsi_s.h"
#include "wine/debug.h"
#include "wine/exception.h"

Include dependency graph for install.c:

Go to the source code of this file.

Macros
#define	COBJMACROS

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (msi)
UINT WINAPI	MsiDoActionA (MSIHANDLE hInstall, LPCSTR szAction)
UINT WINAPI	MsiDoActionW (MSIHANDLE hInstall, LPCWSTR szAction)
UINT WINAPI	MsiSequenceA (MSIHANDLE hInstall, LPCSTR szTable, INT iSequenceMode)
UINT WINAPI	MsiSequenceW (MSIHANDLE hInstall, LPCWSTR szTable, INT iSequenceMode)
UINT	msi_strcpy_to_awstring (const WCHAR *str, int len, awstring *awbuf, DWORD *sz)
UINT	msi_strncpyWtoA (const WCHAR *str, int lenW, char *buf, DWORD *sz, BOOL remote)
UINT	msi_strncpyW (const WCHAR *str, int len, WCHAR *buf, DWORD *sz)
const WCHAR *	msi_get_target_folder (MSIPACKAGE *package, const WCHAR *name)
UINT WINAPI	MsiGetTargetPathA (MSIHANDLE hinst, const char *folder, char *buf, DWORD *sz)
UINT WINAPI	MsiGetTargetPathW (MSIHANDLE hinst, const WCHAR *folder, WCHAR *buf, DWORD *sz)
static WCHAR *	get_source_root (MSIPACKAGE *package)
WCHAR *	msi_resolve_source_folder (MSIPACKAGE *package, const WCHAR *name, MSIFOLDER **folder)
UINT WINAPI	MsiGetSourcePathA (MSIHANDLE hinst, const char *folder, char *buf, DWORD *sz)
UINT WINAPI	MsiGetSourcePathW (MSIHANDLE hinst, const WCHAR *folder, WCHAR *buf, DWORD *sz)
UINT WINAPI	MsiSetTargetPathA (MSIHANDLE hInstall, LPCSTR szFolder, LPCSTR szFolderPath)
static void	set_target_path (MSIPACKAGE *package, MSIFOLDER *folder, const WCHAR *path)
UINT	MSI_SetTargetPathW (MSIPACKAGE *package, LPCWSTR szFolder, LPCWSTR szFolderPath)
UINT WINAPI	MsiSetTargetPathW (MSIHANDLE hInstall, LPCWSTR szFolder, LPCWSTR szFolderPath)
BOOL WINAPI	MsiGetMode (MSIHANDLE hInstall, MSIRUNMODE iRunMode)
UINT WINAPI	MsiSetMode (MSIHANDLE hInstall, MSIRUNMODE iRunMode, BOOL fState)
UINT WINAPI	MsiSetFeatureStateA (MSIHANDLE hInstall, LPCSTR szFeature, INSTALLSTATE iState)
void	ACTION_UpdateComponentStates (MSIPACKAGE *package, MSIFEATURE *feature)
UINT	MSI_SetFeatureStateW (MSIPACKAGE *package, LPCWSTR szFeature, INSTALLSTATE iState)
UINT WINAPI	MsiSetFeatureStateW (MSIHANDLE hInstall, LPCWSTR szFeature, INSTALLSTATE iState)
UINT WINAPI	MsiSetFeatureAttributesA (MSIHANDLE handle, LPCSTR feature, DWORD attrs)
static DWORD	unmap_feature_attributes (DWORD attrs)
UINT WINAPI	MsiSetFeatureAttributesW (MSIHANDLE handle, LPCWSTR name, DWORD attrs)
UINT WINAPI	MsiGetFeatureStateA (MSIHANDLE hInstall, LPCSTR szFeature, INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
UINT	MSI_GetFeatureStateW (MSIPACKAGE *package, LPCWSTR szFeature, INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
UINT WINAPI	MsiGetFeatureStateW (MSIHANDLE hInstall, const WCHAR *szFeature, INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
UINT WINAPI	MsiGetFeatureCostA (MSIHANDLE hInstall, LPCSTR szFeature, MSICOSTTREE iCostTree, INSTALLSTATE iState, LPINT piCost)
static INT	feature_cost (MSIFEATURE *feature)
UINT	MSI_GetFeatureCost (MSIPACKAGE *package, MSIFEATURE *feature, MSICOSTTREE tree, INSTALLSTATE state, LPINT cost)
UINT WINAPI	MsiGetFeatureCostW (MSIHANDLE hInstall, const WCHAR *szFeature, MSICOSTTREE iCostTree, INSTALLSTATE iState, INT *piCost)
UINT WINAPI	MsiGetFeatureInfoA (MSIHANDLE handle, const char *feature, DWORD *attrs, char *title, DWORD *title_len, char *help, DWORD *help_len)
static DWORD	map_feature_attributes (DWORD attrs)
static UINT	MSI_GetFeatureInfo (MSIPACKAGE *package, LPCWSTR name, LPDWORD attrs, LPWSTR title, LPDWORD title_len, LPWSTR help, LPDWORD help_len)
UINT WINAPI	MsiGetFeatureInfoW (MSIHANDLE handle, const WCHAR *feature, DWORD *attrs, WCHAR *title, DWORD *title_len, WCHAR *help, DWORD *help_len)
UINT WINAPI	MsiSetComponentStateA (MSIHANDLE hInstall, LPCSTR szComponent, INSTALLSTATE iState)
UINT WINAPI	MsiGetComponentStateA (MSIHANDLE hInstall, LPCSTR szComponent, INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
static UINT	MSI_SetComponentStateW (MSIPACKAGE *package, LPCWSTR szComponent, INSTALLSTATE iState)
UINT	MSI_GetComponentStateW (MSIPACKAGE *package, LPCWSTR szComponent, INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
UINT WINAPI	MsiSetComponentStateW (MSIHANDLE hInstall, LPCWSTR szComponent, INSTALLSTATE iState)
UINT WINAPI	MsiGetComponentStateW (MSIHANDLE hInstall, const WCHAR *szComponent, INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
LANGID WINAPI	MsiGetLanguage (MSIHANDLE hInstall)
UINT	MSI_SetInstallLevel (MSIPACKAGE *package, int iInstallLevel)
UINT WINAPI	MsiSetInstallLevel (MSIHANDLE hInstall, int iInstallLevel)
UINT WINAPI	MsiGetFeatureValidStatesW (MSIHANDLE hInstall, const WCHAR *szFeature, DWORD *pInstallState)
UINT WINAPI	MsiGetFeatureValidStatesA (MSIHANDLE hInstall, const char *szFeature, DWORD *pInstallState)

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 23 of file install.c.

Function Documentation

ACTION_UpdateComponentStates()

void ACTION_UpdateComponentStates	(	MSIPACKAGE *	package,
		MSIFEATURE *	feature
	)

Definition at line 833 of file install.c.

{
    INSTALLSTATE newstate;
    ComponentList *cl;
 
    newstate = feature->ActionRequest;
    if (newstate == INSTALLSTATE_ABSENT) newstate = INSTALLSTATE_UNKNOWN;
 
    LIST_FOR_EACH_ENTRY(cl, &feature->Components, ComponentList, entry)
    {
        MSICOMPONENT *component = cl->component;
 
        if (!component->Enabled) continue;
 
        TRACE("Modifying (%d): Component %s (Installed %d, Action %d, Request %d)\n",
            newstate, debugstr_w(component->Component), component->Installed,
            component->Action, component->ActionRequest);
 
        if (newstate == INSTALLSTATE_LOCAL)
        {
            component->Action = INSTALLSTATE_LOCAL;
            component->ActionRequest = INSTALLSTATE_LOCAL;
        }
        else
        {
            ComponentList *clist;
            MSIFEATURE *f;
 
            component->hasLocalFeature = FALSE;
 
            component->Action = newstate;
            component->ActionRequest = newstate;
            /* if any other feature wants it local we need to set it local */
            LIST_FOR_EACH_ENTRY(f, &package->features, MSIFEATURE, entry)
            {
                if ( f->ActionRequest != INSTALLSTATE_LOCAL &&
                     f->ActionRequest != INSTALLSTATE_SOURCE )
                {
                    continue;
                }
                LIST_FOR_EACH_ENTRY(clist, &f->Components, ComponentList, entry)
                {
                    if (clist->component == component &&
                        (f->ActionRequest == INSTALLSTATE_LOCAL ||
                         f->ActionRequest == INSTALLSTATE_SOURCE))
                    {
                        TRACE("Saved by %s\n", debugstr_w(f->Feature));
                        component->hasLocalFeature = TRUE;
 
                        if (component->Attributes & msidbComponentAttributesOptional)
                        {
                            if (f->Attributes & msidbFeatureAttributesFavorSource)
                            {
                                component->Action = INSTALLSTATE_SOURCE;
                                component->ActionRequest = INSTALLSTATE_SOURCE;
                            }
                            else
                            {
                                component->Action = INSTALLSTATE_LOCAL;
                                component->ActionRequest = INSTALLSTATE_LOCAL;
                            }
                        }
                        else if (component->Attributes & msidbComponentAttributesSourceOnly)
                        {
                            component->Action = INSTALLSTATE_SOURCE;
                            component->ActionRequest = INSTALLSTATE_SOURCE;
                        }
                        else
                        {
                            component->Action = INSTALLSTATE_LOCAL;
                            component->ActionRequest = INSTALLSTATE_LOCAL;
                        }
                    }
                }
            }
        }
        TRACE("Result (%d): Component %s (Installed %d, Action %d, Request %d)\n",
            newstate, debugstr_w(component->Component), component->Installed,
            component->Action, component->ActionRequest);
    }
}

Referenced by msi_seltree_update_feature_installstate(), and MSI_SetFeatureStateW().

feature_cost()

static INT feature_cost ( MSIFEATURE *  feature )

static

Definition at line 1143 of file install.c.

{
    INT cost = 0;
    ComponentList *cl;
 
    LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
    {
        cost += cl->component->Cost;
    }
    return cost;
}

Referenced by MSI_GetFeatureCost().

get_source_root()

static WCHAR * get_source_root ( MSIPACKAGE *  package )

static

Definition at line 358 of file install.c.

{
    msi_set_sourcedir_props( package, FALSE );
    return msi_dup_property( package->db, L"SourceDir" );
}

Referenced by msi_resolve_source_folder().

map_feature_attributes()

static DWORD map_feature_attributes ( DWORD  attrs )

static

Definition at line 1294 of file install.c.

{
    DWORD ret = 0;
 
    if (attrs == msidbFeatureAttributesFavorLocal)            ret |= INSTALLFEATUREATTRIBUTE_FAVORLOCAL;
    if (attrs & msidbFeatureAttributesFavorSource)            ret |= INSTALLFEATUREATTRIBUTE_FAVORSOURCE;
    if (attrs & msidbFeatureAttributesFollowParent)           ret |= INSTALLFEATUREATTRIBUTE_FOLLOWPARENT;
    if (attrs & msidbFeatureAttributesFavorAdvertise)         ret |= INSTALLFEATUREATTRIBUTE_FAVORADVERTISE;
    if (attrs & msidbFeatureAttributesDisallowAdvertise)      ret |= INSTALLFEATUREATTRIBUTE_DISALLOWADVERTISE;
    if (attrs & msidbFeatureAttributesNoUnsupportedAdvertise) ret |= INSTALLFEATUREATTRIBUTE_NOUNSUPPORTEDADVERTISE;
    return ret;
}

Referenced by MSI_GetFeatureInfo().

msi_get_target_folder()

const WCHAR * msi_get_target_folder	(	MSIPACKAGE *	package,
		const WCHAR *	name
	)

Definition at line 232 of file install.c.

{
    MSIFOLDER *folder = msi_get_loaded_folder( package, name );
 
    if (!folder) return NULL;
    if (!folder->ResolvedTarget)
    {
        MSIFOLDER *parent = folder;
        while (parent->Parent && wcscmp( parent->Parent, parent->Directory ))
        {
            parent = msi_get_loaded_folder( package, parent->Parent );
        }
        msi_resolve_target_folder( package, parent->Directory, TRUE );
    }
    return folder->ResolvedTarget;
}

Referenced by create_directory(), deformat_component(), get_duplicate_filename(), get_ini_file_name(), get_link_file(), HANDLE_CustomType34(), ITERATE_CreateFolders(), ITERATE_CreateShortcuts(), ITERATE_InstallODBCDriver(), ITERATE_RegisterTypeLibraries(), ITERATE_RemoveFolders(), MSI_SetTargetPathW(), MsiGetTargetPathA(), MsiGetTargetPathW(), resolve_keypath(), and set_target_path().

MSI_GetComponentStateW()

UINT MSI_GetComponentStateW	(	MSIPACKAGE *	package,
		LPCWSTR	szComponent,
		INSTALLSTATE *	piInstalled,
		INSTALLSTATE *	piAction
	)

Definition at line 1428 of file install.c.

{
    MSICOMPONENT *comp;
 
    TRACE("%p %s %p %p\n", package, debugstr_w(szComponent),
           piInstalled, piAction);
 
    comp = msi_get_loaded_component(package,szComponent);
    if (!comp)
        return ERROR_UNKNOWN_COMPONENT;
 
    if (piInstalled)
    {
        if (comp->Enabled)
            *piInstalled = comp->Installed;
        else
            *piInstalled = INSTALLSTATE_UNKNOWN;
    }
 
    if (piAction)
    {
        if (comp->Enabled)
            *piAction = comp->Action;
        else
            *piAction = INSTALLSTATE_UNKNOWN;
    }
 
    TRACE("states (%i, %i)\n", comp->Installed, comp->Action );
    return ERROR_SUCCESS;
}

Referenced by MsiGetComponentStateW().

MSI_GetFeatureCost()

UINT MSI_GetFeatureCost	(	MSIPACKAGE *	package,
		MSIFEATURE *	feature,
		MSICOSTTREE	tree,
		INSTALLSTATE	state,
		LPINT	cost
	)

Definition at line 1155 of file install.c.

{
    TRACE("%s, %u, %d, %p\n", debugstr_w(feature->Feature), tree, state, cost);
 
    *cost = 0;
    switch (tree)
    {
    case MSICOSTTREE_CHILDREN:
    {
        MSIFEATURE *child;
 
        LIST_FOR_EACH_ENTRY( child, &feature->Children, MSIFEATURE, entry )
        {
            if (child->ActionRequest == state)
                *cost += feature_cost( child );
        }
        break;
    }
    case MSICOSTTREE_PARENTS:
    {
        const WCHAR *feature_parent = feature->Feature_Parent;
        for (;;)
        {
            MSIFEATURE *parent = msi_get_loaded_feature( package, feature_parent );
            if (!parent)
                break;
 
            if (parent->ActionRequest == state)
                *cost += feature_cost( parent );
 
            feature_parent = parent->Feature_Parent;
        }
        break;
    }
    case MSICOSTTREE_SELFONLY:
        if (feature->ActionRequest == state)
            *cost = feature_cost( feature );
        break;
 
    default:
        WARN("unhandled cost tree %u\n", tree);
        break;
    }
 
    *cost /= 512;
    return ERROR_SUCCESS;
}

Referenced by msi_vcl_get_cost(), and MsiGetFeatureCostW().

MSI_GetFeatureInfo()

static UINT MSI_GetFeatureInfo ( MSIPACKAGE *  package, LPCWSTR  name, LPDWORD  attrs, LPWSTR  title, LPDWORD  title_len, LPWSTR  help, LPDWORD  help_len  )

static

Definition at line 1307 of file install.c.

{
    UINT r = ERROR_SUCCESS;
    MSIFEATURE *feature = msi_get_loaded_feature( package, name );
    int len;
 
    if (!feature) return ERROR_UNKNOWN_FEATURE;
    if (attrs) *attrs = map_feature_attributes( feature->Attributes );
    if (title_len)
    {
        if (feature->Title) len = lstrlenW( feature->Title );
        else len = 0;
        if (*title_len <= len)
        {
            *title_len = len;
            if (title) r = ERROR_MORE_DATA;
        }
        else if (title)
        {
            if (feature->Title) lstrcpyW( title, feature->Title );
            else *title = 0;
            *title_len = len;
        }
    }
    if (help_len)
    {
        if (feature->Description) len = lstrlenW( feature->Description );
        else len = 0;
        if (*help_len <= len)
        {
            *help_len = len;
            if (help) r = ERROR_MORE_DATA;
        }
        else if (help)
        {
            if (feature->Description) lstrcpyW( help, feature->Description );
            else *help = 0;
            *help_len = len;
        }
    }
    return r;
}

Referenced by MsiGetFeatureInfoW().

MSI_GetFeatureStateW()

UINT MSI_GetFeatureStateW	(	MSIPACKAGE *	package,
		LPCWSTR	szFeature,
		INSTALLSTATE *	piInstalled,
		INSTALLSTATE *	piAction
	)

Definition at line 1065 of file install.c.

{
    MSIFEATURE *feature;
 
    feature = msi_get_loaded_feature(package,szFeature);
    if (!feature)
        return ERROR_UNKNOWN_FEATURE;
 
    if (piInstalled)
        *piInstalled = feature->Installed;
 
    if (piAction)
        *piAction = feature->ActionRequest;
 
    TRACE("returning %i %i\n", feature->Installed, feature->ActionRequest);
 
    return ERROR_SUCCESS;
}

Referenced by MsiGetFeatureStateW().

msi_resolve_source_folder()

WCHAR * msi_resolve_source_folder	(	MSIPACKAGE *	package,
		const WCHAR *	name,
		MSIFOLDER **	folder
	)

Definition at line 364 of file install.c.

{
    MSIFOLDER *f;
    LPWSTR p, path = NULL, parent;
 
    TRACE("working to resolve %s\n", debugstr_w(name));
 
    if (!wcscmp( name, L"SourceDir" )) name = L"TARGETDIR";
    if (!(f = msi_get_loaded_folder( package, name ))) return NULL;
 
    /* special resolving for root dir */
    if (!wcscmp( name, L"TARGETDIR" ) && !f->ResolvedSource)
    {
        f->ResolvedSource = get_source_root( package );
    }
    if (folder) *folder = f;
    if (f->ResolvedSource)
    {
        path = strdupW( f->ResolvedSource );
        TRACE("   already resolved to %s\n", debugstr_w(path));
        return path;
    }
    if (!f->Parent) return path;
    parent = f->Parent;
    TRACE(" ! parent is %s\n", debugstr_w(parent));
 
    p = msi_resolve_source_folder( package, parent, NULL );
 
    if (package->WordCount & msidbSumInfoSourceTypeCompressed)
        path = get_source_root( package );
    else if (package->WordCount & msidbSumInfoSourceTypeSFN)
        path = msi_build_directory_name( 3, p, f->SourceShortPath, NULL );
    else
        path = msi_build_directory_name( 3, p, f->SourceLongPath, NULL );
 
    TRACE("-> %s\n", debugstr_w(path));
    f->ResolvedSource = strdupW( path );
    msi_free( p );
 
    return path;
}

Referenced by deformat_component(), msi_resolve_file_source(), msi_resolve_source_folder(), MsiGetSourcePathA(), and MsiGetSourcePathW().

MSI_SetComponentStateW()

static UINT MSI_SetComponentStateW ( MSIPACKAGE *  package, LPCWSTR  szComponent, INSTALLSTATE  iState  )

static

Definition at line 1411 of file install.c.

{
    MSICOMPONENT *comp;
 
    TRACE("%p %s %d\n", package, debugstr_w(szComponent), iState);
 
    comp = msi_get_loaded_component(package, szComponent);
    if (!comp)
        return ERROR_UNKNOWN_COMPONENT;
 
    if (comp->Enabled)
        comp->Action = iState;
 
    return ERROR_SUCCESS;
}

Referenced by MsiSetComponentStateW().

MSI_SetFeatureStateW()

UINT MSI_SetFeatureStateW	(	MSIPACKAGE *	package,
		LPCWSTR	szFeature,
		INSTALLSTATE	iState
	)

Definition at line 915 of file install.c.

{
    UINT rc = ERROR_SUCCESS;
    MSIFEATURE *feature, *child;
 
    TRACE("%s %i\n", debugstr_w(szFeature), iState);
 
    feature = msi_get_loaded_feature( package, szFeature );
    if (!feature)
        return ERROR_UNKNOWN_FEATURE;
 
    if (iState == INSTALLSTATE_ADVERTISED &&
        feature->Attributes & msidbFeatureAttributesDisallowAdvertise)
        return ERROR_FUNCTION_FAILED;
 
    feature->ActionRequest = iState;
 
    ACTION_UpdateComponentStates( package, feature );
 
    /* update all the features that are children of this feature */
    LIST_FOR_EACH_ENTRY( child, &package->features, MSIFEATURE, entry )
    {
        if (child->Feature_Parent && !wcscmp( szFeature, child->Feature_Parent ))
            MSI_SetFeatureStateW(package, child->Feature, iState);
    }
 
    return rc;
}

Referenced by event_add_local(), event_add_source(), event_remove(), MSI_SetFeatureStateW(), MsiConfigureFeatureW(), and MsiSetFeatureStateW().

MSI_SetInstallLevel()

UINT MSI_SetInstallLevel	(	MSIPACKAGE *	package,
		int	iInstallLevel
	)

Definition at line 1572 of file install.c.

{
    WCHAR level[6];
    int len;
    UINT r;
 
    TRACE("%p %i\n", package, iInstallLevel);
 
    if (iInstallLevel > 32767)
        return ERROR_INVALID_PARAMETER;
 
    if (iInstallLevel < 1)
        return MSI_SetFeatureStates( package );
 
    len = swprintf( level, ARRAY_SIZE(level), L"%d", iInstallLevel );
    r = msi_set_property( package->db, L"INSTALLLEVEL", level, len );
    if ( r == ERROR_SUCCESS )
        r = MSI_SetFeatureStates( package );
 
    return r;
}

Referenced by event_set_install_level(), and MsiSetInstallLevel().

MSI_SetTargetPathW()

UINT MSI_SetTargetPathW	(	MSIPACKAGE *	package,
		LPCWSTR	szFolder,
		LPCWSTR	szFolderPath
	)

Definition at line 564 of file install.c.

{
    DWORD attrib;
    MSIFOLDER *folder;
    MSIFILE *file;
 
    TRACE("%p %s %s\n", package, debugstr_w(szFolder), debugstr_w(szFolderPath));
 
    attrib = msi_get_file_attributes( package, szFolderPath );
    /* native MSI tests writeability by making temporary files at each drive */
    if (attrib != INVALID_FILE_ATTRIBUTES &&
        (attrib & FILE_ATTRIBUTE_OFFLINE || attrib & FILE_ATTRIBUTE_READONLY))
    {
        return ERROR_FUNCTION_FAILED;
    }
    if (!(folder = msi_get_loaded_folder( package, szFolder ))) return ERROR_DIRECTORY;
 
    set_target_path( package, folder, szFolderPath );
 
    LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
    {
        const WCHAR *dir;
        MSICOMPONENT *comp = file->Component;
 
        if (!comp->Enabled || msi_is_global_assembly( comp )) continue;
 
        dir = msi_get_target_folder( package, comp->Directory );
        msi_free( file->TargetPath );
        file->TargetPath = msi_build_directory_name( 2, dir, file->FileName );
    }
    return ERROR_SUCCESS;
}

Referenced by ACTION_CustomAction(), event_set_target_path(), and MsiSetTargetPathW().

msi_strcpy_to_awstring()

UINT msi_strcpy_to_awstring	(	const WCHAR *	str,
		int	len,
		awstring *	awbuf,
		DWORD *	sz
	)

Definition at line 158 of file install.c.

{
    UINT r = ERROR_SUCCESS;
 
    if (awbuf->str.w && !sz)
        return ERROR_INVALID_PARAMETER;
    if (!sz)
        return ERROR_SUCCESS;
 
    if (len < 0) len = lstrlenW( str );
 
    if (awbuf->unicode && awbuf->str.w)
    {
        memcpy( awbuf->str.w, str, min(len + 1, *sz) * sizeof(WCHAR) );
        if (*sz && len >= *sz)
            awbuf->str.w[*sz - 1] = 0;
    }
    else
    {
        int lenA = WideCharToMultiByte( CP_ACP, 0, str, len + 1, NULL, 0, NULL, NULL );
        if (lenA) lenA--;
        WideCharToMultiByte( CP_ACP, 0, str, len + 1, awbuf->str.a, *sz, NULL, NULL );
        if (awbuf->str.a && *sz && lenA >= *sz)
            awbuf->str.a[*sz - 1] = 0;
        len = lenA;
    }
    if (awbuf->str.w && len >= *sz)
        r = ERROR_MORE_DATA;
    *sz = len;
    return r;
}

Referenced by MSI_EnumComponentQualifiers(), MSI_GetComponentPath(), MSI_GetProductInfo(), and MSI_GetUserInfo().

msi_strncpyW()

UINT msi_strncpyW	(	const WCHAR *	str,
		int	len,
		WCHAR *	buf,
		DWORD *	sz
	)

Definition at line 213 of file install.c.

{
    UINT r = ERROR_SUCCESS;
 
    if (!sz)
        return buf ? ERROR_INVALID_PARAMETER : ERROR_SUCCESS;
 
    if (len < 0) len = lstrlenW(str);
    if (buf)
        memcpy(buf, str, min(len + 1, *sz) * sizeof(WCHAR));
    if (buf && len >= *sz)
    {
        if (*sz) buf[*sz - 1] = 0;
        r = ERROR_MORE_DATA;
    }
    *sz = len;
    return r;
}

Referenced by MsiFormatRecordW(), MsiGetPropertyW(), MsiGetSourcePathW(), MsiGetTargetPathW(), MsiSummaryInfoGetPropertyW(), and MsiViewGetErrorW().

msi_strncpyWtoA()

UINT msi_strncpyWtoA	(	const WCHAR *	str,
		int	lenW,
		char *	buf,
		DWORD *	sz,
		BOOL	remote
	)

Definition at line 190 of file install.c.

{
    UINT r = ERROR_SUCCESS;
    DWORD lenA;
 
    if (!sz)
        return buf ? ERROR_INVALID_PARAMETER : ERROR_SUCCESS;
 
    if (lenW < 0) lenW = lstrlenW(str);
    lenA = WideCharToMultiByte(CP_ACP, 0, str, lenW + 1, NULL, 0, NULL, NULL);
    WideCharToMultiByte(CP_ACP, 0, str, lenW + 1, buf, *sz, NULL, NULL);
    lenA--;
    if (buf && lenA >= *sz)
    {
        if (*sz) buf[*sz - 1] = 0;
        r = ERROR_MORE_DATA;
    }
    if (remote && lenA >= *sz)
        lenA *= 2;
    *sz = lenA;
    return r;
}

Referenced by MsiFormatRecordA(), MsiGetPropertyA(), MsiGetSourcePathA(), MsiGetTargetPathA(), MsiSummaryInfoGetPropertyA(), and MsiViewGetErrorA().

MsiDoActionA()

UINT WINAPI MsiDoActionA	(	MSIHANDLE	hInstall,
		LPCSTR	szAction
	)

Definition at line 45 of file install.c.

{
    LPWSTR szwAction;
    UINT ret;
 
    TRACE("%s\n", debugstr_a(szAction));
 
    szwAction = strdupAtoW(szAction);
    if (szAction && !szwAction)
        return ERROR_FUNCTION_FAILED;
 
    ret = MsiDoActionW( hInstall, szwAction );
    msi_free( szwAction );
    return ret;
}

Referenced by test_appsearch(), test_appsearch_complocator(), test_appsearch_drlocator(), test_appsearch_inilocator(), test_appsearch_reglocator(), test_ccpsearch(), test_complocator(), test_controlevent(), test_costs(), test_dbtopackage(), test_doaction(), test_externalui_message(), test_featureparents(), test_formatrecord_tables(), test_launchconditions(), test_MsiGetSourcePath(), test_MsiSetComponentState(), test_MsiSetFeatureAttributes(), test_property_table(), test_removefiles(), test_settargetpath(), test_shortlongsource(), test_sourcedir(), test_states(), and test_top_level_action().

MsiDoActionW()

UINT WINAPI MsiDoActionW	(	MSIHANDLE	hInstall,
		LPCWSTR	szAction
	)

Definition at line 64 of file install.c.

{
    MSIPACKAGE *package;
    UINT ret;
 
    TRACE("%s\n",debugstr_w(szAction));
 
    if (!szAction)
        return ERROR_INVALID_PARAMETER;
 
    package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
    if (!package)
    {
        MSIHANDLE remote;
 
        if (!(remote = msi_get_remote(hInstall)))
            return ERROR_INVALID_HANDLE;
 
        __TRY
        {
            ret = remote_DoAction(remote, szAction);
        }
        __EXCEPT(rpc_filter)
        {
            ret = GetExceptionCode();
        }
        __ENDTRY
 
        return ret;
    }
 
    ret = ACTION_PerformAction(package, szAction);
    msiobj_release( &package->hdr );
 
    return ret;
}

Referenced by MsiDoActionA(), s_remote_DoAction(), and session_invoke().

MsiGetComponentStateA()

UINT WINAPI MsiGetComponentStateA	(	MSIHANDLE	hInstall,
		LPCSTR	szComponent,
		INSTALLSTATE *	piInstalled,
		INSTALLSTATE *	piAction
	)

Definition at line 1396 of file install.c.

{
    LPWSTR szwComponent= NULL;
    UINT rc;
 
    szwComponent= strdupAtoW(szComponent);
 
    rc = MsiGetComponentStateW(hInstall,szwComponent,piInstalled, piAction);
 
    msi_free( szwComponent);
 
    return rc;
}

Referenced by test_component_states(), test_feature_states(), test_MsiSetComponentState(), and test_removefiles().

MsiGetComponentStateW()

UINT WINAPI MsiGetComponentStateW	(	MSIHANDLE	hInstall,
		const WCHAR *	szComponent,
		INSTALLSTATE *	piInstalled,
		INSTALLSTATE *	piAction
	)

Definition at line 1501 of file install.c.

{
    MSIPACKAGE* package;
    UINT ret;
 
    TRACE( "%lu, %s, %p, %p\n", hInstall, debugstr_w(szComponent), piInstalled, piAction );
 
    if (!szComponent)
        return ERROR_UNKNOWN_COMPONENT;
 
    package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
    if (!package)
    {
        MSIHANDLE remote;
 
        if (!(remote = msi_get_remote(hInstall)))
            return ERROR_INVALID_HANDLE;
 
        __TRY
        {
            ret = remote_GetComponentState(remote, szComponent, piInstalled, piAction);
        }
        __EXCEPT(rpc_filter)
        {
            ret = GetExceptionCode();
        }
        __ENDTRY
 
        return ret;
    }
 
    ret = MSI_GetComponentStateW( package, szComponent, piInstalled, piAction);
    msiobj_release( &package->hdr );
    return ret;
}

Referenced by MsiGetComponentStateA(), and s_remote_GetComponentState().

MsiGetFeatureCostA()

UINT WINAPI MsiGetFeatureCostA	(	MSIHANDLE	hInstall,
		LPCSTR	szFeature,
		MSICOSTTREE	iCostTree,
		INSTALLSTATE	iState,
		LPINT	piCost
	)

Definition at line 1128 of file install.c.

{
    LPWSTR szwFeature = NULL;
    UINT rc;
 
    szwFeature = strdupAtoW(szFeature);
 
    rc = MsiGetFeatureCostW(hInstall, szwFeature, iCostTree, iState, piCost);
 
    msi_free(szwFeature);
 
    return rc;
}

Referenced by test_costs().

MsiGetFeatureCostW()

UINT WINAPI MsiGetFeatureCostW	(	MSIHANDLE	hInstall,
		const WCHAR *	szFeature,
		MSICOSTTREE	iCostTree,
		INSTALLSTATE	iState,
		INT *	piCost
	)

Definition at line 1207 of file install.c.

{
    MSIPACKAGE *package;
    MSIFEATURE *feature;
    UINT ret;
 
    TRACE( "%lu, %s, %d, %d, %p\n", hInstall, debugstr_w(szFeature), iCostTree, iState, piCost );
 
    if (!szFeature)
        return ERROR_INVALID_PARAMETER;
 
    package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
    if (!package)
    {
        MSIHANDLE remote;
 
        if (!(remote = msi_get_remote(hInstall)))
            return ERROR_INVALID_HANDLE;
 
        __TRY
        {
            ret = remote_GetFeatureCost(remote, szFeature, iCostTree, iState, piCost);
        }
        __EXCEPT(rpc_filter)
        {
            ret = GetExceptionCode();
        }
        __ENDTRY
 
        return ret;
    }
 
    if (!piCost)
    {
        msiobj_release( &package->hdr );
        return ERROR_INVALID_PARAMETER;
    }
 
    feature = msi_get_loaded_feature(package, szFeature);
 
    if (feature)
        ret = MSI_GetFeatureCost(package, feature, iCostTree, iState, piCost);
    else
        ret = ERROR_UNKNOWN_FEATURE;
 
    msiobj_release( &package->hdr );
    return ret;
}

Referenced by MsiGetFeatureCostA(), and s_remote_GetFeatureCost().

MsiGetFeatureInfoA()

UINT WINAPI MsiGetFeatureInfoA	(	MSIHANDLE	handle,
		const char *	feature,
		DWORD *	attrs,
		char *	title,
		DWORD *	title_len,
		char *	help,
		DWORD *	help_len
	)

Definition at line 1260 of file install.c.

{
    UINT r;
    WCHAR *titleW = NULL, *helpW = NULL, *featureW = NULL;
 
    TRACE( "%lu, %s, %p, %p, %p, %p, %p\n", handle, debugstr_a(feature), attrs, title,
           title_len, help, help_len );
 
    if (feature && !(featureW = strdupAtoW( feature ))) return ERROR_OUTOFMEMORY;
 
    if (title && title_len && !(titleW = msi_alloc( *title_len * sizeof(WCHAR) )))
    {
        msi_free( featureW );
        return ERROR_OUTOFMEMORY;
    }
    if (help && help_len && !(helpW = msi_alloc( *help_len * sizeof(WCHAR) )))
    {
        msi_free( featureW );
        msi_free( titleW );
        return ERROR_OUTOFMEMORY;
    }
    r = MsiGetFeatureInfoW( handle, featureW, attrs, titleW, title_len, helpW, help_len );
    if (r == ERROR_SUCCESS)
    {
        if (titleW) WideCharToMultiByte( CP_ACP, 0, titleW, -1, title, *title_len + 1, NULL, NULL );
        if (helpW) WideCharToMultiByte( CP_ACP, 0, helpW, -1, help, *help_len + 1, NULL, NULL );
    }
    msi_free( titleW );
    msi_free( helpW );
    msi_free( featureW );
    return r;
}

Referenced by test_MsiGetFeatureInfo(), and test_MsiSetFeatureAttributes().

MsiGetFeatureInfoW()

UINT WINAPI MsiGetFeatureInfoW	(	MSIHANDLE	handle,
		const WCHAR *	feature,
		DWORD *	attrs,
		WCHAR *	title,
		DWORD *	title_len,
		WCHAR *	help,
		DWORD *	help_len
	)

Definition at line 1354 of file install.c.

{
    UINT r;
    MSIPACKAGE *package;
 
    TRACE( "%lu, %s, %p, %p, %p, %p, %p\n", handle, debugstr_w(feature), attrs, title,
           title_len, help, help_len );
 
    if (!feature) return ERROR_INVALID_PARAMETER;
 
    if (!(package = msihandle2msiinfo( handle, MSIHANDLETYPE_PACKAGE )))
        return ERROR_INVALID_HANDLE;
 
    /* features may not have been loaded yet */
    msi_load_all_components( package );
    msi_load_all_features( package );
 
    r = MSI_GetFeatureInfo( package, feature, attrs, title, title_len, help, help_len );
    msiobj_release( &package->hdr );
    return r;
}

Referenced by MsiGetFeatureInfoA().

MsiGetFeatureStateA()

UINT WINAPI MsiGetFeatureStateA	(	MSIHANDLE	hInstall,
		LPCSTR	szFeature,
		INSTALLSTATE *	piInstalled,
		INSTALLSTATE *	piAction
	)

Definition at line 1052 of file install.c.

{
    LPWSTR szwFeature = NULL;
    UINT rc;
 
    if (szFeature && !(szwFeature = strdupAtoW(szFeature))) return ERROR_OUTOFMEMORY;
 
    rc = MsiGetFeatureStateW(hInstall, szwFeature, piInstalled, piAction);
    msi_free( szwFeature);
    return rc;
}

Referenced by test_feature_states().

MsiGetFeatureStateW()

UINT WINAPI MsiGetFeatureStateW	(	MSIHANDLE	hInstall,
		const WCHAR *	szFeature,
		INSTALLSTATE *	piInstalled,
		INSTALLSTATE *	piAction
	)

Definition at line 1088 of file install.c.

{
    MSIPACKAGE* package;
    UINT ret;
 
    TRACE( "%lu, %s, %p, %p\n", hInstall, debugstr_w(szFeature), piInstalled, piAction );
 
    if (!szFeature)
        return ERROR_UNKNOWN_FEATURE;
 
    package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
    if (!package)
    {
        MSIHANDLE remote;
 
        if (!(remote = msi_get_remote(hInstall)))
            return ERROR_INVALID_HANDLE;
 
        __TRY
        {
            ret = remote_GetFeatureState(remote, szFeature, piInstalled, piAction);
        }
        __EXCEPT(rpc_filter)
        {
            ret = GetExceptionCode();
        }
        __ENDTRY
 
        return ret;
    }
 
    ret = MSI_GetFeatureStateW(package, szFeature, piInstalled, piAction);
    msiobj_release( &package->hdr );
    return ret;
}

Referenced by MsiGetFeatureStateA(), s_remote_GetFeatureState(), and session_invoke().

MsiGetFeatureValidStatesA()

UINT WINAPI MsiGetFeatureValidStatesA	(	MSIHANDLE	hInstall,
		const char *	szFeature,
		DWORD *	pInstallState
	)

Definition at line 1646 of file install.c.

{
    UINT ret;
    WCHAR *szwFeature = strdupAtoW(szFeature);
    ret = MsiGetFeatureValidStatesW(hInstall, szwFeature, pInstallState);
    msi_free(szwFeature);
    return ret;
}

MsiGetFeatureValidStatesW()

UINT WINAPI MsiGetFeatureValidStatesW	(	MSIHANDLE	hInstall,
		const WCHAR *	szFeature,
		DWORD *	pInstallState
	)

Definition at line 1635 of file install.c.

{
    if (pInstallState) *pInstallState = 1 << INSTALLSTATE_LOCAL;
    FIXME( "%lu, %s, %p stub returning %lu\n", hInstall, debugstr_w(szFeature), pInstallState,
           pInstallState ? *pInstallState : 0 );
    return ERROR_SUCCESS;
}

Referenced by MsiGetFeatureValidStatesA().

MsiGetLanguage()

LANGID WINAPI MsiGetLanguage

(

MSIHANDLE

hInstall

)

Definition at line 1541 of file install.c.

{
    MSIPACKAGE* package;
    LANGID langid;
 
    package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
    if (!package)
    {
        MSIHANDLE remote;
 
        if (!(remote = msi_get_remote(hInstall)))
            return ERROR_INVALID_HANDLE;
 
        __TRY
        {
            langid = remote_GetLanguage(remote);
        }
        __EXCEPT(rpc_filter)
        {
            langid = 0;
        }
        __ENDTRY
 
        return langid;
    }
 
    langid = msi_get_property_int( package->db, L"ProductLanguage", 0 );
    msiobj_release( &package->hdr );
    return langid;
}

Referenced by da_deferred(), s_remote_GetLanguage(), session_invoke(), and test_misc().

MsiGetMode()

BOOL WINAPI MsiGetMode	(	MSIHANDLE	hInstall,
		MSIRUNMODE	iRunMode
	)

Definition at line 670 of file install.c.

{
    MSIPACKAGE *package;
    BOOL r = FALSE;
 
    TRACE( "%lu, %d\n", hInstall, iRunMode );
 
    package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
    if (!package)
    {
        MSIHANDLE remote;
 
        if (!(remote = msi_get_remote(hInstall)))
            return FALSE;
 
        __TRY
        {
            r = remote_GetMode(remote, iRunMode);
        }
        __EXCEPT(rpc_filter)
        {
            r = FALSE;
        }
        __ENDTRY
 
        return r;
    }
 
    switch (iRunMode)
    {
    case MSIRUNMODE_ADMIN:
        FIXME("no support for administrative installs\n");
        break;
 
    case MSIRUNMODE_ADVERTISE:
        FIXME("no support for advertised installs\n");
        break;
 
    case MSIRUNMODE_WINDOWS9X:
        if (GetVersion() & 0x80000000)
            r = TRUE;
        break;
 
    case MSIRUNMODE_OPERATIONS:
    case MSIRUNMODE_RESERVED11:
    case MSIRUNMODE_RESERVED14:
    case MSIRUNMODE_RESERVED15:
        break;
 
    case MSIRUNMODE_SCHEDULED:
        r = package->scheduled_action_running;
        break;
 
    case MSIRUNMODE_ROLLBACK:
        r = package->rollback_action_running;
        break;
 
    case MSIRUNMODE_COMMIT:
        r = package->commit_action_running;
        break;
 
    case MSIRUNMODE_MAINTENANCE:
        r = msi_get_property_int( package->db, L"Installed", 0 ) != 0;
        break;
 
    case MSIRUNMODE_ROLLBACKENABLED:
        r = msi_get_property_int( package->db, L"RollbackDisabled", 0 ) == 0;
        break;
 
    case MSIRUNMODE_REBOOTATEND:
        r = package->need_reboot_at_end;
        break;
 
    case MSIRUNMODE_REBOOTNOW:
        r = package->need_reboot_now;
        break;
 
    case MSIRUNMODE_LOGENABLED:
        r = (package->log_file != INVALID_HANDLE_VALUE);
        break;
 
    default:
        FIXME("unimplemented run mode: %d\n", iRunMode);
        r = TRUE;
    }
 
    msiobj_release( &package->hdr );
    return r;
}

Referenced by da_deferred(), da_immediate(), s_remote_GetMode(), and session_invoke().

MsiGetSourcePathA()

UINT WINAPI MsiGetSourcePathA	(	MSIHANDLE	hinst,
		const char *	folder,
		char *	buf,
		DWORD *	sz
	)

Definition at line 409 of file install.c.

{
    MSIPACKAGE *package;
    WCHAR *path, *folderW;
    UINT r;
 
    TRACE("%s %p %p\n", debugstr_a(folder), buf, sz);
 
    if (!folder)
        return ERROR_INVALID_PARAMETER;
 
    if (!(folderW = strdupAtoW(folder)))
        return ERROR_OUTOFMEMORY;
 
    package = msihandle2msiinfo(hinst, MSIHANDLETYPE_PACKAGE);
    if (!package)
    {
        WCHAR *path = NULL;
        MSIHANDLE remote;
 
        if (!(remote = msi_get_remote(hinst)))
        {
            free(folderW);
            return ERROR_INVALID_HANDLE;
        }
 
        __TRY
        {
            r = remote_GetSourcePath(remote, folderW, &path);
        }
        __EXCEPT(rpc_filter)
        {
            r = GetExceptionCode();
        }
        __ENDTRY
 
        if (!r)
            r = msi_strncpyWtoA(path, -1, buf, sz, TRUE);
 
        midl_user_free(path);
        free(folderW);
        return r;
    }
 
    path = msi_resolve_source_folder(package, folderW, NULL);
    if (path)
        r = msi_strncpyWtoA(path, -1, buf, sz, FALSE);
    else
        r = ERROR_DIRECTORY;
 
    free(path);
    free(folderW);
    msiobj_release(&package->hdr);
    return r;
}

Referenced by test_MsiGetSourcePath(), test_shortlongsource(), test_sourcedir(), and test_targetpath().

MsiGetSourcePathW()

UINT WINAPI MsiGetSourcePathW	(	MSIHANDLE	hinst,
		const WCHAR *	folder,
		WCHAR *	buf,
		DWORD *	sz
	)

Definition at line 468 of file install.c.

{
    MSIPACKAGE *package;
    WCHAR *path;
    UINT r;
 
    TRACE("%s %p %p\n", debugstr_w(folder), buf, sz);
 
    if (!folder)
        return ERROR_INVALID_PARAMETER;
 
    package = msihandle2msiinfo(hinst, MSIHANDLETYPE_PACKAGE);
    if (!package)
    {
        WCHAR *path = NULL;
        MSIHANDLE remote;
 
        if (!(remote = msi_get_remote(hinst)))
            return ERROR_INVALID_HANDLE;
 
        __TRY
        {
            r = remote_GetSourcePath(remote, folder, &path);
        }
        __EXCEPT(rpc_filter)
        {
            r = GetExceptionCode();
        }
        __ENDTRY
 
        if (!r)
            r = msi_strncpyW(path, -1, buf, sz);
 
        midl_user_free(path);
        return r;
    }
 
    path = msi_resolve_source_folder(package, folder, NULL);
    if (path)
        r = msi_strncpyW(path, -1, buf, sz);
    else
        r = ERROR_DIRECTORY;
 
    free(path);
    msiobj_release(&package->hdr);
    return r;
}

Referenced by s_remote_GetSourcePath(), and test_targetpath().

MsiGetTargetPathA()

UINT WINAPI MsiGetTargetPathA	(	MSIHANDLE	hinst,
		const char *	folder,
		char *	buf,
		DWORD *	sz
	)

Definition at line 252 of file install.c.

{
    MSIPACKAGE *package;
    const WCHAR *path;
    WCHAR *folderW;
    UINT r;
 
    TRACE("%s %p %p\n", debugstr_a(folder), buf, sz);
 
    if (!folder)
        return ERROR_INVALID_PARAMETER;
 
    if (!(folderW = strdupAtoW(folder)))
        return ERROR_OUTOFMEMORY;
 
    package = msihandle2msiinfo(hinst, MSIHANDLETYPE_PACKAGE);
    if (!package)
    {
        WCHAR *path = NULL;
        MSIHANDLE remote;
 
        if (!(remote = msi_get_remote(hinst)))
        {
            free(folderW);
            return ERROR_INVALID_HANDLE;
        }
 
        __TRY
        {
            r = remote_GetTargetPath(remote, folderW, &path);
        }
        __EXCEPT(rpc_filter)
        {
            r = GetExceptionCode();
        }
        __ENDTRY
 
        if (!r)
            r = msi_strncpyWtoA(path, -1, buf, sz, TRUE);
 
        midl_user_free(path);
        free(folderW);
        return r;
    }
 
    path = msi_get_target_folder(package, folderW);
    if (path)
        r = msi_strncpyWtoA(path, -1, buf, sz, FALSE);
    else
        r = ERROR_DIRECTORY;
 
    free(folderW);
    msiobj_release(&package->hdr);
    return r;
}

Referenced by test_gettargetpath_bad(), test_settargetpath(), and test_targetpath().

MsiGetTargetPathW()

UINT WINAPI MsiGetTargetPathW	(	MSIHANDLE	hinst,
		const WCHAR *	folder,
		WCHAR *	buf,
		DWORD *	sz
	)

Definition at line 311 of file install.c.

{
    MSIPACKAGE *package;
    const WCHAR *path;
    UINT r;
 
    TRACE("%s %p %p\n", debugstr_w(folder), buf, sz);
 
    if (!folder)
        return ERROR_INVALID_PARAMETER;
 
    package = msihandle2msiinfo(hinst, MSIHANDLETYPE_PACKAGE);
    if (!package)
    {
        WCHAR *path = NULL;
        MSIHANDLE remote;
 
        if (!(remote = msi_get_remote(hinst)))
            return ERROR_INVALID_HANDLE;
 
        __TRY
        {
            r = remote_GetTargetPath(remote, folder, &path);
        }
        __EXCEPT(rpc_filter)
        {
            r = GetExceptionCode();
        }
        __ENDTRY
 
        if (!r)
            r = msi_strncpyW(path, -1, buf, sz);
 
        midl_user_free(path);
        return r;
    }
 
    path = msi_get_target_folder(package, folder);
    if (path)
        r = msi_strncpyW(path, -1, buf, sz);
    else
        r = ERROR_DIRECTORY;
 
    msiobj_release(&package->hdr);
    return r;
}

Referenced by s_remote_GetTargetPath(), test_gettargetpath_bad(), and test_targetpath().

MsiSequenceA()

UINT WINAPI MsiSequenceA	(	MSIHANDLE	hInstall,
		LPCSTR	szTable,
		INT	iSequenceMode
	)

Definition at line 104 of file install.c.

{
    LPWSTR szwTable;
    UINT ret;
 
    TRACE("%s, %d\n", debugstr_a(szTable), iSequenceMode);
 
    szwTable = strdupAtoW(szTable);
    if (szTable && !szwTable)
        return ERROR_FUNCTION_FAILED;
 
    ret = MsiSequenceW( hInstall, szwTable, iSequenceMode );
    msi_free( szwTable );
    return ret;
}

Referenced by test_doaction().

MsiSequenceW()

UINT WINAPI MsiSequenceW	(	MSIHANDLE	hInstall,
		LPCWSTR	szTable,
		INT	iSequenceMode
	)

Definition at line 123 of file install.c.

{
    MSIPACKAGE *package;
    UINT ret;
 
    TRACE("%s, %d\n", debugstr_w(szTable), iSequenceMode);
 
    if (!szTable)
        return ERROR_INVALID_PARAMETER;
 
    package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
    if (!package)
    {
        MSIHANDLE remote;
 
        if (!(remote = msi_get_remote(hInstall)))
            return ERROR_INVALID_HANDLE;
 
        __TRY
        {
            ret = remote_Sequence(remote, szTable, iSequenceMode);
        }
        __EXCEPT(rpc_filter)
        {
            ret = GetExceptionCode();
        }
        __ENDTRY
 
        return ret;
    }
    ret = MSI_Sequence( package, szTable );
    msiobj_release( &package->hdr );
    return ret;
}

Referenced by MsiSequenceA(), and s_remote_Sequence().

MsiSetComponentStateA()

UINT WINAPI MsiSetComponentStateA	(	MSIHANDLE	hInstall,
		LPCSTR	szComponent,
		INSTALLSTATE	iState
	)

Definition at line 1380 of file install.c.

{
    UINT rc;
    LPWSTR szwComponent = strdupAtoW(szComponent);
 
    rc = MsiSetComponentStateW(hInstall, szwComponent, iState);
 
    msi_free(szwComponent);
 
    return rc;
}

Referenced by test_feature_states(), test_formatrecord_tables(), test_MsiSetComponentState(), and test_removefiles().

MsiSetComponentStateW()

UINT WINAPI MsiSetComponentStateW	(	MSIHANDLE	hInstall,
		LPCWSTR	szComponent,
		INSTALLSTATE	iState
	)

Definition at line 1463 of file install.c.

{
    MSIPACKAGE* package;
    UINT ret;
 
    if (!szComponent)
        return ERROR_UNKNOWN_COMPONENT;
 
    package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
    if (!package)
    {
        MSIHANDLE remote;
 
        if (!(remote = msi_get_remote(hInstall)))
            return ERROR_INVALID_HANDLE;
 
        __TRY
        {
            ret = remote_SetComponentState(remote, szComponent, iState);
        }
        __EXCEPT(rpc_filter)
        {
            ret = GetExceptionCode();
        }
        __ENDTRY
 
        return ret;
    }
 
    ret = MSI_SetComponentStateW(package, szComponent, iState);
    msiobj_release(&package->hdr);
    return ret;
}

Referenced by MsiSetComponentStateA(), and s_remote_SetComponentState().

MsiSetFeatureAttributesA()

UINT WINAPI MsiSetFeatureAttributesA	(	MSIHANDLE	handle,
		LPCSTR	feature,
		DWORD	attrs
	)

Definition at line 988 of file install.c.

{
    UINT r;
    WCHAR *featureW = NULL;
 
    TRACE( "%lu, %s, %#lx\n", handle, debugstr_a(feature), attrs );
 
    if (feature && !(featureW = strdupAtoW( feature ))) return ERROR_OUTOFMEMORY;
 
    r = MsiSetFeatureAttributesW( handle, featureW, attrs );
    msi_free( featureW );
    return r;
}

Referenced by test_MsiSetFeatureAttributes().

MsiSetFeatureAttributesW()

UINT WINAPI MsiSetFeatureAttributesW	(	MSIHANDLE	handle,
		LPCWSTR	name,
		DWORD	attrs
	)

Definition at line 1018 of file install.c.

{
    MSIPACKAGE *package;
    MSIFEATURE *feature;
    WCHAR *costing;
 
    TRACE( "%lu, %s, %#lx\n", handle, debugstr_w(name), attrs );
 
    if (!name || !name[0]) return ERROR_UNKNOWN_FEATURE;
 
    if (!(package = msihandle2msiinfo( handle, MSIHANDLETYPE_PACKAGE )))
        return ERROR_INVALID_HANDLE;
 
    costing = msi_dup_property( package->db, L"CostingComplete" );
    if (!costing || !wcscmp( costing, L"1" ))
    {
        msi_free( costing );
        msiobj_release( &package->hdr );
        return ERROR_FUNCTION_FAILED;
    }
    msi_free( costing );
    if (!(feature = msi_get_loaded_feature( package, name )))
    {
        msiobj_release( &package->hdr );
        return ERROR_UNKNOWN_FEATURE;
    }
    feature->Attributes = unmap_feature_attributes( attrs );
    msiobj_release( &package->hdr );
    return ERROR_SUCCESS;
}

Referenced by MsiSetFeatureAttributesA().

MsiSetFeatureStateA()

UINT WINAPI MsiSetFeatureStateA	(	MSIHANDLE	hInstall,
		LPCSTR	szFeature,
		INSTALLSTATE	iState
	)

Definition at line 817 of file install.c.

{
    LPWSTR szwFeature = NULL;
    UINT rc;
 
    szwFeature = strdupAtoW(szFeature);
 
    rc = MsiSetFeatureStateW(hInstall,szwFeature, iState);
 
    msi_free(szwFeature);
 
    return rc;
}

Referenced by test_feature_states(), and test_featureparents().

MsiSetFeatureStateW()

UINT WINAPI MsiSetFeatureStateW	(	MSIHANDLE	hInstall,
		LPCWSTR	szFeature,
		INSTALLSTATE	iState
	)

Definition at line 947 of file install.c.

{
    MSIPACKAGE* package;
    UINT rc = ERROR_SUCCESS;
 
    TRACE("%s %i\n",debugstr_w(szFeature), iState);
 
    if (!szFeature)
        return ERROR_UNKNOWN_FEATURE;
 
    package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
    if (!package)
    {
        MSIHANDLE remote;
 
        if (!(remote = msi_get_remote(hInstall)))
            return ERROR_INVALID_HANDLE;
 
        __TRY
        {
            rc = remote_SetFeatureState(remote, szFeature, iState);
        }
        __EXCEPT(rpc_filter)
        {
            rc = GetExceptionCode();
        }
        __ENDTRY
 
        return rc;
    }
 
    rc = MSI_SetFeatureStateW(package,szFeature,iState);
 
    msiobj_release( &package->hdr );
    return rc;
}

Referenced by MsiSetFeatureStateA(), s_remote_SetFeatureState(), and session_invoke().

MsiSetInstallLevel()

UINT WINAPI MsiSetInstallLevel	(	MSIHANDLE	hInstall,
		int	iInstallLevel
	)

Definition at line 1597 of file install.c.

{
    MSIPACKAGE* package;
    UINT r;
 
    TRACE( "%lu %d\n", hInstall, iInstallLevel );
 
    package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
    if (!package)
    {
        MSIHANDLE remote;
 
        if (!(remote = msi_get_remote(hInstall)))
            return ERROR_INVALID_HANDLE;
 
        __TRY
        {
            r = remote_SetInstallLevel(remote, iInstallLevel);
        }
        __EXCEPT(rpc_filter)
        {
            r = GetExceptionCode();
        }
        __ENDTRY
 
        return r;
    }
 
    r = MSI_SetInstallLevel( package, iInstallLevel );
 
    msiobj_release( &package->hdr );
 
    return r;
}

Referenced by s_remote_SetInstallLevel(), session_invoke(), and test_misc().

MsiSetMode()

UINT WINAPI MsiSetMode	(	MSIHANDLE	hInstall,
		MSIRUNMODE	iRunMode,
		BOOL	fState
	)

Definition at line 763 of file install.c.

{
    MSIPACKAGE *package;
    UINT r;
 
    TRACE( "%lu, %d, %d\n", hInstall, iRunMode, fState );
 
    package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
    if (!package)
    {
        MSIHANDLE remote;
 
        if (!(remote = msi_get_remote(hInstall)))
            return FALSE;
 
        __TRY
        {
            r = remote_SetMode(remote, iRunMode, fState);
        }
        __EXCEPT(rpc_filter)
        {
            r = GetExceptionCode();
        }
        __ENDTRY
 
        return r;
    }
 
    switch (iRunMode)
    {
    case MSIRUNMODE_REBOOTATEND:
        package->need_reboot_at_end = (fState != 0);
        r = ERROR_SUCCESS;
        break;
 
    case MSIRUNMODE_REBOOTNOW:
        package->need_reboot_now = (fState != 0);
        r = ERROR_SUCCESS;
        break;
 
    default:
        r = ERROR_ACCESS_DENIED;
    }
 
    msiobj_release( &package->hdr );
    return r;
}

Referenced by s_remote_SetMode(), session_invoke(), and test_misc().

MsiSetTargetPathA()

UINT WINAPI MsiSetTargetPathA	(	MSIHANDLE	hInstall,
		LPCSTR	szFolder,
		LPCSTR	szFolderPath
	)

Definition at line 519 of file install.c.

{
    LPWSTR szwFolder = NULL, szwFolderPath = NULL;
    UINT rc = ERROR_OUTOFMEMORY;
 
    if ( !szFolder || !szFolderPath )
        return ERROR_INVALID_PARAMETER;
 
    szwFolder = strdupAtoW(szFolder);
    szwFolderPath = strdupAtoW(szFolderPath);
    if (!szwFolder || !szwFolderPath)
        goto end;
 
    rc = MsiSetTargetPathW( hInstall, szwFolder, szwFolderPath );
 
end:
    msi_free(szwFolder);
    msi_free(szwFolderPath);
 
    return rc;
}

Referenced by test_settargetpath(), and test_targetpath().

MsiSetTargetPathW()

UINT WINAPI MsiSetTargetPathW	(	MSIHANDLE	hInstall,
		LPCWSTR	szFolder,
		LPCWSTR	szFolderPath
	)

Definition at line 600 of file install.c.

{
    MSIPACKAGE *package;
    UINT ret;
 
    TRACE("%s %s\n",debugstr_w(szFolder),debugstr_w(szFolderPath));
 
    if ( !szFolder || !szFolderPath )
        return ERROR_INVALID_PARAMETER;
 
    package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
    if (!package)
    {
        MSIHANDLE remote;
 
        if (!(remote = msi_get_remote(hInstall)))
            return ERROR_INVALID_HANDLE;
 
        __TRY
        {
            ret = remote_SetTargetPath(remote, szFolder, szFolderPath);
        }
        __EXCEPT(rpc_filter)
        {
            ret = GetExceptionCode();
        }
        __ENDTRY
 
        return ret;
    }
 
    ret = MSI_SetTargetPathW( package, szFolder, szFolderPath );
    msiobj_release( &package->hdr );
    return ret;
}

Referenced by MsiSetTargetPathA(), and s_remote_SetTargetPath().

set_target_path()

static void set_target_path ( MSIPACKAGE *  package, MSIFOLDER *  folder, const WCHAR *  path  )

static

Definition at line 542 of file install.c.

{
    FolderList *fl;
    MSIFOLDER *child;
    WCHAR *target_path;
 
    if (!(target_path = msi_normalize_path( path ))) return;
    if (wcscmp( target_path, folder->ResolvedTarget ))
    {
        msi_free( folder->ResolvedTarget );
        folder->ResolvedTarget = target_path;
        msi_set_property( package->db, folder->Directory, folder->ResolvedTarget, -1 );
 
        LIST_FOR_EACH_ENTRY( fl, &folder->children, FolderList, entry )
        {
            child = fl->folder;
            msi_resolve_target_folder( package, child->Directory, FALSE );
        }
    }
    else msi_free( target_path );
}

Referenced by MSI_SetTargetPathW().

unmap_feature_attributes()

static DWORD unmap_feature_attributes ( DWORD  attrs )

static

Definition at line 1002 of file install.c.

{
    DWORD ret = 0;
 
    if (attrs & INSTALLFEATUREATTRIBUTE_FAVORLOCAL)             ret = msidbFeatureAttributesFavorLocal;
    if (attrs & INSTALLFEATUREATTRIBUTE_FAVORSOURCE)            ret |= msidbFeatureAttributesFavorSource;
    if (attrs & INSTALLFEATUREATTRIBUTE_FOLLOWPARENT)           ret |= msidbFeatureAttributesFollowParent;
    if (attrs & INSTALLFEATUREATTRIBUTE_FAVORADVERTISE)         ret |= msidbFeatureAttributesFavorAdvertise;
    if (attrs & INSTALLFEATUREATTRIBUTE_DISALLOWADVERTISE)      ret |= msidbFeatureAttributesDisallowAdvertise;
    if (attrs & INSTALLFEATUREATTRIBUTE_NOUNSUPPORTEDADVERTISE) ret |= msidbFeatureAttributesNoUnsupportedAdvertise;
    return ret;
}

Referenced by MsiSetFeatureAttributesW().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

msi

)