ReactOS 0.4.16-dev-197-g92996da
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 WCHARmsi_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 WCHARget_source_root (MSIPACKAGE *package)
 
WCHARmsi_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.

834{
835 INSTALLSTATE newstate;
836 ComponentList *cl;
837
838 newstate = feature->ActionRequest;
839 if (newstate == INSTALLSTATE_ABSENT) newstate = INSTALLSTATE_UNKNOWN;
840
842 {
843 MSICOMPONENT *component = cl->component;
844
845 if (!component->Enabled) continue;
846
847 TRACE("Modifying (%d): Component %s (Installed %d, Action %d, Request %d)\n",
848 newstate, debugstr_w(component->Component), component->Installed,
849 component->Action, component->ActionRequest);
850
851 if (newstate == INSTALLSTATE_LOCAL)
852 {
853 component->Action = INSTALLSTATE_LOCAL;
855 }
856 else
857 {
858 ComponentList *clist;
859 MSIFEATURE *f;
860
861 component->hasLocalFeature = FALSE;
862
863 component->Action = newstate;
864 component->ActionRequest = newstate;
865 /* if any other feature wants it local we need to set it local */
867 {
868 if ( f->ActionRequest != INSTALLSTATE_LOCAL &&
869 f->ActionRequest != INSTALLSTATE_SOURCE )
870 {
871 continue;
872 }
873 LIST_FOR_EACH_ENTRY(clist, &f->Components, ComponentList, entry)
874 {
875 if (clist->component == component &&
876 (f->ActionRequest == INSTALLSTATE_LOCAL ||
877 f->ActionRequest == INSTALLSTATE_SOURCE))
878 {
879 TRACE("Saved by %s\n", debugstr_w(f->Feature));
880 component->hasLocalFeature = TRUE;
881
883 {
884 if (f->Attributes & msidbFeatureAttributesFavorSource)
885 {
886 component->Action = INSTALLSTATE_SOURCE;
888 }
889 else
890 {
891 component->Action = INSTALLSTATE_LOCAL;
893 }
894 }
896 {
897 component->Action = INSTALLSTATE_SOURCE;
899 }
900 else
901 {
902 component->Action = INSTALLSTATE_LOCAL;
904 }
905 }
906 }
907 }
908 }
909 TRACE("Result (%d): Component %s (Installed %d, Action %d, Request %d)\n",
910 newstate, debugstr_w(component->Component), component->Installed,
911 component->Action, component->ActionRequest);
912 }
913}
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
GLfloat f
Definition: glext.h:7540
uint32_t entry
Definition: isohybrid.c:63
#define f
Definition: ke_i.h:83
#define debugstr_w
Definition: kernel32.h:32
INTERNETFEATURELIST feature
Definition: misc.c:1719
@ INSTALLSTATE_UNKNOWN
Definition: msi.h:42
@ INSTALLSTATE_LOCAL
Definition: msi.h:46
@ INSTALLSTATE_ABSENT
Definition: msi.h:45
@ INSTALLSTATE_SOURCE
Definition: msi.h:47
@ msidbComponentAttributesOptional
Definition: msidefs.h:161
@ msidbComponentAttributesSourceOnly
Definition: msidefs.h:160
@ msidbFeatureAttributesFavorSource
Definition: msidefs.h:149
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
#define TRACE(s)
Definition: solgame.cpp:4
MSICOMPONENT * component
Definition: msipriv.h:554
unsigned int hasLocalFeature
Definition: msipriv.h:545
LPWSTR Component
Definition: msipriv.h:524
INSTALLSTATE Action
Definition: msipriv.h:532
INSTALLSTATE ActionRequest
Definition: msipriv.h:531
INSTALLSTATE Installed
Definition: msipriv.h:530
struct list features
Definition: msipriv.h:402
int INSTALLSTATE
Definition: winemsi.idl:31

Referenced by MSI_SetFeatureStateW(), and seltree_update_feature_installstate().

◆ feature_cost()

static INT feature_cost ( MSIFEATURE feature)
static

Definition at line 1143 of file install.c.

1144{
1145 INT cost = 0;
1146 ComponentList *cl;
1147
1148 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
1149 {
1150 cost += cl->component->cost;
1151 }
1152 return cost;
1153}
int32_t INT
Definition: typedefs.h:58

Referenced by MSI_GetFeatureCost().

◆ get_source_root()

static WCHAR * get_source_root ( MSIPACKAGE package)
static

Definition at line 358 of file install.c.

359{
360 msi_set_sourcedir_props( package, FALSE );
361 return msi_dup_property( package->db, L"SourceDir" );
362}
UINT msi_set_sourcedir_props(MSIPACKAGE *package, BOOL replace)
Definition: action.c:352
WCHAR * msi_dup_property(MSIDATABASE *db, const WCHAR *prop)
#define L(x)
Definition: ntvdm.h:50
MSIDATABASE * db
Definition: msipriv.h:394

Referenced by msi_resolve_source_folder().

◆ map_feature_attributes()

static DWORD map_feature_attributes ( DWORD  attrs)
static

Definition at line 1293 of file install.c.

1294{
1295 DWORD ret = 0;
1296
1303 return ret;
1304}
unsigned long DWORD
Definition: ntddk_ex.h:95
@ INSTALLFEATUREATTRIBUTE_FAVORSOURCE
Definition: msi.h:222
@ INSTALLFEATUREATTRIBUTE_NOUNSUPPORTEDADVERTISE
Definition: msi.h:226
@ INSTALLFEATUREATTRIBUTE_FAVORLOCAL
Definition: msi.h:221
@ INSTALLFEATUREATTRIBUTE_DISALLOWADVERTISE
Definition: msi.h:225
@ INSTALLFEATUREATTRIBUTE_FAVORADVERTISE
Definition: msi.h:224
@ INSTALLFEATUREATTRIBUTE_FOLLOWPARENT
Definition: msi.h:223
@ msidbFeatureAttributesFavorAdvertise
Definition: msidefs.h:151
@ msidbFeatureAttributesFollowParent
Definition: msidefs.h:150
@ msidbFeatureAttributesDisallowAdvertise
Definition: msidefs.h:152
@ msidbFeatureAttributesNoUnsupportedAdvertise
Definition: msidefs.h:154
@ msidbFeatureAttributesFavorLocal
Definition: msidefs.h:148
int 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.

233{
235
236 if (!folder) return NULL;
237 if (!folder->ResolvedTarget)
238 {
240 while (parent->Parent && wcscmp( parent->Parent, parent->Directory ))
241 {
242 parent = msi_get_loaded_folder( package, parent->Parent );
243 }
244 msi_resolve_target_folder( package, parent->Directory, TRUE );
245 }
246 return folder->ResolvedTarget;
247}
#define NULL
Definition: types.h:112
MSIFOLDER * msi_get_loaded_folder(MSIPACKAGE *package, const WCHAR *dir)
Definition: action.c:583
void msi_resolve_target_folder(MSIPACKAGE *package, const WCHAR *name, BOOL load_prop)
Definition: action.c:2176
r parent
Definition: btrfs.c:3010
_Check_return_ _CRTIMP int __cdecl wcscmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
Definition: fci.c:116
Definition: name.c:39

Referenced by create_folder(), 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 1427 of file install.c.

1429{
1430 MSICOMPONENT *comp;
1431
1432 TRACE("%p %s %p %p\n", package, debugstr_w(szComponent),
1433 piInstalled, piAction);
1434
1435 comp = msi_get_loaded_component(package,szComponent);
1436 if (!comp)
1438
1439 if (piInstalled)
1440 {
1441 if (comp->Enabled)
1442 *piInstalled = comp->Installed;
1443 else
1444 *piInstalled = INSTALLSTATE_UNKNOWN;
1445 }
1446
1447 if (piAction)
1448 {
1449 if (comp->Enabled)
1450 *piAction = comp->Action;
1451 else
1452 *piAction = INSTALLSTATE_UNKNOWN;
1453 }
1454
1455 TRACE("states (%i, %i)\n", comp->Installed, comp->Action );
1456 return ERROR_SUCCESS;
1457}
#define ERROR_SUCCESS
Definition: deptool.c:10
MSICOMPONENT * msi_get_loaded_component(MSIPACKAGE *package, const WCHAR *Component)
Definition: action.c:550
#define ERROR_UNKNOWN_COMPONENT
Definition: winerror.h:965

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.

1157{
1158 TRACE("%s, %u, %d, %p\n", debugstr_w(feature->Feature), tree, state, cost);
1159
1160 *cost = 0;
1161 switch (tree)
1162 {
1164 {
1166
1168 {
1169 if (child->ActionRequest == state)
1170 *cost += feature_cost( child );
1171 }
1172 break;
1173 }
1175 {
1176 const WCHAR *feature_parent = feature->Feature_Parent;
1177 for (;;)
1178 {
1179 MSIFEATURE *parent = msi_get_loaded_feature( package, feature_parent );
1180 if (!parent)
1181 break;
1182
1183 if (parent->ActionRequest == state)
1184 *cost += feature_cost( parent );
1185
1186 feature_parent = parent->Feature_Parent;
1187 }
1188 break;
1189 }
1191 if (feature->ActionRequest == state)
1192 *cost = feature_cost( feature );
1193 break;
1194
1195 default:
1196 WARN("unhandled cost tree %u\n", tree);
1197 break;
1198 }
1199
1200 return ERROR_SUCCESS;
1201}
static int state
Definition: maze.c:121
#define WARN(fmt,...)
Definition: precomp.h:61
MSIFEATURE * msi_get_loaded_feature(MSIPACKAGE *package, const WCHAR *Feature)
Definition: action.c:561
static INT feature_cost(MSIFEATURE *feature)
Definition: install.c:1143
static HWND child
Definition: cursoricon.c:298
@ MSICOSTTREE_PARENTS
Definition: msiquery.h:44
@ MSICOSTTREE_CHILDREN
Definition: msiquery.h:43
@ MSICOSTTREE_SELFONLY
Definition: msiquery.h:42
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by MsiGetFeatureCostW(), and vcl_get_cost().

◆ 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 1306 of file install.c.

1308{
1311 int len;
1312
1313 if (!feature) return ERROR_UNKNOWN_FEATURE;
1314 if (attrs) *attrs = map_feature_attributes( feature->Attributes );
1315 if (title_len)
1316 {
1317 if (feature->Title) len = lstrlenW( feature->Title );
1318 else len = 0;
1319 if (*title_len <= len)
1320 {
1321 *title_len = len;
1322 if (title) r = ERROR_MORE_DATA;
1323 }
1324 else if (title)
1325 {
1326 if (feature->Title) lstrcpyW( title, feature->Title );
1327 else *title = 0;
1328 *title_len = len;
1329 }
1330 }
1331 if (help_len)
1332 {
1333 if (feature->Description) len = lstrlenW( feature->Description );
1334 else len = 0;
1335 if (*help_len <= len)
1336 {
1337 *help_len = len;
1338 if (help) r = ERROR_MORE_DATA;
1339 }
1340 else if (help)
1341 {
1342 if (feature->Description) lstrcpyW( help, feature->Description );
1343 else *help = 0;
1344 *help_len = len;
1345 }
1346 }
1347 return r;
1348}
int help
Definition: sort.c:20
#define ERROR_MORE_DATA
Definition: dderror.h:13
#define lstrcpyW
Definition: compat.h:749
#define lstrlenW
Definition: compat.h:750
static DWORD map_feature_attributes(DWORD attrs)
Definition: install.c:1293
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
GLenum GLsizei len
Definition: glext.h:6722
unsigned int UINT
Definition: ndis.h:50
static char title[]
Definition: ps.c:92
#define ERROR_UNKNOWN_FEATURE
Definition: winerror.h:964

Referenced by MsiGetFeatureInfoW().

◆ MSI_GetFeatureStateW()

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

Definition at line 1065 of file install.c.

1067{
1069
1070 feature = msi_get_loaded_feature(package,szFeature);
1071 if (!feature)
1072 return ERROR_UNKNOWN_FEATURE;
1073
1074 if (piInstalled)
1075 *piInstalled = feature->Installed;
1076
1077 if (piAction)
1078 *piAction = feature->ActionRequest;
1079
1080 TRACE("returning %i %i\n", feature->Installed, feature->ActionRequest);
1081
1082 return ERROR_SUCCESS;
1083}

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.

365{
366 MSIFOLDER *f;
367 LPWSTR p, path = NULL, parent;
368
369 TRACE("working to resolve %s\n", debugstr_w(name));
370
371 if (!wcscmp( name, L"SourceDir" )) name = L"TARGETDIR";
372 if (!(f = msi_get_loaded_folder( package, name ))) return NULL;
373
374 /* special resolving for root dir */
375 if (!wcscmp( name, L"TARGETDIR" ) && !f->ResolvedSource)
376 {
377 f->ResolvedSource = get_source_root( package );
378 }
379 if (folder) *folder = f;
380 if (f->ResolvedSource)
381 {
382 path = wcsdup( f->ResolvedSource );
383 TRACE(" already resolved to %s\n", debugstr_w(path));
384 return path;
385 }
386 if (!f->Parent) return path;
387 parent = f->Parent;
388 TRACE(" ! parent is %s\n", debugstr_w(parent));
389
390 p = msi_resolve_source_folder( package, parent, NULL );
391
393 path = get_source_root( package );
394 else if (package->WordCount & msidbSumInfoSourceTypeSFN)
395 path = msi_build_directory_name( 3, p, f->SourceShortPath, NULL );
396 else
397 path = msi_build_directory_name( 3, p, f->SourceLongPath, NULL );
398
399 TRACE("-> %s\n", debugstr_w(path));
400 f->ResolvedSource = wcsdup( path );
401 free( p );
402
403 return path;
404}
#define free
Definition: debug_ros.c:5
WCHAR *WINAPIV msi_build_directory_name(DWORD count,...)
Definition: action.c:2007
WCHAR * msi_resolve_source_folder(MSIPACKAGE *package, const WCHAR *name, MSIFOLDER **folder)
Definition: install.c:364
static WCHAR * get_source_root(MSIPACKAGE *package)
Definition: install.c:358
GLfloat GLfloat p
Definition: glext.h:8902
@ msidbSumInfoSourceTypeSFN
Definition: msidefs.h:221
@ msidbSumInfoSourceTypeCompressed
Definition: msidefs.h:222
_Check_return_ _CRTIMP wchar_t *__cdecl wcsdup(_In_z_ const wchar_t *_Str)
UINT WordCount
Definition: msipriv.h:458
WCHAR * LPWSTR
Definition: xmlstorage.h:184

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 1410 of file install.c.

1412{
1413 MSICOMPONENT *comp;
1414
1415 TRACE("%p %s %d\n", package, debugstr_w(szComponent), iState);
1416
1417 comp = msi_get_loaded_component(package, szComponent);
1418 if (!comp)
1420
1421 if (comp->Enabled)
1422 comp->Action = iState;
1423
1424 return ERROR_SUCCESS;
1425}

Referenced by MsiSetComponentStateW().

◆ MSI_SetFeatureStateW()

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

Definition at line 915 of file install.c.

916{
917 UINT rc = ERROR_SUCCESS;
919
920 TRACE("%s %i\n", debugstr_w(szFeature), iState);
921
922 feature = msi_get_loaded_feature( package, szFeature );
923 if (!feature)
925
926 if (iState == INSTALLSTATE_ADVERTISED &&
929
930 feature->ActionRequest = iState;
931
933
934 /* update all the features that are children of this feature */
936 {
937 if (child->Feature_Parent && !wcscmp( szFeature, child->Feature_Parent ))
938 MSI_SetFeatureStateW(package, child->Feature, iState);
939 }
940
941 return rc;
942}
UINT MSI_SetFeatureStateW(MSIPACKAGE *package, LPCWSTR szFeature, INSTALLSTATE iState)
Definition: install.c:915
void ACTION_UpdateComponentStates(MSIPACKAGE *package, MSIFEATURE *feature)
Definition: install.c:833
@ INSTALLSTATE_ADVERTISED
Definition: msi.h:44
#define ERROR_FUNCTION_FAILED
Definition: winerror.h:985

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 1571 of file install.c.

1572{
1573 WCHAR level[6];
1574 int len;
1575 UINT r;
1576
1577 TRACE("%p %i\n", package, iInstallLevel);
1578
1579 if (iInstallLevel > 32767)
1581
1582 if (iInstallLevel < 1)
1583 return MSI_SetFeatureStates( package );
1584
1585 len = swprintf( level, ARRAY_SIZE(level), L"%d", iInstallLevel );
1586 r = msi_set_property( package->db, L"INSTALLLEVEL", level, len );
1587 if ( r == ERROR_SUCCESS )
1588 r = MSI_SetFeatureStates( package );
1589
1590 return r;
1591}
#define ARRAY_SIZE(A)
Definition: main.h:20
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
UINT MSI_SetFeatureStates(MSIPACKAGE *package)
Definition: action.c:1639
#define swprintf
Definition: precomp.h:40
GLint level
Definition: gl.h:1546
UINT msi_set_property(MSIDATABASE *, const WCHAR *, const WCHAR *, int)
Definition: package.c:2100

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.

565{
566 DWORD attrib;
568 MSIFILE *file;
569
570 TRACE("%p %s %s\n", package, debugstr_w(szFolder), debugstr_w(szFolderPath));
571
572 attrib = msi_get_file_attributes( package, szFolderPath );
573 /* native MSI tests writeability by making temporary files at each drive */
574 if (attrib != INVALID_FILE_ATTRIBUTES &&
575 (attrib & FILE_ATTRIBUTE_OFFLINE || attrib & FILE_ATTRIBUTE_READONLY))
576 {
578 }
579 if (!(folder = msi_get_loaded_folder( package, szFolder ))) return ERROR_DIRECTORY;
580
581 set_target_path( package, folder, szFolderPath );
582
584 {
585 const WCHAR *dir;
586 MSICOMPONENT *comp = file->Component;
587
588 if (!comp->Enabled || msi_is_global_assembly( comp )) continue;
589
590 dir = msi_get_target_folder( package, comp->Directory );
591 free( file->TargetPath );
592 file->TargetPath = msi_build_directory_name( 2, dir, file->FileName );
593 }
594 return ERROR_SUCCESS;
595}
unsigned int dir
Definition: maze.c:112
BOOL msi_is_global_assembly(MSICOMPONENT *comp)
Definition: action.c:2036
DWORD msi_get_file_attributes(MSIPACKAGE *package, const WCHAR *path)
Definition: files.c:115
static void set_target_path(MSIPACKAGE *package, MSIFOLDER *folder, const WCHAR *path)
Definition: install.c:542
const WCHAR * msi_get_target_folder(MSIPACKAGE *package, const WCHAR *name)
Definition: install.c:232
#define FILE_ATTRIBUTE_READONLY
Definition: nt_native.h:702
#define FILE_ATTRIBUTE_OFFLINE
Definition: nt_native.h:712
Definition: fci.c:127
LPWSTR Directory
Definition: msipriv.h:526
struct list files
Definition: msipriv.h:403
#define INVALID_FILE_ATTRIBUTES
Definition: vfdcmd.c:23
#define ERROR_DIRECTORY
Definition: winerror.h:295

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.

159{
161
162 if (awbuf->str.w && !sz)
164 if (!sz)
165 return ERROR_SUCCESS;
166
167 if (len < 0) len = lstrlenW( str );
168
169 if (awbuf->unicode && awbuf->str.w)
170 {
171 memcpy( awbuf->str.w, str, min(len + 1, *sz) * sizeof(WCHAR) );
172 if (*sz && len >= *sz)
173 awbuf->str.w[*sz - 1] = 0;
174 }
175 else
176 {
177 int lenA = WideCharToMultiByte( CP_ACP, 0, str, len + 1, NULL, 0, NULL, NULL );
178 if (lenA) lenA--;
179 WideCharToMultiByte( CP_ACP, 0, str, len + 1, awbuf->str.a, *sz, NULL, NULL );
180 if (awbuf->str.a && *sz && lenA >= *sz)
181 awbuf->str.a[*sz - 1] = 0;
182 len = lenA;
183 }
184 if (awbuf->str.w && len >= *sz)
186 *sz = len;
187 return r;
188}
#define CP_ACP
Definition: compat.h:109
#define WideCharToMultiByte
Definition: compat.h:111
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define min(a, b)
Definition: monoChain.cc:55
const WCHAR * str
LPWSTR w
Definition: msipriv.h:743
LPSTR a
Definition: msipriv.h:742
union awstring::@501 str
BOOL unicode
Definition: msipriv.h:740

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.

214{
216
217 if (!sz)
219
220 if (len < 0) len = lstrlenW(str);
221 if (buf)
222 memcpy(buf, str, min(len + 1, *sz) * sizeof(WCHAR));
223 if (buf && len >= *sz)
224 {
225 if (*sz) buf[*sz - 1] = 0;
227 }
228 *sz = len;
229 return r;
230}
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751

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.

191{
193 DWORD lenA;
194
195 if (!sz)
197
198 if (lenW < 0) lenW = lstrlenW(str);
199 lenA = WideCharToMultiByte(CP_ACP, 0, str, lenW + 1, NULL, 0, NULL, NULL);
200 WideCharToMultiByte(CP_ACP, 0, str, lenW + 1, buf, *sz, NULL, NULL);
201 lenA--;
202 if (buf && lenA >= *sz)
203 {
204 if (*sz) buf[*sz - 1] = 0;
206 }
207 if (remote && lenA >= *sz)
208 lenA *= 2;
209 *sz = lenA;
210 return r;
211}

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

◆ MsiDoActionA()

UINT WINAPI MsiDoActionA ( MSIHANDLE  hInstall,
LPCSTR  szAction 
)

◆ MsiDoActionW()

UINT WINAPI MsiDoActionW ( MSIHANDLE  hInstall,
LPCWSTR  szAction 
)

Definition at line 64 of file install.c.

65{
66 MSIPACKAGE *package;
67 UINT ret;
68
69 TRACE("%s\n",debugstr_w(szAction));
70
71 if (!szAction)
73
74 package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
75 if (!package)
76 {
77 MSIHANDLE remote;
78
79 if (!(remote = msi_get_remote(hInstall)))
81
82 __TRY
83 {
84 ret = remote_DoAction(remote, szAction);
85 }
87 {
89 }
91
92 return ret;
93 }
94
95 ret = ACTION_PerformAction(package, szAction);
96 msiobj_release( &package->hdr );
97
98 return ret;
99}
#define __TRY
Definition: compat.h:80
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
#define __ENDTRY
Definition: compat.h:82
UINT ACTION_PerformAction(MSIPACKAGE *package, const WCHAR *action)
Definition: action.c:7640
LONG WINAPI rpc_filter(EXCEPTION_POINTERS *eptr)
Definition: custom.c:85
MSIHANDLE msi_get_remote(MSIHANDLE handle)
Definition: handle.c:183
int msiobj_release(MSIOBJECTHDR *info)
Definition: handle.c:241
#define __EXCEPT(func)
Definition: exception.h:84
#define GetExceptionCode()
Definition: seh.h:27
MSIOBJECTHDR hdr
Definition: msipriv.h:393
unsigned long MSIHANDLE
Definition: winemsi.idl:27

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

◆ MsiGetComponentStateA()

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

Definition at line 1395 of file install.c.

1397{
1398 LPWSTR szwComponent= NULL;
1399 UINT rc;
1400
1401 szwComponent= strdupAtoW(szComponent);
1402
1403 rc = MsiGetComponentStateW(hInstall,szwComponent,piInstalled, piAction);
1404
1405 free(szwComponent);
1406
1407 return rc;
1408}
UINT WINAPI MsiGetComponentStateW(MSIHANDLE hInstall, const WCHAR *szComponent, INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
Definition: install.c:1500

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 1500 of file install.c.

1502{
1503 MSIPACKAGE* package;
1504 UINT ret;
1505
1506 TRACE( "%lu, %s, %p, %p\n", hInstall, debugstr_w(szComponent), piInstalled, piAction );
1507
1508 if (!szComponent)
1510
1511 package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
1512 if (!package)
1513 {
1514 MSIHANDLE remote;
1515
1516 if (!(remote = msi_get_remote(hInstall)))
1517 return ERROR_INVALID_HANDLE;
1518
1519 __TRY
1520 {
1521 ret = remote_GetComponentState(remote, szComponent, piInstalled, piAction);
1522 }
1524 {
1526 }
1527 __ENDTRY
1528
1529 return ret;
1530 }
1531
1532 ret = MSI_GetComponentStateW( package, szComponent, piInstalled, piAction);
1533 msiobj_release( &package->hdr );
1534 return ret;
1535}
UINT MSI_GetComponentStateW(MSIPACKAGE *package, LPCWSTR szComponent, INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
Definition: install.c:1427

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.

1130{
1131 LPWSTR szwFeature = NULL;
1132 UINT rc;
1133
1134 szwFeature = strdupAtoW(szFeature);
1135
1136 rc = MsiGetFeatureCostW(hInstall, szwFeature, iCostTree, iState, piCost);
1137
1138 free(szwFeature);
1139
1140 return rc;
1141}
UINT WINAPI MsiGetFeatureCostW(MSIHANDLE hInstall, const WCHAR *szFeature, MSICOSTTREE iCostTree, INSTALLSTATE iState, INT *piCost)
Definition: install.c:1206

Referenced by test_costs().

◆ MsiGetFeatureCostW()

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

Definition at line 1206 of file install.c.

1208{
1209 MSIPACKAGE *package;
1211 UINT ret;
1212
1213 TRACE( "%lu, %s, %d, %d, %p\n", hInstall, debugstr_w(szFeature), iCostTree, iState, piCost );
1214
1215 if (!szFeature)
1217
1218 package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
1219 if (!package)
1220 {
1221 MSIHANDLE remote;
1222
1223 if (!(remote = msi_get_remote(hInstall)))
1224 return ERROR_INVALID_HANDLE;
1225
1226 __TRY
1227 {
1228 ret = remote_GetFeatureCost(remote, szFeature, iCostTree, iState, piCost);
1229 }
1231 {
1233 }
1234 __ENDTRY
1235
1236 return ret;
1237 }
1238
1239 if (!piCost)
1240 {
1241 msiobj_release( &package->hdr );
1243 }
1244
1245 feature = msi_get_loaded_feature(package, szFeature);
1246
1247 if (feature)
1248 ret = MSI_GetFeatureCost(package, feature, iCostTree, iState, piCost);
1249 else
1251
1252 msiobj_release( &package->hdr );
1253 return ret;
1254}
UINT MSI_GetFeatureCost(MSIPACKAGE *package, MSIFEATURE *feature, MSICOSTTREE tree, INSTALLSTATE state, LPINT cost)
Definition: install.c:1155

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 1259 of file install.c.

1261{
1262 UINT r;
1263 WCHAR *titleW = NULL, *helpW = NULL, *featureW = NULL;
1264
1265 TRACE( "%lu, %s, %p, %p, %p, %p, %p\n", handle, debugstr_a(feature), attrs, title,
1266 title_len, help, help_len );
1267
1268 if (feature && !(featureW = strdupAtoW( feature ))) return ERROR_OUTOFMEMORY;
1269
1270 if (title && title_len && !(titleW = malloc( *title_len * sizeof(WCHAR) )))
1271 {
1272 free( featureW );
1273 return ERROR_OUTOFMEMORY;
1274 }
1275 if (help && help_len && !(helpW = malloc( *help_len * sizeof(WCHAR) )))
1276 {
1277 free( featureW );
1278 free( titleW );
1279 return ERROR_OUTOFMEMORY;
1280 }
1281 r = MsiGetFeatureInfoW( handle, featureW, attrs, titleW, title_len, helpW, help_len );
1282 if (r == ERROR_SUCCESS)
1283 {
1284 if (titleW) WideCharToMultiByte( CP_ACP, 0, titleW, -1, title, *title_len + 1, NULL, NULL );
1285 if (helpW) WideCharToMultiByte( CP_ACP, 0, helpW, -1, help, *help_len + 1, NULL, NULL );
1286 }
1287 free( titleW );
1288 free( helpW );
1289 free( featureW );
1290 return r;
1291}
#define malloc
Definition: debug_ros.c:4
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13
UINT WINAPI MsiGetFeatureInfoW(MSIHANDLE handle, const WCHAR *feature, DWORD *attrs, WCHAR *title, DWORD *title_len, WCHAR *help, DWORD *help_len)
Definition: install.c:1353
static const WCHAR titleW[]
Definition: htmlelem.c:1067
static const WCHAR helpW[]
Definition: htmlevent.c:70

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 1353 of file install.c.

1355{
1356 UINT r;
1357 MSIPACKAGE *package;
1358
1359 TRACE( "%lu, %s, %p, %p, %p, %p, %p\n", handle, debugstr_w(feature), attrs, title,
1360 title_len, help, help_len );
1361
1362 if (!feature) return ERROR_INVALID_PARAMETER;
1363
1364 if (!(package = msihandle2msiinfo( handle, MSIHANDLETYPE_PACKAGE )))
1365 return ERROR_INVALID_HANDLE;
1366
1367 /* features may not have been loaded yet */
1368 msi_load_all_components( package );
1369 msi_load_all_features( package );
1370
1371 r = MSI_GetFeatureInfo( package, feature, attrs, title, title_len, help, help_len );
1372 msiobj_release( &package->hdr );
1373 return r;
1374}
UINT msi_load_all_components(MSIPACKAGE *package)
Definition: action.c:807
UINT msi_load_all_features(MSIPACKAGE *package)
Definition: action.c:950
void * msihandle2msiinfo(MSIHANDLE handle, UINT type)
Definition: handle.c:158
static UINT MSI_GetFeatureInfo(MSIPACKAGE *package, LPCWSTR name, LPDWORD attrs, LPWSTR title, LPDWORD title_len, LPWSTR help, LPDWORD help_len)
Definition: install.c:1306
#define MSIHANDLETYPE_PACKAGE
Definition: msipriv.h:726

Referenced by MsiGetFeatureInfoA().

◆ MsiGetFeatureStateA()

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

Definition at line 1052 of file install.c.

1054{
1055 LPWSTR szwFeature = NULL;
1056 UINT rc;
1057
1058 if (szFeature && !(szwFeature = strdupAtoW(szFeature))) return ERROR_OUTOFMEMORY;
1059
1060 rc = MsiGetFeatureStateW(hInstall, szwFeature, piInstalled, piAction);
1061 free(szwFeature);
1062 return rc;
1063}
UINT WINAPI MsiGetFeatureStateW(MSIHANDLE hInstall, const WCHAR *szFeature, INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
Definition: install.c:1088

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.

1090{
1091 MSIPACKAGE* package;
1092 UINT ret;
1093
1094 TRACE( "%lu, %s, %p, %p\n", hInstall, debugstr_w(szFeature), piInstalled, piAction );
1095
1096 if (!szFeature)
1097 return ERROR_UNKNOWN_FEATURE;
1098
1099 package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
1100 if (!package)
1101 {
1102 MSIHANDLE remote;
1103
1104 if (!(remote = msi_get_remote(hInstall)))
1105 return ERROR_INVALID_HANDLE;
1106
1107 __TRY
1108 {
1109 ret = remote_GetFeatureState(remote, szFeature, piInstalled, piAction);
1110 }
1112 {
1114 }
1115 __ENDTRY
1116
1117 return ret;
1118 }
1119
1120 ret = MSI_GetFeatureStateW(package, szFeature, piInstalled, piAction);
1121 msiobj_release( &package->hdr );
1122 return ret;
1123}
UINT MSI_GetFeatureStateW(MSIPACKAGE *package, LPCWSTR szFeature, INSTALLSTATE *piInstalled, INSTALLSTATE *piAction)
Definition: install.c:1065

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

◆ MsiGetFeatureValidStatesA()

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

Definition at line 1645 of file install.c.

1646{
1647 UINT ret;
1648 WCHAR *szwFeature = strdupAtoW(szFeature);
1649 ret = MsiGetFeatureValidStatesW(hInstall, szwFeature, pInstallState);
1650 free(szwFeature);
1651 return ret;
1652}
UINT WINAPI MsiGetFeatureValidStatesW(MSIHANDLE hInstall, const WCHAR *szFeature, DWORD *pInstallState)
Definition: install.c:1634

◆ MsiGetFeatureValidStatesW()

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

Definition at line 1634 of file install.c.

1635{
1636 if (pInstallState) *pInstallState = 1 << INSTALLSTATE_LOCAL;
1637 FIXME( "%lu, %s, %p stub returning %lu\n", hInstall, debugstr_w(szFeature), pInstallState,
1638 pInstallState ? *pInstallState : 0 );
1639 return ERROR_SUCCESS;
1640}
#define FIXME(fmt,...)
Definition: precomp.h:53

Referenced by MsiGetFeatureValidStatesA().

◆ MsiGetLanguage()

LANGID WINAPI MsiGetLanguage ( MSIHANDLE  hInstall)

Definition at line 1540 of file install.c.

1541{
1542 MSIPACKAGE* package;
1543 LANGID langid;
1544
1545 package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
1546 if (!package)
1547 {
1548 MSIHANDLE remote;
1549
1550 if (!(remote = msi_get_remote(hInstall)))
1551 return ERROR_INVALID_HANDLE;
1552
1553 __TRY
1554 {
1555 langid = remote_GetLanguage(remote);
1556 }
1558 {
1559 langid = 0;
1560 }
1561 __ENDTRY
1562
1563 return langid;
1564 }
1565
1566 langid = msi_get_property_int( package->db, L"ProductLanguage", 0 );
1567 msiobj_release( &package->hdr );
1568 return langid;
1569}
USHORT LANGID
Definition: mui.h:9
LANGID langid
Definition: msctf.idl:644
int msi_get_property_int(MSIDATABASE *package, LPCWSTR prop, int def)
Definition: package.c:2305

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.

671{
672 MSIPACKAGE *package;
673 BOOL r = FALSE;
674
675 TRACE( "%lu, %d\n", hInstall, iRunMode );
676
677 package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
678 if (!package)
679 {
680 MSIHANDLE remote;
681
682 if (!(remote = msi_get_remote(hInstall)))
683 return FALSE;
684
685 __TRY
686 {
687 r = remote_GetMode(remote, iRunMode);
688 }
690 {
691 r = FALSE;
692 }
694
695 return r;
696 }
697
698 switch (iRunMode)
699 {
700 case MSIRUNMODE_ADMIN:
701 FIXME("no support for administrative installs\n");
702 break;
703
705 FIXME("no support for advertised installs\n");
706 break;
707
709 if (GetVersion() & 0x80000000)
710 r = TRUE;
711 break;
712
717 break;
718
720 r = package->scheduled_action_running;
721 break;
722
724 r = package->rollback_action_running;
725 break;
726
728 r = package->commit_action_running;
729 break;
730
732 r = msi_get_property_int( package->db, L"Installed", 0 ) != 0;
733 break;
734
736 r = msi_get_property_int( package->db, L"RollbackDisabled", 0 ) == 0;
737 break;
738
740 r = package->need_reboot_at_end;
741 break;
742
744 r = package->need_reboot_now;
745 break;
746
748 r = (package->log_file != INVALID_HANDLE_VALUE);
749 break;
750
751 default:
752 FIXME("unimplemented run mode: %d\n", iRunMode);
753 r = TRUE;
754 }
755
756 msiobj_release( &package->hdr );
757 return r;
758}
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
unsigned int BOOL
Definition: ntddk_ex.h:94
@ MSIRUNMODE_SCHEDULED
Definition: msiquery.h:99
@ MSIRUNMODE_ADVERTISE
Definition: msiquery.h:84
@ MSIRUNMODE_WINDOWS9X
Definition: msiquery.h:95
@ MSIRUNMODE_RESERVED15
Definition: msiquery.h:98
@ MSIRUNMODE_MAINTENANCE
Definition: msiquery.h:85
@ MSIRUNMODE_RESERVED14
Definition: msiquery.h:97
@ MSIRUNMODE_REBOOTATEND
Definition: msiquery.h:89
@ MSIRUNMODE_REBOOTNOW
Definition: msiquery.h:90
@ MSIRUNMODE_ROLLBACK
Definition: msiquery.h:100
@ MSIRUNMODE_LOGENABLED
Definition: msiquery.h:87
@ MSIRUNMODE_OPERATIONS
Definition: msiquery.h:88
@ MSIRUNMODE_ADMIN
Definition: msiquery.h:83
@ MSIRUNMODE_COMMIT
Definition: msiquery.h:101
@ MSIRUNMODE_RESERVED11
Definition: msiquery.h:94
@ MSIRUNMODE_ROLLBACKENABLED
Definition: msiquery.h:86
DWORD WINAPI GetVersion()
Definition: redirtest.c:5
unsigned char commit_action_running
Definition: msipriv.h:467
unsigned char rollback_action_running
Definition: msipriv.h:468
HANDLE log_file
Definition: msipriv.h:414
unsigned char scheduled_action_running
Definition: msipriv.h:466
unsigned char need_reboot_now
Definition: msipriv.h:470
unsigned char need_reboot_at_end
Definition: msipriv.h:469

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.

410{
411 MSIPACKAGE *package;
412 WCHAR *path, *folderW;
413 UINT r;
414
415 TRACE("%s %p %p\n", debugstr_a(folder), buf, sz);
416
417 if (!folder)
419
420 if (!(folderW = strdupAtoW(folder)))
421 return ERROR_OUTOFMEMORY;
422
423 package = msihandle2msiinfo(hinst, MSIHANDLETYPE_PACKAGE);
424 if (!package)
425 {
426 WCHAR *path = NULL;
427 MSIHANDLE remote;
428
429 if (!(remote = msi_get_remote(hinst)))
430 {
431 free(folderW);
433 }
434
435 __TRY
436 {
437 r = remote_GetSourcePath(remote, folderW, &path);
438 }
440 {
442 }
444
445 if (!r)
446 r = msi_strncpyWtoA(path, -1, buf, sz, TRUE);
447
449 free(folderW);
450 return r;
451 }
452
453 path = msi_resolve_source_folder(package, folderW, NULL);
454 if (path)
455 r = msi_strncpyWtoA(path, -1, buf, sz, FALSE);
456 else
458
459 free(path);
460 free(folderW);
461 msiobj_release(&package->hdr);
462 return r;
463}
UINT msi_strncpyWtoA(const WCHAR *str, int lenW, char *buf, DWORD *sz, BOOL remote)
Definition: install.c:190
static HINSTANCE hinst
Definition: edit.c:551
#define midl_user_free
Definition: rpc.h:45

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.

469{
470 MSIPACKAGE *package;
471 WCHAR *path;
472 UINT r;
473
474 TRACE("%s %p %p\n", debugstr_w(folder), buf, sz);
475
476 if (!folder)
478
479 package = msihandle2msiinfo(hinst, MSIHANDLETYPE_PACKAGE);
480 if (!package)
481 {
482 WCHAR *path = NULL;
483 MSIHANDLE remote;
484
485 if (!(remote = msi_get_remote(hinst)))
487
488 __TRY
489 {
490 r = remote_GetSourcePath(remote, folder, &path);
491 }
493 {
495 }
497
498 if (!r)
499 r = msi_strncpyW(path, -1, buf, sz);
500
502 return r;
503 }
504
506 if (path)
507 r = msi_strncpyW(path, -1, buf, sz);
508 else
510
511 free(path);
512 msiobj_release(&package->hdr);
513 return r;
514}
UINT msi_strncpyW(const WCHAR *str, int len, WCHAR *buf, DWORD *sz)
Definition: install.c:213

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.

253{
254 MSIPACKAGE *package;
255 const WCHAR *path;
256 WCHAR *folderW;
257 UINT r;
258
259 TRACE("%s %p %p\n", debugstr_a(folder), buf, sz);
260
261 if (!folder)
263
264 if (!(folderW = strdupAtoW(folder)))
265 return ERROR_OUTOFMEMORY;
266
267 package = msihandle2msiinfo(hinst, MSIHANDLETYPE_PACKAGE);
268 if (!package)
269 {
270 WCHAR *path = NULL;
271 MSIHANDLE remote;
272
273 if (!(remote = msi_get_remote(hinst)))
274 {
275 free(folderW);
277 }
278
279 __TRY
280 {
281 r = remote_GetTargetPath(remote, folderW, &path);
282 }
284 {
286 }
288
289 if (!r)
290 r = msi_strncpyWtoA(path, -1, buf, sz, TRUE);
291
293 free(folderW);
294 return r;
295 }
296
297 path = msi_get_target_folder(package, folderW);
298 if (path)
299 r = msi_strncpyWtoA(path, -1, buf, sz, FALSE);
300 else
302
303 free(folderW);
304 msiobj_release(&package->hdr);
305 return r;
306}

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.

312{
313 MSIPACKAGE *package;
314 const WCHAR *path;
315 UINT r;
316
317 TRACE("%s %p %p\n", debugstr_w(folder), buf, sz);
318
319 if (!folder)
321
322 package = msihandle2msiinfo(hinst, MSIHANDLETYPE_PACKAGE);
323 if (!package)
324 {
325 WCHAR *path = NULL;
326 MSIHANDLE remote;
327
328 if (!(remote = msi_get_remote(hinst)))
330
331 __TRY
332 {
333 r = remote_GetTargetPath(remote, folder, &path);
334 }
336 {
338 }
340
341 if (!r)
342 r = msi_strncpyW(path, -1, buf, sz);
343
345 return r;
346 }
347
349 if (path)
350 r = msi_strncpyW(path, -1, buf, sz);
351 else
353
354 msiobj_release(&package->hdr);
355 return r;
356}

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.

105{
106 LPWSTR szwTable;
107 UINT ret;
108
109 TRACE("%s, %d\n", debugstr_a(szTable), iSequenceMode);
110
111 szwTable = strdupAtoW(szTable);
112 if (szTable && !szwTable)
114
115 ret = MsiSequenceW( hInstall, szwTable, iSequenceMode );
116 free( szwTable );
117 return ret;
118}
UINT WINAPI MsiSequenceW(MSIHANDLE hInstall, LPCWSTR szTable, INT iSequenceMode)
Definition: install.c:123

Referenced by test_doaction().

◆ MsiSequenceW()

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

Definition at line 123 of file install.c.

124{
125 MSIPACKAGE *package;
126 UINT ret;
127
128 TRACE("%s, %d\n", debugstr_w(szTable), iSequenceMode);
129
130 if (!szTable)
132
133 package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
134 if (!package)
135 {
136 MSIHANDLE remote;
137
138 if (!(remote = msi_get_remote(hInstall)))
140
141 __TRY
142 {
143 ret = remote_Sequence(remote, szTable, iSequenceMode);
144 }
146 {
148 }
150
151 return ret;
152 }
153 ret = MSI_Sequence( package, szTable );
154 msiobj_release( &package->hdr );
155 return ret;
156}
UINT MSI_Sequence(MSIPACKAGE *package, LPCWSTR table)
Definition: action.c:450

Referenced by MsiSequenceA(), and s_remote_Sequence().

◆ MsiSetComponentStateA()

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

Definition at line 1379 of file install.c.

1381{
1382 UINT rc;
1383 LPWSTR szwComponent = strdupAtoW(szComponent);
1384
1385 rc = MsiSetComponentStateW(hInstall, szwComponent, iState);
1386
1387 free(szwComponent);
1388
1389 return rc;
1390}
UINT WINAPI MsiSetComponentStateW(MSIHANDLE hInstall, LPCWSTR szComponent, INSTALLSTATE iState)
Definition: install.c:1462

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 1462 of file install.c.

1464{
1465 MSIPACKAGE* package;
1466 UINT ret;
1467
1468 if (!szComponent)
1470
1471 package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
1472 if (!package)
1473 {
1474 MSIHANDLE remote;
1475
1476 if (!(remote = msi_get_remote(hInstall)))
1477 return ERROR_INVALID_HANDLE;
1478
1479 __TRY
1480 {
1481 ret = remote_SetComponentState(remote, szComponent, iState);
1482 }
1484 {
1486 }
1487 __ENDTRY
1488
1489 return ret;
1490 }
1491
1492 ret = MSI_SetComponentStateW(package, szComponent, iState);
1493 msiobj_release(&package->hdr);
1494 return ret;
1495}
static UINT MSI_SetComponentStateW(MSIPACKAGE *package, LPCWSTR szComponent, INSTALLSTATE iState)
Definition: install.c:1410

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.

989{
990 UINT r;
991 WCHAR *featureW = NULL;
992
993 TRACE( "%lu, %s, %#lx\n", handle, debugstr_a(feature), attrs );
994
995 if (feature && !(featureW = strdupAtoW( feature ))) return ERROR_OUTOFMEMORY;
996
997 r = MsiSetFeatureAttributesW( handle, featureW, attrs );
998 free( featureW );
999 return r;
1000}
UINT WINAPI MsiSetFeatureAttributesW(MSIHANDLE handle, LPCWSTR name, DWORD attrs)
Definition: install.c:1018

Referenced by test_MsiSetFeatureAttributes().

◆ MsiSetFeatureAttributesW()

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

Definition at line 1018 of file install.c.

1019{
1020 MSIPACKAGE *package;
1022 WCHAR *costing;
1023
1024 TRACE( "%lu, %s, %#lx\n", handle, debugstr_w(name), attrs );
1025
1026 if (!name || !name[0]) return ERROR_UNKNOWN_FEATURE;
1027
1028 if (!(package = msihandle2msiinfo( handle, MSIHANDLETYPE_PACKAGE )))
1029 return ERROR_INVALID_HANDLE;
1030
1031 costing = msi_dup_property( package->db, L"CostingComplete" );
1032 if (!costing || !wcscmp( costing, L"1" ))
1033 {
1034 free( costing );
1035 msiobj_release( &package->hdr );
1036 return ERROR_FUNCTION_FAILED;
1037 }
1038 free( costing );
1039 if (!(feature = msi_get_loaded_feature( package, name )))
1040 {
1041 msiobj_release( &package->hdr );
1042 return ERROR_UNKNOWN_FEATURE;
1043 }
1044 feature->Attributes = unmap_feature_attributes( attrs );
1045 msiobj_release( &package->hdr );
1046 return ERROR_SUCCESS;
1047}
static DWORD unmap_feature_attributes(DWORD attrs)
Definition: install.c:1002

Referenced by MsiSetFeatureAttributesA().

◆ MsiSetFeatureStateA()

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

Definition at line 817 of file install.c.

819{
820 LPWSTR szwFeature = NULL;
821 UINT rc;
822
823 szwFeature = strdupAtoW(szFeature);
824
825 rc = MsiSetFeatureStateW(hInstall,szwFeature, iState);
826
827 free(szwFeature);
828
829 return rc;
830}
UINT WINAPI MsiSetFeatureStateW(MSIHANDLE hInstall, LPCWSTR szFeature, INSTALLSTATE iState)
Definition: install.c:947

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.

949{
950 MSIPACKAGE* package;
951 UINT rc = ERROR_SUCCESS;
952
953 TRACE("%s %i\n",debugstr_w(szFeature), iState);
954
955 if (!szFeature)
957
958 package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
959 if (!package)
960 {
961 MSIHANDLE remote;
962
963 if (!(remote = msi_get_remote(hInstall)))
965
966 __TRY
967 {
968 rc = remote_SetFeatureState(remote, szFeature, iState);
969 }
971 {
972 rc = GetExceptionCode();
973 }
975
976 return rc;
977 }
978
979 rc = MSI_SetFeatureStateW(package,szFeature,iState);
980
981 msiobj_release( &package->hdr );
982 return rc;
983}

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

◆ MsiSetInstallLevel()

UINT WINAPI MsiSetInstallLevel ( MSIHANDLE  hInstall,
int  iInstallLevel 
)

Definition at line 1596 of file install.c.

1597{
1598 MSIPACKAGE* package;
1599 UINT r;
1600
1601 TRACE( "%lu %d\n", hInstall, iInstallLevel );
1602
1603 package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
1604 if (!package)
1605 {
1606 MSIHANDLE remote;
1607
1608 if (!(remote = msi_get_remote(hInstall)))
1609 return ERROR_INVALID_HANDLE;
1610
1611 __TRY
1612 {
1613 r = remote_SetInstallLevel(remote, iInstallLevel);
1614 }
1616 {
1617 r = GetExceptionCode();
1618 }
1619 __ENDTRY
1620
1621 return r;
1622 }
1623
1624 r = MSI_SetInstallLevel( package, iInstallLevel );
1625
1626 msiobj_release( &package->hdr );
1627
1628 return r;
1629}
UINT MSI_SetInstallLevel(MSIPACKAGE *package, int iInstallLevel)
Definition: install.c:1571

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.

764{
765 MSIPACKAGE *package;
766 UINT r;
767
768 TRACE( "%lu, %d, %d\n", hInstall, iRunMode, fState );
769
770 package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
771 if (!package)
772 {
773 MSIHANDLE remote;
774
775 if (!(remote = msi_get_remote(hInstall)))
776 return FALSE;
777
778 __TRY
779 {
780 r = remote_SetMode(remote, iRunMode, fState);
781 }
783 {
785 }
787
788 return r;
789 }
790
791 switch (iRunMode)
792 {
794 package->need_reboot_at_end = (fState != 0);
796 break;
797
799 package->need_reboot_now = (fState != 0);
801 break;
802
803 default:
805 }
806
807 msiobj_release( &package->hdr );
808 return r;
809}
#define ERROR_ACCESS_DENIED
Definition: compat.h:97

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.

521{
522 LPWSTR szwFolder = NULL, szwFolderPath = NULL;
524
525 if ( !szFolder || !szFolderPath )
527
528 szwFolder = strdupAtoW(szFolder);
529 szwFolderPath = strdupAtoW(szFolderPath);
530 if (!szwFolder || !szwFolderPath)
531 goto end;
532
533 rc = MsiSetTargetPathW( hInstall, szwFolder, szwFolderPath );
534
535end:
536 free(szwFolder);
537 free(szwFolderPath);
538
539 return rc;
540}
UINT WINAPI MsiSetTargetPathW(MSIHANDLE hInstall, LPCWSTR szFolder, LPCWSTR szFolderPath)
Definition: install.c:600
GLuint GLuint end
Definition: gl.h:1545

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.

602{
603 MSIPACKAGE *package;
604 UINT ret;
605
606 TRACE("%s %s\n",debugstr_w(szFolder),debugstr_w(szFolderPath));
607
608 if ( !szFolder || !szFolderPath )
610
611 package = msihandle2msiinfo(hInstall, MSIHANDLETYPE_PACKAGE);
612 if (!package)
613 {
614 MSIHANDLE remote;
615
616 if (!(remote = msi_get_remote(hInstall)))
618
619 __TRY
620 {
621 ret = remote_SetTargetPath(remote, szFolder, szFolderPath);
622 }
624 {
626 }
628
629 return ret;
630 }
631
632 ret = MSI_SetTargetPathW( package, szFolder, szFolderPath );
633 msiobj_release( &package->hdr );
634 return ret;
635}
UINT MSI_SetTargetPathW(MSIPACKAGE *package, LPCWSTR szFolder, LPCWSTR szFolderPath)
Definition: install.c:564

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.

543{
544 FolderList *fl;
546 WCHAR *target_path;
547
548 if (!(target_path = msi_normalize_path( path ))) return;
549 if (wcscmp( target_path, folder->ResolvedTarget ))
550 {
551 free( folder->ResolvedTarget );
552 folder->ResolvedTarget = target_path;
553 msi_set_property( package->db, folder->Directory, folder->ResolvedTarget, -1 );
554
556 {
557 child = fl->folder;
558 msi_resolve_target_folder( package, child->Directory, FALSE );
559 }
560 }
561 else free( target_path );
562}
WCHAR * msi_normalize_path(const WCHAR *in)
Definition: action.c:2116
_In_ FLONG fl
Definition: winddi.h:1279

Referenced by MSI_SetTargetPathW().

◆ unmap_feature_attributes()

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( msi  )