#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "fdi.h"
#include "msi.h"
#include "msiquery.h"
#include "msidefs.h"
#include "objbase.h"
#include "objidl.h"
#include "fusion.h"
#include "winnls.h"
#include "winver.h"
#include "wine/list.h"
#include "wine/debug.h"
#include "msiserver.h"
#include "winemsi.h"

Include dependency graph for msipriv.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	tagMSIOBJECTHDR

struct	tagMSISTREAM

struct	tagMSITRANSFORM

struct	tagMSIDATABASE

struct	tagMSIQUERY

struct	tagMSIFIELD

struct	tagMSIRECORD

struct	tagMSISOURCELISTINFO

struct	tagMSIMEDIADISK

struct	tagMSIMEDIAINFO

struct	tagMSICABINETSTREAM

struct	tagMSIPATCHINFO

struct	tagMSIBINARY

struct	_column_info

struct	tagMSIVIEWOPS

struct	tagMSIVIEW

struct	tagMSIPACKAGE

struct	tagMSIPREVIEW

struct	tagMSISUMMARYINFO

struct	tagMSIFEATURE

struct	tagMSIASSEMBLY

struct	tagMSICOMPONENT

struct	tagComponentList

struct	tagFeatureList

struct	tagMSIFOLDER

struct	tagFolderList

struct	tagMSIFILE

struct	tagMSIFILEPATCH

struct	tagMSIAPPID

struct	tagMSICLASS

struct	tagMSIEXTENSION

struct	tagMSIPROGID

struct	tagMSIVERB

struct	tagMSIMIME

struct	MSIDRLOCATOR

struct	awstring

struct	awcstring

struct	MSICABDATA

Macros
#define	MSI_DATASIZEMASK 0x00ff

#define	MSITYPE_VALID 0x0100

#define	MSITYPE_LOCALIZABLE 0x200

#define	MSITYPE_STRING 0x0800

#define	MSITYPE_NULLABLE 0x1000

#define	MSITYPE_KEY 0x2000

#define	MSITYPE_TEMPORARY 0x4000

#define	MSITYPE_UNKNOWN 0x8000

#define	MAX_STREAM_NAME_LEN 62

#define	LONG_STR_BYTES 3

#define	INSTALLUILEVEL_MASK 0x0007

#define	MSITYPE_IS_BINARY(type) (((type) & ~MSITYPE_NULLABLE) == (MSITYPE_STRING\|MSITYPE_VALID))

#define	MSI_INITIAL_MEDIA_TRANSFORM_OFFSET 10000

#define	MSI_INITIAL_MEDIA_TRANSFORM_DISKID 32000

#define	MSI_OPEN_READONLY 0

#define	MSI_OPEN_TRANSACT 1

#define	MSI_OPEN_DIRECT 2

#define	MSI_OPEN_CREATE 3

#define	MSI_OPEN_CREATEDIRECT 4

#define	MSI_OPEN_PATCHFILE 32

#define	MSI_MAX_PROPS 20

#define	SEQUENCE_UI 0x1

#define	SEQUENCE_EXEC 0x2

#define	MSIHANDLETYPE_ANY 0

#define	MSIHANDLETYPE_DATABASE 1

#define	MSIHANDLETYPE_SUMMARYINFO 2

#define	MSIHANDLETYPE_VIEW 3

#define	MSIHANDLETYPE_RECORD 4

#define	MSIHANDLETYPE_PACKAGE 5

#define	MSIHANDLETYPE_PREVIEW 6

#define	MSI_MAJORVERSION 5

#define	MSI_MINORVERSION 0

#define	MSI_BUILDNUMBER 6001

#define	GUID_SIZE 39

#define	SQUASHED_GUID_SIZE 33

#define	MSIHANDLE_MAGIC 0x4d434923

#define	WINE_OPENPACKAGEFLAGS_RECACHE 0x80000000

#define	MSICABEXTRACT_BEGINEXTRACT 0x01

#define	MSICABEXTRACT_FILEEXTRACTED 0x02

Typedefs
typedef struct tagMSITABLE	MSITABLE

typedef struct string_table	string_table

typedef struct tagMSIOBJECTHDR	MSIOBJECTHDR

typedef VOID(*	msihandledestructor) (MSIOBJECTHDR *)

typedef struct tagMSISTREAM	MSISTREAM

typedef struct tagMSITRANSFORM	MSITRANSFORM

typedef struct tagMSIDATABASE	MSIDATABASE

typedef struct tagMSIVIEW	MSIVIEW

typedef struct tagMSIQUERY	MSIQUERY

typedef struct tagMSIFIELD	MSIFIELD

typedef struct tagMSIRECORD	MSIRECORD

typedef struct tagMSISOURCELISTINFO	MSISOURCELISTINFO

typedef struct tagMSIMEDIADISK	MSIMEDIADISK

typedef struct tagMSIMEDIAINFO	MSIMEDIAINFO

typedef struct tagMSICABINETSTREAM	MSICABINETSTREAM

typedef struct tagMSIPATCHINFO	MSIPATCHINFO

typedef struct tagMSIBINARY	MSIBINARY

typedef struct _column_info	column_info

typedef const struct tagMSICOLUMNHASHENTRY *	MSIITERHANDLE

typedef struct tagMSIVIEWOPS	MSIVIEWOPS

typedef struct msi_dialog_tag	msi_dialog

typedef struct tagMSIPACKAGE	MSIPACKAGE

typedef struct tagMSIPREVIEW	MSIPREVIEW

typedef struct tagMSISUMMARYINFO	MSISUMMARYINFO

typedef struct tagMSIFEATURE	MSIFEATURE

typedef struct tagMSIASSEMBLY	MSIASSEMBLY

typedef struct tagMSICOMPONENT	MSICOMPONENT

typedef struct tagComponentList	ComponentList

typedef struct tagFeatureList	FeatureList

typedef struct tagMSIFOLDER	MSIFOLDER

typedef struct tagFolderList	FolderList

typedef enum _msi_file_state	msi_file_state

typedef struct tagMSIFILE	MSIFILE

typedef struct tagMSIFILEPATCH	MSIFILEPATCH

typedef struct tagMSIAPPID	MSIAPPID

typedef struct tagMSIPROGID	MSIPROGID

typedef struct tagMSICLASS	MSICLASS

typedef struct tagMSIMIME	MSIMIME

typedef struct tagMSIEXTENSION	MSIEXTENSION

typedef struct tagMSIVERB	MSIVERB

typedef UINT(*	record_func) (MSIRECORD *, LPVOID)

typedef BOOL(*	PMSICABEXTRACTCB) (MSIPACKAGE , LPCWSTR, DWORD, LPWSTR , DWORD *, PVOID)

typedef enum tid_t	tid_t

Enumerations
enum	platform { PLATFORM_UNRECOGNIZED , PLATFORM_INTEL , PLATFORM_INTEL64 , PLATFORM_X64 , PLATFORM_ARM , PLATFORM_ARM64 }

enum	clr_version { CLR_VERSION_V10 , CLR_VERSION_V11 , CLR_VERSION_V20 , CLR_VERSION_V40 , CLR_VERSION_MAX }

enum	script { SCRIPT_NONE = -1 , SCRIPT_INSTALL = 0 , SCRIPT_COMMIT = 1 , SCRIPT_ROLLBACK = 2 , SCRIPT_MAX = 3 }

enum	folder_state { FOLDER_STATE_UNINITIALIZED , FOLDER_STATE_EXISTS , FOLDER_STATE_CREATED , FOLDER_STATE_CREATED_PERSISTENT , FOLDER_STATE_REMOVED }

enum	_msi_file_state { msifs_invalid , msifs_missing , msifs_overwrite , msifs_present , msifs_installed , msifs_skipped , msifs_hashmatch }

enum	tid_t { LAST_tid , LAST_tid , Database_tid , Installer_tid , Record_tid , Session_tid , StringList_tid , SummaryInfo_tid , View_tid , LAST_tid , NULL_tid , IXMLDOMAttribute_tid , IXMLDOMCDATASection_tid , IXMLDOMComment_tid , IXMLDOMDocument_tid , IXMLDOMDocument2_tid , IXMLDOMDocument3_tid , IXMLDOMDocumentFragment_tid , IXMLDOMDocumentType_tid , IXMLDOMElement_tid , IXMLDOMEntityReference_tid , IXMLDOMImplementation_tid , IXMLDOMNamedNodeMap_tid , IXMLDOMNode_tid , IXMLDOMNodeList_tid , IXMLDOMParseError2_tid , IXMLDOMProcessingInstruction_tid , IXMLDOMSchemaCollection_tid , IXMLDOMSchemaCollection2_tid , IXMLDOMSelection_tid , IXMLDOMText_tid , IXMLElement_tid , IXMLDocument_tid , IXMLHTTPRequest_tid , IXSLProcessor_tid , IXSLTemplate_tid , IVBSAXAttributes_tid , IVBSAXContentHandler_tid , IVBSAXDeclHandler_tid , IVBSAXDTDHandler_tid , IVBSAXEntityResolver_tid , IVBSAXErrorHandler_tid , IVBSAXLexicalHandler_tid , IVBSAXLocator_tid , IVBSAXXMLFilter_tid , IVBSAXXMLReader_tid , IMXAttributes_tid , IMXReaderControl_tid , IMXWriter_tid , IVBMXNamespaceManager_tid , IServerXMLHTTPRequest_tid , LAST_tid , NULL_tid , ITextDocument_tid , ITextRange_tid , ITextSelection_tid , ITextFont_tid , ITextPara_tid , LAST_tid , NULL_tid , IDictionary_tid , IDrive_tid , IDriveCollection_tid , IFile_tid , IFileCollection_tid , IFileSystem3_tid , IFolder_tid , IFolderCollection_tid , ITextStream_tid , LAST_tid , NULL_tid , IWshCollection_tid , IWshEnvironment_tid , IWshExec_tid , IWshShell3_tid , IWshShortcut_tid , IWshNetwork2_tid , LAST_tid }

Functions
static BOOL	is_platform_64bit (enum platform platform)

UINT	msi_strcpy_to_awstring (const WCHAR , int, awstring , DWORD *)

MSIHANDLE	msi_get_remote (MSIHANDLE handle)

LONG WINAPI	rpc_filter (EXCEPTION_POINTERS *eptr)

void *	msihandle2msiinfo (MSIHANDLE handle, UINT type)

MSIHANDLE	alloc_msihandle (MSIOBJECTHDR *)

MSIHANDLE	alloc_msi_remote_handle (MSIHANDLE remote)

void *	alloc_msiobject (UINT type, UINT size, msihandledestructor destroy)

void	msiobj_addref (MSIOBJECTHDR *)

int	msiobj_release (MSIOBJECTHDR *)

void	msiobj_lock (MSIOBJECTHDR *)

void	msiobj_unlock (MSIOBJECTHDR *)

void	msi_free_handle_table (void)

void	free_cached_tables (MSIDATABASE *db)

UINT	MSI_CommitTables (MSIDATABASE *db)

UINT	msi_commit_streams (MSIDATABASE *db)

int	msi_add_string (string_table st, const WCHAR data, int len, BOOL persistent)

UINT	msi_string2id (const string_table st, const WCHAR data, int len, UINT *id)

VOID	msi_destroy_stringtable (string_table *st)

const WCHAR *	msi_string_lookup (const string_table st, UINT id, int len)

HRESULT	msi_init_string_table (IStorage *stg)

string_table *	msi_load_string_table (IStorage stg, UINT bytes_per_strref)

UINT	msi_save_string_table (const string_table st, IStorage storage, UINT *bytes_per_strref)

UINT	msi_get_string_table_codepage (const string_table *st)

UINT	msi_set_string_table_codepage (string_table *st, UINT codepage)

WCHAR *	msi_strdupW (const WCHAR *value, int len) __WINE_DEALLOC(free) __WINE_MALLOC

BOOL	TABLE_Exists (MSIDATABASE *db, LPCWSTR name)

MSICONDITION	MSI_DatabaseIsTablePersistent (MSIDATABASE *db, LPCWSTR table)

UINT	read_stream_data (IStorage stg, LPCWSTR stname, BOOL table, BYTE pdata, UINT psz)

UINT	write_stream_data (IStorage *stg, LPCWSTR stname, LPCVOID data, UINT sz, BOOL bTable)

UINT	msi_table_apply_transform (MSIDATABASE db, IStorage stg, int err_cond)

UINT	MSI_DatabaseApplyTransformW (MSIDATABASE *db, LPCWSTR szTransformFile, int iErrorCond)

void	append_storage_to_db (MSIDATABASE db, IStorage stg)

UINT	msi_apply_transforms (MSIPACKAGE *package)

UINT	msi_check_patch_applicable (MSIPACKAGE package, MSISUMMARYINFO si)

UINT	msi_apply_patches (MSIPACKAGE *package)

UINT	msi_apply_registered_patch (MSIPACKAGE *package, LPCWSTR patch_code)

void	msi_free_patchinfo (MSIPATCHINFO *patch)

UINT	msi_patch_assembly (MSIPACKAGE , MSIASSEMBLY , MSIFILEPATCH *)

UINT	MSI_InstallPackage (MSIPACKAGE *, LPCWSTR, LPCWSTR)

INT	ACTION_ShowDialog (MSIPACKAGE *, LPCWSTR)

INT	ACTION_DialogBox (MSIPACKAGE *, LPCWSTR)

UINT	ACTION_ForceReboot (MSIPACKAGE *package)

UINT	MSI_Sequence (MSIPACKAGE *package, LPCWSTR szTable)

UINT	MSI_SetFeatureStates (MSIPACKAGE *package)

UINT	msi_parse_command_line (MSIPACKAGE *package, LPCWSTR szCommandLine, BOOL preserve_case)

const WCHAR *	msi_get_command_line_option (const WCHAR cmd, const WCHAR option, UINT *len)

UINT	msi_schedule_action (MSIPACKAGE package, UINT script, const WCHAR action)

INSTALLSTATE	msi_get_component_action (MSIPACKAGE package, MSICOMPONENT comp)

INSTALLSTATE	msi_get_feature_action (MSIPACKAGE package, MSIFEATURE feature)

UINT	msi_load_all_components (MSIPACKAGE *package)

UINT	msi_load_all_features (MSIPACKAGE *package)

UINT	msi_validate_product_id (MSIPACKAGE *package)

void	MSI_CloseRecord (MSIOBJECTHDR *)

UINT	MSI_RecordSetIStream (MSIRECORD , UINT, IStream )

UINT	MSI_RecordGetIStream (MSIRECORD , UINT, IStream *)

const WCHAR *	MSI_RecordGetString (const MSIRECORD *, UINT)

MSIRECORD *	MSI_CreateRecord (UINT)

UINT	MSI_RecordSetInteger (MSIRECORD *, UINT, int)

UINT	MSI_RecordSetStringW (MSIRECORD *, UINT, LPCWSTR)

BOOL	MSI_RecordIsNull (MSIRECORD *, UINT)

UINT	MSI_RecordGetStringW (MSIRECORD *, UINT, LPWSTR, LPDWORD)

UINT	MSI_RecordGetStringA (MSIRECORD *, UINT, LPSTR, LPDWORD)

int	MSI_RecordGetInteger (MSIRECORD *, UINT)

UINT	MSI_RecordReadStream (MSIRECORD , UINT, char , LPDWORD)

UINT	MSI_RecordSetStream (MSIRECORD , UINT, IStream )

UINT	MSI_RecordGetFieldCount (const MSIRECORD *rec)

UINT	MSI_RecordStreamToFile (MSIRECORD *, UINT, LPCWSTR)

UINT	MSI_RecordSetStreamFromFileW (MSIRECORD *, UINT, LPCWSTR)

UINT	MSI_RecordCopyField (MSIRECORD , UINT, MSIRECORD , UINT)

MSIRECORD *	MSI_CloneRecord (MSIRECORD *)

BOOL	MSI_RecordsAreEqual (MSIRECORD , MSIRECORD )

BOOL	MSI_RecordsAreFieldsEqual (MSIRECORD a, MSIRECORD b, UINT field)

UINT	msi_record_set_string (MSIRECORD , UINT, const WCHAR , int)

const WCHAR *	msi_record_get_string (const MSIRECORD , UINT, int )

void	dump_record (MSIRECORD *)

UINT	unmarshal_record (const struct wire_record in, MSIHANDLE out)

struct wire_record *	marshal_record (MSIHANDLE handle)

void	free_remote_record (struct wire_record *rec)

UINT	copy_remote_record (const struct wire_record *rec, MSIHANDLE handle)

void	enum_stream_names (IStorage *stg)

WCHAR *	encode_streamname (BOOL is_table, const WCHAR *in) __WINE_DEALLOC(free) __WINE_MALLOC

BOOL	decode_streamname (LPCWSTR in, LPWSTR out)

UINT	msi_get_stream (MSIDATABASE , const WCHAR , IStream **)

UINT	MSI_OpenDatabaseW (LPCWSTR, LPCWSTR, MSIDATABASE **)

UINT	MSI_DatabaseOpenViewW (MSIDATABASE , LPCWSTR, MSIQUERY *)

UINT WINAPIV	MSI_OpenQuery (MSIDATABASE , MSIQUERY *, LPCWSTR,...)

UINT	MSI_IterateRecords (MSIQUERY *, LPDWORD, record_func, LPVOID)

MSIRECORD *WINAPIV	MSI_QueryGetRecord (MSIDATABASE *db, LPCWSTR query,...)

UINT	MSI_DatabaseGetPrimaryKeys (MSIDATABASE , LPCWSTR, MSIRECORD *)

UINT	MSI_ViewExecute (MSIQUERY , MSIRECORD )

UINT	MSI_ViewFetch (MSIQUERY , MSIRECORD *)

UINT	MSI_ViewClose (MSIQUERY *)

UINT	MSI_ViewGetColumnInfo (MSIQUERY , MSICOLINFO, MSIRECORD *)

UINT	MSI_ViewModify (MSIQUERY , MSIMODIFY, MSIRECORD )

UINT	VIEW_find_column (MSIVIEW , LPCWSTR, LPCWSTR, UINT )

UINT	msi_view_get_row (MSIDATABASE , MSIVIEW , UINT, MSIRECORD **)

UINT	MSI_SetInstallLevel (MSIPACKAGE *package, int iInstallLevel)

MSIPACKAGE *	MSI_CreatePackage (MSIDATABASE *)

UINT	MSI_OpenPackageW (LPCWSTR szPackage, DWORD dwOptions, MSIPACKAGE **pPackage)

UINT	MSI_SetTargetPathW (MSIPACKAGE *, LPCWSTR, LPCWSTR)

INT	MSI_ProcessMessageVerbatim (MSIPACKAGE , INSTALLMESSAGE, MSIRECORD )

INT	MSI_ProcessMessage (MSIPACKAGE , INSTALLMESSAGE, MSIRECORD )

MSICONDITION	MSI_EvaluateConditionW (MSIPACKAGE *, LPCWSTR)

UINT	MSI_GetComponentStateW (MSIPACKAGE , LPCWSTR, INSTALLSTATE , INSTALLSTATE *)

UINT	MSI_GetFeatureStateW (MSIPACKAGE , LPCWSTR, INSTALLSTATE , INSTALLSTATE *)

UINT	MSI_SetFeatureStateW (MSIPACKAGE *, LPCWSTR, INSTALLSTATE)

UINT	msi_download_file (LPCWSTR szUrl, LPWSTR filename)

UINT	msi_package_add_info (MSIPACKAGE *, DWORD, DWORD, LPCWSTR, LPWSTR)

UINT	msi_package_add_media_disk (MSIPACKAGE *, DWORD, DWORD, DWORD, LPWSTR, LPWSTR)

UINT	msi_clone_properties (MSIDATABASE *)

UINT	msi_set_context (MSIPACKAGE *)

void	msi_adjust_privilege_properties (MSIPACKAGE *)

UINT	MSI_GetFeatureCost (MSIPACKAGE , MSIFEATURE , MSICOSTTREE, INSTALLSTATE, LPINT)

UINT	MSI_FormatRecordW (MSIPACKAGE , MSIRECORD , LPWSTR, LPDWORD)

BOOL	unsquash_guid (LPCWSTR in, LPWSTR out)

BOOL	squash_guid (LPCWSTR in, LPWSTR out)

BOOL	encode_base85_guid (GUID *, LPWSTR)

BOOL	decode_base85_guid (LPCWSTR, GUID *)

UINT	MSIREG_OpenUninstallKey (const WCHAR , enum platform, HKEY , BOOL)

UINT	MSIREG_DeleteUninstallKey (const WCHAR *, enum platform)

UINT	MSIREG_OpenProductKey (LPCWSTR szProduct, LPCWSTR szUserSid, MSIINSTALLCONTEXT context, HKEY *key, BOOL create)

UINT	MSIREG_OpenFeaturesKey (LPCWSTR szProduct, LPCWSTR szUserSid, MSIINSTALLCONTEXT context, HKEY *key, BOOL create)

UINT	MSIREG_OpenUserPatchesKey (LPCWSTR szPatch, HKEY *key, BOOL create)

UINT	MSIREG_OpenUserDataFeaturesKey (LPCWSTR szProduct, LPCWSTR szUserSid, MSIINSTALLCONTEXT context, HKEY *key, BOOL create)

UINT	MSIREG_OpenUserComponentsKey (LPCWSTR szComponent, HKEY *key, BOOL create)

UINT	MSIREG_OpenUserDataComponentKey (LPCWSTR szComponent, LPCWSTR szUserSid, HKEY *key, BOOL create)

UINT	MSIREG_OpenPatchesKey (LPCWSTR szPatch, HKEY *key, BOOL create)

UINT	MSIREG_OpenUserDataProductKey (LPCWSTR szProduct, MSIINSTALLCONTEXT dwContext, LPCWSTR szUserSid, HKEY *key, BOOL create)

UINT	MSIREG_OpenUserDataPatchKey (LPCWSTR szPatch, MSIINSTALLCONTEXT dwContext, HKEY *key, BOOL create)

UINT	MSIREG_OpenUserDataProductPatchesKey (LPCWSTR product, MSIINSTALLCONTEXT context, HKEY *key, BOOL create)

UINT	MSIREG_OpenInstallProps (LPCWSTR szProduct, MSIINSTALLCONTEXT dwContext, LPCWSTR szUserSid, HKEY *key, BOOL create)

UINT	MSIREG_OpenUpgradeCodesKey (LPCWSTR szProduct, HKEY *key, BOOL create)

UINT	MSIREG_OpenUserUpgradeCodesKey (LPCWSTR szProduct, HKEY *key, BOOL create)

UINT	MSIREG_DeleteProductKey (LPCWSTR szProduct)

UINT	MSIREG_DeleteUserProductKey (LPCWSTR szProduct)

UINT	MSIREG_DeleteUserDataPatchKey (LPCWSTR patch, MSIINSTALLCONTEXT context)

UINT	MSIREG_DeleteUserDataProductKey (LPCWSTR, MSIINSTALLCONTEXT)

UINT	MSIREG_DeleteUserFeaturesKey (LPCWSTR szProduct)

UINT	MSIREG_DeleteUserDataComponentKey (LPCWSTR szComponent, LPCWSTR szUserSid)

UINT	MSIREG_DeleteUserUpgradeCodesKey (LPCWSTR szUpgradeCode)

UINT	MSIREG_DeleteUpgradeCodesKey (const WCHAR *)

UINT	MSIREG_DeleteClassesUpgradeCodesKey (LPCWSTR szUpgradeCode)

UINT	MSIREG_OpenClassesUpgradeCodesKey (LPCWSTR szUpgradeCode, HKEY *key, BOOL create)

UINT	MSIREG_DeleteLocalClassesProductKey (LPCWSTR szProductCode)

UINT	MSIREG_DeleteLocalClassesFeaturesKey (LPCWSTR szProductCode)

UINT	msi_locate_product (LPCWSTR szProduct, MSIINSTALLCONTEXT *context)

WCHAR *	msi_reg_get_val_str (HKEY hkey, const WCHAR *name) __WINE_DEALLOC(free) __WINE_MALLOC

BOOL	msi_reg_get_val_dword (HKEY hkey, LPCWSTR name, DWORD *val)

DWORD	msi_version_str_to_dword (LPCWSTR p)

void	msi_parse_version_string (LPCWSTR, PDWORD, PDWORD)

int	msi_compare_file_versions (VS_FIXEDFILEINFO , const WCHAR )

int	msi_compare_font_versions (const WCHAR , const WCHAR )

LONG	msi_reg_set_val_str (HKEY hkey, LPCWSTR name, LPCWSTR value)

LONG	msi_reg_set_val_multi_str (HKEY hkey, LPCWSTR name, LPCWSTR value)

LONG	msi_reg_set_val_dword (HKEY hkey, LPCWSTR name, DWORD val)

LONG	msi_reg_set_subkey_val (HKEY hkey, LPCWSTR path, LPCWSTR name, LPCWSTR val)

void	msi_dialog_check_messages (HANDLE)

void	msi_dialog_destroy (msi_dialog *)

void	msi_dialog_unregister_class (void)

UINT	msi_get_suminfo (IStorage stg, UINT uiUpdateCount, MSISUMMARYINFO *si)

UINT	msi_get_db_suminfo (MSIDATABASE db, UINT uiUpdateCount, MSISUMMARYINFO *si)

WCHAR *	msi_suminfo_dup_string (MSISUMMARYINFO *si, UINT property) __WINE_DEALLOC(free) __WINE_MALLOC

INT	msi_suminfo_get_int32 (MSISUMMARYINFO *si, UINT uiProperty)

WCHAR *	msi_get_suminfo_product (IStorage *stg) __WINE_DEALLOC(free) __WINE_MALLOC

UINT	msi_add_suminfo (MSIDATABASE db, LPWSTR *records, int num_records, int num_columns)

UINT	msi_export_suminfo (MSIDATABASE *db, HANDLE handle)

UINT	msi_load_suminfo_properties (MSIPACKAGE *package)

UINT	msi_suminfo_persist (MSISUMMARYINFO *)

UINT	msi_suminfo_get_prop (MSISUMMARYINFO , UINT, UINT , INT , FILETIME , awstring , DWORD )

UINT	msi_suminfo_set_prop (MSISUMMARYINFO , UINT, UINT, INT, FILETIME , awcstring *)

UINT WINAPI	MsiCreateAndVerifyInstallerDirectory (DWORD)

UINT WINAPI	MsiDecomposeDescriptorW (LPCWSTR, LPWSTR, LPWSTR, LPWSTR, LPDWORD)

UINT WINAPI	MsiDecomposeDescriptorA (LPCSTR, LPSTR, LPSTR, LPSTR, LPDWORD)

LANGID WINAPI	MsiLoadStringW (MSIHANDLE, UINT, LPWSTR, int, LANGID)

LANGID WINAPI	MsiLoadStringA (MSIHANDLE, UINT, LPSTR, int, LANGID)

UINT	ACTION_PerformAction (MSIPACKAGE package, const WCHAR action)

void	ACTION_FinishCustomActions (const MSIPACKAGE *package)

UINT	ACTION_CustomAction (MSIPACKAGE package, const WCHAR action)

void	custom_stop_server (HANDLE process, HANDLE pipe)

UINT	ACTION_AppSearch (MSIPACKAGE *package)

UINT	ACTION_CCPSearch (MSIPACKAGE *package)

UINT	ACTION_FindRelatedProducts (MSIPACKAGE *package)

UINT	ACTION_InstallFiles (MSIPACKAGE *package)

UINT	ACTION_PatchFiles (MSIPACKAGE *package)

UINT	ACTION_RemoveFiles (MSIPACKAGE *package)

UINT	ACTION_MoveFiles (MSIPACKAGE *package)

UINT	ACTION_DuplicateFiles (MSIPACKAGE *package)

UINT	ACTION_RemoveDuplicateFiles (MSIPACKAGE *package)

UINT	ACTION_RegisterClassInfo (MSIPACKAGE *package)

UINT	ACTION_RegisterProgIdInfo (MSIPACKAGE *package)

UINT	ACTION_RegisterExtensionInfo (MSIPACKAGE *package)

UINT	ACTION_RegisterMIMEInfo (MSIPACKAGE *package)

UINT	ACTION_RegisterFonts (MSIPACKAGE *package)

UINT	ACTION_UnregisterClassInfo (MSIPACKAGE *package)

UINT	ACTION_UnregisterExtensionInfo (MSIPACKAGE *package)

UINT	ACTION_UnregisterFonts (MSIPACKAGE *package)

UINT	ACTION_UnregisterMIMEInfo (MSIPACKAGE *package)

UINT	ACTION_UnregisterProgIdInfo (MSIPACKAGE *package)

UINT	ACTION_MsiPublishAssemblies (MSIPACKAGE *package)

UINT	ACTION_MsiUnpublishAssemblies (MSIPACKAGE *package)

DWORD	deformat_string (MSIPACKAGE package, LPCWSTR ptr, WCHAR *data)

WCHAR *	msi_dup_record_field (MSIRECORD *row, INT index) __WINE_DEALLOC(free) __WINE_MALLOC

WCHAR *	msi_dup_property (MSIDATABASE db, const WCHAR prop) __WINE_DEALLOC(free) __WINE_MALLOC

UINT	msi_set_property (MSIDATABASE , const WCHAR , const WCHAR *, int)

UINT	msi_get_property (MSIDATABASE *, LPCWSTR, LPWSTR, LPDWORD)

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

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

void	msi_resolve_target_folder (MSIPACKAGE package, const WCHAR name, BOOL load_prop)

WCHAR *	msi_normalize_path (const WCHAR *) __WINE_DEALLOC(free) __WINE_MALLOC

WCHAR *	msi_resolve_file_source (MSIPACKAGE package, MSIFILE file) __WINE_DEALLOC(free) __WINE_MALLOC

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

void	msi_reset_source_folders (MSIPACKAGE *package)

MSICOMPONENT *	msi_get_loaded_component (MSIPACKAGE package, const WCHAR Component)

MSIFEATURE *	msi_get_loaded_feature (MSIPACKAGE package, const WCHAR Feature)

MSIFILE *	msi_get_loaded_file (MSIPACKAGE package, const WCHAR file)

MSIFOLDER *	msi_get_loaded_folder (MSIPACKAGE package, const WCHAR dir)

WCHAR *	msi_create_temp_file (MSIDATABASE *db) __WINE_DEALLOC(free) __WINE_MALLOC

void	msi_free_action_script (MSIPACKAGE *package, UINT script)

WCHAR *	msi_build_icon_path (MSIPACKAGE , const WCHAR ) __WINE_DEALLOC(free) __WINE_MALLOC

WCHAR *WINAPIV	msi_build_directory_name (DWORD,...) __WINE_DEALLOC(free) __WINE_MALLOC

void	msi_reduce_to_long_filename (WCHAR *)

WCHAR *	msi_create_component_advertise_string (MSIPACKAGE , MSICOMPONENT , const WCHAR *) __WINE_DEALLOC(free) __WINE_MALLOC

void	ACTION_UpdateComponentStates (MSIPACKAGE package, MSIFEATURE feature)

UINT	msi_register_unique_action (MSIPACKAGE , const WCHAR )

BOOL	msi_action_is_unique (const MSIPACKAGE , const WCHAR )

UINT	msi_set_last_used_source (LPCWSTR product, LPCWSTR usersid, MSIINSTALLCONTEXT context, DWORD options, LPCWSTR value)

UINT	msi_create_empty_local_file (LPWSTR path, LPCWSTR suffix)

UINT	msi_set_sourcedir_props (MSIPACKAGE *package, BOOL replace)

MSIASSEMBLY *	msi_load_assembly (MSIPACKAGE , MSICOMPONENT )

UINT	msi_install_assembly (MSIPACKAGE , MSICOMPONENT )

UINT	msi_uninstall_assembly (MSIPACKAGE , MSICOMPONENT )

void	msi_destroy_assembly_caches (MSIPACKAGE *)

BOOL	msi_is_global_assembly (MSICOMPONENT *)

IAssemblyEnum *	msi_create_assembly_enum (MSIPACKAGE , const WCHAR )

WCHAR *	msi_get_assembly_path (MSIPACKAGE , const WCHAR ) __WINE_DEALLOC(free) __WINE_MALLOC

WCHAR **	msi_split_string (const WCHAR *, WCHAR)

UINT	msi_set_original_database_property (MSIDATABASE , const WCHAR )

WCHAR *	msi_get_error_message (MSIDATABASE *, int) __WINE_DEALLOC(free) __WINE_MALLOC

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

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

WCHAR *	msi_get_package_code (MSIDATABASE *db) __WINE_DEALLOC(free) __WINE_MALLOC

static void	msi_disable_fs_redirection (MSIPACKAGE *package)

static void	msi_revert_fs_redirection (MSIPACKAGE *package)

BOOL	msi_get_temp_file_name (MSIPACKAGE , const WCHAR , const WCHAR , WCHAR )

HANDLE	msi_create_file (MSIPACKAGE , const WCHAR , DWORD, DWORD, DWORD, DWORD)

BOOL	msi_copy_file (MSIPACKAGE , const WCHAR , const WCHAR *, BOOL)

BOOL	msi_delete_file (MSIPACKAGE , const WCHAR )

BOOL	msi_remove_directory (MSIPACKAGE , const WCHAR )

DWORD	msi_get_file_attributes (MSIPACKAGE , const WCHAR )

BOOL	msi_set_file_attributes (MSIPACKAGE , const WCHAR , DWORD)

HANDLE	msi_find_first_file (MSIPACKAGE , const WCHAR , WIN32_FIND_DATAW *)

BOOL	msi_find_next_file (MSIPACKAGE , HANDLE, WIN32_FIND_DATAW )

BOOL	msi_move_file (MSIPACKAGE , const WCHAR , const WCHAR *, DWORD)

DWORD	msi_get_file_version_info (MSIPACKAGE , const WCHAR , DWORD, BYTE *)

BOOL	msi_create_full_path (MSIPACKAGE , const WCHAR )

DWORD	msi_get_disk_file_size (MSIPACKAGE , const WCHAR )

VS_FIXEDFILEINFO *	msi_get_disk_file_version (MSIPACKAGE , const WCHAR )

UINT	msi_get_filehash (MSIPACKAGE , const WCHAR , MSIFILEHASHINFO *)

WCHAR *	msi_get_font_file_version (MSIPACKAGE , const WCHAR ) __WINE_DEALLOC(free) __WINE_MALLOC

UINT	ready_media (MSIPACKAGE package, BOOL compressed, MSIMEDIAINFO mi)

UINT	msi_load_media_info (MSIPACKAGE package, UINT Sequence, MSIMEDIAINFO mi)

void	msi_free_media_info (MSIMEDIAINFO *mi)

BOOL	msi_cabextract (MSIPACKAGE package, MSIMEDIAINFO mi, LPVOID data)

UINT	msi_add_cabinet_stream (MSIPACKAGE , UINT, IStorage , const WCHAR *)

void	msi_event_fire (MSIPACKAGE , const WCHAR , MSIRECORD *)

void	msi_event_cleanup_all_subscriptions (MSIPACKAGE *)

HRESULT	create_msiserver (IUnknown pOuter, LPVOID ppObj)

HRESULT	create_session (MSIHANDLE msiHandle, IDispatch pInstaller, IDispatch *pDispatch)

HRESULT	get_typeinfo (tid_t tid, ITypeInfo **ti)

void	release_typelib (void)

DWORD	call_script (MSIHANDLE hPackage, INT type, LPCWSTR script, LPCWSTR function, LPCWSTR action)

void	msi_ui_progress (MSIPACKAGE *, int, int, int, int)

static char *	strdupWtoA (LPCWSTR str)

static LPWSTR	strdupAtoW (LPCSTR str)

static char *	strdupWtoU (LPCWSTR str)

static LPWSTR	strdupUtoW (LPCSTR str)

static int	cost_from_size (int size)

Macro Definition Documentation

◆ GUID_SIZE

#define GUID_SIZE 39

Definition at line 757 of file msipriv.h.

◆ INSTALLUILEVEL_MASK

#define INSTALLUILEVEL_MASK 0x0007

Definition at line 60 of file msipriv.h.

◆ LONG_STR_BYTES

#define LONG_STR_BYTES 3

Definition at line 57 of file msipriv.h.

◆ MAX_STREAM_NAME_LEN

#define MAX_STREAM_NAME_LEN 62

Definition at line 56 of file msipriv.h.

◆ MSI_BUILDNUMBER

#define MSI_BUILDNUMBER 6001

Definition at line 755 of file msipriv.h.

◆ MSI_DATASIZEMASK

#define MSI_DATASIZEMASK 0x00ff

Definition at line 47 of file msipriv.h.

◆ MSI_INITIAL_MEDIA_TRANSFORM_DISKID

#define MSI_INITIAL_MEDIA_TRANSFORM_DISKID 32000

Definition at line 84 of file msipriv.h.

◆ MSI_INITIAL_MEDIA_TRANSFORM_OFFSET

#define MSI_INITIAL_MEDIA_TRANSFORM_OFFSET 10000

Definition at line 83 of file msipriv.h.

◆ MSI_MAJORVERSION

#define MSI_MAJORVERSION 5

Definition at line 753 of file msipriv.h.

◆ MSI_MAX_PROPS

#define MSI_MAX_PROPS 20

Definition at line 496 of file msipriv.h.

◆ MSI_MINORVERSION

#define MSI_MINORVERSION 0

Definition at line 754 of file msipriv.h.

◆ MSI_OPEN_CREATE

#define MSI_OPEN_CREATE 3

Definition at line 102 of file msipriv.h.

◆ MSI_OPEN_CREATEDIRECT

#define MSI_OPEN_CREATEDIRECT 4

Definition at line 103 of file msipriv.h.

◆ MSI_OPEN_DIRECT

#define MSI_OPEN_DIRECT 2

Definition at line 101 of file msipriv.h.

◆ MSI_OPEN_PATCHFILE

#define MSI_OPEN_PATCHFILE 32

Definition at line 104 of file msipriv.h.

◆ MSI_OPEN_READONLY

#define MSI_OPEN_READONLY 0

Definition at line 99 of file msipriv.h.

◆ MSI_OPEN_TRANSACT

#define MSI_OPEN_TRANSACT 1

Definition at line 100 of file msipriv.h.

◆ MSICABEXTRACT_BEGINEXTRACT

#define MSICABEXTRACT_BEGINEXTRACT 0x01

Definition at line 1129 of file msipriv.h.

◆ MSICABEXTRACT_FILEEXTRACTED

#define MSICABEXTRACT_FILEEXTRACTED 0x02

Definition at line 1130 of file msipriv.h.

◆ MSIHANDLE_MAGIC

#define MSIHANDLE_MAGIC 0x4d434923

Definition at line 760 of file msipriv.h.

◆ MSIHANDLETYPE_ANY

#define MSIHANDLETYPE_ANY 0

Definition at line 745 of file msipriv.h.

◆ MSIHANDLETYPE_DATABASE

#define MSIHANDLETYPE_DATABASE 1

Definition at line 746 of file msipriv.h.

◆ MSIHANDLETYPE_PACKAGE

#define MSIHANDLETYPE_PACKAGE 5

Definition at line 750 of file msipriv.h.

◆ MSIHANDLETYPE_PREVIEW

#define MSIHANDLETYPE_PREVIEW 6

Definition at line 751 of file msipriv.h.

◆ MSIHANDLETYPE_RECORD

#define MSIHANDLETYPE_RECORD 4

Definition at line 749 of file msipriv.h.

◆ MSIHANDLETYPE_SUMMARYINFO

#define MSIHANDLETYPE_SUMMARYINFO 2

Definition at line 747 of file msipriv.h.

◆ MSIHANDLETYPE_VIEW

#define MSIHANDLETYPE_VIEW 3

Definition at line 748 of file msipriv.h.

◆ MSITYPE_IS_BINARY

#define MSITYPE_IS_BINARY ( type ) (((type) & ~MSITYPE_NULLABLE) == (MSITYPE_STRING|MSITYPE_VALID))

Definition at line 62 of file msipriv.h.

◆ MSITYPE_KEY

#define MSITYPE_KEY 0x2000

Definition at line 52 of file msipriv.h.

◆ MSITYPE_LOCALIZABLE

#define MSITYPE_LOCALIZABLE 0x200

Definition at line 49 of file msipriv.h.

◆ MSITYPE_NULLABLE

#define MSITYPE_NULLABLE 0x1000

Definition at line 51 of file msipriv.h.

◆ MSITYPE_STRING

#define MSITYPE_STRING 0x0800

Definition at line 50 of file msipriv.h.

◆ MSITYPE_TEMPORARY

#define MSITYPE_TEMPORARY 0x4000

Definition at line 53 of file msipriv.h.

◆ MSITYPE_UNKNOWN

#define MSITYPE_UNKNOWN 0x8000

Definition at line 54 of file msipriv.h.

◆ MSITYPE_VALID

#define MSITYPE_VALID 0x0100

Definition at line 48 of file msipriv.h.

◆ SEQUENCE_EXEC

#define SEQUENCE_EXEC 0x2

Definition at line 743 of file msipriv.h.

◆ SEQUENCE_UI

#define SEQUENCE_UI 0x1

Definition at line 742 of file msipriv.h.

◆ SQUASHED_GUID_SIZE

#define SQUASHED_GUID_SIZE 33

Definition at line 758 of file msipriv.h.

◆ WINE_OPENPACKAGEFLAGS_RECACHE

#define WINE_OPENPACKAGEFLAGS_RECACHE 0x80000000

Definition at line 908 of file msipriv.h.

Typedef Documentation

◆ column_info

typedef struct _column_info column_info

◆ ComponentList

typedef struct tagComponentList ComponentList

◆ FeatureList

typedef struct tagFeatureList FeatureList

◆ FolderList

typedef struct tagFolderList FolderList

◆ msi_dialog

typedef struct msi_dialog_tag msi_dialog

Definition at line 361 of file msipriv.h.

◆ msi_file_state

typedef enum _msi_file_state msi_file_state

◆ MSIAPPID

typedef struct tagMSIAPPID MSIAPPID

◆ MSIASSEMBLY

typedef struct tagMSIASSEMBLY MSIASSEMBLY

◆ MSIBINARY

typedef struct tagMSIBINARY MSIBINARY

◆ MSICABINETSTREAM

typedef struct tagMSICABINETSTREAM MSICABINETSTREAM

◆ MSICLASS

typedef struct tagMSICLASS MSICLASS

◆ MSICOMPONENT

typedef struct tagMSICOMPONENT MSICOMPONENT

◆ MSIDATABASE

typedef struct tagMSIDATABASE MSIDATABASE

◆ MSIEXTENSION

typedef struct tagMSIEXTENSION MSIEXTENSION

◆ MSIFEATURE

typedef struct tagMSIFEATURE MSIFEATURE

◆ MSIFIELD

typedef struct tagMSIFIELD MSIFIELD

◆ MSIFILE

typedef struct tagMSIFILE MSIFILE

◆ MSIFILEPATCH

typedef struct tagMSIFILEPATCH MSIFILEPATCH

◆ MSIFOLDER

typedef struct tagMSIFOLDER MSIFOLDER

◆ msihandledestructor

typedef VOID(* msihandledestructor) (MSIOBJECTHDR *)

Definition at line 73 of file msipriv.h.

◆ MSIITERHANDLE

typedef const struct tagMSICOLUMNHASHENTRY* MSIITERHANDLE

Definition at line 229 of file msipriv.h.

◆ MSIMEDIADISK

typedef struct tagMSIMEDIADISK MSIMEDIADISK

◆ MSIMEDIAINFO

typedef struct tagMSIMEDIAINFO MSIMEDIAINFO

◆ MSIMIME

typedef struct tagMSIMIME MSIMIME

Definition at line 684 of file msipriv.h.

◆ MSIOBJECTHDR

typedef struct tagMSIOBJECTHDR MSIOBJECTHDR

Definition at line 71 of file msipriv.h.

◆ MSIPACKAGE

typedef struct tagMSIPACKAGE MSIPACKAGE

◆ MSIPATCHINFO

typedef struct tagMSIPATCHINFO MSIPATCHINFO

◆ MSIPREVIEW

typedef struct tagMSIPREVIEW MSIPREVIEW

◆ MSIPROGID

typedef struct tagMSIPROGID MSIPROGID

Definition at line 661 of file msipriv.h.

◆ MSIQUERY

typedef struct tagMSIQUERY MSIQUERY

◆ MSIRECORD

typedef struct tagMSIRECORD MSIRECORD

◆ MSISOURCELISTINFO

typedef struct tagMSISOURCELISTINFO MSISOURCELISTINFO

◆ MSISTREAM

typedef struct tagMSISTREAM MSISTREAM

◆ MSISUMMARYINFO

typedef struct tagMSISUMMARYINFO MSISUMMARYINFO

◆ MSITABLE

typedef struct tagMSITABLE MSITABLE

Definition at line 65 of file msipriv.h.

◆ MSITRANSFORM

typedef struct tagMSITRANSFORM MSITRANSFORM

◆ MSIVERB

typedef struct tagMSIVERB MSIVERB

◆ MSIVIEW

typedef struct tagMSIVIEW MSIVIEW

Definition at line 125 of file msipriv.h.

◆ MSIVIEWOPS

typedef struct tagMSIVIEWOPS MSIVIEWOPS

◆ PMSICABEXTRACTCB

typedef BOOL(* PMSICABEXTRACTCB) (MSIPACKAGE *, LPCWSTR, DWORD, LPWSTR *, DWORD *, PVOID)

Definition at line 1127 of file msipriv.h.

◆ record_func

typedef UINT(* record_func) (MSIRECORD *, LPVOID)

Definition at line 890 of file msipriv.h.

◆ string_table

typedef struct string_table string_table

Definition at line 68 of file msipriv.h.

◆ tid_t

typedef enum tid_t tid_t

Enumeration Type Documentation

◆ _msi_file_state

enum _msi_file_state

Enumerator
msifs_invalid
msifs_missing
msifs_overwrite
msifs_present
msifs_installed
msifs_skipped
msifs_hashmatch

Definition at line 607 of file msipriv.h.

                             {
    msifs_invalid,
    msifs_missing,
    msifs_overwrite,
    msifs_present,
    msifs_installed,
    msifs_skipped,
    msifs_hashmatch
} msi_file_state;

◆ clr_version

enum clr_version

Enumerator
CLR_VERSION_V10
CLR_VERSION_V11
CLR_VERSION_V20
CLR_VERSION_V40
CLR_VERSION_MAX

Definition at line 386 of file msipriv.h.

{
    CLR_VERSION_V10,
    CLR_VERSION_V11,
    CLR_VERSION_V20,
    CLR_VERSION_V40,
    CLR_VERSION_MAX
};

◆ folder_state

enum folder_state

Enumerator
FOLDER_STATE_UNINITIALIZED
FOLDER_STATE_EXISTS
FOLDER_STATE_CREATED
FOLDER_STATE_CREATED_PERSISTENT
FOLDER_STATE_REMOVED

Definition at line 577 of file msipriv.h.

{
    FOLDER_STATE_UNINITIALIZED,
    FOLDER_STATE_EXISTS,
    FOLDER_STATE_CREATED,
    FOLDER_STATE_CREATED_PERSISTENT,
    FOLDER_STATE_REMOVED
};

◆ platform

enum platform

Enumerator
PLATFORM_UNRECOGNIZED
PLATFORM_INTEL
PLATFORM_INTEL64
PLATFORM_X64
PLATFORM_ARM
PLATFORM_ARM64

Definition at line 363 of file msipriv.h.

{
    PLATFORM_UNRECOGNIZED,
    PLATFORM_INTEL,
    PLATFORM_INTEL64,
    PLATFORM_X64,
    PLATFORM_ARM,
    PLATFORM_ARM64
};

◆ script

enum script

Enumerator
SCRIPT_NONE
SCRIPT_INSTALL
SCRIPT_COMMIT
SCRIPT_ROLLBACK
SCRIPT_MAX

Definition at line 395 of file msipriv.h.

{
    SCRIPT_NONE     = -1,
    SCRIPT_INSTALL  = 0,
    SCRIPT_COMMIT   = 1,
    SCRIPT_ROLLBACK = 2,
    SCRIPT_MAX      = 3
};

◆ tid_t

enum tid_t

Enumerator
LAST_tid
LAST_tid
Database_tid
Installer_tid
Record_tid
Session_tid
StringList_tid
SummaryInfo_tid
View_tid
LAST_tid
NULL_tid
IXMLDOMAttribute_tid
IXMLDOMCDATASection_tid
IXMLDOMComment_tid
IXMLDOMDocument_tid
IXMLDOMDocument2_tid
IXMLDOMDocument3_tid
IXMLDOMDocumentFragment_tid
IXMLDOMDocumentType_tid
IXMLDOMElement_tid
IXMLDOMEntityReference_tid
IXMLDOMImplementation_tid
IXMLDOMNamedNodeMap_tid
IXMLDOMNode_tid
IXMLDOMNodeList_tid
IXMLDOMParseError2_tid
IXMLDOMProcessingInstruction_tid
IXMLDOMSchemaCollection_tid
IXMLDOMSchemaCollection2_tid
IXMLDOMSelection_tid
IXMLDOMText_tid
IXMLElement_tid
IXMLDocument_tid
IXMLHTTPRequest_tid
IXSLProcessor_tid
IXSLTemplate_tid
IVBSAXAttributes_tid
IVBSAXContentHandler_tid
IVBSAXDeclHandler_tid
IVBSAXDTDHandler_tid
IVBSAXEntityResolver_tid
IVBSAXErrorHandler_tid
IVBSAXLexicalHandler_tid
IVBSAXLocator_tid
IVBSAXXMLFilter_tid
IVBSAXXMLReader_tid
IMXAttributes_tid
IMXReaderControl_tid
IMXWriter_tid
IVBMXNamespaceManager_tid
IServerXMLHTTPRequest_tid
LAST_tid
NULL_tid
ITextDocument_tid
ITextRange_tid
ITextSelection_tid
ITextFont_tid
ITextPara_tid
LAST_tid
NULL_tid
IDictionary_tid
IDrive_tid
IDriveCollection_tid
IFile_tid
IFileCollection_tid
IFileSystem3_tid
IFolder_tid
IFolderCollection_tid
ITextStream_tid
LAST_tid
NULL_tid
IWshCollection_tid
IWshEnvironment_tid
IWshExec_tid
IWshShell3_tid
IWshShortcut_tid
IWshNetwork2_tid
LAST_tid

Definition at line 1152 of file msipriv.h.

                   {
    Database_tid,
    Installer_tid,
    Record_tid,
    Session_tid,
    StringList_tid,
    SummaryInfo_tid,
    View_tid,
    LAST_tid
} tid_t;

Function Documentation

◆ ACTION_AppSearch()

UINT ACTION_AppSearch ( MSIPACKAGE * package )

Definition at line 1124 of file appsearch.c.

{
    MSIQUERY *view;
    UINT r;
 
    if (msi_action_is_unique(package, L"AppSearch"))
    {
        TRACE("Skipping AppSearch action: already done in UI sequence\n");
        return ERROR_SUCCESS;
    }
    else
        msi_register_unique_action(package, L"AppSearch");
 
    r = MSI_OpenQuery( package->db, &view, L"SELECT * FROM `AppSearch`" );
    if (r != ERROR_SUCCESS)
        return ERROR_SUCCESS;
 
    r = MSI_IterateRecords( view, NULL, ITERATE_AppSearch, package );
    msiobj_release( &view->hdr );
    return r;
}

◆ ACTION_CCPSearch()

UINT ACTION_CCPSearch ( MSIPACKAGE * package )

Definition at line 1174 of file appsearch.c.

{
    MSIQUERY *view;
    UINT r;
 
    if (msi_action_is_unique(package, L"CCPSearch"))
    {
        TRACE("Skipping AppSearch action: already done in UI sequence\n");
        return ERROR_SUCCESS;
    }
    else
        msi_register_unique_action(package, L"CCPSearch");
 
    r = MSI_OpenQuery(package->db, &view, L"SELECT * FROM `CCPSearch`");
    if (r != ERROR_SUCCESS)
        return ERROR_SUCCESS;
 
    r = MSI_IterateRecords(view, NULL, ITERATE_CCPSearch, package);
    msiobj_release(&view->hdr);
    return r;
}

◆ ACTION_CustomAction()

UINT ACTION_CustomAction	(	MSIPACKAGE *	package,
		const WCHAR *	action
	)

Definition at line 1484 of file custom.c.

{
    UINT rc = ERROR_SUCCESS;
    MSIRECORD *row;
    UINT type;
    const WCHAR *source, *target, *ptr, *deferred_data = NULL;
    WCHAR *deformated = NULL;
    int len;
 
    /* deferred action: [properties]Action */
    if ((ptr = wcsrchr(action, ']')))
    {
        deferred_data = action;
        action = ptr + 1;
    }
 
    row = MSI_QueryGetRecord( package->db, L"SELECT * FROM `CustomAction` WHERE `Action` = '%s'", action );
    if (!row)
        return ERROR_FUNCTION_NOT_CALLED;
 
    type = MSI_RecordGetInteger(row,2);
    source = MSI_RecordGetString(row,3);
    target = MSI_RecordGetString(row,4);
 
    TRACE("Handling custom action %s (%x %s %s)\n",debugstr_w(action),type,
          debugstr_w(source), debugstr_w(target));
 
    /* handle some of the deferred actions */
    if (type & msidbCustomActionTypeTSAware)
        FIXME("msidbCustomActionTypeTSAware not handled\n");
 
    if (type & msidbCustomActionTypeInScript)
    {
        if (type & msidbCustomActionTypeNoImpersonate)
            WARN("msidbCustomActionTypeNoImpersonate not handled\n");
 
        if (!action_type_matches_script(type, package->script))
        {
            rc = defer_custom_action( package, action, type );
            goto end;
        }
        else
        {
            LPWSTR actiondata = msi_dup_property( package->db, action );
 
            if (type & msidbCustomActionTypeInScript)
                package->scheduled_action_running = TRUE;
 
            if (type & msidbCustomActionTypeCommit)
                package->commit_action_running = TRUE;
 
            if (type & msidbCustomActionTypeRollback)
                package->rollback_action_running = TRUE;
 
            if (deferred_data)
                set_deferred_action_props(package, deferred_data);
            else if (actiondata)
                msi_set_property( package->db, L"CustomActionData", actiondata, -1 );
            else
                msi_set_property( package->db, L"CustomActionData", L"", -1 );
 
            free(actiondata);
        }
    }
    else if (!check_execution_scheduling_options(package,action,type))
    {
        rc = ERROR_SUCCESS;
        goto end;
    }
 
    switch (type & CUSTOM_ACTION_TYPE_MASK)
    {
    case 1: /* DLL file stored in a Binary table stream */
        rc = HANDLE_CustomType1( package, source, target, type, action );
        break;
    case 2: /* EXE file stored in a Binary table stream */
        rc = HANDLE_CustomType2( package, source, target, type, action );
        break;
    case 5:
    case 6: /* JScript/VBScript file stored in a Binary table stream */
        rc = HANDLE_CustomType5_6( package, source, target, type, action );
        break;
    case 7: /* Concurrent install from substorage */
        deformat_string( package, target, &deformated );
        rc = HANDLE_CustomType7( package, source, target, type, action );
        free( deformated );
        break;
    case 17:
        rc = HANDLE_CustomType17( package, source, target, type, action );
        break;
    case 18: /* EXE file installed with package */
        rc = HANDLE_CustomType18( package, source, target, type, action );
        break;
    case 19: /* Error that halts install */
        rc = HANDLE_CustomType19( package, source, target, type, action );
        break;
    case 21: /* JScript/VBScript file installed with the product */
    case 22:
        rc = HANDLE_CustomType21_22( package, source, target, type, action );
        break;
    case 23: /* Installs another package in the source tree */
        deformat_string( package, target, &deformated );
        rc = HANDLE_CustomType23( package, source, deformated, type, action );
        free( deformated );
        break;
    case 34: /* EXE to be run in specified directory */
        rc = HANDLE_CustomType34( package, source, target, type, action );
        break;
    case 35: /* Directory set with formatted text */
        deformat_string( package, target, &deformated );
        MSI_SetTargetPathW( package, source, deformated );
        free( deformated );
        break;
    case 37: /* JScript/VBScript text stored in target column */
    case 38:
        rc = HANDLE_CustomType37_38( package, source, target, type, action );
        break;
    case 50: /* EXE file specified by a property value */
        rc = HANDLE_CustomType50( package, source, target, type, action );
        break;
    case 51: /* Property set with formatted text */
        if (!source) break;
        len = deformat_string( package, target, &deformated );
        rc = msi_set_property( package->db, source, deformated, len );
        if (rc == ERROR_SUCCESS && !wcscmp( source, L"SourceDir" )) msi_reset_source_folders( package );
        free( deformated );
        break;
    case 53: /* JScript/VBScript text specified by a property value */
    case 54:
        rc = HANDLE_CustomType53_54( package, source, target, type, action );
        break;
    default:
        FIXME( "unhandled action type %u (%s %s)\n", type & CUSTOM_ACTION_TYPE_MASK, debugstr_w(source),
               debugstr_w(target) );
    }
 
end:
    package->scheduled_action_running = FALSE;
    package->commit_action_running = FALSE;
    package->rollback_action_running = FALSE;
    msiobj_release(&row->hdr);
    return rc;
}

Referenced by ACTION_HandleCustomAction().

◆ ACTION_DialogBox()

INT ACTION_DialogBox	(	MSIPACKAGE *	,
		LPCWSTR
	)

◆ ACTION_DuplicateFiles()

UINT ACTION_DuplicateFiles ( MSIPACKAGE * package )

Definition at line 1315 of file files.c.

{
    MSIQUERY *view;
    UINT rc;
 
    if (package->script == SCRIPT_NONE)
        return msi_schedule_action(package, SCRIPT_INSTALL, L"DuplicateFiles");
 
    rc = MSI_DatabaseOpenViewW(package->db, L"SELECT * FROM `DuplicateFile`", &view);
    if (rc != ERROR_SUCCESS)
        return ERROR_SUCCESS;
 
    rc = MSI_IterateRecords(view, NULL, ITERATE_DuplicateFiles, package);
    msiobj_release(&view->hdr);
    return rc;
}

◆ ACTION_FindRelatedProducts()

UINT ACTION_FindRelatedProducts ( MSIPACKAGE * package )

Definition at line 217 of file upgrade.c.

{
    MSIQUERY *view;
    UINT rc;
 
    if (msi_get_property_int(package->db, L"Installed", 0))
    {
        TRACE("Skipping FindRelatedProducts action: product already installed\n");
        return ERROR_SUCCESS;
    }
    if (msi_action_is_unique(package, L"FindRelatedProducts"))
    {
        TRACE("Skipping FindRelatedProducts action: already done in UI sequence\n");
        return ERROR_SUCCESS;
    }
    else
        msi_register_unique_action(package, L"FindRelatedProducts");
 
    rc = MSI_DatabaseOpenViewW(package->db, L"SELECT * FROM `Upgrade`", &view);
    if (rc != ERROR_SUCCESS)
        return ERROR_SUCCESS;
 
    rc = MSI_IterateRecords(view, NULL, ITERATE_FindRelatedProducts, package);
    msiobj_release(&view->hdr);
    return rc;
}

◆ ACTION_FinishCustomActions()

void ACTION_FinishCustomActions ( const MSIPACKAGE * package )

Definition at line 1628 of file custom.c.

{
    struct list *item;
    HANDLE *wait_handles;
    unsigned int handle_count, i;
    custom_action_info *info, *cursor;
 
    while ((item = list_head( &package->RunningActions )))
    {
        struct running_action *action = LIST_ENTRY( item, struct running_action, entry );
 
        list_remove( &action->entry );
 
        TRACE("waiting for %s\n", debugstr_w( action->name ) );
        msi_dialog_check_messages( action->handle );
 
        CloseHandle( action->handle );
        free( action->name );
        free( action );
    }
 
    EnterCriticalSection( &custom_action_cs );
 
    handle_count = list_count( &pending_custom_actions );
    wait_handles = malloc( handle_count * sizeof(HANDLE) );
 
    handle_count = 0;
    LIST_FOR_EACH_ENTRY_SAFE( info, cursor, &pending_custom_actions, custom_action_info, entry )
    {
        if (info->package == package )
        {
            if (DuplicateHandle(GetCurrentProcess(), info->handle, GetCurrentProcess(), &wait_handles[handle_count], SYNCHRONIZE, FALSE, 0))
                handle_count++;
        }
    }
 
    LeaveCriticalSection( &custom_action_cs );
 
    for (i = 0; i < handle_count; i++)
    {
        msi_dialog_check_messages( wait_handles[i] );
        CloseHandle( wait_handles[i] );
    }
    free( wait_handles );
 
    EnterCriticalSection( &custom_action_cs );
    LIST_FOR_EACH_ENTRY_SAFE( info, cursor, &pending_custom_actions, custom_action_info, entry )
    {
        if (info->package == package)
            free_custom_action_data( info );
    }
    LeaveCriticalSection( &custom_action_cs );
}

Referenced by MSI_InstallPackage().

◆ ACTION_ForceReboot()

UINT ACTION_ForceReboot ( MSIPACKAGE * package )

Definition at line 5227 of file action.c.

{
    WCHAR buffer[256], sysdir[MAX_PATH], squashed_pc[SQUASHED_GUID_SIZE];
    HKEY hkey;
 
    squash_guid( package->ProductCode, squashed_pc );
 
    GetSystemDirectoryW(sysdir, ARRAY_SIZE(sysdir));
    RegCreateKeyW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion\\RunOnce", &hkey);
    swprintf(buffer, ARRAY_SIZE(buffer), L"%s\\MsiExec.exe /@ \"%s\"", sysdir, squashed_pc);
 
    msi_reg_set_val_str( hkey, squashed_pc, buffer );
    RegCloseKey(hkey);
 
    TRACE("Reboot command %s\n",debugstr_w(buffer));
 
    RegCreateKeyW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\RunOnceEntries",
                  &hkey);
    swprintf( buffer, ARRAY_SIZE(buffer), L"/I \"%s\" AFTERREBOOT=1 RUNONCEENTRY=\"%s\"", package->ProductCode,
              squashed_pc );
 
    msi_reg_set_val_str( hkey, squashed_pc, buffer );
    RegCloseKey(hkey);
 
    return ERROR_INSTALL_SUSPEND;
}

Referenced by custom_get_thread_return(), and ITERATE_Actions().

◆ ACTION_InstallFiles()

UINT ACTION_InstallFiles ( MSIPACKAGE * package )

Definition at line 564 of file files.c.

{
    MSIMEDIAINFO *mi;
    UINT rc = ERROR_SUCCESS;
    MSIFILE *file;
 
    msi_set_sourcedir_props(package, FALSE);
 
    if (package->script == SCRIPT_NONE)
        return msi_schedule_action(package, SCRIPT_INSTALL, L"InstallFiles");
 
    schedule_install_files(package);
    mi = calloc(1, sizeof(MSIMEDIAINFO));
 
    LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
    {
        BOOL is_global_assembly = msi_is_global_assembly( file->Component );
 
        file_update_ui( package, file, L"InstallFiles" );
 
        rc = msi_load_media_info( package, file->Sequence, mi );
        if (rc != ERROR_SUCCESS)
        {
            ERR("Unable to load media info for %s (%u)\n", debugstr_w(file->File), rc);
            rc = ERROR_FUNCTION_FAILED;
            goto done;
        }
 
        if (file->state != msifs_hashmatch &&
            file->state != msifs_skipped &&
            (file->state != msifs_present || !msi_get_property_int( package->db, L"Installed", 0 )) &&
            (rc = ready_media( package, file->IsCompressed, mi )))
        {
            ERR("Failed to ready media for %s\n", debugstr_w(file->File));
            goto done;
        }
 
        if (file->state != msifs_missing && !mi->is_continuous && file->state != msifs_overwrite)
            continue;
 
        if (file->Sequence > mi->last_sequence || mi->is_continuous ||
            (file->IsCompressed && !mi->is_extracted))
        {
            MSICABDATA data;
            MSIFILE *cursor = file;
 
            data.mi = mi;
            data.package = package;
            data.cb = installfiles_cb;
            data.user = &cursor;
 
            if (file->IsCompressed && !msi_cabextract(package, mi, &data))
            {
                ERR("Failed to extract cabinet: %s\n", debugstr_w(mi->cabinet));
                rc = ERROR_INSTALL_FAILURE;
                goto done;
            }
        }
 
        if (!file->IsCompressed)
        {
            WCHAR *source = msi_resolve_file_source(package, file);
 
            TRACE("copying %s to %s\n", debugstr_w(source), debugstr_w(file->TargetPath));
 
            if (!is_global_assembly)
            {
                create_folder(package, file->Component->Directory);
            }
            rc = copy_install_file(package, file, source);
            if (rc != ERROR_SUCCESS)
            {
                ERR("Failed to copy %s to %s (%u)\n", debugstr_w(source), debugstr_w(file->TargetPath), rc);
                rc = ERROR_INSTALL_FAILURE;
                free(source);
                goto done;
            }
            if (!is_global_assembly) file->state = msifs_installed;
            free(source);
        }
        else if (!is_global_assembly && file->state != msifs_installed &&
                 !(file->Attributes & msidbFileAttributesPatchAdded))
        {
            ERR("compressed file wasn't installed (%s)\n", debugstr_w(file->File));
            rc = ERROR_INSTALL_FAILURE;
            goto done;
        }
    }
 
done:
    msi_free_media_info(mi);
    return rc;
}

◆ ACTION_MoveFiles()

UINT ACTION_MoveFiles ( MSIPACKAGE * package )

Definition at line 1185 of file files.c.

{
    MSIQUERY *view;
    UINT rc;
 
    if (package->script == SCRIPT_NONE)
        return msi_schedule_action(package, SCRIPT_INSTALL, L"MoveFiles");
 
    rc = MSI_DatabaseOpenViewW(package->db, L"SELECT * FROM `MoveFile`", &view);
    if (rc != ERROR_SUCCESS)
        return ERROR_SUCCESS;
 
    rc = MSI_IterateRecords(view, NULL, ITERATE_MoveFiles, package);
    msiobj_release(&view->hdr);
    return rc;
}

◆ ACTION_MsiPublishAssemblies()

UINT ACTION_MsiPublishAssemblies ( MSIPACKAGE * package )

Definition at line 542 of file assembly.c.

{
    MSICOMPONENT *comp;
 
    if (package->script == SCRIPT_NONE)
        return msi_schedule_action(package, SCRIPT_INSTALL, L"MsiPublishAssemblies");
 
    LIST_FOR_EACH_ENTRY(comp, &package->components, MSICOMPONENT, entry)
    {
        LONG res;
        HKEY hkey;
        GUID guid;
        DWORD size;
        WCHAR buffer[43];
        MSIRECORD *uirow;
        MSIASSEMBLY *assembly = comp->assembly;
        BOOL win32;
 
        if (!assembly || !comp->ComponentId) continue;
 
        comp->Action = msi_get_component_action( package, comp );
        if (comp->Action != INSTALLSTATE_LOCAL)
        {
            TRACE("component not scheduled for installation %s\n", debugstr_w(comp->Component));
            continue;
        }
        TRACE("publishing %s\n", debugstr_w(comp->Component));
 
        CLSIDFromString( package->ProductCode, &guid );
        encode_base85_guid( &guid, buffer );
        buffer[20] = '>';
        CLSIDFromString( comp->ComponentId, &guid );
        encode_base85_guid( &guid, buffer + 21 );
        buffer[42] = 0;
 
        win32 = assembly->attributes & msidbAssemblyAttributesWin32;
        if (assembly->application)
        {
            MSIFILE *file = msi_get_loaded_file( package, assembly->application );
            if (!file)
            {
                WARN("no matching file %s for local assembly\n", debugstr_w(assembly->application));
                continue;
            }
            if ((res = open_local_assembly_key( package->Context, win32, file->TargetPath, &hkey )))
            {
                WARN( "failed to open local assembly key %ld\n", res );
                return ERROR_FUNCTION_FAILED;
            }
        }
        else
        {
            if ((res = open_global_assembly_key( package->Context, win32, &hkey )))
            {
                WARN( "failed to open global assembly key %ld\n", res );
                return ERROR_FUNCTION_FAILED;
            }
        }
        size = sizeof(buffer);
        if ((res = RegSetValueExW( hkey, assembly->display_name, 0, REG_MULTI_SZ, (const BYTE *)buffer, size )))
        {
            WARN( "failed to set assembly value %ld\n", res );
        }
        RegCloseKey( hkey );
 
        uirow = MSI_CreateRecord( 2 );
        MSI_RecordSetStringW( uirow, 2, assembly->display_name );
        MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
        msiobj_release( &uirow->hdr );
    }
    return ERROR_SUCCESS;
}

◆ ACTION_MsiUnpublishAssemblies()

UINT ACTION_MsiUnpublishAssemblies ( MSIPACKAGE * package )

Definition at line 615 of file assembly.c.

{
    MSICOMPONENT *comp;
 
    if (package->script == SCRIPT_NONE)
        return msi_schedule_action(package, SCRIPT_INSTALL, L"MsiUnpublishAssemblies");
 
    LIST_FOR_EACH_ENTRY(comp, &package->components, MSICOMPONENT, entry)
    {
        LONG res;
        MSIRECORD *uirow;
        MSIASSEMBLY *assembly = comp->assembly;
        BOOL win32;
 
        if (!assembly || !comp->ComponentId) continue;
 
        comp->Action = msi_get_component_action( package, comp );
        if (comp->Action != INSTALLSTATE_ABSENT)
        {
            TRACE("component not scheduled for removal %s\n", debugstr_w(comp->Component));
            continue;
        }
        TRACE("unpublishing %s\n", debugstr_w(comp->Component));
 
        win32 = assembly->attributes & msidbAssemblyAttributesWin32;
        if (assembly->application)
        {
            MSIFILE *file = msi_get_loaded_file( package, assembly->application );
            if (!file)
            {
                WARN("no matching file %s for local assembly\n", debugstr_w(assembly->application));
                continue;
            }
            if ((res = delete_local_assembly_key( package->Context, win32, file->TargetPath )))
                WARN( "failed to delete local assembly key %ld\n", res );
        }
        else
        {
            HKEY hkey;
            if ((res = open_global_assembly_key( package->Context, win32, &hkey )))
                WARN( "failed to delete global assembly key %ld\n", res );
            else
            {
                if ((res = RegDeleteValueW( hkey, assembly->display_name )))
                    WARN( "failed to delete global assembly value %ld\n", res );
                RegCloseKey( hkey );
            }
        }
 
        uirow = MSI_CreateRecord( 2 );
        MSI_RecordSetStringW( uirow, 2, assembly->display_name );
        MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
        msiobj_release( &uirow->hdr );
    }
    return ERROR_SUCCESS;
}

◆ ACTION_PatchFiles()

UINT ACTION_PatchFiles ( MSIPACKAGE * package )

Definition at line 776 of file files.c.

{
    MSIFILEPATCH *patch;
    MSIMEDIAINFO *mi;
    UINT rc = ERROR_SUCCESS;
 
    TRACE("%p\n", package);
 
    if (package->script == SCRIPT_NONE)
        return msi_schedule_action(package, SCRIPT_INSTALL, L"PatchFiles");
 
    mi = calloc( 1, sizeof(MSIMEDIAINFO) );
 
    TRACE("extracting files\n");
 
    LIST_FOR_EACH_ENTRY( patch, &package->filepatches, MSIFILEPATCH, entry )
    {
        MSIFILE *file = patch->File;
        MSICOMPONENT *comp = file->Component;
 
        rc = msi_load_media_info( package, patch->Sequence, mi );
        if (rc != ERROR_SUCCESS)
        {
            ERR("Unable to load media info for %s (%u)\n", debugstr_w(file->File), rc);
            rc = ERROR_FUNCTION_FAILED;
            goto done;
        }
        comp->Action = msi_get_component_action( package, comp );
        if (!comp->Enabled || comp->Action != INSTALLSTATE_LOCAL) continue;
 
        if (!patch->extracted)
        {
            MSICABDATA data;
            MSIFILEPATCH *cursor = patch;
 
            rc = ready_media( package, TRUE, mi );
            if (rc != ERROR_SUCCESS)
            {
                ERR("Failed to ready media for %s\n", debugstr_w(file->File));
                goto done;
            }
            data.mi      = mi;
            data.package = package;
            data.cb      = patchfiles_cb;
            data.user    = &cursor;
 
            if (!msi_cabextract( package, mi, &data ))
            {
                ERR("Failed to extract cabinet: %s\n", debugstr_w(mi->cabinet));
                rc = ERROR_INSTALL_FAILURE;
                goto done;
            }
        }
    }
 
    TRACE("applying patches\n");
 
    LIST_FOR_EACH_ENTRY( patch, &package->filepatches, MSIFILEPATCH, entry )
    {
        MSICOMPONENT *comp = patch->File->Component;
 
        if (msi_is_global_assembly( comp ) || !patch->path) continue;
 
        rc = patch_file( package, patch );
        if (rc && !(patch->Attributes & msidbPatchAttributesNonVital))
        {
            ERR("Failed to apply patch to file: %s\n", debugstr_w(patch->File->File));
            break;
        }
    }
 
done:
    msi_free_media_info(mi);
    return rc;
}

◆ ACTION_PerformAction()

UINT ACTION_PerformAction	(	MSIPACKAGE *	package,
		const WCHAR *	action
	)

Definition at line 7837 of file action.c.

{
    UINT rc;
 
    TRACE("Performing action (%s)\n", debugstr_w(action));
 
    package->action_progress_increment = 0;
    rc = ACTION_HandleStandardAction(package, action);
 
    if (rc == ERROR_FUNCTION_NOT_CALLED)
        rc = ACTION_HandleCustomAction(package, action);
 
    if (rc == ERROR_FUNCTION_NOT_CALLED)
        WARN("unhandled msi action %s\n", debugstr_w(action));
 
    return rc;
}

Referenced by ACTION_ExecuteAction(), ACTION_PerformEndAction(), event_do_action(), execute_script(), ITERATE_Actions(), MSI_InstallPackage(), MsiCollectUserInfoA(), MsiCollectUserInfoW(), MsiConfigureFeatureW(), and MsiDoActionW().

◆ ACTION_RegisterClassInfo()

UINT ACTION_RegisterClassInfo ( MSIPACKAGE * package )

Definition at line 690 of file classes.c.

{
    REGSAM access = KEY_ALL_ACCESS;
    MSIRECORD *uirow;
    HKEY hkey, hkey2, hkey3;
    MSICLASS *cls;
    UINT r;
 
    if (package->script == SCRIPT_NONE)
        return msi_schedule_action( package, SCRIPT_INSTALL, L"RegisterClassInfo" );
 
    r = load_classes_and_such( package );
    if (r != ERROR_SUCCESS)
        return r;
 
    if (package->platform == PLATFORM_INTEL)
        access |= KEY_WOW64_32KEY;
    else
        access |= KEY_WOW64_64KEY;
 
    if (RegCreateKeyExW( HKEY_CLASSES_ROOT, L"CLSID", 0, NULL, 0, access, NULL, &hkey, NULL ))
        return ERROR_FUNCTION_FAILED;
 
    LIST_FOR_EACH_ENTRY( cls, &package->classes, MSICLASS, entry )
    {
        MSICOMPONENT *comp;
        MSIFILE *file;
        DWORD size;
        LPWSTR argument;
        MSIFEATURE *feature;
 
        comp = cls->Component;
        if ( !comp )
            continue;
 
        if (!comp->Enabled)
        {
            TRACE("component is disabled\n");
            continue;
        }
 
        feature = cls->Feature;
        if (!feature)
            continue;
 
        feature->Action = msi_get_feature_action( package, feature );
        if (feature->Action != INSTALLSTATE_LOCAL &&
            feature->Action != INSTALLSTATE_ADVERTISED )
        {
            TRACE("feature %s not scheduled for installation, skipping registration of class %s\n",
                  debugstr_w(feature->Feature), debugstr_w(cls->clsid));
            continue;
        }
 
        if (!comp->KeyPath || !(file = msi_get_loaded_file( package, comp->KeyPath )))
        {
            TRACE("COM server not provided, skipping class %s\n", debugstr_w(cls->clsid));
            continue;
        }
        TRACE("Registering class %s (%p)\n", debugstr_w(cls->clsid), cls);
 
        cls->action = INSTALLSTATE_LOCAL;
 
        RegCreateKeyW( hkey, cls->clsid, &hkey2 );
 
        if (cls->Description)
            msi_reg_set_val_str( hkey2, NULL, cls->Description );
 
        RegCreateKeyW( hkey2, cls->Context, &hkey3 );
 
        /*
         * FIXME: Implement install on demand (advertised components).
         *
         * ole32.dll should call msi.MsiProvideComponentFromDescriptor()
         *  when it needs an InProcServer that doesn't exist.
         * The component advertise string should be in the "InProcServer" value.
         */
        size = lstrlenW( file->TargetPath )+1;
        if (cls->Argument)
            size += lstrlenW(cls->Argument)+1;
 
        argument = malloc( size * sizeof(WCHAR) );
        lstrcpyW( argument, file->TargetPath );
 
        if (cls->Argument)
        {
            lstrcatW( argument, L" " );
            lstrcatW( argument, cls->Argument );
        }
 
        msi_reg_set_val_str( hkey3, NULL, argument );
        free(argument);
 
        RegCloseKey(hkey3);
 
        if (cls->ProgID || cls->ProgIDText)
        {
            LPCWSTR progid;
 
            if (cls->ProgID)
                progid = cls->ProgID->ProgID;
            else
                progid = cls->ProgIDText;
 
            msi_reg_set_subkey_val( hkey2, L"ProgID", NULL, progid );
 
            if (cls->ProgID && cls->ProgID->VersionInd)
            {
                msi_reg_set_subkey_val( hkey2, L"VersionIndependentProgID", NULL,
                                        cls->ProgID->VersionInd->ProgID );
            }
        }
 
        if (cls->AppID)
        {
            MSIAPPID *appid = cls->AppID;
            msi_reg_set_val_str( hkey2, L"AppID", appid->AppID );
            register_appid( appid, cls->Description );
        }
 
        if (cls->IconPath)
            msi_reg_set_subkey_val( hkey2, L"DefaultIcon", NULL, cls->IconPath );
 
        if (cls->DefInprocHandler)
            msi_reg_set_subkey_val( hkey2, L"InprocHandler", NULL, cls->DefInprocHandler );
 
        if (cls->DefInprocHandler32)
            msi_reg_set_subkey_val( hkey2, L"InprocHandler32", NULL, cls->DefInprocHandler32 );
        RegCloseKey(hkey2);
 
        /* if there is a FileTypeMask, register the FileType */
        if (cls->FileTypeMask)
        {
            LPWSTR ptr, ptr2;
            LPWSTR keyname;
            INT index = 0;
            ptr = cls->FileTypeMask;
            while (ptr && *ptr)
            {
                ptr2 = wcschr(ptr,';');
                if (ptr2)
                    *ptr2 = 0;
                keyname = malloc( sizeof(L"FileType\\%s\\%d") + (wcslen(cls->clsid) + 3) * sizeof(WCHAR) );
                swprintf( keyname, lstrlenW(L"FileType\\%s\\%d") + lstrlenW(cls->clsid) + 4,
                          L"FileType\\%s\\%d", cls->clsid, index );
 
                msi_reg_set_subkey_val( HKEY_CLASSES_ROOT, keyname, NULL, ptr );
                free( keyname );
 
                if (ptr2)
                    ptr = ptr2+1;
                else
                    ptr = NULL;
 
                index ++;
            }
        }
 
        uirow = MSI_CreateRecord(1);
        MSI_RecordSetStringW( uirow, 1, cls->clsid );
        MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
        msiobj_release(&uirow->hdr);
    }
    RegCloseKey(hkey);
    return ERROR_SUCCESS;
}

◆ ACTION_RegisterExtensionInfo()

UINT ACTION_RegisterExtensionInfo ( MSIPACKAGE * package )

Definition at line 1196 of file classes.c.

{
    HKEY hkey = NULL;
    MSIEXTENSION *ext;
    MSIRECORD *uirow;
    BOOL install_on_demand = TRUE;
    LONG res;
    UINT r;
 
    if (package->script == SCRIPT_NONE)
        return msi_schedule_action( package, SCRIPT_INSTALL, L"RegisterExtensionInfo" );
 
    r = load_classes_and_such( package );
    if (r != ERROR_SUCCESS)
        return r;
 
    /* We need to set install_on_demand based on if the shell handles advertised
     * shortcuts and the like. Because Mike McCormack is working on this i am
     * going to default to TRUE
     */
 
    LIST_FOR_EACH_ENTRY( ext, &package->extensions, MSIEXTENSION, entry )
    {
        LPWSTR extension;
        MSIFEATURE *feature;
 
        if (!ext->Component)
            continue;
 
        if (!ext->Component->Enabled)
        {
            TRACE("component is disabled\n");
            continue;
        }
 
        feature = ext->Feature;
        if (!feature)
            continue;
 
        /*
         * yes. MSDN says that these are based on _Feature_ not on
         * Component.  So verify the feature is to be installed
         */
        feature->Action = msi_get_feature_action( package, feature );
        if (feature->Action != INSTALLSTATE_LOCAL &&
            !(install_on_demand && feature->Action == INSTALLSTATE_ADVERTISED))
        {
            TRACE("feature %s not scheduled for installation, skipping registration of extension %s\n",
                  debugstr_w(feature->Feature), debugstr_w(ext->Extension));
            continue;
        }
        TRACE("Registering extension %s (%p)\n", debugstr_w(ext->Extension), ext);
 
        ext->action = INSTALLSTATE_LOCAL;
 
        extension = malloc( (wcslen( ext->Extension ) + 2) * sizeof(WCHAR) );
        if (extension)
        {
            extension[0] = '.';
            lstrcpyW( extension + 1, ext->Extension );
            res = RegCreateKeyW( HKEY_CLASSES_ROOT, extension, &hkey );
            free( extension );
            if (res != ERROR_SUCCESS)
                WARN("failed to create extension key %ld\n", res);
        }
 
        if (ext->Mime)
            msi_reg_set_val_str( hkey, L"Content Type", ext->Mime->ContentType );
 
        if (ext->ProgID || ext->ProgIDText)
        {
            HKEY hkey2;
            LPWSTR newkey;
            LPCWSTR progid;
            MSIVERB *verb;
            INT Sequence = MSI_NULL_INTEGER;
 
            if (ext->ProgID)
                progid = ext->ProgID->ProgID;
            else
                progid = ext->ProgIDText;
 
            msi_reg_set_val_str( hkey, NULL, progid );
 
            newkey = malloc( wcslen(progid) * sizeof(WCHAR) + sizeof(L"\\ShellNew") );
 
            lstrcpyW(newkey, progid);
            lstrcatW(newkey, L"\\ShellNew");
            RegCreateKeyW(hkey, newkey, &hkey2);
            RegCloseKey(hkey2);
 
            free(newkey);
 
            /* do all the verbs */
            LIST_FOR_EACH_ENTRY( verb, &ext->verbs, MSIVERB, entry )
            {
                register_verb( package, progid, ext->Component,
                               ext, verb, &Sequence);
            }
        }
 
        RegCloseKey(hkey);
 
        uirow = MSI_CreateRecord(1);
        MSI_RecordSetStringW( uirow, 1, ext->Extension );
        MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
        msiobj_release(&uirow->hdr);
    }
    return ERROR_SUCCESS;
}

◆ ACTION_RegisterFonts()

UINT ACTION_RegisterFonts ( MSIPACKAGE * package )

Definition at line 279 of file font.c.

{
    MSIQUERY *view;
    UINT rc;
 
    if (package->script == SCRIPT_NONE)
        return msi_schedule_action(package, SCRIPT_INSTALL, L"RegisterFonts");
 
    rc = MSI_DatabaseOpenViewW(package->db, L"SELECT * FROM `Font`", &view);
    if (rc != ERROR_SUCCESS)
        return ERROR_SUCCESS;
 
    rc = MSI_IterateRecords(view, NULL, ITERATE_RegisterFonts, package);
    msiobj_release(&view->hdr);
    return rc;
}

◆ ACTION_RegisterMIMEInfo()

UINT ACTION_RegisterMIMEInfo ( MSIPACKAGE * package )

Definition at line 1392 of file classes.c.

{
    MSIRECORD *uirow;
    MSIMIME *mt;
    UINT r;
 
    if (package->script == SCRIPT_NONE)
        return msi_schedule_action( package, SCRIPT_INSTALL, L"RegisterMIMEInfo" );
 
    r = load_classes_and_such( package );
    if (r != ERROR_SUCCESS)
        return r;
 
    LIST_FOR_EACH_ENTRY( mt, &package->mimes, MSIMIME, entry )
    {
        LPWSTR extension = NULL, key;
 
        /*
         * check if the MIME is to be installed. Either as requested by an
         * extension or Class
         */
        if ((!mt->Class || mt->Class->action != INSTALLSTATE_LOCAL) &&
            (!mt->Extension || mt->Extension->action != INSTALLSTATE_LOCAL))
        {
            TRACE("MIME %s not scheduled to be installed\n", debugstr_w(mt->ContentType));
            continue;
        }
 
        TRACE("Registering MIME type %s\n", debugstr_w(mt->ContentType));
 
        if (mt->Extension) extension = malloc( (wcslen( mt->Extension->Extension ) + 2) * sizeof(WCHAR) );
        key = malloc( sizeof( L"MIME\\Database\\Content Type\\" ) +
                      wcslen( mt->ContentType ) * sizeof(WCHAR) );
 
        if (extension && key)
        {
            extension[0] = '.';
            lstrcpyW( extension + 1, mt->Extension->Extension );
 
            lstrcpyW( key, L"MIME\\Database\\Content Type\\" );
            lstrcatW( key, mt->ContentType );
            msi_reg_set_subkey_val( HKEY_CLASSES_ROOT, key, L"Extension", extension );
 
            if (mt->clsid)
                msi_reg_set_subkey_val( HKEY_CLASSES_ROOT, key, L"CLSID", mt->clsid );
        }
        free( extension );
        free( key );
 
        uirow = MSI_CreateRecord( 2 );
        MSI_RecordSetStringW( uirow, 1, mt->ContentType );
        MSI_RecordSetStringW( uirow, 2, mt->suffix );
        MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
        msiobj_release( &uirow->hdr );
    }
    return ERROR_SUCCESS;
}

◆ ACTION_RegisterProgIdInfo()

UINT ACTION_RegisterProgIdInfo ( MSIPACKAGE * package )

Definition at line 1026 of file classes.c.

{
    MSIPROGID *progid;
    MSIRECORD *uirow;
    UINT r;
 
    if (package->script == SCRIPT_NONE)
        return msi_schedule_action( package, SCRIPT_INSTALL, L"RegisterProgIdInfo" );
 
    r = load_classes_and_such( package );
    if (r != ERROR_SUCCESS)
        return r;
 
    LIST_FOR_EACH_ENTRY( progid, &package->progids, MSIPROGID, entry )
    {
        if (!has_class_installed( progid ) && !has_one_extension_installed( package, progid ))
        {
            TRACE("progid %s not scheduled to be installed\n", debugstr_w(progid->ProgID));
            continue;
        }
        TRACE("Registering progid %s\n", debugstr_w(progid->ProgID));
 
        register_progid( progid );
 
        uirow = MSI_CreateRecord( 1 );
        MSI_RecordSetStringW( uirow, 1, progid->ProgID );
        MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
        msiobj_release( &uirow->hdr );
    }
    return ERROR_SUCCESS;
}

◆ ACTION_RemoveDuplicateFiles()

UINT ACTION_RemoveDuplicateFiles ( MSIPACKAGE * package )

Definition at line 1390 of file files.c.

{
    MSIQUERY *view;
    UINT rc;
 
    if (package->script == SCRIPT_NONE)
        return msi_schedule_action(package, SCRIPT_INSTALL, L"RemoveDuplicateFiles");
 
    rc = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `DuplicateFile`", &view );
    if (rc != ERROR_SUCCESS)
        return ERROR_SUCCESS;
 
    rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveDuplicateFiles, package );
    msiobj_release( &view->hdr );
    return rc;
}

◆ ACTION_RemoveFiles()

UINT ACTION_RemoveFiles ( MSIPACKAGE * package )

Definition at line 1528 of file files.c.

{
    MSIQUERY *view;
    MSICOMPONENT *comp;
    MSIFILE *file;
    UINT r;
 
    if (package->script == SCRIPT_NONE)
        return msi_schedule_action(package, SCRIPT_INSTALL, L"RemoveFiles");
 
    r = MSI_DatabaseOpenViewW(package->db, L"SELECT * FROM `RemoveFile`", &view);
    if (r == ERROR_SUCCESS)
    {
        r = MSI_IterateRecords(view, NULL, ITERATE_RemoveFiles, package);
        msiobj_release(&view->hdr);
        if (r != ERROR_SUCCESS)
            return r;
    }
 
    LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
    {
        MSIRECORD *uirow;
        VS_FIXEDFILEINFO *ver;
 
        comp = file->Component;
        file_update_ui( package, file, L"RemoveFiles" );
 
        comp->Action = msi_get_component_action( package, comp );
        if (comp->Action != INSTALLSTATE_ABSENT || comp->Installed == INSTALLSTATE_SOURCE)
            continue;
 
        if (comp->assembly && !comp->assembly->application)
            continue;
 
        if (comp->Attributes & msidbComponentAttributesPermanent)
        {
            TRACE("permanent component, not removing file\n");
            continue;
        }
 
        if (file->Version)
        {
            ver = msi_get_disk_file_version( package, file->TargetPath );
            if (ver && msi_compare_file_versions( ver, file->Version ) > 0)
            {
                TRACE("newer version detected, not removing file\n");
                free( ver );
                continue;
            }
            free( ver );
        }
 
        if (file->state == msifs_installed)
            WARN("removing installed file %s\n", debugstr_w(file->TargetPath));
 
        TRACE("removing %s\n", debugstr_w(file->File) );
 
        msi_set_file_attributes( package, file->TargetPath, FILE_ATTRIBUTE_NORMAL );
        if (!msi_delete_file( package, file->TargetPath ))
        {
            WARN( "failed to delete %s (%lu)\n",  debugstr_w(file->TargetPath), GetLastError() );
        }
        file->state = msifs_missing;
 
        uirow = MSI_CreateRecord( 9 );
        MSI_RecordSetStringW( uirow, 1, file->FileName );
        MSI_RecordSetStringW( uirow, 9, comp->Directory );
        MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
        msiobj_release( &uirow->hdr );
    }
 
    LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
    {
        comp->Action = msi_get_component_action( package, comp );
        if (comp->Action != INSTALLSTATE_ABSENT) continue;
 
        if (comp->Attributes & msidbComponentAttributesPermanent)
        {
            TRACE("permanent component, not removing directory\n");
            continue;
        }
        if (comp->assembly && !comp->assembly->application)
            msi_uninstall_assembly( package, comp );
        else
        {
            MSIFOLDER *folder = msi_get_loaded_folder( package, comp->Directory );
            if (folder) remove_folder( folder );
        }
    }
    return ERROR_SUCCESS;
}

◆ ACTION_ShowDialog()

INT ACTION_ShowDialog	(	MSIPACKAGE *	,
		LPCWSTR
	)

◆ ACTION_UnregisterClassInfo()

UINT ACTION_UnregisterClassInfo ( MSIPACKAGE * package )

Definition at line 857 of file classes.c.

{
    REGSAM access = KEY_ALL_ACCESS;
    MSIRECORD *uirow;
    MSICLASS *cls;
    HKEY hkey, hkey2;
    UINT r;
 
    if (package->script == SCRIPT_NONE)
        return msi_schedule_action( package, SCRIPT_INSTALL, L"UnregisterClassInfo" );
 
    r = load_classes_and_such( package );
    if (r != ERROR_SUCCESS)
        return r;
 
    if (package->platform == PLATFORM_INTEL)
        access |= KEY_WOW64_32KEY;
    else
        access |= KEY_WOW64_64KEY;
 
    if (RegCreateKeyExW( HKEY_CLASSES_ROOT, L"CLSID", 0, NULL, 0, access, NULL, &hkey, NULL ))
        return ERROR_FUNCTION_FAILED;
 
    LIST_FOR_EACH_ENTRY( cls, &package->classes, MSICLASS, entry )
    {
        MSIFEATURE *feature;
        MSICOMPONENT *comp;
        LPWSTR filetype;
        LONG res;
 
        comp = cls->Component;
        if (!comp)
            continue;
 
        if (!comp->Enabled)
        {
            TRACE("component is disabled\n");
            continue;
        }
 
        feature = cls->Feature;
        if (!feature)
            continue;
 
        feature->Action = msi_get_feature_action( package, feature );
        if (feature->Action != INSTALLSTATE_ABSENT)
        {
            TRACE("feature %s not scheduled for removal, skipping unregistration of class %s\n",
                  debugstr_w(feature->Feature), debugstr_w(cls->clsid));
            continue;
        }
        TRACE("Unregistering class %s (%p)\n", debugstr_w(cls->clsid), cls);
 
        cls->action = INSTALLSTATE_ABSENT;
 
        res = RegDeleteTreeW( hkey, cls->clsid );
        if (res != ERROR_SUCCESS)
            WARN("failed to delete class key %ld\n", res);
 
        if (cls->AppID)
        {
            res = RegOpenKeyW( HKEY_CLASSES_ROOT, L"AppID", &hkey2 );
            if (res == ERROR_SUCCESS)
            {
                res = RegDeleteKeyW( hkey2, cls->AppID->AppID );
                if (res != ERROR_SUCCESS)
                    WARN("failed to delete appid key %ld\n", res);
                RegCloseKey( hkey2 );
            }
        }
        if (cls->FileTypeMask)
        {
            filetype = malloc( sizeof( L"FileType\\" ) + wcslen( cls->clsid ) * sizeof(WCHAR) );
            if (filetype)
            {
                lstrcpyW( filetype, L"FileType\\" );
                lstrcatW( filetype, cls->clsid );
                res = RegDeleteTreeW( HKEY_CLASSES_ROOT, filetype );
                free( filetype );
 
                if (res != ERROR_SUCCESS)
                    WARN("failed to delete file type %ld\n", res);
            }
        }
 
        uirow = MSI_CreateRecord( 1 );
        MSI_RecordSetStringW( uirow, 1, cls->clsid );
        MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
        msiobj_release( &uirow->hdr );
    }
    RegCloseKey( hkey );
    return ERROR_SUCCESS;
}

◆ ACTION_UnregisterExtensionInfo()

UINT ACTION_UnregisterExtensionInfo ( MSIPACKAGE * package )

Definition at line 1307 of file classes.c.

{
    MSIEXTENSION *ext;
    MSIRECORD *uirow;
    LONG res;
    UINT r;
 
    if (package->script == SCRIPT_NONE)
        return msi_schedule_action( package, SCRIPT_INSTALL, L"UnregisterExtensionInfo" );
 
    r = load_classes_and_such( package );
    if (r != ERROR_SUCCESS)
        return r;
 
    LIST_FOR_EACH_ENTRY( ext, &package->extensions, MSIEXTENSION, entry )
    {
        LPWSTR extension;
        MSIFEATURE *feature;
 
        if (!ext->Component)
            continue;
 
        if (!ext->Component->Enabled)
        {
            TRACE("component is disabled\n");
            continue;
        }
 
        feature = ext->Feature;
        if (!feature)
            continue;
 
        feature->Action = msi_get_feature_action( package, feature );
        if (feature->Action != INSTALLSTATE_ABSENT)
        {
            TRACE("feature %s not scheduled for removal, skipping unregistration of extension %s\n",
                  debugstr_w(feature->Feature), debugstr_w(ext->Extension));
            continue;
        }
        TRACE("Unregistering extension %s\n", debugstr_w(ext->Extension));
 
        ext->action = INSTALLSTATE_ABSENT;
 
        extension = malloc( (wcslen( ext->Extension ) + 2) * sizeof(WCHAR) );
        if (extension)
        {
            extension[0] = '.';
            lstrcpyW( extension + 1, ext->Extension );
            res = RegDeleteTreeW( HKEY_CLASSES_ROOT, extension );
            free( extension );
            if (res != ERROR_SUCCESS)
                WARN("failed to delete extension key %ld\n", res);
        }
 
        if (ext->ProgID || ext->ProgIDText)
        {
            LPCWSTR progid;
            LPWSTR progid_shell;
 
            if (ext->ProgID)
                progid = ext->ProgID->ProgID;
            else
                progid = ext->ProgIDText;
 
            progid_shell = malloc( wcslen( progid ) * sizeof(WCHAR) + sizeof( L"\\shell" ) );
            if (progid_shell)
            {
                lstrcpyW( progid_shell, progid );
                lstrcatW( progid_shell, L"\\shell" );
                res = RegDeleteTreeW( HKEY_CLASSES_ROOT, progid_shell );
                free( progid_shell );
                if (res != ERROR_SUCCESS)
                    WARN("failed to delete shell key %ld\n", res);
                RegDeleteKeyW( HKEY_CLASSES_ROOT, progid );
            }
        }
 
        uirow = MSI_CreateRecord( 1 );
        MSI_RecordSetStringW( uirow, 1, ext->Extension );
        MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
        msiobj_release( &uirow->hdr );
    }
    return ERROR_SUCCESS;
}

◆ ACTION_UnregisterFonts()

UINT ACTION_UnregisterFonts ( MSIPACKAGE * package )

Definition at line 360 of file font.c.

{
    MSIQUERY *view;
    UINT r;
 
    if (package->script == SCRIPT_NONE)
        return msi_schedule_action(package, SCRIPT_INSTALL, L"UnregisterFonts");
 
    r = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `Font`", &view );
    if (r != ERROR_SUCCESS)
        return ERROR_SUCCESS;
 
    r = MSI_IterateRecords( view, NULL, ITERATE_UnregisterFonts, package );
    msiobj_release( &view->hdr );
    return r;
}

◆ ACTION_UnregisterMIMEInfo()

UINT ACTION_UnregisterMIMEInfo ( MSIPACKAGE * package )

Definition at line 1450 of file classes.c.

{
    MSIRECORD *uirow;
    MSIMIME *mime;
    UINT r;
 
    if (package->script == SCRIPT_NONE)
        return msi_schedule_action( package, SCRIPT_INSTALL, L"UnregisterMIMEInfo" );
 
    r = load_classes_and_such( package );
    if (r != ERROR_SUCCESS)
        return r;
 
    LIST_FOR_EACH_ENTRY( mime, &package->mimes, MSIMIME, entry )
    {
        LONG res;
        LPWSTR mime_key;
 
        if ((!mime->Class || mime->Class->action != INSTALLSTATE_ABSENT) &&
            (!mime->Extension || mime->Extension->action != INSTALLSTATE_ABSENT))
        {
            TRACE("MIME %s not scheduled to be removed\n", debugstr_w(mime->ContentType));
            continue;
        }
 
        TRACE("Unregistering MIME type %s\n", debugstr_w(mime->ContentType));
 
        mime_key = malloc( sizeof( L"MIME\\Database\\Content Type\\" ) +
                           wcslen( mime->ContentType ) * sizeof(WCHAR) );
        if (mime_key)
        {
            lstrcpyW( mime_key, L"MIME\\Database\\Content Type\\" );
            lstrcatW( mime_key, mime->ContentType );
            res = RegDeleteKeyW( HKEY_CLASSES_ROOT, mime_key );
            if (res != ERROR_SUCCESS)
                WARN("failed to delete MIME key %ld\n", res);
            free( mime_key );
        }
 
        uirow = MSI_CreateRecord( 2 );
        MSI_RecordSetStringW( uirow, 1, mime->ContentType );
        MSI_RecordSetStringW( uirow, 2, mime->suffix );
        MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
        msiobj_release( &uirow->hdr );
    }
    return ERROR_SUCCESS;
}

◆ ACTION_UnregisterProgIdInfo()

UINT ACTION_UnregisterProgIdInfo ( MSIPACKAGE * package )

Definition at line 1088 of file classes.c.

{
    MSIPROGID *progid;
    MSIRECORD *uirow;
    LONG res;
    UINT r;
 
    if (package->script == SCRIPT_NONE)
        return msi_schedule_action( package, SCRIPT_INSTALL, L"UnregisterProgIdInfo" );
 
    r = load_classes_and_such( package );
    if (r != ERROR_SUCCESS)
        return r;
 
    LIST_FOR_EACH_ENTRY( progid, &package->progids, MSIPROGID, entry )
    {
        if (!has_class_removed( progid ) ||
            (has_extensions( package, progid ) && !has_all_extensions_removed( package, progid )))
        {
            TRACE("progid %s not scheduled to be removed\n", debugstr_w(progid->ProgID));
            continue;
        }
        TRACE("Unregistering progid %s\n", debugstr_w(progid->ProgID));
 
        res = RegDeleteTreeW( HKEY_CLASSES_ROOT, progid->ProgID );
        if (res != ERROR_SUCCESS)
            TRACE("failed to delete progid key %ld\n", res);
 
        uirow = MSI_CreateRecord( 1 );
        MSI_RecordSetStringW( uirow, 1, progid->ProgID );
        MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
        msiobj_release( &uirow->hdr );
    }
    return ERROR_SUCCESS;
}

◆ 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_SetFeatureStateW(), and seltree_update_feature_installstate().

◆ alloc_msi_remote_handle()

MSIHANDLE alloc_msi_remote_handle ( MSIHANDLE remote )

Definition at line 135 of file handle.c.

{
    struct handle_info *entry;
    MSIHANDLE ret;
 
    EnterCriticalSection( &handle_cs );
 
    ret = alloc_handle_table_entry();
    if (ret)
    {
        entry = &handle_table[ ret - 1 ];
        entry->u.rem = remote;
        entry->dwThreadId = GetCurrentThreadId();
        entry->remote = TRUE;
    }
 
    LeaveCriticalSection( &handle_cs );
 
    TRACE( "%lu -> %lu\n", remote, ret );
 
    return ret;
}

Referenced by __wine_msi_call_dll_function(), MsiDatabaseOpenViewW(), MsiGetActiveDatabase(), and MsiGetSummaryInformationW().

◆ alloc_msihandle()

MSIHANDLE alloc_msihandle ( MSIOBJECTHDR * obj )

Definition at line 111 of file handle.c.

{
    struct handle_info *entry;
    MSIHANDLE ret;
 
    EnterCriticalSection( &handle_cs );
 
    ret = alloc_handle_table_entry();
    if (ret)
    {
        entry = &handle_table[ ret - 1 ];
        msiobj_addref( obj );
        entry->u.obj = obj;
        entry->dwThreadId = GetCurrentThreadId();
        entry->remote = FALSE;
    }
 
    LeaveCriticalSection( &handle_cs );
 
    TRACE( "%p -> %lu\n", obj, ret );
 
    return ret;
}

Referenced by ACTION_CallScript(), MSI_ProcessMessageVerbatim(), MsiCreateRecord(), MsiDatabaseGetPrimaryKeysW(), MsiDatabaseOpenViewW(), MsiEnableUIPreview(), MsiGetActiveDatabase(), MsiGetSummaryInformationW(), MsiOpenDatabaseW(), MsiOpenPackageExW(), MsiOpenProductW(), MsiViewFetch(), MsiViewGetColumnInfo(), and s_remote_GetActionInfo().

◆ alloc_msiobject()

void * alloc_msiobject	(	UINT	type,
		UINT	size,
		msihandledestructor	destroy
	)

Definition at line 201 of file handle.c.

{
    MSIOBJECTHDR *info;
 
    info = calloc( 1, size );
    if( info )
    {
        info->magic = MSIHANDLE_MAGIC;
        info->type = type;
        info->refcount = 1;
        info->destructor = destroy;
    }
 
    return info;
}

Referenced by create_suminfo(), MSI_CreateRecord(), MSI_DatabaseOpenViewW(), MSI_EnableUIPreview(), and MSI_OpenDatabaseW().

◆ append_storage_to_db()

void append_storage_to_db	(	MSIDATABASE *	db,
		IStorage *	stg
	)

Definition at line 76 of file database.c.

{
    MSITRANSFORM *t;
 
    t = malloc( sizeof *t );
    t->stg = stg;
    IStorage_AddRef( stg );
    list_add_head( &db->transforms, &t->entry );
}

Referenced by msi_table_apply_transform().

◆ call_script()

DWORD call_script	(	MSIHANDLE	hPackage,
		INT	type,
		LPCWSTR	script,
		LPCWSTR	function,
		LPCWSTR	action
	)

Definition at line 289 of file script.c.

{
    HRESULT hr;
    IActiveScript *pActiveScript = NULL;
    IActiveScriptParse *pActiveScriptParse = NULL;
    struct script_site *scriptsite;
    IDispatch *pDispatch = NULL;
    DISPPARAMS dispparamsNoArgs = {NULL, NULL, 0, 0};
    DISPID dispid;
    CLSID clsid;
    VARIANT var;
    DWORD ret = ERROR_INSTALL_FAILURE;
 
    CoInitialize(NULL);
 
    /* Create MsiActiveScriptSite object */
    hr = create_activescriptsite(&scriptsite);
    if (hr != S_OK) goto done;
 
    /* Create an installer object */
    hr = create_msiserver(NULL, (void**)&scriptsite->installer);
    if (hr != S_OK) goto done;
 
    /* Create a session object */
    hr = create_session(hPackage, scriptsite->installer, &scriptsite->session);
    if (hr != S_OK) goto done;
 
    /* Create the scripting engine */
    type &= msidbCustomActionTypeJScript|msidbCustomActionTypeVBScript;
    if (type == msidbCustomActionTypeJScript)
        hr = CLSIDFromProgID(L"JScript", &clsid);
    else if (type == msidbCustomActionTypeVBScript)
        hr = CLSIDFromProgID(L"VBScript", &clsid);
    else {
        ERR("Unknown script type %d\n", type);
        goto done;
    }
    if (FAILED(hr)) {
        ERR("Could not find CLSID for Windows Script\n");
        goto done;
    }
    hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IActiveScript, (void **)&pActiveScript);
    if (FAILED(hr)) {
        ERR("Could not instantiate class for Windows Script\n");
        goto done;
    }
 
    hr = IActiveScript_QueryInterface(pActiveScript, &IID_IActiveScriptParse, (void **)&pActiveScriptParse);
    if (FAILED(hr)) goto done;
 
    hr = IActiveScript_SetScriptSite(pActiveScript, &scriptsite->IActiveScriptSite_iface);
    if (FAILED(hr)) goto done;
 
    hr = IActiveScriptParse_InitNew(pActiveScriptParse);
    if (FAILED(hr)) goto done;
 
    hr = IActiveScript_AddNamedItem(pActiveScript, L"Session", SCRIPTITEM_GLOBALMEMBERS|SCRIPTITEM_ISVISIBLE);
    if (FAILED(hr)) goto done;
 
    hr = IActiveScriptParse_ParseScriptText(pActiveScriptParse, script, NULL, NULL, NULL, 0, 0, 0L, NULL, NULL);
    if (FAILED(hr)) goto done;
 
    hr = IActiveScript_SetScriptState(pActiveScript, SCRIPTSTATE_CONNECTED);
    if (FAILED(hr)) goto done;
 
    /* Call a function if necessary through the IDispatch interface */
    if (function && function[0]) {
        TRACE("Calling function %s\n", debugstr_w(function));
 
        hr = IActiveScript_GetScriptDispatch(pActiveScript, NULL, &pDispatch);
        if (FAILED(hr)) goto done;
 
        hr = IDispatch_GetIDsOfNames(pDispatch, &IID_NULL, (WCHAR **)&function, 1,LOCALE_USER_DEFAULT, &dispid);
        if (FAILED(hr)) goto done;
 
        hr = IDispatch_Invoke(pDispatch, dispid, &IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &dispparamsNoArgs, &var, NULL, NULL);
        if (FAILED(hr)) goto done;
 
        hr = VariantChangeType(&var, &var, 0, VT_I4);
        if (FAILED(hr)) goto done;
 
        ret = map_return_value(V_I4(&var));
 
        VariantClear(&var);
    } else {
        /* If no function to be called, MSI behavior is to succeed */
        ret = ERROR_SUCCESS;
    }
 
done:
 
    if (pDispatch) IDispatch_Release(pDispatch);
    if (pActiveScript) IActiveScript_Release(pActiveScript);
    if (pActiveScriptParse) IActiveScriptParse_Release(pActiveScriptParse);
    if (scriptsite)
    {
        if (scriptsite->session) IDispatch_Release(scriptsite->session);
        if (scriptsite->installer) IDispatch_Release(scriptsite->installer);
        IActiveScriptSite_Release(&scriptsite->IActiveScriptSite_iface);
    }
    CoUninitialize();    /* must call even if CoInitialize failed */
    return ret;
}

Referenced by ACTION_CallScript().

◆ copy_remote_record()

UINT copy_remote_record	(	const struct wire_record *	rec,
		MSIHANDLE	handle
	)

Definition at line 1052 of file record.c.

{
    MSIRECORD *rec;
    unsigned int i;
    UINT r = ERROR_SUCCESS;
 
    if (!(rec = msihandle2msiinfo(out, MSIHANDLETYPE_RECORD)))
        return ERROR_INVALID_HANDLE;
 
    rec->cookie = in->cookie;
    for (i = 0; i <= in->count; i++)
    {
        switch (in->fields[i].type)
        {
        case MSIFIELD_NULL:
            MSI_FreeField(&rec->fields[i]);
            rec->fields[i].type = MSIFIELD_NULL;
            break;
        case MSIFIELD_INT:
            r = MSI_RecordSetInteger(rec, i, in->fields[i].u.iVal);
            break;
        case MSIFIELD_WSTR:
            r = MSI_RecordSetStringW(rec, i, in->fields[i].u.szwVal);
            break;
        case MSIFIELD_STREAM:
            r = MSI_RecordSetIStream(rec, i, in->fields[i].u.stream);
            break;
        default:
            ERR("invalid field type %d\n", in->fields[i].type);
            break;
        }
 
        if (r)
        {
            msiobj_release(&rec->hdr);
            return r;
        }
    }
 
    msiobj_release(&rec->hdr);
    return ERROR_SUCCESS;
}

Referenced by MsiViewModify(), and unmarshal_record().

◆ cost_from_size()

static int cost_from_size ( int size )

inlinestatic

Definition at line 1226 of file msipriv.h.

{
    /* Cost is size rounded up to the nearest 4096 bytes,
     * expressed in units of 512 bytes. */
    return ((size + 4095) & ~4095) / 512;
}

Referenced by calculate_file_cost(), and MsiEnumComponentCostsW().

◆ create_msiserver()

HRESULT create_msiserver	(	IUnknown *	pOuter,
		LPVOID *	ppObj
	)

◆ create_session()

HRESULT create_session	(	MSIHANDLE	msiHandle,
		IDispatch *	pInstaller,
		IDispatch **	pDispatch
	)

Definition at line 2446 of file automation.c.

{
    struct session_object *session;
 
    session = malloc(sizeof(*session));
    if (!session) return E_OUTOFMEMORY;
 
    init_automation_object(&session->autoobj, msiHandle, Session_tid);
 
    session->installer = installer;
    *disp = &session->autoobj.IDispatch_iface;
 
    return S_OK;
}

Referenced by call_script(), and InstallerImpl_OpenPackage().

◆ custom_stop_server()

void custom_stop_server	(	HANDLE	process,
		HANDLE	pipe
	)

Definition at line 681 of file custom.c.

{
    DWORD size;
 
    WriteFile(pipe, &GUID_NULL, sizeof(GUID_NULL), &size, NULL);
    WaitForSingleObject(process, INFINITE);
    CloseHandle(process);
    CloseHandle(pipe);
}

Referenced by MSI_FreePackage().

◆ decode_base85_guid()

BOOL decode_base85_guid	(	LPCWSTR	str,
		GUID *	guid
	)

Definition at line 132 of file registry.c.

{
    DWORD i, val = 0, base = 1, *p;
 
    if (!str)
        return FALSE;
 
    p = (DWORD*) guid;
    for( i=0; i<20; i++ )
    {
        if( (i%5) == 0 )
        {
            val = 0;
            base = 1;
        }
        val += table_dec85[str[i]] * base;
        if( str[i] >= 0x80 )
            return FALSE;
        if( table_dec85[str[i]] == 0xff )
            return FALSE;
        if( (i%5) == 4 )
            p[i/5] = val;
        base *= 85;
    }
    return TRUE;
}

Referenced by MSI_ProvideQualifiedComponentEx(), MsiDecomposeDescriptorW(), and query_feature_state().

◆ decode_streamname()

BOOL decode_streamname	(	LPCWSTR	in,
		LPWSTR	out
	)

Definition at line 180 of file table.c.

{
    WCHAR ch;
    DWORD count = 0;
 
    while ( (ch = *in++) )
    {
        if( (ch >= 0x3800 ) && (ch < 0x4840 ) )
        {
            if( ch >= 0x4800 )
                ch = mime2utf(ch-0x4800);
            else
            {
                ch -= 0x3800;
                *out++ = mime2utf(ch&0x3f);
                count++;
                ch = mime2utf((ch>>6)&0x3f);
            }
        }
        *out++ = ch;
        count++;
    }
    *out = 0;
    return count;
}

Referenced by admin_remove_cabinet_streams(), enum_stream_names(), load_streams(), and msi_table_apply_transform().

◆ deformat_string()

DWORD deformat_string	(	MSIPACKAGE *	package,
		LPCWSTR	ptr,
		WCHAR **	data
	)

◆ dump_record()

void dump_record ( MSIRECORD * rec )

Definition at line 1028 of file record.c.

{
    int i;
    if (!rec)
    {
        TRACE("(null)\n");
        return;
    }
 
    TRACE("[");
    for (i = 0; i <= rec->count; i++)
    {
        switch(rec->fields[i].type)
        {
        case MSIFIELD_NULL: TRACE("(null)"); break;
        case MSIFIELD_INT: TRACE("%d", rec->fields[i].u.iVal); break;
        case MSIFIELD_WSTR: TRACE("%s", debugstr_w(rec->fields[i].u.szwVal)); break;
        case MSIFIELD_STREAM: TRACE("%p", rec->fields[i].u.stream); break;
        }
        if (i < rec->count) TRACE(", ");
    }
    TRACE("]\n");
}

Referenced by MSI_FormatRecordW(), MSI_ProcessMessageVerbatim(), and table_load_transform().

◆ encode_base85_guid()

BOOL encode_base85_guid	(	GUID *	guid,
		LPWSTR	str
	)

Definition at line 165 of file registry.c.

{
    unsigned int x, *p, i;
 
    p = (unsigned int*) guid;
    for( i=0; i<4; i++ )
    {
        x = p[i];
        *str++ = table_enc85[x%85];
        x = x/85;
        *str++ = table_enc85[x%85];
        x = x/85;
        *str++ = table_enc85[x%85];
        x = x/85;
        *str++ = table_enc85[x%85];
        x = x/85;
        *str++ = table_enc85[x%85];
    }
    *str = 0;
 
    return TRUE;
}

Referenced by ACTION_MsiPublishAssemblies(), ACTION_PublishFeatures(), and msi_create_component_advertise_string().

◆ encode_streamname()

WCHAR * encode_streamname	(	BOOL	is_table,
		const WCHAR *	in
	)

Referenced by cabinet_open_stream(), msi_commit_streams(), msi_get_stream(), and STREAMS_delete_row().

◆ enum_stream_names()

void enum_stream_names ( IStorage * stg )

Definition at line 206 of file table.c.

{
    IEnumSTATSTG *stgenum = NULL;
    HRESULT r;
    STATSTG stat;
    ULONG n, count;
    WCHAR name[0x40];
 
    r = IStorage_EnumElements( stg, 0, NULL, 0, &stgenum );
    if( FAILED( r ) )
        return;
 
    n = 0;
    while( 1 )
    {
        count = 0;
        r = IEnumSTATSTG_Next( stgenum, 1, &stat, &count );
        if( FAILED( r ) || !count )
            break;
        decode_streamname( stat.pwcsName, name );
        TRACE( "stream %2lu -> %s %s\n", n, debugstr_w(stat.pwcsName), debugstr_w(name) );
        CoTaskMemFree( stat.pwcsName );
        n++;
    }
 
    IEnumSTATSTG_Release( stgenum );
}

Referenced by MSI_DatabaseApplyTransformW(), and MSI_OpenDatabaseW().

◆ free_cached_tables()

void free_cached_tables ( MSIDATABASE * db )

Definition at line 472 of file table.c.

{
    while( !list_empty( &db->tables ) )
    {
        MSITABLE *t = LIST_ENTRY( list_head( &db->tables ), MSITABLE, entry );
 
        list_remove( &t->entry );
        free_table( t );
    }
}

Referenced by MSI_CloseDatabase().

◆ free_remote_record()

void free_remote_record ( struct wire_record * rec )

Definition at line 1149 of file record.c.

{
    int i;
 
    for (i = 0; i <= rec->count; i++)
    {
        if (rec->fields[i].type == MSIFIELD_WSTR)
            midl_user_free(rec->fields[i].u.szwVal);
        else if (rec->fields[i].type == MSIFIELD_STREAM)
            IStream_Release(rec->fields[i].u.stream);
    }
 
    midl_user_free(rec);
}

Referenced by MsiDatabaseGetPrimaryKeysW(), MsiViewFetch(), MsiViewGetColumnInfo(), and MsiViewModify().

◆ get_typeinfo()

HRESULT get_typeinfo	(	tid_t	tid,
		ITypeInfo **	ti
	)

Definition at line 61 of file ieframe_main.c.

{
    HRESULT hres;
 
    if(!typelib)
        hres = load_typelib();
    if(!typelib)
        return hres;
 
    if(!typeinfos[tid]) {
        ITypeInfo *ti;
 
        hres = ITypeLib_GetTypeInfoOfGuid(typelib, tid_ids[tid], &ti);
        if(FAILED(hres)) {
            ERR("GetTypeInfoOfGuid(%s) failed: %08x\n", debugstr_guid(tid_ids[tid]), hres);
            return hres;
        }
 
        if(InterlockedCompareExchangePointer((void**)(typeinfos+tid), ti, NULL))
            ITypeInfo_Release(ti);
    }
 
    *typeinfo = typeinfos[tid];
    return S_OK;
}

◆ is_platform_64bit()

static BOOL is_platform_64bit ( enum platform platform )

inlinestatic

Definition at line 373 of file msipriv.h.

{
    switch (platform)
    {
    case PLATFORM_INTEL64:
    case PLATFORM_X64:
    case PLATFORM_ARM64:
        return TRUE;
    default:
        return FALSE;
    }
}

Referenced by msi_disable_fs_redirection(), and msi_revert_fs_redirection().

◆ marshal_record()

struct wire_record * marshal_record ( MSIHANDLE handle )

Definition at line 1109 of file record.c.

{
    struct wire_record *ret;
    unsigned int i;
    MSIRECORD *rec;
 
    if (!(rec = msihandle2msiinfo(handle, MSIHANDLETYPE_RECORD)))
        return NULL;
 
    ret = midl_user_allocate(sizeof(*ret) + rec->count * sizeof(ret->fields[0]));
    ret->count = rec->count;
    ret->cookie = rec->cookie;
 
    for (i = 0; i <= rec->count; i++)
    {
        switch (rec->fields[i].type)
        {
        case MSIFIELD_NULL:
            break;
        case MSIFIELD_INT:
            ret->fields[i].u.iVal = rec->fields[i].u.iVal;
            break;
        case MSIFIELD_WSTR:
            ret->fields[i].u.szwVal = wcsdup(rec->fields[i].u.szwVal);
            break;
        case MSIFIELD_STREAM:
            IStream_AddRef(rec->fields[i].u.stream);
            ret->fields[i].u.stream = rec->fields[i].u.stream;
            break;
        default:
            ERR("invalid field type %d\n", rec->fields[i].type);
            break;
        }
        ret->fields[i].type = rec->fields[i].type;
    }
 
    msiobj_release(&rec->hdr);
    return ret;
}

Referenced by s_remote_DatabaseGetPrimaryKeys(), s_remote_ViewFetch(), s_remote_ViewGetColumnInfo(), and s_remote_ViewModify().

◆ msi_action_is_unique()

BOOL msi_action_is_unique	(	const MSIPACKAGE *	package,
		const WCHAR *	action
	)

Definition at line 130 of file custom.c.

{
    UINT i;
 
    for (i = 0; i < package->unique_actions_count; i++)
    {
        if (!wcscmp( package->unique_actions[i], action )) return TRUE;
    }
    return FALSE;
}

Referenced by ACTION_AppSearch(), ACTION_CCPSearch(), ACTION_FindRelatedProducts(), and check_execution_scheduling_options().

◆ msi_add_cabinet_stream()

UINT msi_add_cabinet_stream	(	MSIPACKAGE *	package,
		UINT	disk_id,
		IStorage *	storage,
		const WCHAR *	name
	)

Definition at line 923 of file media.c.

{
    MSICABINETSTREAM *cab, *item;
 
    TRACE("%p, %u, %p, %s\n", package, disk_id, storage, debugstr_w(name));
 
    LIST_FOR_EACH_ENTRY( item, &package->cabinet_streams, MSICABINETSTREAM, entry )
    {
        if (item->disk_id == disk_id)
        {
            TRACE("duplicate disk id %u\n", disk_id);
            return ERROR_FUNCTION_FAILED;
        }
    }
    if (!(cab = malloc( sizeof(*cab) ))) return ERROR_OUTOFMEMORY;
    if (!(cab->stream = malloc( (wcslen( name ) + 1) * sizeof(WCHAR) )))
    {
        free( cab );
        return ERROR_OUTOFMEMORY;
    }
    lstrcpyW( cab->stream, name );
    cab->disk_id = disk_id;
    cab->storage = storage;
    IStorage_AddRef( storage );
    list_add_tail( &package->cabinet_streams, &cab->entry );
 
    return ERROR_SUCCESS;
}

Referenced by load_media(), and patch_add_media().

◆ msi_add_string()

int msi_add_string	(	string_table *	st,
		const WCHAR *	data,
		int	len,
		BOOL	persistent
	)

Definition at line 303 of file string.c.

{
    UINT n;
    LPWSTR str;
 
    if( !data )
        return 0;
 
    if (len < 0) len = lstrlenW( data );
 
    if( !data[0] && !len )
        return 0;
 
    if (msi_string2id( st, data, len, &n) == ERROR_SUCCESS )
    {
        if (persistent)
            st->strings[n].persistent_refcount++;
        else
            st->strings[n].nonpersistent_refcount++;
        return n;
    }
 
    n = st_find_free_entry( st );
    if( n == -1 )
        return -1;
 
    /* allocate a new string */
    TRACE( "%s, n = %d len = %d\n", debugstr_wn(data, len), n, len );
 
    str = malloc( (len + 1) * sizeof(WCHAR) );
    if( !str )
        return -1;
    memcpy( str, data, len*sizeof(WCHAR) );
    str[len] = 0;
 
    set_st_entry( st, n, str, len, 1, persistent );
    return n;
}

Referenced by add_storages_to_table(), append_stream(), find_insert_index(), msi_create_table(), STORAGES_set_row(), STREAMS_set_row(), TABLE_add_column(), TABLE_set_row(), and TABLE_set_string().

◆ msi_add_suminfo()

UINT msi_add_suminfo	(	MSIDATABASE *	db,
		LPWSTR **	records,
		int	num_records,
		int	num_columns
	)

Definition at line 1077 of file suminfo.c.

{
    UINT r;
    int i, j;
    MSISUMMARYINFO *si;
 
    r = msi_get_suminfo( db->storage, num_records * (num_columns / 2), &si );
    if (r != ERROR_SUCCESS)
    {
        if (!(si = create_suminfo( db->storage, num_records * (num_columns / 2) )))
            return ERROR_OUTOFMEMORY;
        r = ERROR_SUCCESS;
    }
 
    for (i = 0; i < num_records; i++)
    {
        for (j = 0; j < num_columns; j += 2)
        {
            UINT pid;
            INT int_value = 0;
            FILETIME ft_value;
            awcstring str_value;
 
            r = parse_prop( records[i][j], records[i][j + 1], &pid, &int_value, &ft_value, &str_value );
            if (r != ERROR_SUCCESS)
                goto end;
 
            r = set_prop( si, pid, get_type(pid), int_value, &ft_value, &str_value );
            if (r != ERROR_SUCCESS)
                goto end;
        }
    }
 
end:
    if (r == ERROR_SUCCESS)
        r = msi_suminfo_persist( si );
 
    msiobj_release( &si->hdr );
    return r;
}

Referenced by MSI_DatabaseImport().

◆ msi_adjust_privilege_properties()

void msi_adjust_privilege_properties ( MSIPACKAGE * package )

Definition at line 967 of file package.c.

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

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

◆ msi_apply_patches()

UINT msi_apply_patches ( MSIPACKAGE * package )

Definition at line 932 of file patch.c.

{
    LPWSTR patch_list, *patches;
    UINT i, r = ERROR_SUCCESS;
 
    patch_list = msi_dup_property( package->db, L"PATCH" );
 
    TRACE("patches to be applied: %s\n", debugstr_w(patch_list));
 
    patches = msi_split_string( patch_list, ';' );
    for (i = 0; patches && patches[i] && r == ERROR_SUCCESS; i++)
        r = apply_patch_package( package, patches[i] );
 
    free( patches );
    free( patch_list );
    return r;
}

Referenced by MSI_InstallPackage().

◆ msi_apply_registered_patch()

UINT msi_apply_registered_patch	(	MSIPACKAGE *	package,
		LPCWSTR	patch_code
	)

Definition at line 990 of file patch.c.

{
    UINT r;
    DWORD len;
    WCHAR patch_file[MAX_PATH];
    MSIDATABASE *patch_db;
    MSIPATCHINFO *patch_info;
    MSISUMMARYINFO *si;
 
    TRACE("%p, %s\n", package, debugstr_w(patch_code));
 
    len = ARRAY_SIZE( patch_file );
    r = MsiGetPatchInfoExW( patch_code, package->ProductCode, NULL, package->Context,
                            INSTALLPROPERTY_LOCALPACKAGEW, patch_file, &len );
    if (r != ERROR_SUCCESS)
    {
        ERR("failed to get patch filename %u\n", r);
        return r;
    }
    r = MSI_OpenDatabaseW( patch_file, MSIDBOPEN_READONLY + MSIDBOPEN_PATCHFILE, &patch_db );
    if (r != ERROR_SUCCESS)
    {
        ERR("failed to open patch database %s\n", debugstr_w( patch_file ));
        return r;
    }
    r = msi_get_suminfo( patch_db->storage, 0, &si );
    if (r != ERROR_SUCCESS)
    {
        msiobj_release( &patch_db->hdr );
        return r;
    }
    r = parse_patch_summary( si, &patch_info );
    msiobj_release( &si->hdr );
    if (r != ERROR_SUCCESS)
    {
        ERR("failed to parse patch summary %u\n", r);
        msiobj_release( &patch_db->hdr );
        return r;
    }
    patch_info->registered = TRUE;
    patch_info->localfile = wcsdup( patch_file );
    if (!patch_info->localfile)
    {
        msiobj_release( &patch_db->hdr );
        msi_free_patchinfo( patch_info );
        return ERROR_OUTOFMEMORY;
    }
    r = apply_patch_db( package, patch_db, patch_info );
    msiobj_release( &patch_db->hdr );
    if (r != ERROR_SUCCESS)
    {
        ERR("failed to apply patch %u\n", r);
        msi_free_patchinfo( patch_info );
    }
    return r;
}

Referenced by MSI_OpenPackageW().

◆ msi_apply_transforms()

UINT msi_apply_transforms ( MSIPACKAGE * package )

Definition at line 950 of file patch.c.

{
    LPWSTR xform_list, *xforms;
    UINT i, r = ERROR_SUCCESS;
 
    xform_list = msi_dup_property( package->db, L"TRANSFORMS" );
    xforms = msi_split_string( xform_list, ';' );
 
    for (i = 0; xforms && xforms[i] && r == ERROR_SUCCESS; i++)
    {
        if (xforms[i][0] == ':')
            r = apply_substorage_transform( package, package->db, xforms[i] );
        else
        {
            WCHAR *transform;
 
            if (!PathIsRelativeW( xforms[i] )) transform = xforms[i];
            else
            {
                WCHAR *p = wcsrchr( package->PackagePath, '\\' );
                DWORD len = p - package->PackagePath + 1;
 
                if (!(transform = malloc( (len + wcslen( xforms[i] ) + 1) * sizeof(WCHAR)) ))
                {
                    free( xforms );
                    free( xform_list );
                    return ERROR_OUTOFMEMORY;
                }
                memcpy( transform, package->PackagePath, len * sizeof(WCHAR) );
                memcpy( transform + len, xforms[i], (lstrlenW( xforms[i] ) + 1) * sizeof(WCHAR) );
            }
            r = MSI_DatabaseApplyTransformW( package->db, transform, 0 );
            if (transform != xforms[i]) free( transform );
        }
    }
    free( xforms );
    free( xform_list );
    return r;
}

Referenced by MSI_InstallPackage().

◆ msi_build_directory_name()

WCHAR *WINAPIV msi_build_directory_name	(	DWORD	count,
			...
	)

Definition at line 2006 of file action.c.

{
    DWORD sz = 1, i;
    WCHAR *dir;
    va_list va;
 
    va_start( va, count );
    for (i = 0; i < count; i++)
    {
        const WCHAR *str = va_arg( va, const WCHAR * );
        if (str) sz += lstrlenW( str ) + 1;
    }
    va_end( va );
 
    dir = malloc( sz * sizeof(WCHAR) );
    dir[0] = 0;
 
    va_start( va, count );
    for (i = 0; i < count; i++)
    {
        const WCHAR *str = va_arg( va, const WCHAR * );
        if (!str) continue;
        lstrcatW( dir, str );
        if ( i + 1 != count && dir[0] && dir[lstrlenW( dir ) - 1] != '\\') lstrcatW( dir, L"\\" );
    }
    va_end( va );
    return dir;
}

Referenced by get_duplicate_filename(), get_ini_file_name(), get_link_file(), ITERATE_InstallODBCDriver(), msi_build_icon_path(), msi_resolve_file_source(), msi_resolve_source_folder(), msi_resolve_target_folder(), MSI_SetTargetPathW(), register_verb(), and set_target_path().

◆ msi_build_icon_path()

WCHAR * msi_build_icon_path	(	MSIPACKAGE *	package,
		const WCHAR *	icon_name
	)

Definition at line 3721 of file action.c.

{
    WCHAR *folder, *dest, *path;
 
    if (package->Context == MSIINSTALLCONTEXT_MACHINE)
        folder = msi_dup_property( package->db, L"WindowsFolder" );
    else
    {
        WCHAR *appdata = msi_dup_property( package->db, L"AppDataFolder" );
        folder = msi_build_directory_name( 2, appdata, L"Microsoft\\" );
        free( appdata );
    }
    dest = msi_build_directory_name( 3, folder, L"Installer\\", package->ProductCode );
    msi_create_full_path( package, dest );
    path = msi_build_directory_name( 2, dest, icon_name );
    free( folder );
    free( dest );
    return path;
}

Referenced by ITERATE_CreateShortcuts(), ITERATE_PublishIcon(), ITERATE_UnpublishIcon(), load_class(), load_progid(), and publish_product_properties().

◆ msi_cabextract()

BOOL msi_cabextract	(	MSIPACKAGE *	package,
		MSIMEDIAINFO *	mi,
		LPVOID	data
	)

Definition at line 640 of file media.c.

{
    if (mi->cabinet[0] == '#')
    {
        return extract_cabinet_stream( package, mi, data );
    }
    return extract_cabinet( package, mi, data );
}

Referenced by ACTION_InstallFiles(), and ACTION_PatchFiles().

◆ msi_check_patch_applicable()

UINT msi_check_patch_applicable	(	MSIPACKAGE *	package,
		MSISUMMARYINFO *	si
	)

Definition at line 294 of file patch.c.

{
    LPWSTR guid_list, *guids, product_code;
    UINT i, ret = ERROR_FUNCTION_FAILED;
 
    product_code = msi_dup_property( package->db, L"ProductCode" );
    if (!product_code)
    {
        /* FIXME: the property ProductCode should be written into the DB somewhere */
        ERR("no product code to check\n");
        return ERROR_SUCCESS;
    }
    guid_list = msi_suminfo_dup_string( si, PID_TEMPLATE );
    guids = msi_split_string( guid_list, ';' );
    for (i = 0; guids[i] && ret != ERROR_SUCCESS; i++)
    {
        if (!wcscmp( guids[i], product_code )) ret = ERROR_SUCCESS;
    }
    free( guids );
    free( guid_list );
    free( product_code );
    return ret;
}

Referenced by apply_patch_package(), and MSI_ApplicablePatchW().

◆ msi_clone_properties()

UINT msi_clone_properties ( MSIDATABASE * db )

Definition at line 381 of file package.c.

{
    MSIQUERY *view_select;
    UINT rc;
 
    rc = MSI_DatabaseOpenViewW( db, L"SELECT * FROM `Property`", &view_select );
    if (rc != ERROR_SUCCESS)
        return rc;
 
    rc = MSI_ViewExecute( view_select, 0 );
    if (rc != ERROR_SUCCESS)
    {
        MSI_ViewClose( view_select );
        msiobj_release( &view_select->hdr );
        return rc;
    }
 
    while (1)
    {
        MSIQUERY *view_insert, *view_update;
        MSIRECORD *rec_select;
 
        rc = MSI_ViewFetch( view_select, &rec_select );
        if (rc != ERROR_SUCCESS)
            break;
 
        rc = MSI_DatabaseOpenViewW( db, L"INSERT INTO `_Property` (`_Property`,`Value`) VALUES (?,?)", &view_insert );
        if (rc != ERROR_SUCCESS)
        {
            msiobj_release( &rec_select->hdr );
            continue;
        }
 
        rc = MSI_ViewExecute( view_insert, rec_select );
        MSI_ViewClose( view_insert );
        msiobj_release( &view_insert->hdr );
        if (rc != ERROR_SUCCESS)
        {
            MSIRECORD *rec_update;
 
            TRACE("insert failed, trying update\n");
 
            rc = MSI_DatabaseOpenViewW( db, L"UPDATE `_Property` SET `Value` = ? WHERE `_Property` = ?", &view_update );
            if (rc != ERROR_SUCCESS)
            {
                WARN("open view failed %u\n", rc);
                msiobj_release( &rec_select->hdr );
                continue;
            }
 
            rec_update = MSI_CreateRecord( 2 );
            MSI_RecordCopyField( rec_select, 1, rec_update, 2 );
            MSI_RecordCopyField( rec_select, 2, rec_update, 1 );
            rc = MSI_ViewExecute( view_update, rec_update );
            if (rc != ERROR_SUCCESS)
                WARN("update failed %u\n", rc);
 
            MSI_ViewClose( view_update );
            msiobj_release( &view_update->hdr );
            msiobj_release( &rec_update->hdr );
        }
 
        msiobj_release( &rec_select->hdr );
    }
 
    MSI_ViewClose( view_select );
    msiobj_release( &view_select->hdr );
    return rc;
}

Referenced by MSI_CreatePackage(), and msi_table_apply_transform().

◆ MSI_CloneRecord()

MSIRECORD * MSI_CloneRecord ( MSIRECORD * rec )

Definition at line 921 of file record.c.

{
    MSIRECORD *clone;
    UINT r, i, count;
 
    count = MSI_RecordGetFieldCount(rec);
    clone = MSI_CreateRecord(count);
    if (!clone)
        return NULL;
 
    for (i = 0; i <= count; i++)
    {
        if (rec->fields[i].type == MSIFIELD_STREAM)
        {
            if (FAILED(IStream_Clone(rec->fields[i].u.stream,
                                     &clone->fields[i].u.stream)))
            {
                msiobj_release(&clone->hdr);
                return NULL;
            }
            clone->fields[i].type = MSIFIELD_STREAM;
        }
        else
        {
            r = MSI_RecordCopyField(rec, i, clone, i);
            if (r != ERROR_SUCCESS)
            {
                msiobj_release(&clone->hdr);
                return NULL;
            }
        }
    }
 
    return clone;
}

Referenced by iterate_properties(), merge_diff_row(), and MSI_FormatRecordW().

◆ MSI_CloseRecord()

void MSI_CloseRecord ( MSIOBJECTHDR * arg )

Definition at line 67 of file record.c.

{
    MSIRECORD *rec = (MSIRECORD *) arg;
    UINT i;
 
    for( i=0; i<=rec->count; i++ )
        MSI_FreeField( &rec->fields[i] );
}

Referenced by MSI_CreateRecord(), and refresh_record().

◆ msi_commit_streams()

UINT msi_commit_streams ( MSIDATABASE * db )

Definition at line 607 of file streams.c.

{
    UINT i;
    const WCHAR *name;
    WCHAR *encname;
    IStream *stream;
    HRESULT hr;
 
    TRACE("got %u streams\n", db->num_streams);
 
    for (i = 0; i < db->num_streams; i++)
    {
        name = msi_string_lookup( db->strings, db->streams[i].str_index, NULL );
        if (!wcscmp( name, L"\5SummaryInformation" )) continue;
 
        if (!(encname = encode_streamname( FALSE, name ))) return ERROR_OUTOFMEMORY;
        TRACE("saving stream %s as %s\n", debugstr_w(name), debugstr_w(encname));
 
        hr = IStorage_CreateStream( db->storage, encname, STGM_WRITE|STGM_SHARE_EXCLUSIVE, 0, 0, &stream );
        if (SUCCEEDED( hr ))
        {
            hr = write_stream( stream, db->streams[i].stream );
            if (FAILED( hr ))
            {
                ERR( "failed to write stream %s (hr = %#lx)\n", debugstr_w(encname), hr );
                free( encname );
                IStream_Release( stream );
                return ERROR_FUNCTION_FAILED;
            }
            hr = IStream_Commit( stream, 0 );
            IStream_Release( stream );
            if (FAILED( hr ))
            {
                ERR( "failed to commit stream %s (hr = %#lx)\n", debugstr_w(encname), hr );
                free( encname );
                return ERROR_FUNCTION_FAILED;
            }
        }
        else if (hr != STG_E_FILEALREADYEXISTS)
        {
            ERR( "failed to create stream %s (hr = %#lx)\n", debugstr_w(encname), hr );
            free( encname );
            return ERROR_FUNCTION_FAILED;
        }
        free( encname );
    }
 
    return ERROR_SUCCESS;
}

Referenced by MsiDatabaseCommit().

◆ MSI_CommitTables()

UINT MSI_CommitTables ( MSIDATABASE * db )

Definition at line 2903 of file table.c.

{
    UINT r, bytes_per_strref;
    HRESULT hr;
    MSITABLE *table = NULL;
 
    TRACE("%p\n",db);
 
    r = msi_save_string_table( db->strings, db->storage, &bytes_per_strref );
    if( r != ERROR_SUCCESS )
    {
        WARN("failed to save string table r=%08x\n",r);
        return r;
    }
 
    LIST_FOR_EACH_ENTRY( table, &db->tables, MSITABLE, entry )
    {
        r = save_table( db, table, bytes_per_strref );
        if( r != ERROR_SUCCESS )
        {
            WARN("failed to save table %s (r=%08x)\n",
                  debugstr_w(table->name), r);
            return r;
        }
    }
 
    hr = IStorage_Commit( db->storage, 0 );
    if (FAILED( hr ))
    {
        WARN( "failed to commit changes %#lx\n", hr );
        r = ERROR_FUNCTION_FAILED;
    }
    return r;
}

Referenced by MsiDatabaseCommit().

◆ msi_compare_file_versions()

int msi_compare_file_versions	(	VS_FIXEDFILEINFO *	fi,
		const WCHAR *	version
	)

Definition at line 1928 of file action.c.

{
    DWORD ms, ls;
 
    msi_parse_version_string( version, &ms, &ls );
 
    if (fi->dwFileVersionMS > ms) return 1;
    else if (fi->dwFileVersionMS < ms) return -1;
    else if (fi->dwFileVersionLS > ls) return 1;
    else if (fi->dwFileVersionLS < ls) return -1;
    return 0;
}

Referenced by ACTION_RemoveFiles(), calculate_file_cost(), and calculate_install_state().

◆ msi_compare_font_versions()

int msi_compare_font_versions	(	const WCHAR *	ver1,
		const WCHAR *	ver2
	)

Definition at line 1941 of file action.c.

{
    DWORD ms1, ms2;
 
    msi_parse_version_string( ver1, &ms1, NULL );
    msi_parse_version_string( ver2, &ms2, NULL );
 
    if (ms1 > ms2) return 1;
    else if (ms1 < ms2) return -1;
    return 0;
}

Referenced by calculate_file_cost(), and calculate_install_state().

◆ msi_copy_file()

BOOL msi_copy_file	(	MSIPACKAGE *	package,
		const WCHAR *	src,
		const WCHAR *	dst,
		BOOL	fail_if_exists
	)

Definition at line 70 of file files.c.

{
    BOOL ret;
    msi_disable_fs_redirection( package );
    ret = CopyFileW( src, dst, fail_if_exists );
    msi_revert_fs_redirection( package );
    return ret;
}

Referenced by ACTION_InstallAdminPackage(), copy_file_attributes(), copy_install_file(), ITERATE_DuplicateFiles(), move_file(), and msi_patch_assembly().

◆ msi_create_assembly_enum()

IAssemblyEnum * msi_create_assembly_enum	(	MSIPACKAGE *	package,
		const WCHAR *	displayname
	)

Definition at line 244 of file assembly.c.

{
    HRESULT hr;
    IAssemblyName *name;
    IAssemblyEnum *ret;
    WCHAR *str;
    DWORD len = 0;
 
    if (!init_assembly_caches( package ) || !package->pCreateAssemblyNameObject || !package->pCreateAssemblyEnum)
        return NULL;
 
    hr = package->pCreateAssemblyNameObject( &name, displayname, CANOF_PARSE_DISPLAY_NAME, NULL );
    if (FAILED( hr )) return NULL;
 
    hr = IAssemblyName_GetName( name, &len, NULL );
    if (hr != E_NOT_SUFFICIENT_BUFFER || !(str = malloc( len * sizeof(WCHAR) )))
    {
        IAssemblyName_Release( name );
        return NULL;
    }
 
    hr = IAssemblyName_GetName( name, &len, str );
    IAssemblyName_Release( name );
    if (FAILED( hr ))
    {
        free( str );
        return NULL;
    }
 
    hr = package->pCreateAssemblyNameObject( &name, str, 0, NULL );
    free( str );
    if (FAILED( hr )) return NULL;
 
    hr = package->pCreateAssemblyEnum( &ret, NULL, name, ASM_CACHE_GAC, NULL );
    IAssemblyName_Release( name );
    if (FAILED( hr )) return NULL;
 
    return ret;
}

Referenced by msi_patch_assembly().

◆ msi_create_component_advertise_string()

WCHAR * msi_create_component_advertise_string	(	MSIPACKAGE *	package,
		MSICOMPONENT *	component,
		const WCHAR *	feature
	)

Definition at line 5538 of file action.c.

{
    WCHAR productid_85[21], component_85[21], *ret;
    GUID clsid;
    DWORD sz;
 
    /* > is used if there is a component GUID and < if not.  */
 
    productid_85[0] = 0;
    component_85[0] = 0;
    CLSIDFromString( package->ProductCode, &clsid );
 
    encode_base85_guid( &clsid, productid_85 );
    if (component)
    {
        CLSIDFromString( component->ComponentId, &clsid );
        encode_base85_guid( &clsid, component_85 );
    }
 
    TRACE("product=%s feature=%s component=%s\n", debugstr_w(productid_85), debugstr_w(feature),
          debugstr_w(component_85));
 
    sz = 20 + lstrlenW( feature ) + 20 + 3;
    ret = calloc( 1, sz * sizeof(WCHAR) );
    if (ret) swprintf( ret, sz, L"%s%s%c%s", productid_85, feature, component ? '>' : '<', component_85 );
    return ret;
}

Referenced by ITERATE_PublishComponent(), and register_verb().

◆ msi_create_empty_local_file()

UINT msi_create_empty_local_file	(	LPWSTR	path,
		LPCWSTR	suffix
	)

Definition at line 1066 of file package.c.

{
    DWORD time, len, i, offset;
    HANDLE handle;
 
    time = GetTickCount();
    GetWindowsDirectoryW( path, MAX_PATH );
    lstrcatW( path, L"\\Installer\\" );
    CreateDirectoryW( path, NULL );
 
    len = lstrlenW(path);
    for (i = 0; i < 0x10000; i++)
    {
        offset = swprintf( path + len, MAX_PATH - len, L"%x", (time + i) & 0xffff );
        memcpy( path + len + offset, suffix, (lstrlenW( suffix ) + 1) * sizeof(WCHAR) );
        handle = CreateFileW( path, GENERIC_WRITE, 0, NULL,
                              CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0 );
        if (handle != INVALID_HANDLE_VALUE)
        {
            CloseHandle(handle);
            break;
        }
        if (GetLastError() != ERROR_FILE_EXISTS &&
            GetLastError() != ERROR_SHARING_VIOLATION)
            return ERROR_FUNCTION_FAILED;
    }
 
    return ERROR_SUCCESS;
}

Referenced by apply_patch_package(), and MSI_OpenPackageW().

◆ msi_create_file()

HANDLE msi_create_file	(	MSIPACKAGE *	package,
		const WCHAR *	filename,
		DWORD	access,
		DWORD	sharing,
		DWORD	creation,
		DWORD	flags
	)

Definition at line 60 of file files.c.

{
    HANDLE handle;
    msi_disable_fs_redirection( package );
    handle = CreateFileW( filename, access, sharing, NULL, creation, flags, NULL );
    msi_revert_fs_redirection( package );
    return handle;
}

Referenced by admin_create_dest_file(), cabinet_copy_file(), HANDLE_CustomType21_22(), ITERATE_PublishIcon(), load_ttf_name_id(), msi_get_disk_file_size(), and msi_get_filehash().

◆ msi_create_full_path()

BOOL msi_create_full_path	(	MSIPACKAGE *	package,
		const WCHAR *	path
	)

Definition at line 211 of file files.c.

{
    BOOL ret = TRUE;
    WCHAR *new_path;
    int len;
 
    if (!(new_path = malloc( (wcslen( path ) + 1) * sizeof(WCHAR) ))) return FALSE;
    lstrcpyW( new_path, path );
 
    while ((len = lstrlenW( new_path )) && new_path[len - 1] == '\\')
    new_path[len - 1] = 0;
 
    while (!create_directory( package, new_path ))
    {
        WCHAR *slash;
        DWORD last_error = GetLastError();
        if (last_error == ERROR_ALREADY_EXISTS) break;
        if (last_error != ERROR_PATH_NOT_FOUND)
        {
            ret = FALSE;
            break;
        }
        if (!(slash = wcsrchr( new_path, '\\' )))
        {
            ret = FALSE;
            break;
        }
        len = slash - new_path;
        new_path[len] = 0;
        if (!msi_create_full_path( package, new_path ))
        {
            ret = FALSE;
            break;
        }
        new_path[len] = '\\';
    }
    free( new_path );
    return ret;
}

Referenced by admin_create_dest_file(), create_folder(), get_duplicate_filename(), get_link_file(), ITERATE_CreateFolders(), ITERATE_MoveFiles(), msi_build_icon_path(), and msi_create_full_path().

◆ msi_create_temp_file()

WCHAR * msi_create_temp_file ( MSIDATABASE * db )

Definition at line 214 of file custom.c.

{
    WCHAR *ret;
 
    if (!db->tempfolder)
    {
        WCHAR tmp[MAX_PATH];
        DWORD len = ARRAY_SIZE( tmp );
 
        if (msi_get_property( db, L"TempFolder", tmp, &len ) ||
            GetFileAttributesW( tmp ) != FILE_ATTRIBUTE_DIRECTORY)
        {
            GetTempPathW( MAX_PATH, tmp );
        }
        if (!(db->tempfolder = wcsdup( tmp ))) return NULL;
    }
 
    if ((ret = malloc( (wcslen( db->tempfolder ) + 20) * sizeof(WCHAR) )))
    {
        if (!GetTempFileNameW( db->tempfolder, L"msi", 0, ret ))
        {
            free( ret );
            return NULL;
        }
    }
 
    return ret;
}

Referenced by create_temp_binary(), HANDLE_CustomType7(), load_image(), patch_file(), and patchfiles_cb().

◆ MSI_CreatePackage()

MSIPACKAGE * MSI_CreatePackage ( MSIDATABASE * db )

Definition at line 981 of file package.c.

{
    MSIPACKAGE *package;
    WCHAR uilevel[11];
    int len;
    UINT r;
 
    TRACE("%p\n", db);
 
    package = alloc_package();
    if (package)
    {
        msiobj_addref( &db->hdr );
        package->db = db;
 
        package->LastAction = NULL;
        package->LastActionTemplate = NULL;
        package->LastActionResult = MSI_NULL_INTEGER;
        package->WordCount = 0;
        package->PackagePath = wcsdup( db->path );
 
        create_temp_property_table( package );
        msi_clone_properties( package->db );
        msi_adjust_privilege_properties( package );
 
        package->ProductCode = msi_dup_property( package->db, L"ProductCode" );
 
        set_installer_properties( package );
 
        package->ui_level = gUILevel;
        len = swprintf( uilevel, ARRAY_SIZE(uilevel), L"%u", gUILevel & INSTALLUILEVEL_MASK );
        msi_set_property( package->db, L"UILevel", uilevel, len );
 
        r = msi_load_suminfo_properties( package );
        if (r != ERROR_SUCCESS)
        {
            msiobj_release( &package->hdr );
            return NULL;
        }
 
        if (package->WordCount & msidbSumInfoSourceTypeAdminImage)
            load_admin_properties( package );
 
        package->log_file = INVALID_HANDLE_VALUE;
        package->script = SCRIPT_NONE;
    }
    return package;
}

◆ MSI_CreateRecord()

MSIRECORD * MSI_CreateRecord ( UINT cParams )

Definition at line 76 of file record.c.

{
    MSIRECORD *rec;
 
    TRACE("%d\n", cParams);
 
    if( cParams>65535 )
        return NULL;
 
    rec = alloc_msiobject( MSIHANDLETYPE_RECORD, FIELD_OFFSET(MSIRECORD, fields[cParams + 1]),
            MSI_CloseRecord );
    if( rec )
        rec->count = cParams;
    return rec;
}

Referenced by ACTION_AllocateRegistrySpace(), ACTION_ExecuteAction(), ACTION_MsiPublishAssemblies(), ACTION_MsiUnpublishAssemblies(), ACTION_ProcessComponents(), ACTION_PublishFeatures(), ACTION_PublishProduct(), ACTION_RegisterClassInfo(), ACTION_RegisterExtensionInfo(), ACTION_RegisterMIMEInfo(), ACTION_RegisterProduct(), ACTION_RegisterProgIdInfo(), ACTION_RegisterUser(), ACTION_RemoveFiles(), ACTION_ResolveSource(), ACTION_ShowDialog(), ACTION_UnregisterClassInfo(), ACTION_UnregisterExtensionInfo(), ACTION_UnregisterMIMEInfo(), ACTION_UnregisterProgIdInfo(), add_stream(), arrange_record(), change_media(), construct_record(), deformat_string(), dialog_create(), dialog_seltree_handler(), event_set_target_path(), file_update_ui(), get_property_row(), get_transform_record(), internal_ui_handler(), ITERATE_AppSearch(), ITERATE_CreateFolders(), ITERATE_DeleteService(), ITERATE_DuplicateFiles(), ITERATE_FindRelatedProducts(), ITERATE_InstallODBCDataSource(), ITERATE_InstallODBCDriver(), ITERATE_InstallODBCTranslator(), ITERATE_MoveFiles(), ITERATE_PublishComponent(), ITERATE_RegisterFonts(), ITERATE_RemoveDuplicateFiles(), ITERATE_RemoveEnvironmentString(), ITERATE_RemoveFiles(), ITERATE_RemoveFolders(), ITERATE_RemoveIniValuesOnInstall(), ITERATE_RemoveIniValuesOnUninstall(), ITERATE_RemoveODBCDataSource(), ITERATE_RemoveODBCDriver(), ITERATE_RemoveODBCTranslator(), ITERATE_RemoveRegistryValuesOnInstall(), ITERATE_RemoveRegistryValuesOnUninstall(), ITERATE_SelfRegModules(), ITERATE_SelfUnregModules(), ITERATE_StartService(), ITERATE_StopService(), ITERATE_UnpublishComponent(), ITERATE_UnregisterFonts(), ITERATE_WriteEnvironmentString(), ITERATE_WriteIniValues(), ITERATE_WriteRegistryValues(), msi_clone_properties(), MSI_CloneRecord(), msi_create_table(), MSI_DatabaseGetPrimaryKeys(), MSI_OpenPackageW(), msi_query_merge_record(), msi_set_property(), msi_ui_progress(), msi_view_get_row(), MSI_ViewGetColumnInfo(), MsiCreateRecord(), patch_add_media(), patch_offset_get_filepatches(), patch_offset_get_files(), patch_offset_modify_db(), patch_update_filepatch_sequence(), SELECT_set_row(), TABLE_add_column(), TABLE_drop(), TABLE_remove_column(), translate_record(), ui_actioninfo(), ui_actionstart(), unpublish_feature(), UPDATE_execute(), and WHERE_set_row().

◆ MSI_DatabaseApplyTransformW()

UINT MSI_DatabaseApplyTransformW	(	MSIDATABASE *	db,
		LPCWSTR	szTransformFile,
		int	iErrorCond
	)

Referenced by msi_apply_transforms().

◆ MSI_DatabaseGetPrimaryKeys()

UINT MSI_DatabaseGetPrimaryKeys	(	MSIDATABASE *	,
		LPCWSTR	,
		MSIRECORD **
	)

Referenced by create_diff_row_query(), get_table_labels(), merge_verify_primary_keys(), and MSI_DatabaseExport().

◆ MSI_DatabaseIsTablePersistent()

MSICONDITION MSI_DatabaseIsTablePersistent	(	MSIDATABASE *	db,
		LPCWSTR	table
	)

Definition at line 2938 of file table.c.

{
    MSITABLE *t;
    UINT r;
 
    TRACE("%p %s\n", db, debugstr_w(table));
 
    if (!table)
        return MSICONDITION_ERROR;
 
    r = get_table( db, table, &t );
    if (r != ERROR_SUCCESS)
        return MSICONDITION_NONE;
 
    return t->persistent;
}

Referenced by MsiDatabaseIsTablePersistentW().

◆ MSI_DatabaseOpenViewW()

UINT MSI_DatabaseOpenViewW	(	MSIDATABASE *	,
		LPCWSTR	,
		MSIQUERY **
	)

Referenced by ACTION_BindImage(), ACTION_CostFinalize(), ACTION_CreateFolders(), ACTION_CreateShortcuts(), ACTION_DeleteServices(), ACTION_DuplicateFiles(), ACTION_FindRelatedProducts(), ACTION_InstallODBC(), ACTION_InstallServices(), ACTION_InstallValidate(), ACTION_LaunchConditions(), ACTION_MigrateFeatureStates(), ACTION_MoveFiles(), ACTION_ProcessUISequence(), ACTION_PublishComponents(), ACTION_RegisterFonts(), ACTION_RegisterTypeLibraries(), ACTION_RemoveDuplicateFiles(), ACTION_RemoveEnvironmentStrings(), ACTION_RemoveExistingProducts(), ACTION_RemoveFiles(), ACTION_RemoveFolders(), ACTION_RemoveIniValues(), ACTION_RemoveODBC(), ACTION_RemoveRegistryValues(), ACTION_RemoveShortcuts(), ACTION_SelfRegModules(), ACTION_SelfUnregModules(), ACTION_SetODBCFolders(), ACTION_StartServices(), ACTION_StopServices(), ACTION_UnpublishComponents(), ACTION_UnregisterFonts(), ACTION_UnregisterTypeLibraries(), ACTION_WriteEnvironmentStrings(), ACTION_WriteIniValues(), ACTION_WriteRegistryValues(), add_stream(), add_table_to_db(), create_temp_property_table(), gather_merge_data(), get_property(), get_property_row(), is_uninstallable(), load_all_classes(), load_all_drlocators(), load_all_extensions(), load_all_files(), load_all_folders(), load_all_media(), load_all_mimes(), load_all_patches(), load_all_progids(), load_all_verbs(), merge_diff_row(), msi_clone_properties(), msi_load_all_components(), msi_load_all_features(), msi_set_property(), msi_table_apply_transform(), patch_add_media(), patch_offset_get_filepatches(), patch_offset_get_files(), patch_offset_modify_db(), patch_set_media_source_prop(), patch_set_offsets(), patch_update_filepatch_sequence(), publish_icons(), TransformView_add_column(), TransformView_Create(), TransformView_create_table(), TransformView_delete_row(), TransformView_drop_table(), TransformView_insert_row(), TransformView_set_row(), ui_sequence_exists(), and unpublish_icons().

◆ msi_delete_file()

BOOL msi_delete_file	(	MSIPACKAGE *	package,
		const WCHAR *	filename
	)

Definition at line 79 of file files.c.

{
    BOOL ret;
    msi_disable_fs_redirection( package );
    ret = DeleteFileW( filename );
    msi_revert_fs_redirection( package );
    return ret;
}

Referenced by ACTION_RemoveFiles(), cabinet_copy_file(), ITERATE_PublishIcon(), ITERATE_RemoveDuplicateFiles(), ITERATE_RemoveFiles(), ITERATE_RemoveShortcuts(), ITERATE_UnpublishIcon(), and patch_file().

◆ msi_destroy_assembly_caches()

void msi_destroy_assembly_caches ( MSIPACKAGE * package )

Definition at line 89 of file assembly.c.

{
    UINT i;
 
    if (package->cache_sxs)
    {
        IAssemblyCache_Release( package->cache_sxs );
        package->cache_sxs = NULL;
    }
    for (i = 0; i < CLR_VERSION_MAX; i++)
    {
        if (package->cache_net[i])
        {
            IAssemblyCache_Release( package->cache_net[i] );
            package->cache_net[i] = NULL;
        }
    }
    package->pGetFileVersion = NULL;
    package->pCreateAssemblyNameObject = NULL;
    package->pCreateAssemblyEnum = NULL;
    FreeLibrary( package->hfusion10 );
    FreeLibrary( package->hfusion11 );
    FreeLibrary( package->hfusion20 );
    FreeLibrary( package->hfusion40 );
    FreeLibrary( package->hmscoree );
    package->hfusion10 = NULL;
    package->hfusion11 = NULL;
    package->hfusion20 = NULL;
    package->hfusion40 = NULL;
    package->hmscoree = NULL;
}

Referenced by MSI_FreePackage().

◆ msi_destroy_stringtable()

VOID msi_destroy_stringtable ( string_table * st )

Definition at line 107 of file string.c.

{
    UINT i;
 
    for( i=0; i<st->maxcount; i++ )
    {
        if( st->strings[i].persistent_refcount ||
            st->strings[i].nonpersistent_refcount )
            free( st->strings[i].data );
    }
    free( st->strings );
    free( st->sorted );
    free( st );
}

Referenced by MSI_CloseDatabase(), and msi_table_apply_transform().

◆ msi_dialog_check_messages()

void msi_dialog_check_messages ( HANDLE handle )

Definition at line 3991 of file dialog.c.

{
    DWORD r;
 
    /* in threads other than the UI thread, block */
    if( uiThreadId != GetCurrentThreadId() )
    {
        if (!handle) return;
        while (MsgWaitForMultipleObjectsEx( 1, &handle, INFINITE, QS_ALLINPUT, 0 ) == WAIT_OBJECT_0 + 1)
        {
            MSG msg;
            while (PeekMessageW( &msg, NULL, 0, 0, PM_REMOVE ))
            {
                TranslateMessage( &msg );
                DispatchMessageW( &msg );
            }
        }
        return;
    }
 
    /* there are two choices for the UI thread */
    while (1)
    {
        process_pending_messages( NULL );
 
        if( !handle )
            break;
 
        /*
         * block here until somebody creates a new dialog or
         * the handle we're waiting on becomes ready
         */
        r = MsgWaitForMultipleObjects( 1, &handle, 0, INFINITE, QS_ALLINPUT );
        if( r == WAIT_OBJECT_0 )
            break;
    }
}

Referenced by ACTION_FinishCustomActions(), dialog_handle_event(), ITERATE_Actions(), msi_ui_progress(), register_dll(), wait_process_handle(), and wait_thread_handle().

◆ msi_dialog_destroy()

void msi_dialog_destroy ( msi_dialog * dialog )

Definition at line 4059 of file dialog.c.

{
    struct font *font, *next;
 
    if( uiThreadId != GetCurrentThreadId() )
    {
        SendMessageW( hMsiHiddenWindow, WM_MSI_DIALOG_DESTROY, 0, (LPARAM) dialog );
        return;
    }
 
    if( dialog->hwnd )
    {
        ShowWindow( dialog->hwnd, SW_HIDE );
        DestroyWindow( dialog->hwnd );
    }
 
    /* unsubscribe events */
    event_cleanup_subscriptions( dialog->package, dialog->name );
 
    /* destroy the list of controls */
    while( !list_empty( &dialog->controls ) )
    {
        struct control *t;
 
        t = LIST_ENTRY( list_head( &dialog->controls ), struct control, entry );
        destroy_control( t );
    }
 
    /* destroy the list of fonts */
    LIST_FOR_EACH_ENTRY_SAFE( font, next, &dialog->fonts, struct font, entry )
    {
        list_remove( &font->entry );
        DeleteObject( font->hfont );
        free( font );
    }
    free( dialog->default_font );
 
    free( dialog->control_default );
    free( dialog->control_cancel );
    dialog->package = NULL;
    free( dialog );
}

Referenced by dialog_create(), event_do_dialog(), MSI_FreePackage(), MSI_PreviewDialogW(), and MSIHiddenWindowProc().

◆ msi_dialog_unregister_class()

void msi_dialog_unregister_class ( void )

Definition at line 4102 of file dialog.c.

{
    DestroyWindow( hMsiHiddenWindow );
    hMsiHiddenWindow = NULL;
    UnregisterClassW( L"MsiDialogCloseClass", NULL );
    UnregisterClassW( L"MsiHiddenWindow", NULL );
    uiThreadId = 0;
}

Referenced by DllMain().

◆ msi_disable_fs_redirection()

static void msi_disable_fs_redirection ( MSIPACKAGE * package )

inlinestatic

Definition at line 1099 of file msipriv.h.

{
    if (is_wow64 && is_platform_64bit( package->platform )) Wow64DisableWow64FsRedirection( &package->cookie );
}

Referenced by apply_filepatch(), bind_image(), create_directory(), ITERATE_CreateShortcuts(), load_library(), load_typelib(), msi_copy_file(), msi_create_file(), msi_delete_file(), msi_find_first_file(), msi_find_next_file(), msi_get_file_attributes(), msi_get_file_version_info(), msi_get_temp_file_name(), msi_move_file(), msi_remove_directory(), and msi_set_file_attributes().

◆ msi_download_file()

UINT msi_download_file	(	LPCWSTR	szUrl,
		LPWSTR	filename
	)

Definition at line 1030 of file package.c.

{
    LPINTERNET_CACHE_ENTRY_INFOW cache_entry;
    DWORD size = 0;
    HRESULT hr;
 
    /* call will always fail, because size is 0,
     * but will return ERROR_FILE_NOT_FOUND first
     * if the file doesn't exist
     */
    GetUrlCacheEntryInfoW( szUrl, NULL, &size );
    if ( GetLastError() != ERROR_FILE_NOT_FOUND )
    {
        cache_entry = malloc( size );
        if ( !GetUrlCacheEntryInfoW( szUrl, cache_entry, &size ) )
        {
            UINT error = GetLastError();
            free( cache_entry );
            return error;
        }
 
        lstrcpyW( filename, cache_entry->lpszLocalFileName );
        free( cache_entry );
        return ERROR_SUCCESS;
    }
 
    hr = URLDownloadToCacheFileW( NULL, szUrl, filename, MAX_PATH, 0, NULL );
    if ( FAILED(hr) )
    {
        WARN("failed to download %s to cache file\n", debugstr_w(szUrl));
        return ERROR_FUNCTION_FAILED;
    }
 
    return ERROR_SUCCESS;
}

Referenced by MSI_OpenPackageW(), and ready_media().

◆ msi_dup_property()

WCHAR * msi_dup_property	(	MSIDATABASE *	db,
		const WCHAR *	prop
	)

Referenced by ACTION_CostFinalize(), ACTION_CustomAction(), ACTION_ExecuteAction(), ACTION_RegisterProduct(), ACTION_RegisterUser(), admin_create_dest_file(), append_productcode(), change_media(), check_transform_applicable(), defer_custom_action(), dialog_combobox_update(), dialog_dup_property(), dialog_edit_control(), dialog_maskedit_control(), dialog_oncreate(), dialog_radiogroup_control(), event_set_target_path(), get_base_url(), get_checkbox_value(), get_duplicate_filename(), get_ini_file_name(), get_source_root(), HANDLE_CustomType23(), HANDLE_CustomType50(), HANDLE_CustomType53_54(), is_admin_install(), ITERATE_MoveFiles(), ITERATE_RemoveExistingProducts(), ITERATE_RemoveFiles(), MSI_ApplicablePatchXML(), msi_apply_patches(), msi_apply_transforms(), msi_build_icon_path(), msi_check_patch_applicable(), MSI_CreatePackage(), msi_get_property_int(), MSI_InstallPackage(), msi_load_media_info(), MSI_OpenPackageW(), msi_resolve_target_folder(), msi_set_sourcedir_props(), msi_validate_product_id(), MsiSetFeatureAttributesW(), patch_set_media_source_prop(), process_state_property(), publish_install_properties(), publish_product_properties(), publish_upgrade_code(), ready_media(), and remove_product_upgrade_code().

◆ msi_dup_record_field()

WCHAR * msi_dup_record_field	(	MSIRECORD *	row,
		INT	index
	)

Definition at line 1002 of file record.c.

{
    DWORD sz = 0;
    WCHAR *str;
    UINT r;
 
    if (MSI_RecordIsNull( rec, field )) return NULL;
 
    r = MSI_RecordGetStringW( rec, field, NULL, &sz );
    if (r != ERROR_SUCCESS)
        return NULL;
 
    sz++;
    str = malloc( sz * sizeof(WCHAR) );
    if (!str) return NULL;
    str[0] = 0;
    r = MSI_RecordGetStringW( rec, field, str, &sz );
    if (r != ERROR_SUCCESS)
    {
        ERR("failed to get string!\n");
        free( str );
        return NULL;
    }
    return str;
}

Referenced by get_ini_file_name(), get_key_value(), get_link_file(), get_signature(), internal_ui_handler(), iterate_load_verb(), ITERATE_RegisterFonts(), ITERATE_UnregisterFonts(), load_appid(), load_class(), load_component(), load_drlocator(), load_extension(), load_feature(), load_file(), load_folder(), load_mime(), load_progid(), MSI_FormatRecordW(), msi_get_error_message(), MSI_ProcessMessage(), patch_add_media(), patch_offset_get_filepatches(), patch_offset_get_files(), and search_ini().

◆ MSI_EvaluateConditionW()

MSICONDITION MSI_EvaluateConditionW	(	MSIPACKAGE *	,
		LPCWSTR
	)

Referenced by ACTION_CostFinalize(), ACTION_PerformEndAction(), dialog_control_event(), dialog_set_control_condition(), ITERATE_Actions(), ITERATE_CostFinalizeConditions(), and ITERATE_LaunchConditions().

◆ msi_event_cleanup_all_subscriptions()

void msi_event_cleanup_all_subscriptions ( MSIPACKAGE * package )

Definition at line 4111 of file dialog.c.

{
    struct list *item, *next;
 
    LIST_FOR_EACH_SAFE( item, next, &package->subscriptions )
    {
        struct subscriber *sub = LIST_ENTRY( item, struct subscriber, entry );
        list_remove( &sub->entry );
        free_subscriber( sub );
    }
}

Referenced by event_new_dialog(), and free_package_structures().

◆ msi_event_fire()

void msi_event_fire	(	MSIPACKAGE *	package,
		const WCHAR *	event,
		MSIRECORD *	rec
	)

Definition at line 4421 of file dialog.c.

{
    struct subscriber *sub;
 
    TRACE("firing event %s\n", debugstr_w(event));
 
    LIST_FOR_EACH_ENTRY( sub, &package->subscriptions, struct subscriber, entry )
    {
        if (wcsicmp( sub->event, event )) continue;
        dialog_handle_event( sub->dialog, sub->control, sub->attribute, rec );
    }
}

Referenced by dialog_seltree_handler(), event_set_target_path(), and internal_ui_handler().

◆ msi_export_suminfo()

UINT msi_export_suminfo	(	MSIDATABASE *	db,
		HANDLE	handle
	)

Definition at line 1194 of file suminfo.c.

{
    UINT i, r, num_rows;
    MSISUMMARYINFO *si;
 
    r = msi_get_suminfo( db->storage, 0, &si );
    if (r != ERROR_SUCCESS)
        r = msi_get_db_suminfo( db, 0, &si );
    if (r != ERROR_SUCCESS)
        return r;
 
    num_rows = get_property_count( si->property );
    if (!num_rows)
    {
        msiobj_release( &si->hdr );
        return ERROR_FUNCTION_FAILED;
    }
 
    for (i = 0; i < num_rows; i++)
    {
        r = save_prop( si, handle, i );
        if (r != ERROR_SUCCESS)
        {
            msiobj_release( &si->hdr );
            return r;
        }
    }
 
    msiobj_release( &si->hdr );
    return ERROR_SUCCESS;
}

Referenced by export_summaryinformation().

◆ msi_find_first_file()

HANDLE msi_find_first_file	(	MSIPACKAGE *	package,
		const WCHAR *	filename,
		WIN32_FIND_DATAW *	data
	)

Definition at line 124 of file files.c.

{
    HANDLE handle;
    msi_disable_fs_redirection( package );
    handle = FindFirstFileW( filename, data );
    msi_revert_fs_redirection( package );
    return handle;
}

Referenced by move_files_wildcard(), and recurse_search_directory().

◆ msi_find_next_file()

BOOL msi_find_next_file	(	MSIPACKAGE *	package,
		HANDLE	handle,
		WIN32_FIND_DATAW *	data
	)

Definition at line 133 of file files.c.

{
    BOOL ret;
    msi_disable_fs_redirection( package );
    ret = FindNextFileW( handle, data );
    msi_revert_fs_redirection( package );
    return ret;
}

Referenced by move_files_wildcard(), and recurse_search_directory().

◆ MSI_FormatRecordW()

UINT MSI_FormatRecordW	(	MSIPACKAGE *	package,
		MSIRECORD *	record,
		LPWSTR	buffer,
		LPDWORD	size
	)

Definition at line 838 of file format.c.

{
    WCHAR *format, *deformated = NULL;
    UINT rc = ERROR_INVALID_PARAMETER;
    DWORD len;
    MSIRECORD *record_deformated;
    int field_count, i;
 
    dump_record(record);
 
    if (!(format = msi_dup_record_field( record, 0 )))
        format = build_default_format( record );
 
    field_count = MSI_RecordGetFieldCount(record);
    record_deformated = MSI_CloneRecord(record);
    if (!record_deformated)
    {
        rc = ERROR_OUTOFMEMORY;
        goto end;
    }
    MSI_RecordSetStringW(record_deformated, 0, format);
    for (i = 1; i <= field_count; i++)
    {
        if (MSI_RecordGetString(record, i))
        {
            deformat_string_internal(package, MSI_RecordGetString(record, i), &deformated, &len, NULL);
            MSI_RecordSetStringW(record_deformated, i, deformated);
            free(deformated);
        }
    }
 
    deformat_string_internal(package, format, &deformated, &len, record_deformated);
    if (buffer)
    {
        if (*size>len)
        {
            memcpy(buffer,deformated,len*sizeof(WCHAR));
            rc = ERROR_SUCCESS;
            buffer[len] = 0;
        }
        else
        {
            if (*size > 0)
            {
                memcpy(buffer,deformated,(*size)*sizeof(WCHAR));
                buffer[(*size)-1] = 0;
            }
            rc = ERROR_MORE_DATA;
        }
    }
    else rc = ERROR_SUCCESS;
 
    *size = len;
    msiobj_release(&record_deformated->hdr);
end:
    free( format );
    free( deformated );
    return rc;
}

Referenced by deformat_string(), MSI_ProcessMessageVerbatim(), MsiFormatRecordA(), and MsiFormatRecordW().

◆ msi_free_action_script()

void msi_free_action_script	(	MSIPACKAGE *	package,
		UINT	script
	)

Definition at line 137 of file package.c.

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

Referenced by execute_script(), and free_package_structures().

◆ msi_free_handle_table()

void msi_free_handle_table ( void )

Definition at line 71 of file handle.c.

{
    free( handle_table );
    handle_table = NULL;
    handle_table_size = 0;
    DeleteCriticalSection(&handle_cs);
    DeleteCriticalSection(&object_cs);
}

Referenced by DllMain().

◆ msi_free_media_info()

void msi_free_media_info ( MSIMEDIAINFO * mi )

Definition at line 649 of file media.c.

{
    free(mi->disk_prompt);
    free(mi->cabinet);
    free(mi->volume_label);
    free(mi->last_volume);
    free(mi);
}

Referenced by ACTION_InstallFiles(), and ACTION_PatchFiles().

◆ msi_free_patchinfo()

void msi_free_patchinfo ( MSIPATCHINFO * patch )

Definition at line 865 of file patch.c.

{
    free( patch->patchcode );
    free( patch->products );
    free( patch->transforms );
    free( patch->filename );
    free( patch->localfile );
    free( patch );
}

Referenced by apply_patch_package(), free_package_structures(), and msi_apply_registered_patch().

◆ msi_get_assembly_path()

WCHAR * msi_get_assembly_path	(	MSIPACKAGE *	package,
		const WCHAR *	displayname
	)

Definition at line 219 of file assembly.c.

{
    HRESULT hr;
    ASSEMBLY_INFO info;
    IAssemblyCache *cache;
 
    if (!init_assembly_caches( package ) || !(cache = package->cache_net[CLR_VERSION_V40])) return NULL;
 
    memset( &info, 0, sizeof(info) );
    info.cbAssemblyInfo = sizeof(info);
    hr = IAssemblyCache_QueryAssemblyInfo( cache, 0, displayname, &info );
    if (hr != E_NOT_SUFFICIENT_BUFFER) return NULL;
 
    if (!(info.pszCurrentAssemblyPathBuf = malloc( info.cchBuf * sizeof(WCHAR) ))) return NULL;
 
    hr = IAssemblyCache_QueryAssemblyInfo( cache, 0, displayname, &info );
    if (FAILED( hr ))
    {
        free( info.pszCurrentAssemblyPathBuf );
        return NULL;
    }
    TRACE("returning %s\n", debugstr_w(info.pszCurrentAssemblyPathBuf));
    return info.pszCurrentAssemblyPathBuf;
}

Referenced by msi_patch_assembly().

◆ msi_get_command_line_option()

const WCHAR * msi_get_command_line_option	(	const WCHAR *	cmd,
		const WCHAR *	option,
		UINT *	len
	)

Definition at line 266 of file action.c.

{
    DWORD opt_len = lstrlenW(option);
 
    if (!cmd)
        return NULL;
 
    while (*cmd)
    {
        BOOL found = FALSE;
 
        while (*cmd == ' ') cmd++;
        if (!*cmd) break;
 
        if(!wcsnicmp(cmd, option, opt_len))
            found = TRUE;
 
        cmd = wcschr( cmd, '=' );
        if(!cmd) break;
        cmd++;
        while (*cmd == ' ') cmd++;
        if (!*cmd) break;
 
        *len = parse_prop( cmd, NULL, NULL);
        if (found) return cmd;
        cmd += *len;
    }
 
    return NULL;
}

Referenced by MsiInstallProductW().

◆ msi_get_component_action()

INSTALLSTATE msi_get_component_action	(	MSIPACKAGE *	package,
		MSICOMPONENT *	comp
	)

Definition at line 608 of file action.c.

{
    if (!comp->Enabled)
    {
        TRACE("component is disabled: %s\n", debugstr_w(comp->Component));
        return INSTALLSTATE_UNKNOWN;
    }
    if (package->need_rollback) return comp->Installed;
    if (comp->num_clients > 0 && comp->ActionRequest == INSTALLSTATE_ABSENT)
    {
        TRACE("%s has %u clients left\n", debugstr_w(comp->Component), comp->num_clients);
        return INSTALLSTATE_UNKNOWN;
    }
    return comp->ActionRequest;
}

Referenced by ACTION_MsiPublishAssemblies(), ACTION_MsiUnpublishAssemblies(), ACTION_PatchFiles(), ACTION_RemoveFiles(), calculate_install_state(), ITERATE_CreateFolders(), ITERATE_CreateShortcuts(), ITERATE_DeleteService(), ITERATE_DuplicateFiles(), ITERATE_InstallODBCDataSource(), ITERATE_InstallODBCDriver(), ITERATE_InstallODBCTranslator(), ITERATE_InstallService(), ITERATE_MoveFiles(), ITERATE_RegisterFonts(), ITERATE_RegisterTypeLibraries(), ITERATE_RemoveDuplicateFiles(), ITERATE_RemoveEnvironmentString(), ITERATE_RemoveFiles(), ITERATE_RemoveFolders(), ITERATE_RemoveIniValuesOnInstall(), ITERATE_RemoveIniValuesOnUninstall(), ITERATE_RemoveODBCDataSource(), ITERATE_RemoveODBCDriver(), ITERATE_RemoveODBCTranslator(), ITERATE_RemoveRegistryValuesOnInstall(), ITERATE_RemoveRegistryValuesOnUninstall(), ITERATE_RemoveShortcuts(), ITERATE_SelfRegModules(), ITERATE_SelfUnregModules(), ITERATE_StartService(), ITERATE_StopService(), ITERATE_UnregisterFonts(), ITERATE_UnregisterTypeLibraries(), ITERATE_WriteEnvironmentString(), ITERATE_WriteIniValues(), ITERATE_WriteRegistryValues(), and patchfiles_cb().

◆ msi_get_db_suminfo()

UINT msi_get_db_suminfo	(	MSIDATABASE *	db,
		UINT	uiUpdateCount,
		MSISUMMARYINFO **	si
	)

Definition at line 491 of file suminfo.c.

{
    IStream *stm;
    MSISUMMARYINFO *si;
    UINT r;
 
    if (!(si = create_suminfo( db->storage, uiUpdateCount ))) return ERROR_OUTOFMEMORY;
 
    r = msi_get_stream( db, L"\5SummaryInformation", &stm );
    if (r != ERROR_SUCCESS)
    {
        msiobj_release( &si->hdr );
        return r;
    }
 
    r = load_summary_info( si, stm );
    IStream_Release( stm );
    if (r != ERROR_SUCCESS)
    {
        msiobj_release( &si->hdr );
        return r;
    }
 
    *ret = si;
    return ERROR_SUCCESS;
}

Referenced by msi_export_suminfo(), msi_get_package_code(), msi_load_suminfo_properties(), MSI_OpenPackageW(), and MsiGetSummaryInformationW().

◆ msi_get_disk_file_size()

DWORD msi_get_disk_file_size	(	MSIPACKAGE *	package,
		const WCHAR *	filename
	)

Definition at line 199 of file files.c.

{
    DWORD size;
    HANDLE file;
    file = msi_create_file( package, filename, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, 0 );
    if (file == INVALID_HANDLE_VALUE) return INVALID_FILE_SIZE;
    size = GetFileSize( file, NULL );
    CloseHandle( file );
    return size;
}

Referenced by calculate_file_cost(), and calculate_install_state().

◆ msi_get_disk_file_version()

VS_FIXEDFILEINFO * msi_get_disk_file_version	(	MSIPACKAGE *	package,
		const WCHAR *	filename
	)

Definition at line 170 of file files.c.

{
    VS_FIXEDFILEINFO *ptr, *ret;
    DWORD version_size;
    UINT size;
    void *version;
 
    if (!(version_size = msi_get_file_version_info( package, filename, 0, NULL ))) return NULL;
    if (!(version = malloc( version_size ))) return NULL;
 
    msi_get_file_version_info( package, filename, version_size, version );
 
    if (!VerQueryValueW( version, L"\\", (void **)&ptr, &size ))
    {
        free( version );
        return NULL;
    }
 
    if (!(ret = malloc( size )))
    {
        free( version );
        return NULL;
    }
 
    memcpy( ret, ptr, size );
    free( version );
    return ret;
}

Referenced by ACTION_RemoveFiles(), calculate_file_cost(), and calculate_install_state().

◆ msi_get_error_message()

WCHAR * msi_get_error_message	(	MSIDATABASE *	db,
		int	error
	)

Definition at line 1850 of file package.c.

{
    MSIRECORD *record;
    LPWSTR ret = NULL;
 
    if ((record = MSI_QueryGetRecord(db, L"SELECT `Message` FROM `Error` WHERE `Error` = %d", error)))
    {
        ret = msi_dup_record_field(record, 1);
        msiobj_release(&record->hdr);
    }
    else if (error < 2000)
    {
        int len = LoadStringW(msi_hInstance, IDS_ERROR_BASE + error, (LPWSTR) &ret, 0);
        if (len)
        {
            ret = malloc((len + 1) * sizeof(WCHAR));
            LoadStringW(msi_hInstance, IDS_ERROR_BASE + error, ret, len + 1);
        }
        else
            ret = NULL;
    }
 
    return ret;
}

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

◆ msi_get_feature_action()

INSTALLSTATE msi_get_feature_action	(	MSIPACKAGE *	package,
		MSIFEATURE *	feature
	)

Definition at line 624 of file action.c.

{
    if (package->need_rollback) return feature->Installed;
    return feature->ActionRequest;
}

Referenced by ACTION_RegisterClassInfo(), ACTION_RegisterExtensionInfo(), ACTION_UnregisterClassInfo(), ACTION_UnregisterExtensionInfo(), check_publish(), check_unpublish(), ITERATE_PublishComponent(), ITERATE_UnpublishComponent(), and refcount_component().

◆ msi_get_file_attributes()

DWORD msi_get_file_attributes	(	MSIPACKAGE *	package,
		const WCHAR *	path
	)

Definition at line 115 of file files.c.

{
    DWORD attrs;
    msi_disable_fs_redirection( package );
    attrs = GetFileAttributesW( path );
    msi_revert_fs_redirection( package );
    return attrs;
}

Referenced by cabinet_copy_file(), calculate_file_cost(), calculate_install_state(), check_directory(), ITERATE_MoveFiles(), move_file(), msi_resolve_file_source(), MSI_SetTargetPathW(), search_components(), search_directory(), search_dr(), and search_file().

◆ msi_get_file_version_info()

DWORD msi_get_file_version_info	(	MSIPACKAGE *	package,
		const WCHAR *	path,
		DWORD	buflen,
		BYTE *	buffer
	)

Definition at line 160 of file files.c.

{
    DWORD size, handle;
    msi_disable_fs_redirection( package );
    if (buffer) size = GetFileVersionInfoW( path, 0, buflen, buffer );
    else size = GetFileVersionInfoSizeW( path, &handle );
    msi_revert_fs_redirection( package );
    return size;
}

Referenced by file_version_matches(), msi_get_disk_file_version(), and search_file().

◆ msi_get_filehash()

UINT msi_get_filehash	(	MSIPACKAGE *	package,
		const WCHAR *	path,
		MSIFILEHASHINFO *	hash
	)

Definition at line 4018 of file msi.c.

{
    HANDLE handle, mapping;
    void *p;
    DWORD length;
    UINT r = ERROR_FUNCTION_FAILED;
 
    if (package)
        handle = msi_create_file( package, path, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_DELETE, OPEN_EXISTING, 0 );
    else
        handle = CreateFileW( path, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_DELETE, NULL, OPEN_EXISTING, 0, NULL );
    if (handle == INVALID_HANDLE_VALUE)
    {
        WARN( "can't open file %lu\n", GetLastError() );
        return ERROR_FILE_NOT_FOUND;
    }
    if ((length = GetFileSize( handle, NULL )))
    {
        if ((mapping = CreateFileMappingW( handle, NULL, PAGE_READONLY, 0, 0, NULL )))
        {
            if ((p = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, length )))
            {
                struct md5_ctx ctx;
 
                MD5Init( &ctx );
                MD5Update( &ctx, p, length );
                MD5Final( &ctx );
                UnmapViewOfFile( p );
 
                memcpy( hash->dwData, ctx.digest, sizeof(hash->dwData) );
                r = ERROR_SUCCESS;
            }
            CloseHandle( mapping );
        }
    }
    else
    {
        /* Empty file -> set hash to 0 */
        memset( hash->dwData, 0, sizeof(hash->dwData) );
        r = ERROR_SUCCESS;
    }
 
    CloseHandle( handle );
    return r;
}

Referenced by file_hash_matches(), and MsiGetFileHashW().

◆ msi_get_font_file_version()

WCHAR * msi_get_font_file_version	(	MSIPACKAGE *	package,
		const WCHAR *	filename
	)

Definition at line 189 of file font.c.

{
    WCHAR *version, *p, *q, *ret = NULL;
 
    if ((version = load_ttf_name_id( package, filename, NAME_ID_VERSION )))
    {
        int len, major = 0, minor = 0;
        if ((p = wcschr( version, ';' ))) *p = 0;
        p = version;
        while (*p && !iswdigit( *p )) p++;
        if ((q = wcschr( p, '.' )))
        {
            major = wcstol( p, NULL, 10 );
            p = ++q;
            while (*q && iswdigit( *q )) q++;
            if (!*q || *q == ' ') minor = wcstol( p, NULL, 10 );
            else major = 0;
        }
        len = lstrlenW( L"%u.%u.0.0" ) + 20;
        ret = malloc( len * sizeof(WCHAR) );
        swprintf( ret, len, L"%u.%u.0.0", major, minor );
        free( version );
    }
    return ret;
}

Referenced by calculate_file_cost(), calculate_install_state(), and MsiGetFileVersionW().

◆ msi_get_loaded_component()

MSICOMPONENT * msi_get_loaded_component	(	MSIPACKAGE *	package,
		const WCHAR *	Component
	)

Definition at line 549 of file action.c.

{
    MSICOMPONENT *comp;
 
    LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
    {
        if (!wcscmp( Component, comp->Component )) return comp;
    }
    return NULL;
}

Referenced by deformat_component(), iterate_all_classes(), iterate_all_extensions(), ITERATE_CreateFolders(), ITERATE_CreateShortcuts(), ITERATE_DeleteService(), ITERATE_DuplicateFiles(), ITERATE_InstallODBCDataSource(), ITERATE_InstallODBCDriver(), ITERATE_InstallODBCTranslator(), ITERATE_InstallService(), iterate_load_featurecomponents(), ITERATE_MoveFiles(), iterate_patched_component(), ITERATE_PublishComponent(), ITERATE_RegisterFonts(), ITERATE_RegisterTypeLibraries(), ITERATE_RemoveDuplicateFiles(), ITERATE_RemoveEnvironmentString(), ITERATE_RemoveFiles(), ITERATE_RemoveFolders(), ITERATE_RemoveIniValuesOnInstall(), ITERATE_RemoveIniValuesOnUninstall(), ITERATE_RemoveODBCDataSource(), ITERATE_RemoveODBCDriver(), ITERATE_RemoveODBCTranslator(), ITERATE_RemoveRegistryValuesOnInstall(), ITERATE_RemoveRegistryValuesOnUninstall(), ITERATE_RemoveShortcuts(), ITERATE_StartService(), ITERATE_StopService(), ITERATE_UnpublishComponent(), ITERATE_UnregisterFonts(), ITERATE_UnregisterTypeLibraries(), ITERATE_WriteEnvironmentString(), ITERATE_WriteIniValues(), ITERATE_WriteRegistryValues(), load_class(), load_extension(), load_file(), MSI_GetComponentStateW(), MSI_SetComponentStateW(), and MsiEnumComponentCostsW().

◆ msi_get_loaded_feature()

MSIFEATURE * msi_get_loaded_feature	(	MSIPACKAGE *	package,
		const WCHAR *	Feature
	)

Definition at line 560 of file action.c.

{
    MSIFEATURE *feature;
 
    LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
    {
        if (!wcscmp( Feature, feature->Feature )) return feature;
    }
    return NULL;
}

Referenced by find_feature_children(), ITERATE_CostFinalizeConditions(), ITERATE_PublishComponent(), ITERATE_UnpublishComponent(), load_class(), load_extension(), MSI_GetFeatureCost(), MSI_GetFeatureInfo(), MSI_GetFeatureStateW(), msi_install_assembly(), MSI_SetFeatureStates(), MSI_SetFeatureStateW(), msi_uninstall_assembly(), MsiGetFeatureCostW(), and MsiSetFeatureAttributesW().

◆ msi_get_loaded_file()

MSIFILE * msi_get_loaded_file	(	MSIPACKAGE *	package,
		const WCHAR *	file
	)

Definition at line 571 of file action.c.

{
    MSIFILE *file;
 
    LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
    {
        if (!wcscmp( key, file->File )) return file;
    }
    return NULL;
}

Referenced by ACTION_MsiPublishAssemblies(), ACTION_MsiUnpublishAssemblies(), ACTION_ProcessComponents(), ACTION_RegisterClassInfo(), deformat_file(), HANDLE_CustomType17(), HANDLE_CustomType18(), HANDLE_CustomType21_22(), ITERATE_BindImage(), ITERATE_DuplicateFiles(), ITERATE_InstallODBCDriver(), ITERATE_InstallODBCTranslator(), ITERATE_InstallService(), ITERATE_RegisterFonts(), ITERATE_RegisterTypeLibraries(), ITERATE_RemoveDuplicateFiles(), ITERATE_SelfRegModules(), ITERATE_SelfUnregModules(), ITERATE_UnregisterFonts(), load_patch(), msi_install_assembly(), MsiEnumComponentCostsW(), and resolve_keypath().

◆ msi_get_loaded_folder()

MSIFOLDER * msi_get_loaded_folder	(	MSIPACKAGE *	package,
		const WCHAR *	dir
	)

Definition at line 582 of file action.c.

{
    MSIFOLDER *folder;
 
    LIST_FOR_EACH_ENTRY( folder, &package->folders, MSIFOLDER, entry )
    {
        if (!wcscmp( dir, folder->Directory )) return folder;
    }
    return NULL;
}

Referenced by ACTION_RemoveFiles(), create_folder(), dialog_seltree_handler(), find_folder_children(), ITERATE_CreateFolders(), ITERATE_RemoveFolders(), msi_get_target_folder(), msi_resolve_source_folder(), msi_resolve_target_folder(), and MSI_SetTargetPathW().

◆ msi_get_package_code()

WCHAR * msi_get_package_code ( MSIDATABASE * db )

Definition at line 1309 of file package.c.

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

Referenced by ACTION_PublishProduct(), and publish_product_properties().

◆ msi_get_property()

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

Definition at line 2282 of file package.c.

{
    MSIRECORD *row;
    UINT rc = ERROR_FUNCTION_FAILED;
 
    TRACE("%p %s %p %p\n", db, debugstr_w(szName), szValueBuf, pchValueBuf);
 
    row = get_property_row( db, szName );
 
    if (*pchValueBuf > 0)
        szValueBuf[0] = 0;
 
    if (row)
    {
        rc = MSI_RecordGetStringW(row, 1, szValueBuf, pchValueBuf);
        msiobj_release(&row->hdr);
    }
 
    if (rc == ERROR_SUCCESS)
        TRACE("returning %s for property %s\n", debugstr_wn(szValueBuf, *pchValueBuf),
            debugstr_w(szName));
    else if (rc == ERROR_MORE_DATA)
        TRACE( "need %lu sized buffer for %s\n", *pchValueBuf, debugstr_w(szName) );
    else
    {
        *pchValueBuf = 0;
        TRACE("property %s not found\n", debugstr_w(szName));
    }
 
    return rc;
}

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

◆ msi_get_property_int()

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

Definition at line 2337 of file package.c.

{
    LPWSTR str = msi_dup_property( db, prop );
    int val = str ? wcstol(str, NULL, 10) : def;
    free(str);
    return val;
}

Referenced by ACTION_AllocateRegistrySpace(), ACTION_CostFinalize(), ACTION_FindRelatedProducts(), ACTION_InstallFiles(), ACTION_MigrateFeatureStates(), ACTION_RegisterProduct(), dialog_adjust_dialog_pos(), get_root_key(), is_obsoleted_by_patch(), msi_adjust_privilege_properties(), MSI_InstallPackage(), msi_set_context(), MSI_SetFeatureStates(), MsiEnumComponentCostsW(), MsiGetLanguage(), MsiGetMode(), publish_install_properties(), and publish_product_properties().

◆ msi_get_remote()

MSIHANDLE msi_get_remote ( MSIHANDLE handle )

Definition at line 183 of file handle.c.

{
    MSIHANDLE ret = 0;
 
    EnterCriticalSection( &handle_cs );
    handle--;
    if (handle >= handle_table_size)
        goto out;
    if (!handle_table[handle].remote)
        goto out;
    ret = handle_table[handle].u.rem;
 
out:
    LeaveCriticalSection( &handle_cs );
 
    return ret;
}

Referenced by MsiDatabaseCommit(), MsiDatabaseGetPrimaryKeysW(), MsiDatabaseIsTablePersistentW(), MsiDatabaseOpenViewW(), MsiDoActionW(), MsiEnumComponentCostsW(), MsiFormatRecordA(), MsiFormatRecordW(), MsiGetActiveDatabase(), MsiGetComponentStateW(), MsiGetFeatureCostW(), MsiGetFeatureStateW(), MsiGetLanguage(), MsiGetMode(), MsiGetPropertyA(), MsiGetPropertyW(), MsiGetSourcePathA(), MsiGetSourcePathW(), MsiGetSummaryInformationW(), MsiGetTargetPathA(), MsiGetTargetPathW(), MsiProcessMessage(), MsiSequenceW(), MsiSetComponentStateW(), MsiSetFeatureStateW(), MsiSetInstallLevel(), MsiSetMode(), MsiSetPropertyW(), MsiSetTargetPathW(), MsiSummaryInfoGetPropertyA(), MsiSummaryInfoGetPropertyCount(), MsiSummaryInfoGetPropertyW(), MsiSummaryInfoSetPropertyA(), MsiSummaryInfoSetPropertyW(), MsiViewClose(), MsiViewExecute(), MsiViewFetch(), MsiViewGetColumnInfo(), MsiViewGetErrorA(), MsiViewGetErrorW(), and MsiViewModify().

◆ msi_get_stream()

UINT msi_get_stream	(	MSIDATABASE *	db,
		const WCHAR *	name,
		IStream **	ret
	)

Definition at line 499 of file streams.c.

{
    MSISTREAM *stream;
    WCHAR *encname;
    HRESULT hr;
    UINT r;
 
    if ((stream = find_stream( db, name )))
    {
        LARGE_INTEGER pos;
 
        pos.QuadPart = 0;
        hr = IStream_Seek( stream->stream, pos, STREAM_SEEK_SET, NULL );
        if (FAILED( hr ))
            return ERROR_FUNCTION_FAILED;
 
        *ret = stream->stream;
        IStream_AddRef( *ret );
        return ERROR_SUCCESS;
    }
 
    if (!(encname = encode_streamname( FALSE, name )))
        return ERROR_OUTOFMEMORY;
 
    hr = open_stream( db, encname, ret );
    free( encname );
    if (FAILED( hr ))
        return ERROR_FUNCTION_FAILED;
 
    r = append_stream( db, name, *ret );
    if (r != ERROR_SUCCESS)
    {
        IStream_Release( *ret );
        return r;
    }
 
    IStream_AddRef( *ret );
    return ERROR_SUCCESS;
}

Referenced by cabinet_open_stream(), msi_get_db_suminfo(), and TABLE_fetch_stream().

◆ msi_get_string_table_codepage()

UINT msi_get_string_table_codepage ( const string_table * st )

Definition at line 671 of file string.c.

{
    return st->codepage;
}

Referenced by ACTION_ExecuteAction(), MSI_DatabaseExport(), and MSI_OpenPackageW().

◆ msi_get_suminfo()

UINT msi_get_suminfo	(	IStorage *	stg,
		UINT	uiUpdateCount,
		MSISUMMARYINFO **	si
	)

Definition at line 461 of file suminfo.c.

{
    IStream *stm;
    MSISUMMARYINFO *si;
    HRESULT hr;
    UINT r;
 
    TRACE("%p, %u\n", stg, uiUpdateCount);
 
    if (!(si = create_suminfo( stg, uiUpdateCount ))) return ERROR_OUTOFMEMORY;
 
    hr = IStorage_OpenStream( si->storage, L"\5SummaryInformation", 0, STGM_READ|STGM_SHARE_EXCLUSIVE, 0, &stm );
    if (FAILED( hr ))
    {
        msiobj_release( &si->hdr );
        return ERROR_FUNCTION_FAILED;
    }
 
    r = load_summary_info( si, stm );
    IStream_Release( stm );
    if (r != ERROR_SUCCESS)
    {
        msiobj_release( &si->hdr );
        return r;
    }
 
    *ret = si;
    return ERROR_SUCCESS;
}

Referenced by admin_update_package_info(), apply_patch_package(), check_transform_applicable(), msi_add_suminfo(), MSI_ApplicablePatchW(), msi_apply_registered_patch(), msi_export_suminfo(), msi_get_package_code(), msi_get_suminfo_product(), msi_load_suminfo_properties(), MSI_OpenPackageW(), and MsiGetSummaryInformationW().

◆ msi_get_suminfo_product()

WCHAR * msi_get_suminfo_product ( IStorage * stg )

Definition at line 724 of file suminfo.c.

{
    MSISUMMARYINFO *si;
    LPWSTR prod;
    UINT r;
 
    r = msi_get_suminfo( stg, 0, &si );
    if (r != ERROR_SUCCESS)
    {
        ERR("no summary information!\n");
        return NULL;
    }
    prod = msi_suminfo_dup_string( si, PID_REVNUMBER );
    msiobj_release( &si->hdr );
    return prod;
}

Referenced by check_transform_applicable().

◆ 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_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_get_temp_file_name()

BOOL msi_get_temp_file_name	(	MSIPACKAGE *	package,
		const WCHAR *	tmp_path,
		const WCHAR *	prefix,
		WCHAR *	tmp_filename
	)

Definition at line 51 of file files.c.

{
    BOOL ret;
    msi_disable_fs_redirection( package );
    ret = GetTempFileNameW( tmp_path, prefix, 0, tmp_filename );
    msi_revert_fs_redirection( package );
    return ret;
}

Referenced by ACTION_InstallAdminPackage(), and cabinet_copy_file().

◆ MSI_GetComponentStateW()

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

Definition at line 1430 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 1158 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;
    }
 
    return ERROR_SUCCESS;
}

Referenced by MsiGetFeatureCostW(), and vcl_get_cost().

◆ MSI_GetFeatureStateW()

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

Definition at line 1068 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_init_string_table()

HRESULT msi_init_string_table ( IStorage * stg )

Definition at line 460 of file string.c.

{
    USHORT zero[2] = { 0, 0 };
    UINT ret;
 
    /* create the StringPool stream... add the zero string to it*/
    ret = write_stream_data(stg, L"_StringPool", zero, sizeof zero, TRUE);
    if (ret != ERROR_SUCCESS)
        return E_FAIL;
 
    /* create the StringData stream... make it zero length */
    ret = write_stream_data(stg, L"_StringData", NULL, 0, TRUE);
    if (ret != ERROR_SUCCESS)
        return E_FAIL;
 
    return S_OK;
}

Referenced by db_initialize().

◆ msi_install_assembly()

UINT msi_install_assembly	(	MSIPACKAGE *	package,
		MSICOMPONENT *	comp
	)

Definition at line 356 of file assembly.c.

{
    HRESULT hr;
    const WCHAR *manifest;
    IAssemblyCache *cache;
    MSIASSEMBLY *assembly = comp->assembly;
    MSIFEATURE *feature = NULL;
 
    if (!init_assembly_caches( package )) return ERROR_FUNCTION_FAILED;
 
    if (comp->assembly->feature)
        feature = msi_get_loaded_feature( package, comp->assembly->feature );
 
    if (assembly->application)
    {
        if (feature) feature->Action = INSTALLSTATE_LOCAL;
        return ERROR_SUCCESS;
    }
    if (assembly->attributes == msidbAssemblyAttributesWin32)
    {
        if (!assembly->manifest)
        {
            WARN("no manifest\n");
            return ERROR_FUNCTION_FAILED;
        }
        manifest = msi_get_loaded_file( package, assembly->manifest )->TargetPath;
        cache = package->cache_sxs;
    }
    else
    {
        manifest = msi_get_loaded_file( package, comp->KeyPath )->TargetPath;
        cache = package->cache_net[get_clr_version( package, manifest )];
        if (!cache) return ERROR_SUCCESS;
    }
    TRACE("installing assembly %s\n", debugstr_w(manifest));
 
    hr = IAssemblyCache_InstallAssembly( cache, 0, manifest, NULL );
    if (hr != S_OK)
    {
        ERR( "failed to install assembly %s (%#lx)\n", debugstr_w(manifest), hr );
        return ERROR_FUNCTION_FAILED;
    }
    if (feature) feature->Action = INSTALLSTATE_LOCAL;
    return ERROR_SUCCESS;
}

Referenced by ACTION_InstallFinalize().

◆ MSI_InstallPackage()

UINT MSI_InstallPackage	(	MSIPACKAGE *	package,
		LPCWSTR	szPackagePath,
		LPCWSTR	szCommandLine
	)

Definition at line 7917 of file action.c.

{
    WCHAR *reinstall = NULL, *productcode, *action;
    UINT rc;
    DWORD len = 0;
 
    if (szPackagePath)
    {
        LPWSTR p, dir;
        LPCWSTR file;
 
        dir = wcsdup(szPackagePath);
        p = wcsrchr(dir, '\\');
        if (p)
        {
            *(++p) = 0;
            file = szPackagePath + (p - dir);
        }
        else
        {
            free(dir);
            dir = malloc(MAX_PATH * sizeof(WCHAR));
            GetCurrentDirectoryW(MAX_PATH, dir);
            lstrcatW(dir, L"\\");
            file = szPackagePath;
        }
 
        free(package->PackagePath);
        package->PackagePath = malloc((wcslen(dir) + wcslen(file) + 1) * sizeof(WCHAR));
        if (!package->PackagePath)
        {
            free(dir);
            return ERROR_OUTOFMEMORY;
        }
 
        lstrcpyW(package->PackagePath, dir);
        lstrcatW(package->PackagePath, file);
        free(dir);
 
        msi_set_sourcedir_props(package, FALSE);
    }
 
    rc = msi_parse_command_line( package, szCommandLine, FALSE );
    if (rc != ERROR_SUCCESS)
        return rc;
 
    msi_apply_transforms( package );
    msi_apply_patches( package );
 
    if (msi_get_property( package->db, L"ACTION", NULL, &len ))
        msi_set_property( package->db, L"ACTION", L"INSTALL", -1 );
    action = msi_dup_property( package->db, L"ACTION" );
    CharUpperW(action);
 
    msi_set_original_database_property( package->db, szPackagePath );
    msi_parse_command_line( package, szCommandLine, FALSE );
    msi_adjust_privilege_properties( package );
    msi_set_context( package );
 
    productcode = msi_dup_property( package->db, L"ProductCode" );
    if (wcsicmp( productcode, package->ProductCode ))
    {
        TRACE( "product code changed %s -> %s\n", debugstr_w(package->ProductCode), debugstr_w(productcode) );
        free( package->ProductCode );
        package->ProductCode = productcode;
    }
    else free( productcode );
 
    if (msi_get_property_int( package->db, L"DISABLEROLLBACK", 0 ))
    {
        TRACE("disabling rollback\n");
        msi_set_property( package->db, L"RollbackDisabled", L"1", -1 );
    }
 
    rc = ACTION_PerformAction(package, action);
 
    /* process the ending type action */
    if (rc == ERROR_SUCCESS)
        ACTION_PerformEndAction(package, action, -1);
    else if (rc == ERROR_INSTALL_USEREXIT)
        ACTION_PerformEndAction(package, action, -2);
    else if (rc == ERROR_INSTALL_SUSPEND)
        ACTION_PerformEndAction(package, action, -4);
    else  /* failed */
    {
        ACTION_PerformEndAction(package, action, -3);
        if (!msi_get_property_int( package->db, L"RollbackDisabled", 0 ))
        {
            package->need_rollback = TRUE;
        }
    }
 
    /* finish up running custom actions */
    ACTION_FinishCustomActions(package);
 
    if (package->need_rollback && !(reinstall = msi_dup_property( package->db, L"REINSTALL" )))
    {
        WARN("installation failed, running rollback script\n");
        execute_script( package, SCRIPT_ROLLBACK );
    }
    free( reinstall );
    free( action );
 
    if (rc == ERROR_SUCCESS && package->need_reboot_at_end)
        return ERROR_SUCCESS_REBOOT_REQUIRED;
 
    return rc;
}

Referenced by MsiConfigureFeatureW(), MsiConfigureProductExW(), MsiInstallProductW(), and MsiReinstallFeatureW().

◆ msi_is_global_assembly()

BOOL msi_is_global_assembly ( MSICOMPONENT * comp )

Definition at line 2035 of file action.c.

{
    return comp->assembly && !comp->assembly->application;
}

Referenced by ACTION_InstallFiles(), ACTION_InstallFinalize(), ACTION_PatchFiles(), free_package_structures(), installfiles_cb(), MSI_SetTargetPathW(), MsiEnumComponentCostsW(), and set_target_path().

◆ MSI_IterateRecords()

UINT MSI_IterateRecords	(	MSIQUERY *	view,
		LPDWORD	count,
		record_func	func,
		LPVOID	param
	)

Definition at line 163 of file msiquery.c.

{
    MSIRECORD *rec = NULL;
    UINT r, n = 0, max = 0;
 
    r = MSI_ViewExecute( view, NULL );
    if( r != ERROR_SUCCESS )
        return r;
 
    if( count )
        max = *count;
 
    /* iterate a query */
    for( n = 0; (max == 0) || (n < max); n++ )
    {
        r = MSI_ViewFetch( view, &rec );
        if( r != ERROR_SUCCESS )
            break;
        if (func)
            r = func( rec, param );
        msiobj_release( &rec->hdr );
        if( r != ERROR_SUCCESS )
            break;
    }
 
    MSI_ViewClose( view );
 
    if( count )
        *count = n;
 
    if( r == ERROR_NO_MORE_ITEMS )
        r = ERROR_SUCCESS;
 
    return r;
}

Referenced by ACTION_AppSearch(), ACTION_BindImage(), ACTION_CCPSearch(), ACTION_CostFinalize(), ACTION_CreateFolders(), ACTION_CreateShortcuts(), ACTION_DeleteServices(), ACTION_DuplicateFiles(), ACTION_ExecuteAction(), ACTION_FindRelatedProducts(), ACTION_InstallODBC(), ACTION_InstallServices(), ACTION_InstallValidate(), ACTION_LaunchConditions(), ACTION_MigrateFeatureStates(), ACTION_MoveFiles(), ACTION_ProcessExecSequence(), ACTION_ProcessUISequence(), ACTION_PublishComponents(), ACTION_RegisterFonts(), ACTION_RegisterTypeLibraries(), ACTION_RemoveDuplicateFiles(), ACTION_RemoveEnvironmentStrings(), ACTION_RemoveExistingProducts(), ACTION_RemoveFiles(), ACTION_RemoveFolders(), ACTION_RemoveIniValues(), ACTION_RemoveODBC(), ACTION_RemoveRegistryValues(), ACTION_RemoveShortcuts(), ACTION_SelfRegModules(), ACTION_SelfUnregModules(), ACTION_SetODBCFolders(), ACTION_StartServices(), ACTION_StopServices(), ACTION_UnpublishComponents(), ACTION_UnregisterFonts(), ACTION_UnregisterTypeLibraries(), ACTION_WriteEnvironmentStrings(), ACTION_WriteIniValues(), ACTION_WriteRegistryValues(), combobox_add_items(), dialog_build_font_list(), dialog_button_handler(), dialog_evaluate_control_conditions(), dialog_fill_controls(), dialog_map_events(), dialog_radiogroup_control(), gather_merge_data(), get_assembly_display_name(), listbox_add_items(), listview_add_items(), load_all_classes(), load_all_drlocators(), load_all_extensions(), load_all_files(), load_all_folders(), load_all_media(), load_all_mimes(), load_all_patches(), load_all_progids(), load_all_verbs(), load_feature(), mark_patched_components(), merge_diff_tables(), MSI_DatabaseExport(), MSI_DatabaseGetPrimaryKeys(), msi_load_all_components(), msi_load_all_features(), MSI_Sequence(), publish_icons(), ui_sequence_exists(), unimplemented_action_stub(), and unpublish_icons().

◆ msi_load_all_components()

UINT msi_load_all_components ( MSIPACKAGE * package )

Definition at line 806 of file action.c.

{
    MSIQUERY *view;
    UINT r;
 
    if (!list_empty(&package->components))
        return ERROR_SUCCESS;
 
    r = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `Component`", &view );
    if (r != ERROR_SUCCESS)
        return r;
 
    r = MSI_IterateRecords(view, NULL, load_component, package);
    msiobj_release(&view->hdr);
    return r;
}

Referenced by ACTION_CostInitialize(), and MsiGetFeatureInfoW().

◆ msi_load_all_features()

UINT msi_load_all_features ( MSIPACKAGE * package )

Definition at line 949 of file action.c.

{
    MSIQUERY *view;
    UINT r;
 
    if (!list_empty(&package->features))
        return ERROR_SUCCESS;
 
    r = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `Feature` ORDER BY `Display`", &view );
    if (r != ERROR_SUCCESS)
        return r;
 
    r = MSI_IterateRecords( view, NULL, load_feature, package );
    if (r != ERROR_SUCCESS)
    {
        msiobj_release( &view->hdr );
        return r;
    }
    r = MSI_IterateRecords( view, NULL, find_feature_children, package );
    msiobj_release( &view->hdr );
    return r;
}

Referenced by ACTION_CostInitialize(), and MsiGetFeatureInfoW().

◆ msi_load_assembly()

MSIASSEMBLY * msi_load_assembly	(	MSIPACKAGE *	package,
		MSICOMPONENT *	comp
	)

Definition at line 292 of file assembly.c.

{
    MSIRECORD *rec;
    MSIASSEMBLY *a;
 
    if (!(rec = get_assembly_record( package, comp->Component ))) return NULL;
    if (!(a = calloc( 1, sizeof(MSIASSEMBLY) )))
    {
        msiobj_release( &rec->hdr );
        return NULL;
    }
    a->feature = wcsdup( MSI_RecordGetString( rec, 2 ) );
    TRACE("feature %s\n", debugstr_w(a->feature));
 
    a->manifest = wcsdup( MSI_RecordGetString( rec, 3 ) );
    TRACE("manifest %s\n", debugstr_w(a->manifest));
 
    a->application = wcsdup( MSI_RecordGetString( rec, 4 ) );
    TRACE("application %s\n", debugstr_w(a->application));
 
    a->attributes = MSI_RecordGetInteger( rec, 5 );
    TRACE( "attributes %lu\n", a->attributes );
 
    if (!(a->display_name = get_assembly_display_name( package->db, comp->Component, a )))
    {
        WARN("can't get display name\n");
        msiobj_release( &rec->hdr );
        free( a->feature );
        free( a->manifest );
        free( a->application );
        free( a );
        return NULL;
    }
    TRACE("display name %s\n", debugstr_w(a->display_name));
 
    msiobj_release( &rec->hdr );
    return a;
}

Referenced by load_component().

◆ msi_load_media_info()

UINT msi_load_media_info	(	MSIPACKAGE *	package,
		UINT	Sequence,
		MSIMEDIAINFO *	mi
	)

Definition at line 677 of file media.c.

{
    MSIRECORD *row;
    WCHAR *source_dir, *source, *base_url = NULL;
    DWORD options;
 
    if (Sequence <= mi->last_sequence) /* already loaded */
        return ERROR_SUCCESS;
 
    row = MSI_QueryGetRecord(package->db, L"SELECT * FROM `Media` WHERE `LastSequence` >= %d ORDER BY `DiskId`", Sequence);
    if (!row)
    {
        TRACE("Unable to query row\n");
        return ERROR_FUNCTION_FAILED;
    }
 
    mi->is_extracted = FALSE;
    mi->disk_id = MSI_RecordGetInteger(row, 1);
    mi->last_sequence = MSI_RecordGetInteger(row, 2);
    free(mi->disk_prompt);
    mi->disk_prompt = wcsdup(MSI_RecordGetString(row, 3));
    free(mi->cabinet);
    mi->cabinet = wcsdup(MSI_RecordGetString(row, 4));
    free(mi->volume_label);
    mi->volume_label = wcsdup(MSI_RecordGetString(row, 5));
    msiobj_release(&row->hdr);
 
    msi_set_sourcedir_props(package, FALSE);
    source_dir = msi_dup_property(package->db, L"SourceDir");
    lstrcpyW(mi->sourcedir, source_dir);
    PathAddBackslashW(mi->sourcedir);
    mi->type = get_drive_type(source_dir);
 
    options = MSICODE_PRODUCT;
    if (mi->type == DRIVE_CDROM || mi->type == DRIVE_REMOVABLE)
    {
        source = source_dir;
        options |= MSISOURCETYPE_MEDIA;
    }
    else if ((base_url = get_base_url(package->db)))
    {
        source = base_url;
        options |= MSISOURCETYPE_URL;
    }
    else
    {
        source = mi->sourcedir;
        options |= MSISOURCETYPE_NETWORK;
    }
 
    msi_package_add_media_disk(package, package->Context,
                               MSICODE_PRODUCT, mi->disk_id,
                               mi->volume_label, mi->disk_prompt);
 
    msi_package_add_info(package, package->Context,
                         options, INSTALLPROPERTY_LASTUSEDSOURCEW, source);
 
    TRACE("sequence %u -> cabinet %s disk id %u\n", Sequence, debugstr_w(mi->cabinet), mi->disk_id);
 
    free(base_url);
    free(source_dir);
    return ERROR_SUCCESS;
}

Referenced by ACTION_InstallFiles(), and ACTION_PatchFiles().

◆ msi_load_string_table()

string_table * msi_load_string_table	(	IStorage *	stg,
		UINT *	bytes_per_strref
	)

Definition at line 478 of file string.c.

{
    string_table *st = NULL;
    CHAR *data = NULL;
    USHORT *pool = NULL;
    UINT r, datasize = 0, poolsize = 0, codepage;
    DWORD i, count, offset, len, n, refs;
 
    r = read_stream_data( stg, L"_StringPool", TRUE, (BYTE **)&pool, &poolsize );
    if( r != ERROR_SUCCESS)
        goto end;
    r = read_stream_data( stg, L"_StringData", TRUE, (BYTE **)&data, &datasize );
    if( r != ERROR_SUCCESS)
        goto end;
 
    if ( (poolsize > 4) && (pool[1] & 0x8000) )
        *bytes_per_strref = LONG_STR_BYTES;
    else
        *bytes_per_strref = sizeof(USHORT);
 
    count = poolsize/4;
    if( poolsize > 4 )
        codepage = pool[0] | ( (pool[1] & ~0x8000) << 16 );
    else
        codepage = CP_ACP;
    st = init_stringtable( count, codepage );
    if (!st)
        goto end;
 
    offset = 0;
    n = 1;
    i = 1;
    while( i<count )
    {
        /* the string reference count is always the second word */
        refs = pool[i*2+1];
 
        /* empty entries have two zeros, still have a string id */
        if (pool[i*2] == 0 && refs == 0)
        {
            i++;
            n++;
            continue;
        }
 
        /*
         * If a string is over 64k, the previous string entry is made null
         * and its the high word of the length is inserted in the null string's
         * reference count field.
         */
        if( pool[i*2] == 0)
        {
            len = (pool[i*2+3] << 16) + pool[i*2+2];
            i += 2;
        }
        else
        {
            len = pool[i*2];
            i += 1;
        }
 
        if ( (offset + len) > datasize )
        {
            ERR("string table corrupt?\n");
            break;
        }
 
        r = add_string( st, n, data+offset, len, refs, TRUE );
        if( r != n )
            ERR( "Failed to add string %lu\n", n );
        n++;
        offset += len;
    }
 
    if ( datasize != offset )
        ERR( "string table load failed! (%u != %lu), please report\n", datasize, offset );
 
    TRACE( "loaded %lu strings\n", count );
 
end:
    free( pool );
    free( data );
 
    return st;
}

Referenced by MSI_OpenDatabaseW(), and msi_table_apply_transform().

◆ msi_load_suminfo_properties()

UINT msi_load_suminfo_properties ( MSIPACKAGE * package )

Definition at line 1266 of file suminfo.c.

{
    MSISUMMARYINFO *si;
    WCHAR *package_code;
    UINT r;
    DWORD len;
    awstring str;
    INT count;
 
    r = msi_get_suminfo( package->db->storage, 0, &si );
    if (r != ERROR_SUCCESS)
    {
        r = msi_get_db_suminfo( package->db, 0, &si );
        if (r != ERROR_SUCCESS)
        {
            ERR("Unable to open summary information stream %u\n", r);
            return r;
        }
    }
 
    str.unicode = TRUE;
    str.str.w = NULL;
    len = 0;
    r = msi_suminfo_get_prop( si, PID_REVNUMBER, NULL, NULL, NULL, &str, &len );
    if (r != ERROR_MORE_DATA)
    {
        WARN("Unable to query revision number %u\n", r);
        msiobj_release( &si->hdr );
        return ERROR_FUNCTION_FAILED;
    }
 
    len++;
    if (!(package_code = malloc( len * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
    str.str.w = package_code;
 
    r = msi_suminfo_get_prop( si, PID_REVNUMBER, NULL, NULL, NULL, &str, &len );
    if (r != ERROR_SUCCESS)
    {
        free( package_code );
        msiobj_release( &si->hdr );
        return r;
    }
 
    r = msi_set_property( package->db, L"PackageCode", package_code, len );
    free( package_code );
 
    count = 0;
    msi_suminfo_get_prop( si, PID_WORDCOUNT, NULL, &count, NULL, NULL, NULL );
    package->WordCount = count;
 
    msiobj_release( &si->hdr );
    return r;
}

Referenced by MSI_CreatePackage().

◆ msi_locate_product()

UINT msi_locate_product	(	LPCWSTR	szProduct,
		MSIINSTALLCONTEXT *	context
	)

Definition at line 54 of file msi.c.

{
    HKEY hkey = NULL;
 
    *context = MSIINSTALLCONTEXT_NONE;
    if (!szProduct) return ERROR_UNKNOWN_PRODUCT;
 
    if (MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_USERMANAGED,
                              &hkey, FALSE) == ERROR_SUCCESS)
        *context = MSIINSTALLCONTEXT_USERMANAGED;
    else if (MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_MACHINE,
                                   &hkey, FALSE) == ERROR_SUCCESS)
        *context = MSIINSTALLCONTEXT_MACHINE;
    else if (MSIREG_OpenProductKey(szProduct, NULL,
                                   MSIINSTALLCONTEXT_USERUNMANAGED,
                                   &hkey, FALSE) == ERROR_SUCCESS)
        *context = MSIINSTALLCONTEXT_USERUNMANAGED;
 
    RegCloseKey(hkey);
 
    if (*context == MSIINSTALLCONTEXT_NONE)
        return ERROR_UNKNOWN_PRODUCT;
 
    return ERROR_SUCCESS;
}

Referenced by get_registered_local_package(), MSI_OpenPackageW(), MSI_OpenProductW(), MSI_ProvideQualifiedComponentEx(), msi_set_context(), MsiConfigureProductExW(), and MsiReinstallFeatureW().

◆ msi_move_file()

BOOL msi_move_file	(	MSIPACKAGE *	package,
		const WCHAR *	from,
		const WCHAR *	to,
		DWORD	flags
	)

Definition at line 142 of file files.c.

{
    BOOL ret;
    msi_disable_fs_redirection( package );
    ret = MoveFileExW( from, to, flags );
    msi_revert_fs_redirection( package );
    return ret;
}

Referenced by cabinet_copy_file(), copy_install_file(), move_file(), and patch_file().

◆ msi_normalize_path()

WCHAR * msi_normalize_path ( const WCHAR * in )

Definition at line 2115 of file action.c.

{
    const WCHAR *p = in;
    WCHAR *q, *ret;
    int n, len = lstrlenW( in ) + 2;
 
    if (!(q = ret = malloc( len * sizeof(WCHAR) ))) return NULL;
 
    len = 0;
    while (1)
    {
        /* copy until the end of the string or a space */
        while (*p != ' ' && (*q = *p))
        {
            p++, len++;
            /* reduce many backslashes to one */
            if (*p != '\\' || *q != '\\')
                q++;
        }
 
        /* quit at the end of the string */
        if (!*p)
            break;
 
        /* count the number of spaces */
        n = 0;
        while (p[n] == ' ')
            n++;
 
        /* if it's leading or trailing space, skip it */
        if ( len == 0 || p[-1] == '\\' || p[n] == '\\' )
            p += n;
        else  /* copy n spaces */
            while (n && (*q++ = *p++)) n--;
    }
    while (q - ret > 0 && q[-1] == ' ') q--;
    if (q - ret > 0 && q[-1] != '\\')
    {
        q[0] = '\\';
        q[1] = 0;
    }
    return ret;
}

Referenced by msi_resolve_target_folder(), and set_target_path().

◆ MSI_OpenDatabaseW()

UINT MSI_OpenDatabaseW	(	LPCWSTR	szDBPath,
		LPCWSTR	szPersist,
		MSIDATABASE **	pdb
	)

Definition at line 140 of file database.c.

{
    IStorage *stg = NULL;
    HRESULT r;
    MSIDATABASE *db = NULL;
    UINT ret = ERROR_FUNCTION_FAILED;
    LPCWSTR save_path;
    UINT mode;
    STATSTG stat;
    BOOL created = FALSE, patch = FALSE;
    WCHAR path[MAX_PATH];
 
    TRACE("%s %s\n",debugstr_w(szDBPath),debugstr_w(szPersist) );
 
    if( !pdb )
        return ERROR_INVALID_PARAMETER;
 
    save_path = szDBPath;
    if ( IS_INTMSIDBOPEN(szPersist) )
    {
        mode = LOWORD(szPersist);
    }
    else
    {
        if (!CopyFileW( szDBPath, szPersist, FALSE ))
            return ERROR_OPEN_FAILED;
 
        szDBPath = szPersist;
        mode = MSI_OPEN_TRANSACT;
        created = TRUE;
    }
 
    if ((mode & MSI_OPEN_PATCHFILE) == MSI_OPEN_PATCHFILE)
    {
        TRACE("Database is a patch\n");
        mode &= ~MSI_OPEN_PATCHFILE;
        patch = TRUE;
    }
 
    if( mode == MSI_OPEN_READONLY )
    {
        r = StgOpenStorage( szDBPath, NULL,
              STGM_DIRECT|STGM_READ|STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
    }
    else if( mode == MSI_OPEN_CREATE )
    {
        r = StgCreateDocfile( szDBPath,
              STGM_CREATE|STGM_TRANSACTED|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, 0, &stg );
 
        if( SUCCEEDED(r) )
            r = db_initialize( stg, patch ? &CLSID_MsiPatch : &CLSID_MsiDatabase );
        created = TRUE;
    }
    else if( mode == MSI_OPEN_CREATEDIRECT )
    {
        r = StgCreateDocfile( szDBPath,
              STGM_CREATE|STGM_DIRECT|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, 0, &stg );
 
        if( SUCCEEDED(r) )
            r = db_initialize( stg, patch ? &CLSID_MsiPatch : &CLSID_MsiDatabase );
        created = TRUE;
    }
    else if( mode == MSI_OPEN_TRANSACT )
    {
        r = StgOpenStorage( szDBPath, NULL,
              STGM_TRANSACTED|STGM_READWRITE|STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
    }
    else if( mode == MSI_OPEN_DIRECT )
    {
        r = StgOpenStorage( szDBPath, NULL,
              STGM_DIRECT|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, NULL, 0, &stg);
    }
    else
    {
        ERR("unknown flag %x\n",mode);
        return ERROR_INVALID_PARAMETER;
    }
 
    if( FAILED( r ) || !stg )
    {
        WARN("open failed r = %#lx for %s\n", r, debugstr_w(szDBPath));
        return ERROR_FUNCTION_FAILED;
    }
 
    r = IStorage_Stat( stg, &stat, STATFLAG_NONAME );
    if( FAILED( r ) )
    {
        FIXME("Failed to stat storage\n");
        goto end;
    }
 
    if ( !IsEqualGUID( &stat.clsid, &CLSID_MsiDatabase ) &&
         !IsEqualGUID( &stat.clsid, &CLSID_MsiPatch ) &&
         !IsEqualGUID( &stat.clsid, &CLSID_MsiTransform ) )
    {
        ERR("storage GUID is not a MSI database GUID %s\n",
             debugstr_guid(&stat.clsid) );
        goto end;
    }
 
    if ( patch && !IsEqualGUID( &stat.clsid, &CLSID_MsiPatch ) )
    {
        ERR("storage GUID is not the MSI patch GUID %s\n",
             debugstr_guid(&stat.clsid) );
        ret = ERROR_OPEN_FAILED;
        goto end;
    }
 
    db = alloc_msiobject( MSIHANDLETYPE_DATABASE, sizeof (MSIDATABASE),
                              MSI_CloseDatabase );
    if( !db )
    {
        FIXME("Failed to allocate a handle\n");
        goto end;
    }
 
    if (!wcschr( save_path, '\\' ))
    {
        GetCurrentDirectoryW( MAX_PATH, path );
        lstrcatW( path, L"\\" );
        lstrcatW( path, save_path );
    }
    else
        lstrcpyW( path, save_path );
 
    db->path = wcsdup( path );
    db->media_transform_offset = MSI_INITIAL_MEDIA_TRANSFORM_OFFSET;
    db->media_transform_disk_id = MSI_INITIAL_MEDIA_TRANSFORM_DISKID;
 
    if( TRACE_ON( msi ) )
        enum_stream_names( stg );
 
    db->storage = stg;
    db->mode = mode;
    if (created)
        db->deletefile = wcsdup( szDBPath );
    list_init( &db->tables );
    list_init( &db->transforms );
 
    db->strings = msi_load_string_table( stg, &db->bytes_per_strref );
    if( !db->strings )
        goto end;
 
    ret = ERROR_SUCCESS;
 
    msiobj_addref( &db->hdr );
    IStorage_AddRef( stg );
    *pdb = db;
 
end:
    if( db )
        msiobj_release( &db->hdr );
    if( stg )
        IStorage_Release( stg );
 
    return ret;
}

Referenced by apply_patch_package(), MSI_ApplicablePatchW(), msi_apply_registered_patch(), MSI_OpenPackageW(), MsiGetSummaryInformationW(), and MsiOpenDatabaseW().

◆ MSI_OpenPackageW()

UINT MSI_OpenPackageW	(	LPCWSTR	szPackage,
		DWORD	dwOptions,
		MSIPACKAGE **	pPackage
	)

Definition at line 1416 of file package.c.

{
    MSIDATABASE *db;
    MSIPACKAGE *package;
    MSIHANDLE handle;
    MSIRECORD *data_row, *info_row;
    UINT r;
    WCHAR localfile[MAX_PATH], cachefile[MAX_PATH];
    LPCWSTR file = szPackage;
    DWORD index = 0;
    MSISUMMARYINFO *si;
    BOOL delete_on_close = FALSE;
    WCHAR *info_template, *productname, *product_code;
    MSIINSTALLCONTEXT context;
 
    TRACE("%s %p\n", debugstr_w(szPackage), pPackage);
 
    MSI_ProcessMessage(NULL, INSTALLMESSAGE_INITIALIZE, 0);
 
    localfile[0] = 0;
    if( szPackage[0] == '#' )
    {
        handle = wcstol(&szPackage[1], NULL, 10);
        if (!(db = msihandle2msiinfo(handle, MSIHANDLETYPE_DATABASE)))
            return ERROR_INVALID_HANDLE;
    }
    else
    {
        WCHAR *product_version = NULL;
 
        if ( UrlIsW( szPackage, URLIS_URL ) )
        {
            r = msi_download_file( szPackage, cachefile );
            if (r != ERROR_SUCCESS)
                return r;
 
            file = cachefile;
        }
#ifdef __REACTOS__
        AppHelpCheckPackage(file);
#endif
 
        r = MSI_OpenDatabaseW( file, MSIDBOPEN_READONLY, &db );
        if (r != ERROR_SUCCESS)
        {
            if (GetFileAttributesW( file ) == INVALID_FILE_ATTRIBUTES)
                return ERROR_FILE_NOT_FOUND;
            return r;
        }
        r = get_local_package( db, localfile );
        if (r != ERROR_SUCCESS || GetFileAttributesW( localfile ) == INVALID_FILE_ATTRIBUTES)
        {
            DWORD localfile_attr;
 
            r = msi_create_empty_local_file( localfile, L".msi" );
            if (r != ERROR_SUCCESS)
            {
                msiobj_release( &db->hdr );
                return r;
            }
 
            if (!CopyFileW( file, localfile, FALSE ))
            {
                r = GetLastError();
                WARN("unable to copy package %s to %s (%u)\n", debugstr_w(file), debugstr_w(localfile), r);
                DeleteFileW( localfile );
                msiobj_release( &db->hdr );
                return r;
            }
            delete_on_close = TRUE;
 
            /* Remove read-only bit, we are opening it with write access in MSI_OpenDatabaseW below. */
            localfile_attr = GetFileAttributesW( localfile );
            if (localfile_attr & FILE_ATTRIBUTE_READONLY)
                SetFileAttributesW( localfile, localfile_attr & ~FILE_ATTRIBUTE_READONLY);
        }
        else if (dwOptions & WINE_OPENPACKAGEFLAGS_RECACHE)
        {
            if (!CopyFileW( file, localfile, FALSE ))
            {
                r = GetLastError();
                WARN("unable to update cached package (%u)\n", r);
                msiobj_release( &db->hdr );
                return r;
            }
        }
        else
            product_version = get_product_version( db );
        msiobj_release( &db->hdr );
        TRACE("opening package %s\n", debugstr_w( localfile ));
        r = MSI_OpenDatabaseW( localfile, MSIDBOPEN_TRANSACT, &db );
        if (r != ERROR_SUCCESS)
        {
            free( product_version );
            return r;
        }
 
        if (product_version)
        {
            WCHAR *cache_version = get_product_version( db );
            if (!product_version != !cache_version ||
                    (product_version && wcscmp(product_version, cache_version)))
            {
                msiobj_release( &db->hdr );
                free( product_version );
                free( cache_version );
                return ERROR_PRODUCT_VERSION;
            }
            free( product_version );
            free( cache_version );
        }
    }
    package = MSI_CreatePackage( db );
    msiobj_release( &db->hdr );
    if (!package) return ERROR_INSTALL_PACKAGE_INVALID;
    package->localfile = wcsdup( localfile );
    package->delete_on_close = delete_on_close;
 
    r = msi_get_suminfo( db->storage, 0, &si );
    if (r != ERROR_SUCCESS)
    {
        r = msi_get_db_suminfo( db, 0, &si );
        if (r != ERROR_SUCCESS)
        {
            WARN("failed to load summary info\n");
            msiobj_release( &package->hdr );
            return ERROR_INSTALL_PACKAGE_INVALID;
        }
    }
    r = parse_suminfo( si, package );
    msiobj_release( &si->hdr );
    if (r != ERROR_SUCCESS)
    {
        WARN("failed to parse summary info %u\n", r);
        msiobj_release( &package->hdr );
        return r;
    }
    r = validate_package( package );
    if (r != ERROR_SUCCESS)
    {
        msiobj_release( &package->hdr );
        return r;
    }
    msi_set_property( package->db, L"DATABASE", db->path, -1 );
    set_installed_prop( package );
    msi_set_context( package );
 
    product_code = get_product_code( db );
    if (msi_locate_product( product_code, &context ) == ERROR_SUCCESS)
    {
        TRACE("product already registered\n");
        msi_set_property( package->db, L"ProductToBeRegistered", L"1", -1 );
    }
    free( product_code );
 
    while (1)
    {
        WCHAR patch_code[GUID_SIZE];
        r = MsiEnumPatchesExW( package->ProductCode, NULL, package->Context,
                               MSIPATCHSTATE_APPLIED, index, patch_code, NULL, NULL, NULL, NULL );
        if (r != ERROR_SUCCESS)
            break;
 
        TRACE("found registered patch %s\n", debugstr_w(patch_code));
 
        r = msi_apply_registered_patch( package, patch_code );
        if (r != ERROR_SUCCESS)
        {
            ERR("registered patch failed to apply %u\n", r);
            msiobj_release( &package->hdr );
            return r;
        }
        index++;
    }
    if (index) msi_adjust_privilege_properties( package );
 
    r = msi_set_original_database_property( package->db, szPackage );
    if (r != ERROR_SUCCESS)
    {
        msiobj_release( &package->hdr );
        return r;
    }
    if (gszLogFile)
        package->log_file = CreateFileW( gszLogFile, GENERIC_WRITE, FILE_SHARE_WRITE, NULL,
                                         OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
 
    /* FIXME: when should these messages be sent? */
    data_row = MSI_CreateRecord(3);
    if (!data_row)
    return ERROR_OUTOFMEMORY;
    MSI_RecordSetStringW(data_row, 0, NULL);
    MSI_RecordSetInteger(data_row, 1, 0);
    MSI_RecordSetInteger(data_row, 2, package->num_langids ? package->langids[0] : 0);
    MSI_RecordSetInteger(data_row, 3, msi_get_string_table_codepage(package->db->strings));
    MSI_ProcessMessageVerbatim(package, INSTALLMESSAGE_COMMONDATA, data_row);
 
    info_row = MSI_CreateRecord(0);
    if (!info_row)
    {
    msiobj_release(&data_row->hdr);
    return ERROR_OUTOFMEMORY;
    }
    info_template = msi_get_error_message(package->db, MSIERR_INFO_LOGGINGSTART);
    MSI_RecordSetStringW(info_row, 0, info_template);
    free(info_template);
    MSI_ProcessMessage(package, INSTALLMESSAGE_INFO|MB_ICONHAND, info_row);
 
    MSI_ProcessMessage(package, INSTALLMESSAGE_COMMONDATA, data_row);
 
    productname = msi_dup_property(package->db, INSTALLPROPERTY_PRODUCTNAMEW);
    MSI_RecordSetInteger(data_row, 1, 1);
    MSI_RecordSetStringW(data_row, 2, productname);
    MSI_RecordSetStringW(data_row, 3, NULL);
    MSI_ProcessMessage(package, INSTALLMESSAGE_COMMONDATA, data_row);
 
    free(productname);
    msiobj_release(&info_row->hdr);
    msiobj_release(&data_row->hdr);
 
    *pPackage = package;
    return ERROR_SUCCESS;
}

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

◆ MSI_OpenQuery()

UINT WINAPIV MSI_OpenQuery	(	MSIDATABASE *	db,
		MSIQUERY **	view,
		LPCWSTR	fmt,
			...
	)

Definition at line 138 of file msiquery.c.

{
    UINT r;
    int size = 100, res;
    LPWSTR query;
 
    /* construct the string */
    for (;;)
    {
        va_list va;
        query = malloc(size * sizeof(WCHAR));
        va_start(va, fmt);
        res = vswprintf(query, size, fmt, va);
        va_end(va);
        if (res == -1) size *= 2;
        else if (res >= size) size = res + 1;
        else break;
        free(query);
    }
    /* perform the query */
    r = MSI_DatabaseOpenViewW(db, query, view);
    free(query);
    return r;
}

Referenced by ACTION_AppSearch(), ACTION_CCPSearch(), ACTION_ExecuteAction(), ACTION_ProcessExecSequence(), add_records_to_table(), combobox_add_items(), dialog_build_font_list(), dialog_button_handler(), dialog_evaluate_control_conditions(), dialog_fill_controls(), dialog_map_events(), dialog_radiogroup_control(), get_assembly_display_name(), get_assembly_record(), get_merge_table(), listbox_add_items(), listview_add_items(), load_feature(), load_file_hash(), load_folder_persistence(), mark_patched_components(), merge_diff_tables(), MSI_DatabaseExport(), MSI_DatabaseGetPrimaryKeys(), MSI_Sequence(), MsiGetProductPropertyW(), unimplemented_action_stub(), and update_merge_errors().

◆ msi_package_add_info()

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

Definition at line 2657 of file package.c.

{
    MSISOURCELISTINFO *info;
 
    LIST_FOR_EACH_ENTRY( info, &package->sourcelist_info, MSISOURCELISTINFO, entry )
    {
        if (!wcscmp( info->value, value )) return ERROR_SUCCESS;
    }
 
    info = malloc(sizeof(MSISOURCELISTINFO));
    if (!info)
        return ERROR_OUTOFMEMORY;
 
    info->context = context;
    info->options = options;
    info->property = property;
    info->value = wcsdup(value);
    list_add_head(&package->sourcelist_info, &info->entry);
 
    return ERROR_SUCCESS;
}

Referenced by msi_load_media_info().

◆ msi_package_add_media_disk()

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

Definition at line 2680 of file package.c.

{
    MSIMEDIADISK *disk;
 
    LIST_FOR_EACH_ENTRY( disk, &package->sourcelist_media, MSIMEDIADISK, entry )
    {
        if (disk->disk_id == disk_id) return ERROR_SUCCESS;
    }
 
    disk = malloc(sizeof(MSIMEDIADISK));
    if (!disk)
        return ERROR_OUTOFMEMORY;
 
    disk->context = context;
    disk->options = options;
    disk->disk_id = disk_id;
    disk->volume_label = wcsdup(volume_label);
    disk->disk_prompt = wcsdup(disk_prompt);
    list_add_head(&package->sourcelist_media, &disk->entry);
 
    return ERROR_SUCCESS;
}

Referenced by msi_load_media_info().

◆ msi_parse_command_line()

UINT msi_parse_command_line	(	MSIPACKAGE *	package,
		LPCWSTR	szCommandLine,
		BOOL	preserve_case
	)

Definition at line 206 of file action.c.

{
    LPCWSTR ptr, ptr2;
    int num_quotes;
    DWORD len;
    WCHAR *prop, *val;
    UINT r;
 
    if (!szCommandLine)
        return ERROR_SUCCESS;
 
    ptr = szCommandLine;
    while (*ptr)
    {
        while (*ptr == ' ') ptr++;
        if (!*ptr) break;
 
        ptr2 = wcschr( ptr, '=' );
        if (!ptr2) return ERROR_INVALID_COMMAND_LINE;
 
        len = ptr2 - ptr;
        if (!len) return ERROR_INVALID_COMMAND_LINE;
 
        while (ptr[len - 1] == ' ') len--;
 
        prop = malloc( (len + 1) * sizeof(WCHAR) );
        memcpy( prop, ptr, len * sizeof(WCHAR) );
        prop[len] = 0;
        if (!preserve_case) wcsupr( prop );
 
        ptr2++;
        while (*ptr2 == ' ') ptr2++;
 
        num_quotes = 0;
        val = malloc( (wcslen( ptr2 ) + 1) * sizeof(WCHAR) );
        len = parse_prop( ptr2, val, &num_quotes );
        if (num_quotes % 2)
        {
            WARN("unbalanced quotes\n");
            free( val );
            free( prop );
            return ERROR_INVALID_COMMAND_LINE;
        }
        remove_quotes( val );
        TRACE("Found commandline property %s = %s\n", debugstr_w(prop), debugstr_w(val));
 
        r = msi_set_property( package->db, prop, val, -1 );
        if (r == ERROR_SUCCESS && !wcscmp( prop, L"SourceDir" ))
            msi_reset_source_folders( package );
 
        free( val );
        free( prop );
 
        ptr = ptr2 + len;
    }
 
    return ERROR_SUCCESS;
}

Referenced by load_admin_properties(), and MSI_InstallPackage().

◆ msi_parse_version_string()

void msi_parse_version_string	(	LPCWSTR	verStr,
		PDWORD	ms,
		PDWORD	ls
	)

Definition at line 52 of file appsearch.c.

{
    const WCHAR *ptr;
    int x1 = 0, x2 = 0, x3 = 0, x4 = 0;
 
    x1 = wcstol(verStr, NULL, 10);
    ptr = wcschr(verStr, '.');
    if (ptr)
    {
        x2 = wcstol(ptr + 1, NULL, 10);
        ptr = wcschr(ptr + 1, '.');
    }
    if (ptr)
    {
        x3 = wcstol(ptr + 1, NULL, 10);
        ptr = wcschr(ptr + 1, '.');
    }
    if (ptr)
        x4 = wcstol(ptr + 1, NULL, 10);
    /* FIXME: byte-order dependent? */
    *ms = x1 << 16 | x2;
    if (ls) *ls = x3 << 16 | x4;
}

Referenced by check_transform_applicable(), get_signature(), msi_compare_file_versions(), and msi_compare_font_versions().

◆ msi_patch_assembly()

UINT msi_patch_assembly	(	MSIPACKAGE *	package,
		MSIASSEMBLY *	assembly,
		MSIFILEPATCH *	patch
	)

Definition at line 726 of file files.c.

{
    UINT r = ERROR_FUNCTION_FAILED;
    IAssemblyName *name;
    IAssemblyEnum *iter;
 
    if (!(iter = msi_create_assembly_enum( package, assembly->display_name )))
        return ERROR_FUNCTION_FAILED;
 
    while ((IAssemblyEnum_GetNextAssembly( iter, NULL, &name, 0 ) == S_OK))
    {
        WCHAR *displayname, *path;
        DWORD len = 0;
        HRESULT hr;
 
        hr = IAssemblyName_GetDisplayName( name, NULL, &len, 0 );
        if (hr != E_NOT_SUFFICIENT_BUFFER || !(displayname = malloc( len * sizeof(WCHAR) )))
            break;
 
        hr = IAssemblyName_GetDisplayName( name, displayname, &len, 0 );
        if (FAILED( hr ))
        {
            free( displayname );
            break;
        }
 
        if ((path = msi_get_assembly_path( package, displayname )))
        {
            if (!msi_copy_file( package, path, patch->File->TargetPath, FALSE ))
            {
                ERR( "failed to copy file %s -> %s (%lu)\n", debugstr_w(path),
                     debugstr_w(patch->File->TargetPath), GetLastError() );
                free( path );
                free( displayname );
                IAssemblyName_Release( name );
                break;
            }
            r = patch_file( package, patch );
            free( path );
        }
 
        free( displayname );
        IAssemblyName_Release( name );
        if (r == ERROR_SUCCESS) break;
    }
 
    IAssemblyEnum_Release( iter );
    return r;
}

Referenced by ACTION_InstallFinalize().

◆ MSI_ProcessMessage()

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

Definition at line 1941 of file package.c.

{
    switch (eMessageType & 0xff000000)
    {
    case INSTALLMESSAGE_FATALEXIT:
    case INSTALLMESSAGE_ERROR:
    case INSTALLMESSAGE_WARNING:
    case INSTALLMESSAGE_USER:
    case INSTALLMESSAGE_INFO:
    case INSTALLMESSAGE_OUTOFDISKSPACE:
        if (MSI_RecordGetInteger(record, 1) != MSI_NULL_INTEGER)
        {
            /* error message */
 
            LPWSTR template;
            LPWSTR template_rec = NULL, template_prefix = NULL;
            int error = MSI_RecordGetInteger(record, 1);
 
            if (MSI_RecordIsNull(record, 0))
            {
                if (error >= 32)
                {
                    template_rec = msi_get_error_message(package->db, error);
 
                    if (!template_rec && error >= 2000)
                    {
                        /* internal error, not localized */
                        if ((template_rec = (LPWSTR) get_internal_error_message(error)))
                        {
                            MSI_RecordSetStringW(record, 0, template_rec);
                            MSI_ProcessMessageVerbatim(package, INSTALLMESSAGE_INFO, record);
                        }
                        template_rec = msi_get_error_message(package->db, MSIERR_INSTALLERROR);
                        MSI_RecordSetStringW(record, 0, template_rec);
                        MSI_ProcessMessageVerbatim(package, eMessageType, record);
                        free(template_rec);
                        return 0;
                    }
                }
            }
            else
                template_rec = msi_dup_record_field(record, 0);
 
            template_prefix = msi_get_error_message(package->db, eMessageType >> 24);
            if (!template_prefix) template_prefix = wcsdup(L"");
 
            if (!template_rec)
            {
                /* always returns 0 */
                MSI_RecordSetStringW(record, 0, template_prefix);
                MSI_ProcessMessageVerbatim(package, eMessageType, record);
                free(template_prefix);
                return 0;
            }
 
            template = malloc((wcslen(template_rec) + wcslen(template_prefix) + 1) * sizeof(WCHAR));
            if (!template)
            {
                free(template_prefix);
                free(template_rec);
                return ERROR_OUTOFMEMORY;
            }
 
            lstrcpyW(template, template_prefix);
            lstrcatW(template, template_rec);
            MSI_RecordSetStringW(record, 0, template);
 
            free(template_prefix);
            free(template_rec);
            free(template);
        }
        break;
    case INSTALLMESSAGE_ACTIONSTART:
    {
        WCHAR *template = msi_get_error_message(package->db, MSIERR_ACTIONSTART);
        MSI_RecordSetStringW(record, 0, template);
        free(template);
 
        free(package->LastAction);
        free(package->LastActionTemplate);
        package->LastAction = msi_dup_record_field(record, 1);
        if (!package->LastAction) package->LastAction = wcsdup(L"");
        package->LastActionTemplate = msi_dup_record_field(record, 3);
        break;
    }
    case INSTALLMESSAGE_ACTIONDATA:
        if (package->LastAction && package->LastActionTemplate)
        {
            size_t len = lstrlenW(package->LastAction) + lstrlenW(package->LastActionTemplate) + 7;
            WCHAR *template = malloc(len * sizeof(WCHAR));
            if (!template) return ERROR_OUTOFMEMORY;
            swprintf(template, len, L"{{%s: }}%s", package->LastAction, package->LastActionTemplate);
            MSI_RecordSetStringW(record, 0, template);
            free(template);
        }
        break;
    case INSTALLMESSAGE_COMMONDATA:
    {
        WCHAR *template = msi_get_error_message(package->db, MSIERR_COMMONDATA);
        MSI_RecordSetStringW(record, 0, template);
        free(template);
    }
    break;
    }
 
    return MSI_ProcessMessageVerbatim(package, eMessageType, record);
}

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

◆ MSI_ProcessMessageVerbatim()

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

Definition at line 1875 of file package.c.

{
    LPWSTR message = {0};
    DWORD len;
    DWORD log_type = 1 << (eMessageType >> 24);
    UINT res;
    INT rc = 0;
    char *msg;
 
    TRACE("%x\n", eMessageType);
    if (TRACE_ON(msi)) dump_record(record);
 
    if (!package || !record)
        message = NULL;
    else {
        res = MSI_FormatRecordW(package, record, message, &len);
        if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA)
            return res;
        len++;
        message = malloc(len * sizeof(WCHAR));
        if (!message) return ERROR_OUTOFMEMORY;
        MSI_FormatRecordW(package, record, message, &len);
    }
 
    /* convert it to ANSI */
    len = WideCharToMultiByte( CP_ACP, 0, message, -1, NULL, 0, NULL, NULL );
    msg = malloc( len );
    WideCharToMultiByte( CP_ACP, 0, message, -1, msg, len, NULL, NULL );
 
    if (gUIHandlerRecord && (gUIFilterRecord & log_type))
    {
        MSIHANDLE rec = alloc_msihandle(&record->hdr);
        TRACE( "calling UI handler %p(pvContext = %p, iMessageType = %#x, hRecord = %lu)\n",
               gUIHandlerRecord, gUIContextRecord, eMessageType, rec );
        rc = gUIHandlerRecord( gUIContextRecord, eMessageType, rec );
        MsiCloseHandle( rec );
    }
    if (!rc && gUIHandlerW && (gUIFilter & log_type))
    {
        TRACE( "calling UI handler %p(pvContext = %p, iMessageType = %#x, szMessage = %s)\n",
               gUIHandlerW, gUIContext, eMessageType, debugstr_w(message) );
        rc = gUIHandlerW( gUIContext, eMessageType, message );
    }
    else if (!rc && gUIHandlerA && (gUIFilter & log_type))
    {
        TRACE( "calling UI handler %p(pvContext = %p, iMessageType = %#x, szMessage = %s)\n",
               gUIHandlerA, gUIContext, eMessageType, debugstr_a(msg) );
        rc = gUIHandlerA( gUIContext, eMessageType, msg );
    }
 
    if (!rc)
        rc = internal_ui_handler(package, eMessageType, record, message);
 
    if (!rc && package && package->log_file != INVALID_HANDLE_VALUE &&
        (eMessageType & 0xff000000) != INSTALLMESSAGE_PROGRESS)
    {
        DWORD written;
        WriteFile( package->log_file, msg, len - 1, &written, NULL );
        WriteFile( package->log_file, "\n", 1, &written, NULL );
    }
    free( msg );
    free( message );
 
    return rc;
}

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

◆ MSI_QueryGetRecord()

MSIRECORD *WINAPIV MSI_QueryGetRecord	(	MSIDATABASE *	db,
		LPCWSTR	query,
			...
	)

Definition at line 201 of file msiquery.c.

{
    MSIRECORD *rec = NULL;
    MSIQUERY *view = NULL;
    UINT r;
    int size = 100, res;
    LPWSTR query;
 
    /* construct the string */
    for (;;)
    {
        va_list va;
        query = malloc(size * sizeof(WCHAR));
        va_start(va, fmt);
        res = vswprintf(query, size, fmt, va);
        va_end(va);
        if (res == -1) size *= 2;
        else if (res >= size) size = res + 1;
        else break;
        free(query);
    }
    /* perform the query */
    r = MSI_DatabaseOpenViewW(db, query, &view);
    free(query);
 
    if( r == ERROR_SUCCESS )
    {
        MSI_ViewExecute( view, NULL );
        MSI_ViewFetch( view, &rec );
        MSI_ViewClose( view );
        msiobj_release( &view->hdr );
    }
    return rec;
}

Referenced by ACTION_CustomAction(), ACTION_PerformEndAction(), ACTION_ProcessComponents(), create_temp_binary(), dialog_get_uitext(), dialog_seltree_handler(), get_checkbox_value(), get_dialog_record(), get_signature(), HANDLE_CustomType19(), HANDLE_CustomType5_6(), ITERATE_InstallService(), load_file_disk_id(), load_given_appid(), load_given_class(), load_given_extension(), load_given_mime(), load_given_progid(), load_image(), load_patch_disk_id(), load_picture(), media_get_disk_info(), msi_get_error_message(), msi_load_media_info(), resolve_keypath(), search_components(), search_ini(), search_reg(), and ui_actionstart().

◆ msi_record_get_string()

const WCHAR * msi_record_get_string	(	const MSIRECORD *	rec,
		UINT	field,
		int *	len
	)

Definition at line 420 of file record.c.

{
    if (field > rec->count)
        return NULL;
 
    if (rec->fields[field].type != MSIFIELD_WSTR)
        return NULL;
 
    if (len) *len = rec->fields[field].len;
 
    return rec->fields[field].u.szwVal;
}

Referenced by find_insert_index(), get_table_value_from_record(), ITERATE_WriteRegistryValues(), MSI_RecordGetString(), msi_select_update(), MsiGetPropertyA(), MsiGetPropertyW(), record_to_row(), TABLE_set_row(), table_validate_new(), TransformView_Create(), and TransformView_create_table().

◆ msi_record_set_string()

UINT msi_record_set_string	(	MSIRECORD *	rec,
		UINT	field,
		const WCHAR *	value,
		int	len
	)

Definition at line 573 of file record.c.

{
    if (field > rec->count)
        return ERROR_INVALID_FIELD;
 
    MSI_FreeField( &rec->fields[field] );
 
    if (value && len < 0) len = lstrlenW( value );
 
    if (value && len)
    {
        rec->fields[field].type = MSIFIELD_WSTR;
        rec->fields[field].u.szwVal = msi_strdupW( value, len );
        rec->fields[field].len = len;
    }
    else
    {
        rec->fields[field].type = MSIFIELD_NULL;
        rec->fields[field].u.szwVal = NULL;
        rec->fields[field].len = 0;
    }
    return 0;
}

Referenced by get_transform_record(), MSI_RecordSetStringW(), msi_set_property(), and msi_view_refresh_row().

◆ MSI_RecordCopyField()

UINT MSI_RecordCopyField	(	MSIRECORD *	in_rec,
		UINT	in_n,
		MSIRECORD *	out_rec,
		UINT	out_n
	)

Definition at line 166 of file record.c.

{
    UINT r = ERROR_SUCCESS;
 
    msiobj_lock( &in_rec->hdr );
 
    if ( in_n > in_rec->count || out_n > out_rec->count )
        r = ERROR_FUNCTION_FAILED;
    else if ( in_rec != out_rec || in_n != out_n )
    {
        LPWSTR str;
        MSIFIELD *in, *out;
 
        in = &in_rec->fields[in_n];
        out = &out_rec->fields[out_n];
 
        switch ( in->type )
        {
        case MSIFIELD_NULL:
            break;
        case MSIFIELD_INT:
            out->u.iVal = in->u.iVal;
            break;
        case MSIFIELD_WSTR:
            if ((str = msi_strdupW( in->u.szwVal, in->len )))
            {
                out->u.szwVal = str;
                out->len = in->len;
            }
            else r = ERROR_OUTOFMEMORY;
            break;
        case MSIFIELD_STREAM:
            IStream_AddRef( in->u.stream );
            out->u.stream = in->u.stream;
            break;
        default:
            ERR("invalid field type %d\n", in->type);
        }
        if (r == ERROR_SUCCESS)
            out->type = in->type;
    }
 
    msiobj_unlock( &in_rec->hdr );
    return r;
}

Referenced by arrange_record(), msi_clone_properties(), MSI_CloneRecord(), msi_query_merge_record(), refresh_record(), SELECT_set_row(), translate_record(), UPDATE_execute(), and WHERE_set_row().

◆ MSI_RecordGetFieldCount()

UINT MSI_RecordGetFieldCount ( const MSIRECORD * rec )

Definition at line 108 of file record.c.

{
    return rec->count;
}

Referenced by arrange_record(), build_default_format(), create_diff_row_query(), export_record(), get_query_columns(), get_query_types(), get_table_labels(), join_modify_update(), merge_verify_colnames(), merge_verify_primary_keys(), MSI_CloneRecord(), MSI_FormatRecordW(), MsiRecordGetFieldCount(), refresh_record(), and UPDATE_execute().

◆ MSI_RecordGetInteger()

int MSI_RecordGetInteger	(	MSIRECORD *	rec,
		UINT	iField
	)

Definition at line 213 of file record.c.

{
    int ret = 0;
 
    TRACE("%p %d\n", rec, iField );
 
    if( iField > rec->count )
        return MSI_NULL_INTEGER;
 
    switch( rec->fields[iField].type )
    {
    case MSIFIELD_INT:
        return rec->fields[iField].u.iVal;
    case MSIFIELD_WSTR:
        if( string2intW( rec->fields[iField].u.szwVal, &ret ) )
            return ret;
        return MSI_NULL_INTEGER;
    default:
        break;
    }
 
    return MSI_NULL_INTEGER;
}

Referenced by ACTION_CustomAction(), ACTION_ProcessComponents(), dialog_add_control(), dialog_add_font(), dialog_adjust_dialog_pos(), dialog_bitmap_control(), dialog_button_control(), dialog_combo_control(), dialog_create(), dialog_create_window(), dialog_directory_combo(), dialog_directory_list(), dialog_handle_event(), dialog_hyperlink(), dialog_icon_control(), dialog_list_box(), dialog_listview(), dialog_oncreate(), dialog_pathedit_control(), dialog_progress_bar(), dialog_radiogroup_control(), dialog_selection_tree(), dialog_text_control(), dialog_volumeselect_combo(), get_signature(), get_table_value_from_record(), internal_ui_handler(), ITERATE_CostFinalizeConditions(), ITERATE_CreateShortcuts(), ITERATE_DeleteService(), ITERATE_FindRelatedProducts(), ITERATE_InstallODBCDataSource(), ITERATE_InstallService(), iterate_load_verb(), ITERATE_MigrateFeatureStates(), ITERATE_MoveFiles(), ITERATE_RemoveExistingProducts(), ITERATE_RemoveFiles(), ITERATE_RemoveIniValuesOnInstall(), ITERATE_RemoveIniValuesOnUninstall(), ITERATE_RemoveODBCDataSource(), ITERATE_RemoveRegistryValuesOnInstall(), ITERATE_RemoveRegistryValuesOnUninstall(), ITERATE_StartService(), ITERATE_StopService(), ITERATE_UnregisterTypeLibraries(), ITERATE_WriteIniValues(), ITERATE_WriteRegistryValues(), load_class(), load_component(), load_drlocator(), load_feature(), load_file(), load_file_disk_id(), load_file_hash(), load_media(), load_patch(), load_patch_disk_id(), load_progid(), msi_load_assembly(), msi_load_media_info(), MSI_ProcessMessage(), msi_select_update(), MsiRecordGetInteger(), patch_add_media(), patch_offset_get_filepatches(), patch_offset_get_files(), patch_set_offsets(), patch_update_file_sequence(), patch_update_filepatch_sequence(), primary_key_iterator(), record_to_row(), resolve_keypath(), search_components(), search_ini(), search_reg(), table_load_transform(), table_validate_new(), and WHERE_evaluate().

◆ MSI_RecordGetIStream()

UINT MSI_RecordGetIStream	(	MSIRECORD *	rec,
		UINT	iField,
		IStream **	pstm
	)

Definition at line 852 of file record.c.

{
    TRACE("%p %d %p\n", rec, iField, pstm);
 
    if( iField > rec->count )
        return ERROR_INVALID_FIELD;
 
    if( rec->fields[iField].type != MSIFIELD_STREAM )
        return ERROR_INVALID_FIELD;
 
    *pstm = rec->fields[iField].u.stream;
    IStream_AddRef( *pstm );
 
    return ERROR_SUCCESS;
}

Referenced by load_picture(), MSI_RecordStreamToFile(), msi_select_update(), STORAGES_set_row(), STREAMS_set_row(), and TABLE_set_row().

◆ MSI_RecordGetString()

const WCHAR * MSI_RecordGetString	(	const MSIRECORD *	rec,
		UINT	iField
	)

Definition at line 433 of file record.c.

{
    return msi_record_get_string( rec, iField, NULL );
}

Referenced by ACTION_CustomAction(), ACTION_PerformEndAction(), combobox_add_item(), create_diff_row_query(), dialog_add_control(), dialog_add_font(), dialog_checkbox_control(), dialog_combo_control(), dialog_control_event(), dialog_create(), dialog_create_controls(), dialog_create_radiobutton(), dialog_create_window(), dialog_directory_combo(), dialog_directory_list(), dialog_edit_control(), dialog_get_uitext(), dialog_handle_event(), dialog_hyperlink(), dialog_list_box(), dialog_listview(), dialog_maskedit_control(), dialog_oncreate(), dialog_pathedit_control(), dialog_radiogroup_control(), dialog_scrolltext_control(), dialog_selection_tree(), dialog_seltree_handler(), dialog_set_control_condition(), dialog_text_control(), dialog_vcl_add_columns(), dialog_volumeselect_combo(), find_feature_children(), find_folder_children(), get_assembly_name_attribute(), get_assembly_record(), get_deformatted_field(), get_duplicate_filename(), get_ini_file_name(), get_key_value(), get_link_file(), get_property(), get_query_columns(), get_query_types(), get_table_labels(), HANDLE_CustomType19(), internal_ui_handler(), is_uninstallable(), ITERATE_Actions(), iterate_all_classes(), iterate_all_extensions(), iterate_all_mimes(), iterate_all_progids(), ITERATE_AppSearch(), ITERATE_BindImage(), ITERATE_CCPSearch(), ITERATE_CostFinalizeConditions(), ITERATE_CreateFolders(), ITERATE_CreateShortcuts(), ITERATE_DeleteService(), ITERATE_DuplicateFiles(), ITERATE_FindRelatedProducts(), ITERATE_InstallODBCDataSource(), ITERATE_InstallODBCDriver(), ITERATE_InstallODBCTranslator(), ITERATE_InstallService(), ITERATE_LaunchConditions(), iterate_load_featurecomponents(), iterate_load_verb(), ITERATE_MigrateFeatureStates(), ITERATE_MoveFiles(), iterate_patched_component(), ITERATE_PublishComponent(), ITERATE_PublishIcon(), ITERATE_RegisterFonts(), ITERATE_RegisterTypeLibraries(), ITERATE_RemoveDuplicateFiles(), ITERATE_RemoveEnvironmentString(), ITERATE_RemoveExistingProducts(), ITERATE_RemoveFiles(), ITERATE_RemoveFolders(), ITERATE_RemoveIniValuesOnInstall(), ITERATE_RemoveIniValuesOnUninstall(), ITERATE_RemoveODBCDataSource(), ITERATE_RemoveODBCDriver(), ITERATE_RemoveODBCTranslator(), ITERATE_RemoveRegistryValuesOnInstall(), ITERATE_RemoveRegistryValuesOnUninstall(), ITERATE_RemoveShortcuts(), ITERATE_SelfRegModules(), ITERATE_SelfUnregModules(), ITERATE_StartService(), ITERATE_StopService(), ITERATE_UnpublishComponent(), ITERATE_UnpublishIcon(), ITERATE_UnregisterFonts(), ITERATE_UnregisterTypeLibraries(), ITERATE_WriteEnvironmentString(), ITERATE_WriteIniValues(), ITERATE_WriteRegistryValues(), join_find_row(), listbox_add_item(), listview_add_item(), load_appid(), load_class(), load_extension(), load_file(), load_media(), load_mime(), load_patch(), load_progid(), map_event(), media_get_disk_info(), merge_diff_tables(), merge_verify_colnames(), merge_verify_primary_keys(), MSI_FormatRecordW(), msi_load_assembly(), msi_load_media_info(), MsiGetProductPropertyW(), patch_set_media_source_prop(), patch_update_file_sequence(), patch_update_filepatch_sequence(), primary_key_iterator(), resolve_keypath(), search_components(), search_reg(), storages_find_row(), STORAGES_set_row(), streams_find_row(), STREAMS_set_row(), STRING_evaluate(), and ui_actionstart().

◆ MSI_RecordGetStringA()

UINT MSI_RecordGetStringA	(	MSIRECORD *	rec,
		UINT	iField,
		LPSTR	szValue,
		LPDWORD	pcchValue
	)

Definition at line 351 of file record.c.

{
    UINT len = 0, ret = ERROR_SUCCESS;
    CHAR buffer[16];
 
    TRACE("%p %d %p %p\n", rec, iField, szValue, pcchValue);
 
    if( iField > rec->count )
    {
        if ( szValue && *pcchValue > 0 )
            szValue[0] = 0;
 
        *pcchValue = 0;
        return ERROR_SUCCESS;
    }
 
    switch( rec->fields[iField].type )
    {
    case MSIFIELD_INT:
        wsprintfA(buffer, "%d", rec->fields[iField].u.iVal);
        len = lstrlenA( buffer );
        if (szValue)
            lstrcpynA(szValue, buffer, *pcchValue);
        break;
    case MSIFIELD_WSTR:
        len = WideCharToMultiByte( CP_ACP, 0, rec->fields[iField].u.szwVal,
                                   rec->fields[iField].len + 1, NULL, 0 , NULL, NULL );
        if (szValue)
            WideCharToMultiByte( CP_ACP, 0, rec->fields[iField].u.szwVal,
                                 rec->fields[iField].len + 1, szValue, *pcchValue, NULL, NULL );
        if( szValue && *pcchValue && len>*pcchValue )
            szValue[*pcchValue-1] = 0;
        if( len )
            len--;
        break;
    case MSIFIELD_NULL:
        if( szValue && *pcchValue > 0 )
            szValue[0] = 0;
        break;
    default:
        ret = ERROR_INVALID_PARAMETER;
        break;
    }
 
    if( szValue && *pcchValue <= len )
        ret = ERROR_MORE_DATA;
    *pcchValue = len;
 
    return ret;
}

Referenced by export_field(), and MsiRecordGetStringA().

◆ MSI_RecordGetStringW()

UINT MSI_RecordGetStringW	(	MSIRECORD *	,
		UINT	,
		LPWSTR	,
		LPDWORD
	)

Referenced by create_key_string(), deformat_index(), export_stream(), get_duplicate_filename(), get_key_value(), msi_get_property(), record_stream_name(), table_load_transform(), TransformView_add_column(), and TransformView_set_row().

◆ MSI_RecordIsNull()

BOOL MSI_RecordIsNull	(	MSIRECORD *	rec,
		UINT	iField
	)

Definition at line 321 of file record.c.

{
    BOOL r = TRUE;
 
    TRACE("%p %d\n", rec, iField );
 
    r = ( iField > rec->count ) ||
        ( rec->fields[iField].type == MSIFIELD_NULL );
 
    return r;
}

Referenced by deformat_index(), get_duplicate_filename(), get_table_value_from_record(), ITERATE_CreateShortcuts(), ITERATE_MoveFiles(), ITERATE_RegisterFonts(), ITERATE_RemoveRegistryValuesOnUninstall(), ITERATE_UnregisterFonts(), ITERATE_WriteRegistryValues(), load_appid(), load_class(), load_feature(), load_progid(), msi_dup_record_field(), MSI_ProcessMessage(), MsiRecordIsNull(), row_has_null_primary_keys(), and TABLE_set_row().

◆ MSI_RecordReadStream()

UINT MSI_RecordReadStream	(	MSIRECORD *	rec,
		UINT	iField,
		char *	buf,
		LPDWORD	sz
	)

Definition at line 761 of file record.c.

{
    ULONG count;
    HRESULT r;
    IStream *stm;
 
    TRACE("%p %d %p %p\n", rec, iField, buf, sz);
 
    if( !sz )
        return ERROR_INVALID_PARAMETER;
 
    if( iField > rec->count)
        return ERROR_INVALID_PARAMETER;
 
    if ( rec->fields[iField].type == MSIFIELD_NULL )
    {
        *sz = 0;
        return ERROR_INVALID_DATA;
    }
 
    if( rec->fields[iField].type != MSIFIELD_STREAM )
        return ERROR_INVALID_DATATYPE;
 
    stm = rec->fields[iField].u.stream;
    if( !stm )
        return ERROR_INVALID_PARAMETER;
 
    /* if there's no buffer pointer, calculate the length to the end */
    if( !buf )
    {
        LARGE_INTEGER ofs;
        ULARGE_INTEGER end, cur;
 
        ofs.QuadPart = cur.QuadPart = 0;
        end.QuadPart = 0;
        IStream_Seek( stm, ofs, STREAM_SEEK_SET, &cur );
        IStream_Seek( stm, ofs, STREAM_SEEK_END, &end );
        ofs.QuadPart = cur.QuadPart;
        IStream_Seek( stm, ofs, STREAM_SEEK_SET, &cur );
        *sz = end.QuadPart - cur.QuadPart;
 
        return ERROR_SUCCESS;
    }
 
    /* read the data */
    count = 0;
    r = IStream_Read( stm, buf, *sz, &count );
    if( FAILED( r ) )
    {
        *sz = 0;
        return ERROR_FUNCTION_FAILED;
    }
 
    *sz = count;
 
    return ERROR_SUCCESS;
}

Referenced by create_temp_binary(), export_stream(), HANDLE_CustomType5_6(), ITERATE_PublishIcon(), and MsiRecordReadStream().

◆ MSI_RecordsAreEqual()

BOOL MSI_RecordsAreEqual	(	MSIRECORD *	a,
		MSIRECORD *	b
	)

Definition at line 986 of file record.c.

{
    UINT i;
 
    if (a->count != b->count)
        return FALSE;
 
    for (i = 0; i <= a->count; i++)
    {
        if (!MSI_RecordsAreFieldsEqual( a, b, i ))
            return FALSE;
    }
 
    return TRUE;
}

Referenced by merge_diff_row().

◆ MSI_RecordsAreFieldsEqual()

BOOL MSI_RecordsAreFieldsEqual	(	MSIRECORD *	a,
		MSIRECORD *	b,
		UINT	field
	)

Definition at line 957 of file record.c.

{
    if (a->fields[field].type != b->fields[field].type)
        return FALSE;
 
    switch (a->fields[field].type)
    {
        case MSIFIELD_NULL:
            break;
 
        case MSIFIELD_INT:
            if (a->fields[field].u.iVal != b->fields[field].u.iVal)
                return FALSE;
            break;
 
        case MSIFIELD_WSTR:
            if (a->fields[field].len != b->fields[field].len) return FALSE;
            if (memcmp( a->fields[field].u.szwVal, b->fields[field].u.szwVal,
                        a->fields[field].len * sizeof(WCHAR) )) return FALSE;
            break;
 
        case MSIFIELD_STREAM:
        default:
            return FALSE;
    }
    return TRUE;
}

Referenced by join_modify_update(), and MSI_RecordsAreEqual().

◆ MSI_RecordSetInteger()

UINT MSI_RecordSetInteger	(	MSIRECORD *	rec,
		UINT	iField,
		int	iVal
	)

Definition at line 280 of file record.c.

{
    TRACE("%p %u %d\n", rec, iField, iVal);
 
    if( iField > rec->count )
        return ERROR_INVALID_PARAMETER;
 
    MSI_FreeField( &rec->fields[iField] );
 
    if (iVal == MSI_NULL_INTEGER)
    {
        rec->fields[iField].type = MSIFIELD_NULL;
        rec->fields[iField].u.szwVal = NULL;
    }
    else
    {
        rec->fields[iField].type = MSIFIELD_INT;
        rec->fields[iField].u.iVal = iVal;
    }
 
    return ERROR_SUCCESS;
}

Referenced by ACTION_AllocateRegistrySpace(), ACTION_ExecuteAction(), ACTION_ResolveSource(), ACTION_ShowDialog(), change_media(), construct_record(), copy_remote_record(), file_update_ui(), get_transform_record(), internal_ui_handler(), ITERATE_DuplicateFiles(), ITERATE_InstallODBCDataSource(), ITERATE_MoveFiles(), ITERATE_RemoveEnvironmentString(), ITERATE_RemoveODBCDataSource(), ITERATE_WriteEnvironmentString(), msi_create_table(), MSI_OpenPackageW(), msi_query_merge_record(), msi_ui_progress(), msi_view_refresh_row(), MSI_ViewFetch(), MsiRecordSetInteger(), patch_add_media(), patch_offset_get_filepatches(), patch_offset_get_files(), patch_offset_modify_db(), patch_set_offsets(), patch_update_file_sequence(), patch_update_filepatch_sequence(), TABLE_add_column(), table_load_transform(), TABLE_remove_column(), and ui_actioninfo().

◆ MSI_RecordSetIStream()

UINT MSI_RecordSetIStream	(	MSIRECORD *	rec,
		UINT	iField,
		IStream *	stm
	)

Definition at line 836 of file record.c.

{
    TRACE("%p %d %p\n", rec, iField, stm);
 
    if( iField > rec->count )
        return ERROR_INVALID_FIELD;
 
    MSI_FreeField( &rec->fields[iField] );
 
    rec->fields[iField].type = MSIFIELD_STREAM;
    rec->fields[iField].u.stream = stm;
    IStream_AddRef( stm );
 
    return ERROR_SUCCESS;
}

Referenced by add_stream(), copy_remote_record(), and msi_view_refresh_row().

◆ MSI_RecordSetStream()

UINT MSI_RecordSetStream	(	MSIRECORD *	rec,
		UINT	iField,
		IStream *	stream
	)

Definition at line 671 of file record.c.

{
    if ( (iField == 0) || (iField > rec->count) )
        return ERROR_INVALID_PARAMETER;
 
    MSI_FreeField( &rec->fields[iField] );
    rec->fields[iField].type = MSIFIELD_STREAM;
    rec->fields[iField].u.stream = stream;
 
    return ERROR_SUCCESS;
}

Referenced by get_transform_record(), and MSI_RecordSetStreamFromFileW().

◆ MSI_RecordSetStreamFromFileW()

UINT MSI_RecordSetStreamFromFileW	(	MSIRECORD *	rec,
		UINT	iField,
		LPCWSTR	szFilename
	)

Definition at line 683 of file record.c.

{
    IStream *stm = NULL;
    HRESULT hr;
    UINT ret;
 
    if( (iField == 0) || (iField > rec->count) )
        return ERROR_INVALID_PARAMETER;
 
    /* no filename means we should seek back to the start of the stream */
    if( !szFilename )
    {
        LARGE_INTEGER ofs;
        ULARGE_INTEGER cur;
 
        if( rec->fields[iField].type != MSIFIELD_STREAM )
            return ERROR_INVALID_FIELD;
 
        stm = rec->fields[iField].u.stream;
        if( !stm )
            return ERROR_INVALID_FIELD;
 
        ofs.QuadPart = 0;
        hr = IStream_Seek( stm, ofs, STREAM_SEEK_SET, &cur );
        if (FAILED( hr ))
            return ERROR_FUNCTION_FAILED;
    }
    else
    {
        /* read the file into a stream and save the stream in the record */
        ret = RECORD_StreamFromFile(szFilename, &stm);
        if (ret != ERROR_SUCCESS)
            return ret;
 
        /* if all's good, store it in the record */
        MSI_RecordSetStream(rec, iField, stm);
    }
 
    return ERROR_SUCCESS;
}

Referenced by construct_record(), and MsiRecordSetStreamW().

◆ MSI_RecordSetStringW()

UINT MSI_RecordSetStringW	(	MSIRECORD *	rec,
		UINT	iField,
		LPCWSTR	szValue
	)

Definition at line 597 of file record.c.

{
    TRACE("%p %d %s\n", rec, iField, debugstr_w(szValue));
 
    return msi_record_set_string( rec, iField, szValue, -1 );
}

Referenced by ACTION_ExecuteAction(), ACTION_MsiPublishAssemblies(), ACTION_MsiUnpublishAssemblies(), ACTION_ProcessComponents(), ACTION_PublishFeatures(), ACTION_PublishProduct(), ACTION_RegisterClassInfo(), ACTION_RegisterExtensionInfo(), ACTION_RegisterMIMEInfo(), ACTION_RegisterProduct(), ACTION_RegisterProgIdInfo(), ACTION_RegisterUser(), ACTION_RemoveFiles(), ACTION_ResolveSource(), ACTION_ShowDialog(), ACTION_UnregisterClassInfo(), ACTION_UnregisterExtensionInfo(), ACTION_UnregisterMIMEInfo(), ACTION_UnregisterProgIdInfo(), add_stream(), change_media(), construct_record(), copy_remote_record(), deformat_string(), dialog_create(), dialog_seltree_handler(), event_set_target_path(), file_update_ui(), get_property_row(), internal_ui_handler(), ITERATE_AppSearch(), ITERATE_CreateFolders(), ITERATE_DeleteService(), ITERATE_DuplicateFiles(), ITERATE_FindRelatedProducts(), ITERATE_InstallODBCDataSource(), ITERATE_InstallODBCDriver(), ITERATE_InstallODBCTranslator(), ITERATE_MoveFiles(), iterate_properties(), ITERATE_PublishComponent(), ITERATE_RegisterFonts(), ITERATE_RemoveDuplicateFiles(), ITERATE_RemoveEnvironmentString(), ITERATE_RemoveFiles(), ITERATE_RemoveFolders(), ITERATE_RemoveIniValuesOnInstall(), ITERATE_RemoveIniValuesOnUninstall(), ITERATE_RemoveODBCDataSource(), ITERATE_RemoveODBCDriver(), ITERATE_RemoveODBCTranslator(), ITERATE_RemoveRegistryValuesOnInstall(), ITERATE_RemoveRegistryValuesOnUninstall(), ITERATE_SelfRegModules(), ITERATE_SelfUnregModules(), ITERATE_StartService(), ITERATE_StopService(), ITERATE_UnpublishComponent(), ITERATE_UnregisterFonts(), ITERATE_WriteEnvironmentString(), ITERATE_WriteIniValues(), ITERATE_WriteRegistryValues(), msi_create_table(), MSI_DatabaseExport(), MSI_FormatRecordW(), MSI_OpenPackageW(), MSI_ProcessMessage(), msi_query_merge_record(), MSI_ViewGetColumnInfo(), MsiRecordSetStringA(), MsiRecordSetStringW(), patch_add_media(), patch_update_filepatch_sequence(), primary_key_iterator(), set_record_type_string(), TABLE_add_column(), TABLE_drop(), TABLE_remove_column(), ui_actioninfo(), ui_actionstart(), and unpublish_feature().

◆ MSI_RecordStreamToFile()

UINT MSI_RecordStreamToFile	(	MSIRECORD *	rec,
		UINT	iField,
		LPCWSTR	name
	)

Definition at line 900 of file record.c.

{
    IStream *stm = NULL;
    UINT r;
 
    TRACE("%p %u %s\n", rec, iField, debugstr_w(name));
 
    msiobj_lock( &rec->hdr );
 
    r = MSI_RecordGetIStream( rec, iField, &stm );
    if( r == ERROR_SUCCESS )
    {
        r = dump_stream_to_file( stm, name );
        IStream_Release( stm );
    }
 
    msiobj_unlock( &rec->hdr );
 
    return r;
}

Referenced by load_image().

◆ msi_reduce_to_long_filename()

void msi_reduce_to_long_filename ( WCHAR * filename )

Definition at line 1053 of file files.c.

{
    WCHAR *p = wcschr( filename, '|' );
    if (p) memmove( filename, p + 1, (lstrlenW( p + 1 ) + 1) * sizeof(WCHAR) );
}

Referenced by get_duplicate_filename(), get_link_file(), ITERATE_MoveFiles(), ITERATE_RemoveFiles(), load_class(), and load_file().

◆ msi_reg_get_val_dword()

BOOL msi_reg_get_val_dword	(	HKEY	hkey,
		LPCWSTR	name,
		DWORD *	val
	)

Definition at line 262 of file registry.c.

{
    DWORD type, len = sizeof (DWORD);
    LONG r = RegQueryValueExW(hkey, name, NULL, &type, (LPBYTE) val, &len);
    return r == ERROR_SUCCESS && type == REG_DWORD;
}

Referenced by MSI_GetComponentPath(), MsiQueryProductStateW(), and reg_get_value().

◆ msi_reg_get_val_str()

WCHAR * msi_reg_get_val_str	(	HKEY	hkey,
		const WCHAR *	name
	)

Referenced by ACTION_PublishProduct(), get_install_location(), get_registered_local_package(), ITERATE_PublishComponent(), MSI_GetComponentPath(), MSI_GetUserInfo(), MSI_OpenProductW(), open_package(), query_feature_state(), reg_get_value(), and set_installer_properties().

◆ msi_reg_set_subkey_val()

LONG msi_reg_set_subkey_val	(	HKEY	hkey,
		LPCWSTR	path,
		LPCWSTR	name,
		LPCWSTR	val
	)

Definition at line 230 of file registry.c.

{
    HKEY hsubkey = 0;
    LONG r;
 
    r = RegCreateKeyW( hkey, path, &hsubkey );
    if (r != ERROR_SUCCESS)
        return r;
    r = msi_reg_set_val_str( hsubkey, name, val );
    RegCloseKey( hsubkey );
    return r;
}

Referenced by ACTION_RegisterClassInfo(), ACTION_RegisterMIMEInfo(), register_progid(), and register_verb().

◆ msi_reg_set_val_dword()

LONG msi_reg_set_val_dword	(	HKEY	hkey,
		LPCWSTR	name,
		DWORD	val
	)

Definition at line 225 of file registry.c.

{
    return RegSetValueExW( hkey, name, 0, REG_DWORD, (LPBYTE)&val, sizeof (DWORD) );
}

Referenced by publish_install_properties(), publish_product_properties(), and write_shared_dlls_count().

◆ msi_reg_set_val_multi_str()

LONG msi_reg_set_val_multi_str	(	HKEY	hkey,
		LPCWSTR	name,
		LPCWSTR	value
	)

Definition at line 217 of file registry.c.

{
    LPCWSTR p = value;
    while (*p) p += lstrlenW(p) + 1;
    return RegSetValueExW( hkey, name, 0, REG_MULTI_SZ,
                           (const BYTE *)value, (p + 1 - value) * sizeof(WCHAR) );
}

Referenced by ITERATE_PublishComponent(), publish_product_properties(), and register_verb().

◆ msi_reg_set_val_str()

LONG msi_reg_set_val_str	(	HKEY	hkey,
		LPCWSTR	name,
		LPCWSTR	value
	)

Definition at line 209 of file registry.c.

{
    DWORD len;
    if (!value) value = L"";
    len = (lstrlenW(value) + 1) * sizeof (WCHAR);
    return RegSetValueExW( hkey, name, 0, REG_SZ, (const BYTE *)value, len );
}

Referenced by ACTION_ForceReboot(), ACTION_ProcessComponents(), ACTION_PublishFeatures(), ACTION_RegisterClassInfo(), ACTION_RegisterExtensionInfo(), ACTION_RegisterProduct(), ACTION_RegisterUser(), ITERATE_RegisterFonts(), msi_reg_set_subkey_val(), MsiSourceListSetInfoW(), publish_install_properties(), publish_product_properties(), publish_upgrade_code(), register_appid(), register_progid(), and register_verb().

◆ msi_register_unique_action()

UINT msi_register_unique_action	(	MSIPACKAGE *	package,
		const WCHAR *	action
	)

Definition at line 112 of file custom.c.

{
    UINT count;
    WCHAR **newbuf = NULL;
 
    TRACE("Registering %s as unique action\n", debugstr_w(action));
 
    count = package->unique_actions_count;
    package->unique_actions_count++;
    if (count != 0) newbuf = realloc( package->unique_actions,
                                      package->unique_actions_count * sizeof(WCHAR *) );
    else newbuf = malloc( sizeof(WCHAR *) );
 
    newbuf[count] = wcsdup( action );
    package->unique_actions = newbuf;
    return ERROR_SUCCESS;
}

Referenced by ACTION_AppSearch(), ACTION_CCPSearch(), ACTION_FindRelatedProducts(), and check_execution_scheduling_options().

◆ msi_remove_directory()

BOOL msi_remove_directory	(	MSIPACKAGE *	package,
		const WCHAR *	path
	)

Definition at line 97 of file files.c.

{
    BOOL ret;
    msi_disable_fs_redirection( package );
    ret = RemoveDirectoryW( path );
    msi_revert_fs_redirection( package );
    return ret;
}

Referenced by ITERATE_RemoveFiles(), ITERATE_UnpublishIcon(), and remove_path().

◆ msi_reset_source_folders()

void msi_reset_source_folders ( MSIPACKAGE * package )

Definition at line 2121 of file package.c.

{
    MSIFOLDER *folder;
 
    LIST_FOR_EACH_ENTRY( folder, &package->folders, MSIFOLDER, entry )
    {
        free( folder->ResolvedSource );
        folder->ResolvedSource = NULL;
    }
}

Referenced by ACTION_CustomAction(), append_productcode(), dialog_set_property(), ITERATE_AppSearch(), msi_parse_command_line(), msi_set_sourcedir_props(), and MsiSetPropertyW().

◆ msi_resolve_file_source()

WCHAR * msi_resolve_file_source	(	MSIPACKAGE *	package,
		MSIFILE *	file
	)

Definition at line 536 of file files.c.

{
    WCHAR *p, *path;
 
    TRACE("Working to resolve source of file %s\n", debugstr_w(file->File));
 
    if (file->IsCompressed) return NULL;
 
    p = msi_resolve_source_folder( package, file->Component->Directory, NULL );
    path = msi_build_directory_name( 2, p, file->ShortName );
 
    if (file->LongName && msi_get_file_attributes( package, path ) == INVALID_FILE_ATTRIBUTES)
    {
        free( path );
        path = msi_build_directory_name( 2, p, file->LongName );
    }
    free( p );
    TRACE("file %s source resolves to %s\n", debugstr_w(file->File), debugstr_w(path));
    return path;
}

Referenced by ACTION_InstallFiles(), and ACTION_ProcessComponents().

◆ 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 = wcsdup( 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 = wcsdup( path );
    free( p );
 
    return path;
}

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

◆ msi_resolve_target_folder()

void msi_resolve_target_folder	(	MSIPACKAGE *	package,
		const WCHAR *	name,
		BOOL	load_prop
	)

Definition at line 2183 of file action.c.

{
    FolderList *fl;
    MSIFOLDER *folder, *parent, *child;
    WCHAR *path, *normalized_path;
 
    TRACE("resolving %s\n", debugstr_w(name));
 
    if (!(folder = msi_get_loaded_folder( package, name ))) return;
 
    if (!wcscmp( folder->Directory, L"TARGETDIR" )) /* special resolving for target root dir */
    {
        if (!(path = get_install_location( package )) &&
            (!load_prop || !(path = msi_dup_property( package->db, L"TARGETDIR" ))))
        {
            path = msi_dup_property( package->db, L"ROOTDRIVE" );
        }
        if (is_admin_install( package )) load_prop = FALSE;
    }
    else if (!load_prop || !(path = msi_dup_property( package->db, folder->Directory )))
    {
        if (folder->Parent && wcscmp( folder->Directory, folder->Parent ))
        {
            parent = msi_get_loaded_folder( package, folder->Parent );
            path = msi_build_directory_name( 3, parent->ResolvedTarget, folder->TargetDefault, NULL );
        }
        else
            path = msi_build_directory_name( 2, folder->TargetDefault, NULL );
    }
 
    normalized_path = msi_normalize_path( path );
    msi_set_property( package->db, folder->Directory, normalized_path, -1 );
    free( path );
 
    free( folder->ResolvedTarget );
    folder->ResolvedTarget = normalized_path;
 
    LIST_FOR_EACH_ENTRY( fl, &folder->children, FolderList, entry )
    {
        child = fl->folder;
        msi_resolve_target_folder( package, child->Directory, load_prop );
    }
    TRACE("%s resolves to %s\n", debugstr_w(name), debugstr_w(folder->ResolvedTarget));
}

Referenced by ACTION_CostFinalize(), msi_get_target_folder(), msi_resolve_target_folder(), and set_target_path().

◆ msi_revert_fs_redirection()

static void msi_revert_fs_redirection ( MSIPACKAGE * package )

inlinestatic

Definition at line 1103 of file msipriv.h.

{
    if (is_wow64 && is_platform_64bit( package->platform )) Wow64RevertWow64FsRedirection( package->cookie );
}

Referenced by apply_filepatch(), bind_image(), create_directory(), ITERATE_CreateShortcuts(), load_library(), load_typelib(), msi_copy_file(), msi_create_file(), msi_delete_file(), msi_find_first_file(), msi_find_next_file(), msi_get_file_attributes(), msi_get_file_version_info(), msi_get_temp_file_name(), msi_move_file(), msi_remove_directory(), and msi_set_file_attributes().

◆ msi_save_string_table()

UINT msi_save_string_table	(	const string_table *	st,
		IStorage *	storage,
		UINT *	bytes_per_strref
	)

Definition at line 564 of file string.c.

{
    UINT i, datasize = 0, poolsize = 0, sz, used, r, codepage, n;
    UINT ret = ERROR_FUNCTION_FAILED;
    CHAR *data = NULL;
    USHORT *pool = NULL;
 
    TRACE("\n");
 
    /* construct the new table in memory first */
    string_totalsize( st, &datasize, &poolsize );
 
    TRACE("%u %u %u\n", st->maxcount, datasize, poolsize );
 
    pool = malloc( poolsize );
    if( ! pool )
    {
        WARN("Failed to alloc pool %d bytes\n", poolsize );
        goto err;
    }
    data = malloc( datasize );
    if( ! data )
    {
        WARN("Failed to alloc data %d bytes\n", datasize );
        goto err;
    }
 
    used = 0;
    codepage = st->codepage;
    pool[0] = codepage & 0xffff;
    pool[1] = codepage >> 16;
    if (st->maxcount > 0xffff)
    {
        pool[1] |= 0x8000;
        *bytes_per_strref = LONG_STR_BYTES;
    }
    else
        *bytes_per_strref = sizeof(USHORT);
 
    n = 1;
    for( i=1; i<st->maxcount; i++ )
    {
        if( !st->strings[i].persistent_refcount )
        {
            pool[ n*2 ] = 0;
            pool[ n*2 + 1] = 0;
            n++;
            continue;
        }
 
        sz = datasize - used;
        r = id2string( st, i, data+used, &sz );
        if( r != ERROR_SUCCESS )
        {
            ERR("failed to fetch string\n");
            sz = 0;
        }
 
        if (sz)
            pool[ n*2 + 1 ] = st->strings[i].persistent_refcount;
        else
            pool[ n*2 + 1 ] = 0;
        if (sz < 0x10000)
        {
            pool[ n*2 ] = sz;
            n++;
        }
        else
        {
            pool[ n*2 ] = 0;
            pool[ n*2 + 2 ] = sz&0xffff;
            pool[ n*2 + 3 ] = (sz>>16);
            n += 2;
        }
        used += sz;
        if( used > datasize  )
        {
            ERR("oops overran %d >= %d\n", used, datasize);
            goto err;
        }
    }
 
    if( used != datasize )
    {
        ERR("oops used %d != datasize %d\n", used, datasize);
        goto err;
    }
 
    /* write the streams */
    r = write_stream_data( storage, L"_StringData", data, datasize, TRUE );
    TRACE("Wrote StringData r=%08x\n", r);
    if( r )
        goto err;
    r = write_stream_data( storage, L"_StringPool", pool, poolsize, TRUE );
    TRACE("Wrote StringPool r=%08x\n", r);
    if( r )
        goto err;
 
    ret = ERROR_SUCCESS;
 
err:
    free( data );
    free( pool );
 
    return ret;
}

Referenced by MSI_CommitTables().

◆ msi_schedule_action()

UINT msi_schedule_action	(	MSIPACKAGE *	package,
		UINT	script,
		const WCHAR *	action
	)

Definition at line 89 of file custom.c.

{
    UINT count;
    WCHAR **newbuf = NULL;
 
    if (script >= SCRIPT_MAX)
    {
        FIXME("Unknown script requested %u\n", script);
        return ERROR_FUNCTION_FAILED;
    }
    TRACE("Scheduling action %s in script %u\n", debugstr_w(action), script);
 
    count = package->script_actions_count[script];
    package->script_actions_count[script]++;
    if (count != 0) newbuf = realloc( package->script_actions[script],
                                      package->script_actions_count[script] * sizeof(WCHAR *) );
    else newbuf = malloc( sizeof(WCHAR *) );
 
    newbuf[count] = wcsdup( action );
    package->script_actions[script] = newbuf;
    return ERROR_SUCCESS;
}

Referenced by ACTION_CreateFolders(), ACTION_CreateShortcuts(), ACTION_DeleteServices(), ACTION_DuplicateFiles(), ACTION_HandleStandardAction(), ACTION_InstallFiles(), ACTION_InstallODBC(), ACTION_InstallServices(), ACTION_MoveFiles(), ACTION_MsiPublishAssemblies(), ACTION_MsiUnpublishAssemblies(), ACTION_PatchFiles(), ACTION_ProcessComponents(), ACTION_PublishComponents(), ACTION_PublishFeatures(), ACTION_PublishProduct(), ACTION_RegisterClassInfo(), ACTION_RegisterExtensionInfo(), ACTION_RegisterFonts(), ACTION_RegisterMIMEInfo(), ACTION_RegisterProduct(), ACTION_RegisterProgIdInfo(), ACTION_RegisterTypeLibraries(), ACTION_RegisterUser(), ACTION_RemoveDuplicateFiles(), ACTION_RemoveEnvironmentStrings(), ACTION_RemoveFiles(), ACTION_RemoveFolders(), ACTION_RemoveIniValues(), ACTION_RemoveODBC(), ACTION_RemoveRegistryValues(), ACTION_RemoveShortcuts(), ACTION_SelfRegModules(), ACTION_SelfUnregModules(), ACTION_StartServices(), ACTION_StopServices(), ACTION_UnpublishComponents(), ACTION_UnpublishFeatures(), ACTION_UnregisterClassInfo(), ACTION_UnregisterExtensionInfo(), ACTION_UnregisterFonts(), ACTION_UnregisterMIMEInfo(), ACTION_UnregisterProgIdInfo(), ACTION_UnregisterTypeLibraries(), ACTION_WriteEnvironmentStrings(), ACTION_WriteIniValues(), ACTION_WriteRegistryValues(), and defer_custom_action().

◆ MSI_Sequence()

UINT MSI_Sequence	(	MSIPACKAGE *	package,
		LPCWSTR	szTable
	)

Definition at line 446 of file action.c.

{
    MSIQUERY *view;
    UINT r;
 
    TRACE("%p %s\n", package, debugstr_w(table));
 
    r = MSI_OpenQuery( package->db, &view, L"SELECT * FROM `%s` WHERE `Sequence` > 0 ORDER BY `Sequence`", table );
    if (r == ERROR_SUCCESS)
    {
        r = MSI_IterateRecords( view, NULL, ITERATE_Actions, package );
        msiobj_release(&view->hdr);
    }
    return r;
}

Referenced by MsiSequenceW().

◆ msi_set_context()

UINT msi_set_context ( MSIPACKAGE * package )

Definition at line 390 of file action.c.

{
    UINT r = msi_locate_product( package->ProductCode, &package->Context );
    if (r != ERROR_SUCCESS)
    {
        int num = msi_get_property_int( package->db, L"ALLUSERS", 0 );
        if (num == 1 || num == 2)
            package->Context = MSIINSTALLCONTEXT_MACHINE;
        else
            package->Context = MSIINSTALLCONTEXT_USERUNMANAGED;
    }
    return ERROR_SUCCESS;
}

Referenced by MSI_InstallPackage(), and MSI_OpenPackageW().

◆ msi_set_file_attributes()

BOOL msi_set_file_attributes	(	MSIPACKAGE *	package,
		const WCHAR *	filename,
		DWORD	attrs
	)

Definition at line 106 of file files.c.

{
    BOOL ret;
    msi_disable_fs_redirection( package );
    ret = SetFileAttributesW( filename, attrs );
    msi_revert_fs_redirection( package );
    return ret;
}

Referenced by ACTION_RemoveFiles(), cabinet_copy_file(), copy_file_attributes(), and copy_install_file().

◆ msi_set_last_used_source()

UINT msi_set_last_used_source	(	LPCWSTR	product,
		LPCWSTR	usersid,
		MSIINSTALLCONTEXT	context,
		DWORD	options,
		LPCWSTR	value
	)

Definition at line 686 of file source.c.

{
    HKEY source;
    LPWSTR buffer;
    WCHAR typechar;
    DWORD size;
    UINT r;
    int index = 1;
 
    if (options & MSISOURCETYPE_NETWORK)
        typechar = 'n';
    else if (options & MSISOURCETYPE_URL)
        typechar = 'u';
    else if (options & MSISOURCETYPE_MEDIA)
        typechar = 'm';
    else
        return ERROR_INVALID_PARAMETER;
 
    if (!(options & MSISOURCETYPE_MEDIA))
    {
        r = MsiSourceListAddSourceExW(product, usersid, context,
                                      options, value, 0);
        if (r != ERROR_SUCCESS)
            return r;
 
        index = 0;
        while ((r = MsiSourceListEnumSourcesW(product, usersid, context, options,
                                              index, NULL, NULL)) == ERROR_SUCCESS)
            index++;
 
        if (r != ERROR_NO_MORE_ITEMS)
            return r;
    }
 
    size = lstrlenW(L"%c;%d;%s") + lstrlenW(value) + 7;
    buffer = malloc(size * sizeof(WCHAR));
    if (!buffer)
        return ERROR_OUTOFMEMORY;
 
    r = OpenSourceKey(product, &source, MSICODE_PRODUCT, context, FALSE);
    if (r != ERROR_SUCCESS)
    {
        free(buffer);
        return r;
    }
 
    swprintf(buffer, size, L"%c;%d;%s", typechar, index, value);
 
    size = (lstrlenW(buffer) + 1) * sizeof(WCHAR);
    r = RegSetValueExW(source, INSTALLPROPERTY_LASTUSEDSOURCEW, 0,
                       REG_SZ, (LPBYTE)buffer, size);
    free(buffer);
 
    RegCloseKey(source);
    return r;
}

Referenced by MsiSourceListSetInfoW(), and publish_sourcelist().

◆ msi_set_original_database_property()

UINT msi_set_original_database_property	(	MSIDATABASE *	db,
		const WCHAR *	package
	)

Definition at line 1342 of file package.c.

{
    UINT r;
 
    if (UrlIsW( package, URLIS_URL ))
        r = msi_set_property( db, L"OriginalDatabase", package, -1 );
    else if (package[0] == '#')
        r = msi_set_property( db, L"OriginalDatabase", db->path, -1 );
    else
    {
        DWORD len;
        WCHAR *path;
 
        if (!(len = GetFullPathNameW( package, 0, NULL, NULL ))) return GetLastError();
        if (!(path = malloc( len * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
        len = GetFullPathNameW( package, len, path, NULL );
        r = msi_set_property( db, L"OriginalDatabase", path, len );
        free( path );
    }
    return r;
}

Referenced by MSI_InstallPackage(), and MSI_OpenPackageW().

◆ msi_set_property()

UINT msi_set_property	(	MSIDATABASE *	db,
		const WCHAR *	name,
		const WCHAR *	value,
		int	len
	)

Definition at line 2132 of file package.c.

{
    MSIQUERY *view;
    MSIRECORD *row = NULL;
    DWORD sz = 0;
    WCHAR query[1024];
    UINT rc;
 
    TRACE("%p %s %s %d\n", db, debugstr_w(name), debugstr_wn(value, len), len);
 
    if (!name)
        return ERROR_INVALID_PARAMETER;
 
    /* this one is weird... */
    if (!name[0])
        return value ? ERROR_FUNCTION_FAILED : ERROR_SUCCESS;
 
    if (value && len < 0) len = lstrlenW( value );
 
    rc = msi_get_property( db, name, 0, &sz );
    if (!value || (!*value && !len))
    {
        swprintf( query, ARRAY_SIZE(query), L"DELETE FROM `_Property` WHERE `_Property` = '%s'", name );
    }
    else if (rc == ERROR_MORE_DATA || rc == ERROR_SUCCESS)
    {
        swprintf( query, ARRAY_SIZE(query), L"UPDATE `_Property` SET `Value` = ? WHERE `_Property` = '%s'", name );
        row = MSI_CreateRecord(1);
        msi_record_set_string( row, 1, value, len );
    }
    else
    {
        lstrcpyW( query, L"INSERT INTO `_Property` (`_Property`,`Value`) VALUES (?,?)" );
        row = MSI_CreateRecord(2);
        msi_record_set_string( row, 1, name, -1 );
        msi_record_set_string( row, 2, value, len );
    }
 
    rc = MSI_DatabaseOpenViewW(db, query, &view);
    if (rc == ERROR_SUCCESS)
    {
        rc = MSI_ViewExecute(view, row);
        MSI_ViewClose(view);
        msiobj_release(&view->hdr);
    }
    if (row) msiobj_release(&row->hdr);
    return rc;
}

Referenced by ACTION_ADMIN(), ACTION_CostFinalize(), ACTION_CostInitialize(), ACTION_CustomAction(), ACTION_DisableRollback(), ACTION_INSTALL(), ACTION_ProcessExecSequence(), append_productcode(), dialog_set_property(), event_add_local(), event_add_source(), event_reinstall(), event_reinstall_mode(), event_remove(), ITERATE_AppSearch(), ITERATE_CCPSearch(), msi_adjust_privilege_properties(), MSI_CreatePackage(), MSI_InstallPackage(), msi_load_suminfo_properties(), MSI_OpenPackageW(), msi_parse_command_line(), msi_resolve_target_folder(), msi_set_original_database_property(), msi_set_sourcedir_props(), MSI_SetInstallLevel(), msi_validate_product_id(), MsiSetPropertyW(), patch_set_media_source_prop(), process_overrides(), set_deferred_action_props(), set_installed_prop(), set_installer_properties(), set_msi_assembly_prop(), set_target_path(), and set_user_sid_prop().

◆ msi_set_sourcedir_props()

UINT msi_set_sourcedir_props	(	MSIPACKAGE *	package,
		BOOL	replace
	)

Definition at line 348 of file action.c.

{
    WCHAR *source, *check, *p, *db;
    DWORD len;
 
    if (!(db = msi_dup_property( package->db, L"OriginalDatabase" )))
        return ERROR_OUTOFMEMORY;
 
    if (!(p = wcsrchr( db, '\\' )) && !(p = wcsrchr( db, '/' )))
    {
        free(db);
        return ERROR_SUCCESS;
    }
    len = p - db + 2;
    source = malloc( len * sizeof(WCHAR) );
    lstrcpynW( source, db, len );
    free( db );
 
    check = msi_dup_property( package->db, L"SourceDir" );
    if (!check || replace)
    {
        UINT r = msi_set_property( package->db, L"SourceDir", source, -1 );
        if (r == ERROR_SUCCESS)
            msi_reset_source_folders( package );
    }
    free( check );
 
    check = msi_dup_property( package->db, L"SOURCEDIR" );
    if (!check || replace)
        msi_set_property( package->db, L"SOURCEDIR", source, -1 );
 
    free( check );
    free( source );
 
    return ERROR_SUCCESS;
}

Referenced by ACTION_InstallFiles(), ACTION_ProcessComponents(), ACTION_ResolveSource(), get_source_root(), MSI_InstallPackage(), and msi_load_media_info().

◆ msi_set_string_table_codepage()

UINT msi_set_string_table_codepage	(	string_table *	st,
		UINT	codepage
	)

Definition at line 676 of file string.c.

{
    if (validate_codepage( codepage ))
    {
        st->codepage = codepage;
        return ERROR_SUCCESS;
    }
    return ERROR_FUNCTION_FAILED;
}

Referenced by MSI_DatabaseImport().

◆ MSI_SetFeatureStates()

UINT MSI_SetFeatureStates ( MSIPACKAGE * package )

Definition at line 1638 of file action.c.

{
    int level;
    MSICOMPONENT* component;
    MSIFEATURE *feature;
 
    TRACE("Checking Install Level\n");
 
    level = msi_get_property_int(package->db, L"INSTALLLEVEL", 1);
 
    if (msi_get_property_int( package->db, L"Preselected", 0 ))
    {
        LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
        {
            if (!is_feature_selected( feature, level )) continue;
 
            if (feature->ActionRequest == INSTALLSTATE_UNKNOWN)
            {
                if (feature->Installed == INSTALLSTATE_ABSENT)
                {
                    feature->Action = INSTALLSTATE_UNKNOWN;
                    feature->ActionRequest = INSTALLSTATE_UNKNOWN;
                }
                else
                {
                    feature->Action = feature->Installed;
                    feature->ActionRequest = feature->Installed;
                }
            }
        }
    }
    else if (!msi_get_property_int( package->db, L"Installed", 0 ))
    {
        LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
        {
            if (!is_feature_selected( feature, level )) continue;
 
            if (feature->ActionRequest == INSTALLSTATE_UNKNOWN)
            {
                if (feature->Attributes & msidbFeatureAttributesFavorSource)
                {
                    feature->Action = INSTALLSTATE_SOURCE;
                    feature->ActionRequest = INSTALLSTATE_SOURCE;
                }
                else if (feature->Attributes & msidbFeatureAttributesFavorAdvertise)
                {
                    feature->Action = INSTALLSTATE_ADVERTISED;
                    feature->ActionRequest = INSTALLSTATE_ADVERTISED;
                }
                else
                {
                    feature->Action = INSTALLSTATE_LOCAL;
                    feature->ActionRequest = INSTALLSTATE_LOCAL;
                }
            }
        }
    }
    else
    {
        LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
        {
            ComponentList *cl;
            MSIFEATURE *cur;
 
            if (!is_feature_selected( feature, level )) continue;
            if (feature->ActionRequest != INSTALLSTATE_UNKNOWN) continue;
 
            LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
            {
                if (!cl->component->updated && !cl->component->added)
                    continue;
 
                cur = feature;
                while (cur)
                {
                    if (cur->ActionRequest != INSTALLSTATE_UNKNOWN)
                        break;
 
                    if (cur->Installed != INSTALLSTATE_ABSENT)
                    {
                        cur->Action = cur->Installed;
                        cur->ActionRequest = cur->Installed;
                    }
                    else if (!cl->component->added)
                    {
                        break;
                    }
                    else if (cur->Attributes & msidbFeatureAttributesFavorSource)
                    {
                        cur->Action = INSTALLSTATE_SOURCE;
                        cur->ActionRequest = INSTALLSTATE_SOURCE;
                    }
                    else if (cur->Attributes & msidbFeatureAttributesFavorAdvertise)
                    {
                        cur->Action = INSTALLSTATE_ADVERTISED;
                        cur->ActionRequest = INSTALLSTATE_ADVERTISED;
                    }
                    else
                    {
                        cur->Action = INSTALLSTATE_LOCAL;
                        cur->ActionRequest = INSTALLSTATE_LOCAL;
                    }
 
                    if (!cur->Feature_Parent)
                        break;
                    cur = msi_get_loaded_feature(package, cur->Feature_Parent);
                }
            }
        }
    }
 
    /* disable child features of unselected parent or follow parent */
    LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
    {
        if (feature->Feature_Parent) continue;
        disable_children( feature, level );
        follow_parent( feature );
    }
 
    /* now we want to set component state based based on feature state */
    LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
    {
        ComponentList *cl;
 
        TRACE("examining feature %s (level %d installed %d request %d action %d)\n",
              debugstr_w(feature->Feature), feature->Level, feature->Installed,
              feature->ActionRequest, feature->Action);
 
        /* features with components that have compressed files are made local */
        LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
        {
            if (cl->component->ForceLocalState &&
                feature->ActionRequest == INSTALLSTATE_SOURCE)
            {
                feature->Action = INSTALLSTATE_LOCAL;
                feature->ActionRequest = INSTALLSTATE_LOCAL;
                break;
            }
        }
 
        LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
        {
            component = cl->component;
 
            switch (feature->ActionRequest)
            {
            case INSTALLSTATE_ABSENT:
                component->anyAbsent = 1;
                break;
            case INSTALLSTATE_ADVERTISED:
                component->hasAdvertisedFeature = 1;
                break;
            case INSTALLSTATE_SOURCE:
                component->hasSourceFeature = 1;
                break;
            case INSTALLSTATE_LOCAL:
                component->hasLocalFeature = 1;
                break;
            case INSTALLSTATE_DEFAULT:
                if (feature->Attributes & msidbFeatureAttributesFavorAdvertise)
                    component->hasAdvertisedFeature = 1;
                else if (feature->Attributes & msidbFeatureAttributesFavorSource)
                    component->hasSourceFeature = 1;
                else
                    component->hasLocalFeature = 1;
                break;
            case INSTALLSTATE_UNKNOWN:
                if (feature->Installed == INSTALLSTATE_ADVERTISED)
                    component->hasAdvertisedFeature = 1;
                if (feature->Installed == INSTALLSTATE_SOURCE)
                    component->hasSourceFeature = 1;
                if (feature->Installed == INSTALLSTATE_LOCAL)
                    component->hasLocalFeature = 1;
                break;
            default:
                break;
            }
        }
    }
 
    LIST_FOR_EACH_ENTRY( component, &package->components, MSICOMPONENT, entry )
    {
        /* check if it's local or source */
        if (!(component->Attributes & msidbComponentAttributesOptional) &&
             (component->hasLocalFeature || component->hasSourceFeature))
        {
            if ((component->Attributes & msidbComponentAttributesSourceOnly) &&
                 !component->ForceLocalState)
            {
                component->Action = INSTALLSTATE_SOURCE;
                component->ActionRequest = INSTALLSTATE_SOURCE;
            }
            else
            {
                component->Action = INSTALLSTATE_LOCAL;
                component->ActionRequest = INSTALLSTATE_LOCAL;
            }
            continue;
        }
 
        /* if any feature is local, the component must be local too */
        if (component->hasLocalFeature)
        {
            component->Action = INSTALLSTATE_LOCAL;
            component->ActionRequest = INSTALLSTATE_LOCAL;
            continue;
        }
        if (component->hasSourceFeature)
        {
            component->Action = INSTALLSTATE_SOURCE;
            component->ActionRequest = INSTALLSTATE_SOURCE;
            continue;
        }
        if (component->hasAdvertisedFeature)
        {
            component->Action = INSTALLSTATE_ADVERTISED;
            component->ActionRequest = INSTALLSTATE_ADVERTISED;
            continue;
        }
        TRACE("nobody wants component %s\n", debugstr_w(component->Component));
        if (component->anyAbsent && component->ComponentId)
        {
            component->Action = INSTALLSTATE_ABSENT;
            component->ActionRequest = INSTALLSTATE_ABSENT;
        }
    }
 
    LIST_FOR_EACH_ENTRY( component, &package->components, MSICOMPONENT, entry )
    {
        if (component->ActionRequest == INSTALLSTATE_DEFAULT)
        {
            TRACE("%s was default, setting to local\n", debugstr_w(component->Component));
            component->Action = INSTALLSTATE_LOCAL;
            component->ActionRequest = INSTALLSTATE_LOCAL;
        }
 
        if (component->ActionRequest == INSTALLSTATE_SOURCE &&
            component->Installed == INSTALLSTATE_SOURCE &&
            component->hasSourceFeature)
        {
            component->Action = INSTALLSTATE_UNKNOWN;
            component->ActionRequest = INSTALLSTATE_UNKNOWN;
        }
 
        if (component->Action == INSTALLSTATE_LOCAL || component->Action == INSTALLSTATE_SOURCE)
            component->num_clients++;
        else if (component->Action == INSTALLSTATE_ABSENT)
        {
            component->num_clients--;
 
            if (component->num_clients > 0)
            {
                TRACE("multiple clients uses %s - disallowing uninstallation\n", debugstr_w(component->Component));
                component->Action = INSTALLSTATE_UNKNOWN;
            }
        }
 
        TRACE("component %s (installed %d request %d action %d)\n",
              debugstr_w(component->Component), component->Installed, component->ActionRequest, component->Action);
    }
 
    return ERROR_SUCCESS;
}

Referenced by ACTION_CostFinalize(), and MSI_SetInstallLevel().

◆ 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)
    {
        TRACE("Advertising is disallowed; making feature absent\n");
        iState = INSTALLSTATE_ABSENT;
    }
 
    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 1574 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 );
        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_split_string()

WCHAR ** msi_split_string	(	const WCHAR *	str,
		WCHAR	sep
	)

Definition at line 297 of file action.c.

{
    LPCWSTR pc;
    LPWSTR p, *ret = NULL;
    UINT count = 0;
 
    if (!str)
        return ret;
 
    /* count the number of substrings */
    for ( pc = str, count = 0; pc; count++ )
    {
        pc = wcschr( pc, sep );
        if (pc)
            pc++;
    }
 
    /* allocate space for an array of substring pointers and the substrings */
    ret = malloc( (count + 1) * sizeof(WCHAR *) + (wcslen(str) + 1) * sizeof(WCHAR) );
    if (!ret)
        return ret;
 
    /* copy the string and set the pointers */
    p = (LPWSTR) &ret[count+1];
    lstrcpyW( p, str );
    for( count = 0; (ret[count] = p); count++ )
    {
        p = wcschr( p, sep );
        if (p)
            *p++ = 0;
    }
 
    return ret;
}

Referenced by apply_patch_db(), get_patch_product_codes(), ITERATE_BindImage(), msi_apply_patches(), msi_apply_transforms(), and msi_check_patch_applicable().

◆ 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_strdupW()

WCHAR * msi_strdupW	(	const WCHAR *	value,
		int	len
	)

Definition at line 155 of file record.c.

{
    WCHAR *ret;
 
    if (!value) return NULL;
    if (!(ret = malloc( (len + 1) * sizeof(WCHAR) ))) return NULL;
    memcpy( ret, value, len * sizeof(WCHAR) );
    ret[len] = 0;
    return ret;
}

Referenced by ACTION_ExecuteAction(), msi_record_set_string(), MSI_RecordCopyField(), and parse_value().

◆ msi_string2id()

UINT msi_string2id	(	const string_table *	st,
		const WCHAR *	data,
		int	len,
		UINT *	id
	)

Definition at line 400 of file string.c.

{
    int i, c, low = 0, high = st->sortcount - 1;
 
    if (len < 0) len = lstrlenW( str );
 
    while (low <= high)
    {
        i = (low + high) / 2;
        c = cmp_string( str, len, st->strings[st->sorted[i]].data, st->strings[st->sorted[i]].len );
 
        if (c < 0)
            high = i - 1;
        else if (c > 0)
            low = i + 1;
        else
        {
            *id = st->sorted[i];
            return ERROR_SUCCESS;
        }
    }
    return ERROR_INVALID_PARAMETER;
}

Referenced by find_stream(), get_table_value_from_record(), get_tablecolumns(), join_find_row(), msi_add_string(), record_to_row(), storages_find_row(), streams_find_row(), string2id(), TABLE_add_column(), TABLE_Exists(), TABLE_set_string(), and TransformView_Create().

◆ msi_string_lookup()

const WCHAR * msi_string_lookup	(	const string_table *	st,
		UINT	id,
		int *	len
	)

Definition at line 343 of file string.c.

{
    if( id == 0 )
    {
        if (len) *len = 0;
        return L"";
    }
    if( id >= st->maxcount )
        return NULL;
 
    if( id && !st->strings[id].persistent_refcount && !st->strings[id].nonpersistent_refcount)
        return NULL;
 
    if (len) *len = st->strings[id].len;
 
    return st->strings[id].data;
}

Referenced by dump_table(), get_stream_name(), get_tablecolumns(), get_transform_record(), id2string(), msi_commit_streams(), msi_create_table(), msi_view_refresh_row(), STORAGES_set_stream(), STREAMS_delete_row(), STRING_evaluate(), TABLE_add_column(), TransformView_Create(), and TransformView_drop_table().

◆ 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	len,
		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().

◆ msi_suminfo_dup_string()

WCHAR * msi_suminfo_dup_string	(	MSISUMMARYINFO *	si,
		UINT	property
	)

Definition at line 700 of file suminfo.c.

{
    PROPVARIANT *prop;
 
    if ( uiProperty >= MSI_MAX_PROPS )
        return NULL;
    prop = &si->property[uiProperty];
    if( prop->vt != VT_LPSTR )
        return NULL;
    return strdupAtoW( prop->pszVal );
}

Referenced by check_transform_applicable(), msi_check_patch_applicable(), msi_get_package_code(), msi_get_suminfo_product(), parse_patch_summary(), and parse_suminfo().

◆ msi_suminfo_get_int32()

INT msi_suminfo_get_int32	(	MSISUMMARYINFO *	si,
		UINT	uiProperty
	)

Definition at line 712 of file suminfo.c.

{
    PROPVARIANT *prop;
 
    if ( uiProperty >= MSI_MAX_PROPS )
        return -1;
    prop = &si->property[uiProperty];
    if( prop->vt != VT_I4 )
        return -1;
    return prop->lVal;
}

Referenced by check_transform_applicable(), and parse_suminfo().

◆ msi_suminfo_get_prop()

UINT msi_suminfo_get_prop	(	MSISUMMARYINFO *	si,
		UINT	uiProperty,
		UINT *	puiDataType,
		INT *	piValue,
		FILETIME *	pftValue,
		awstring *	str,
		DWORD *	pcchValueBuf
	)

Definition at line 645 of file suminfo.c.

{
    PROPVARIANT *prop;
    UINT ret = ERROR_SUCCESS;
 
    prop = &si->property[uiProperty];
 
    if( puiDataType )
        *puiDataType = prop->vt;
 
    switch( prop->vt )
    {
    case VT_I2:
        if( piValue )
            *piValue = prop->iVal;
        break;
    case VT_I4:
        if( piValue )
            *piValue = prop->lVal;
        break;
    case VT_LPSTR:
        if( pcchValueBuf )
        {
            DWORD len = 0;
 
            if( str->unicode )
            {
                len = MultiByteToWideChar( CP_ACP, 0, prop->pszVal, -1, NULL, 0 ) - 1;
                MultiByteToWideChar( CP_ACP, 0, prop->pszVal, -1, str->str.w, *pcchValueBuf );
            }
            else
            {
                len = lstrlenA( prop->pszVal );
                if( str->str.a )
                    lstrcpynA(str->str.a, prop->pszVal, *pcchValueBuf );
            }
            if (len >= *pcchValueBuf)
                ret = ERROR_MORE_DATA;
            *pcchValueBuf = len;
        }
        break;
    case VT_FILETIME:
        if( pftValue )
            *pftValue = prop->filetime;
        break;
    case VT_EMPTY:
        break;
    default:
        FIXME("Unknown property variant type\n");
        break;
    }
    return ret;
}

Referenced by admin_update_package_info(), msi_load_suminfo_properties(), MsiSummaryInfoGetPropertyA(), MsiSummaryInfoGetPropertyW(), and save_prop().

◆ msi_suminfo_persist()

UINT msi_suminfo_persist ( MSISUMMARYINFO * si )

Definition at line 971 of file suminfo.c.

{
    UINT ret = ERROR_FUNCTION_FAILED;
    IStream *stm = NULL;
    DWORD grfMode;
    HRESULT r;
 
    grfMode = STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE;
    r = IStorage_CreateStream( si->storage, L"\5SummaryInformation", grfMode, 0, 0, &stm );
    if( SUCCEEDED(r) )
    {
        ret = save_summary_info( si, stm );
        IStream_Release( stm );
    }
    return ret;
}

Referenced by admin_update_package_info(), msi_add_suminfo(), and MsiSummaryInfoPersist().

◆ msi_suminfo_set_prop()

UINT msi_suminfo_set_prop	(	MSISUMMARYINFO *	si,
		UINT	uiProperty,
		UINT	uiDataType,
		INT	iValue,
		FILETIME *	pftValue,
		awcstring *	str
	)

Definition at line 895 of file suminfo.c.

{
    UINT type = get_type( uiProperty );
    if (type == VT_EMPTY || type != uiDataType)
        return ERROR_DATATYPE_MISMATCH;
 
    if (uiDataType == VT_LPSTR && !str->str.a)
        return ERROR_INVALID_PARAMETER;
 
    if (uiDataType == VT_FILETIME && !pftValue)
        return ERROR_INVALID_PARAMETER;
 
    return set_prop( si, uiProperty, type, iValue, pftValue, str );
}

Referenced by admin_update_package_info(), MsiSummaryInfoSetPropertyA(), and MsiSummaryInfoSetPropertyW().

◆ msi_table_apply_transform()

UINT msi_table_apply_transform	(	MSIDATABASE *	db,
		IStorage *	stg,
		int	err_cond
	)

Definition at line 3385 of file table.c.

{
    struct list transforms;
    IEnumSTATSTG *stgenum = NULL;
    struct transform_data *transform;
    struct transform_data *tables = NULL, *columns = NULL;
    HRESULT hr;
    STATSTG stat;
    string_table *strings;
    UINT ret = ERROR_FUNCTION_FAILED;
    UINT bytes_per_strref;
    BOOL property_update = FALSE;
    MSIVIEW *transform_view = NULL;
 
    TRACE("%p %p\n", db, stg );
 
    strings = msi_load_string_table( stg, &bytes_per_strref );
    if( !strings )
        goto end;
 
    hr = IStorage_EnumElements( stg, 0, NULL, 0, &stgenum );
    if (FAILED( hr ))
        goto end;
 
    list_init(&transforms);
 
    while ( TRUE )
    {
        struct table_view *tv = NULL;
        WCHAR name[0x40];
        ULONG count = 0;
 
        hr = IEnumSTATSTG_Next( stgenum, 1, &stat, &count );
        if (FAILED( hr ) || !count)
            break;
 
        decode_streamname( stat.pwcsName, name );
        CoTaskMemFree( stat.pwcsName );
        if ( name[0] != 0x4840 )
            continue;
 
        if ( !wcscmp( name+1, L"_StringPool" ) ||
             !wcscmp( name+1, L"_StringData" ) )
            continue;
 
        transform = calloc( 1, sizeof(*transform) );
        if ( !transform )
            break;
 
        list_add_tail( &transforms, &transform->entry );
 
        transform->name = wcsdup( name + 1 );
 
        if ( !wcscmp( transform->name, L"_Tables" ) )
            tables = transform;
        else if (!wcscmp( transform->name, L"_Columns" ) )
            columns = transform;
        else if (!wcscmp( transform->name, L"Property" ))
            property_update = TRUE;
 
        TRACE("transform contains stream %s\n", debugstr_w(name));
 
        /* load the table */
        if (TABLE_CreateView( db, transform->name, (MSIVIEW**) &tv ) != ERROR_SUCCESS)
            continue;
 
        if (tv->view.ops->execute( &tv->view, NULL ) != ERROR_SUCCESS)
        {
            tv->view.ops->delete( &tv->view );
            continue;
        }
 
        tv->view.ops->delete( &tv->view );
    }
 
    if (err_cond & MSITRANSFORM_ERROR_VIEWTRANSFORM)
    {
        static const WCHAR create_query[] = L"CREATE TABLE `_TransformView` ( "
            L"`Table` CHAR(0) NOT NULL TEMPORARY, `Column` CHAR(0) NOT NULL TEMPORARY, "
            L"`Row` CHAR(0) TEMPORARY, `Data` CHAR(0) TEMPORARY, `Current` CHAR(0) TEMPORARY "
            L"PRIMARY KEY `Table`, `Column`, `Row` ) HOLD";
 
        MSIQUERY *query;
        UINT r;
 
        r = MSI_DatabaseOpenViewW( db, create_query, &query );
        if (r != ERROR_SUCCESS)
            goto end;
 
        r = MSI_ViewExecute( query, NULL );
        if (r == ERROR_SUCCESS)
            MSI_ViewClose( query );
        msiobj_release( &query->hdr );
        if (r != ERROR_BAD_QUERY_SYNTAX && r != ERROR_SUCCESS)
            goto end;
 
        if (TABLE_CreateView(db, L"_TransformView", &transform_view) != ERROR_SUCCESS)
            goto end;
 
        if (r == ERROR_BAD_QUERY_SYNTAX)
            transform_view->ops->add_ref( transform_view );
 
        r = transform_view->ops->add_column( transform_view, L"new",
                MSITYPE_TEMPORARY | MSITYPE_NULLABLE | 0x402 /* INT */, FALSE );
        if (r != ERROR_SUCCESS)
            goto end;
    }
 
    /*
     * Apply _Tables and _Columns transforms first so that
     * the table metadata is correct, and empty tables exist.
     */
    ret = table_load_transform( db, stg, strings, tables, bytes_per_strref, err_cond );
    if (ret != ERROR_SUCCESS && ret != ERROR_INVALID_TABLE)
        goto end;
 
    ret = table_load_transform( db, stg, strings, columns, bytes_per_strref, err_cond );
    if (ret != ERROR_SUCCESS && ret != ERROR_INVALID_TABLE)
        goto end;
 
    ret = ERROR_SUCCESS;
 
    while ( !list_empty( &transforms ) )
    {
        transform = LIST_ENTRY( list_head( &transforms ), struct transform_data, entry );
 
        if ( wcscmp( transform->name, L"_Columns" ) &&
             wcscmp( transform->name, L"_Tables" ) &&
             ret == ERROR_SUCCESS )
        {
            ret = table_load_transform( db, stg, strings, transform, bytes_per_strref, err_cond );
        }
 
        list_remove( &transform->entry );
        free( transform->name );
        free( transform );
    }
 
    if ( ret == ERROR_SUCCESS )
    {
        append_storage_to_db( db, stg );
        if (property_update) msi_clone_properties( db );
    }
 
end:
    if ( stgenum )
        IEnumSTATSTG_Release( stgenum );
    if ( strings )
        msi_destroy_stringtable( strings );
    if (transform_view)
    {
        struct tagMSITABLE *table = ((struct table_view *)transform_view)->table;
 
        if (ret != ERROR_SUCCESS)
            transform_view->ops->release( transform_view );
 
        if (!wcscmp(table->colinfo[table->col_count - 1].colname, L"new"))
            TABLE_remove_column( transform_view, table->colinfo[table->col_count - 1].number );
        transform_view->ops->delete( transform_view );
    }
 
    return ret;
}

Referenced by apply_substorage_transform(), and MSI_DatabaseApplyTransformW().

◆ msi_ui_progress()

void msi_ui_progress	(	MSIPACKAGE *	package,
		int	a,
		int	b,
		int	c,
		int	d
	)

Definition at line 593 of file action.c.

{
    MSIRECORD *row;
 
    row = MSI_CreateRecord( 4 );
    MSI_RecordSetInteger( row, 1, a );
    MSI_RecordSetInteger( row, 2, b );
    MSI_RecordSetInteger( row, 3, c );
    MSI_RecordSetInteger( row, 4, d );
    MSI_ProcessMessage( package, INSTALLMESSAGE_PROGRESS, row );
    msiobj_release( &row->hdr );
 
    msi_dialog_check_messages( NULL );
}

Referenced by ACTION_InstallValidate(), ACTION_ProcessComponents(), file_update_ui(), ITERATE_RemoveRegistryValuesOnUninstall(), and ITERATE_WriteRegistryValues().

◆ msi_uninstall_assembly()

UINT msi_uninstall_assembly	(	MSIPACKAGE *	package,
		MSICOMPONENT *	comp
	)

Definition at line 402 of file assembly.c.

{
    HRESULT hr;
    IAssemblyCache *cache;
    MSIASSEMBLY *assembly = comp->assembly;
    MSIFEATURE *feature = NULL;
 
    if (!init_assembly_caches( package )) return ERROR_FUNCTION_FAILED;
 
    if (comp->assembly->feature)
        feature = msi_get_loaded_feature( package, comp->assembly->feature );
 
    if (assembly->application)
    {
        if (feature) feature->Action = INSTALLSTATE_ABSENT;
        return ERROR_SUCCESS;
    }
    TRACE("removing %s\n", debugstr_w(assembly->display_name));
 
    if (assembly->attributes == msidbAssemblyAttributesWin32)
    {
        cache = package->cache_sxs;
        hr = IAssemblyCache_UninstallAssembly( cache, 0, assembly->display_name, NULL, NULL );
        if (FAILED( hr )) WARN( "failed to uninstall assembly %#lx\n", hr );
    }
    else
    {
        unsigned int i;
        for (i = 0; i < CLR_VERSION_MAX; i++)
        {
            if (!assembly->clr_version[i]) continue;
            cache = package->cache_net[i];
            if (cache)
            {
                hr = IAssemblyCache_UninstallAssembly( cache, 0, assembly->display_name, NULL, NULL );
                if (FAILED( hr )) WARN( "failed to uninstall assembly %#lx\n", hr );
            }
        }
    }
    if (feature) feature->Action = INSTALLSTATE_ABSENT;
    return ERROR_SUCCESS;
}

Referenced by ACTION_RemoveFiles().

◆ msi_validate_product_id()

UINT msi_validate_product_id ( MSIPACKAGE * package )

Definition at line 7221 of file action.c.

{
    LPWSTR key, template, id;
    UINT r = ERROR_SUCCESS;
 
    id = msi_dup_property( package->db, L"ProductID" );
    if (id)
    {
        free( id );
        return ERROR_SUCCESS;
    }
    template = msi_dup_property( package->db, L"PIDTemplate" );
    key = msi_dup_property( package->db, L"PIDKEY" );
    if (key && template)
    {
        FIXME( "partial stub: template %s key %s\n", debugstr_w(template), debugstr_w(key) );
#ifdef __REACTOS__
        WARN("Product key validation HACK, see CORE-14710\n");
#else
        r = msi_set_property( package->db, L"ProductID", key, -1 );
#endif
    }
    free( template );
    free( key );
    return r;
}

Referenced by ACTION_ValidateProductID(), and event_validate_product_id().

◆ msi_version_str_to_dword()

DWORD msi_version_str_to_dword ( LPCWSTR p )

Definition at line 188 of file registry.c.

{
    DWORD major, minor = 0, build = 0, version = 0;
 
    if (!p)
        return version;
 
    major = wcstol(p, NULL, 10);
 
    p = wcschr(p, '.');
    if (p)
    {
        minor = wcstol(p+1, NULL, 10);
        p = wcschr(p+1, '.');
        if (p)
            build = wcstol(p+1, NULL, 10);
    }
 
    return MAKELONG(build, MAKEWORD(minor, major));
}

Referenced by ITERATE_FindRelatedProducts(), publish_install_properties(), and publish_product_properties().

◆ msi_view_get_row()

UINT msi_view_get_row	(	MSIDATABASE *	db,
		MSIVIEW *	view,
		UINT	row,
		MSIRECORD **	rec
	)

Definition at line 351 of file msiquery.c.

{
    UINT row_count = 0, col_count = 0, r;
    MSIRECORD *object;
 
    if ((r = view->ops->get_dimensions(view, &row_count, &col_count)))
        return r;
 
    if (row >= row_count)
        return ERROR_NO_MORE_ITEMS;
 
    if (!(object = MSI_CreateRecord( col_count )))
        return ERROR_OUTOFMEMORY;
 
    if ((r = msi_view_refresh_row(db, view, row, object)))
        msiobj_release( &object->hdr );
    else
        *rec = object;
 
    return r;
}

Referenced by join_modify_update(), MSI_ViewFetch(), TABLE_get_row(), TransformView_delete_row(), and TransformView_set_row().

◆ MSI_ViewClose()

UINT MSI_ViewClose ( MSIQUERY * query )

Definition at line 450 of file msiquery.c.

{
    MSIVIEW *view;
 
    TRACE("%p\n", query );
 
    view = query->view;
    if( !view )
        return ERROR_FUNCTION_FAILED;
    if( !view->ops->close )
        return ERROR_FUNCTION_FAILED;
 
    return view->ops->close( view );
}

Referenced by add_table_to_db(), create_temp_property_table(), get_property(), get_property_row(), msi_clone_properties(), MSI_IterateRecords(), MSI_QueryGetRecord(), msi_set_property(), msi_table_apply_transform(), MsiGetProductPropertyW(), MsiViewClose(), and TransformView_Create().

◆ MSI_ViewExecute()

UINT MSI_ViewExecute	(	MSIQUERY *	query,
		MSIRECORD *	rec
	)

Definition at line 498 of file msiquery.c.

{
    MSIVIEW *view;
 
    TRACE("%p %p\n", query, rec);
 
    view = query->view;
    if( !view )
        return ERROR_FUNCTION_FAILED;
    if( !view->ops->execute )
        return ERROR_FUNCTION_FAILED;
    query->row = 0;
 
    return view->ops->execute( view, rec );
}

Referenced by add_stream(), add_table_to_db(), create_temp_property_table(), get_assembly_record(), get_property(), get_property_row(), is_uninstallable(), load_file_hash(), load_folder_persistence(), mark_patched_components(), merge_diff_row(), msi_clone_properties(), MSI_IterateRecords(), MSI_QueryGetRecord(), msi_set_property(), msi_table_apply_transform(), MsiGetProductPropertyW(), MsiViewExecute(), patch_add_media(), patch_offset_get_filepatches(), patch_offset_get_files(), patch_offset_modify_db(), patch_set_media_source_prop(), patch_set_offsets(), patch_update_filepatch_sequence(), TransformView_add_column(), TransformView_Create(), TransformView_create_table(), TransformView_delete_row(), TransformView_drop_table(), TransformView_insert_row(), TransformView_set_row(), and update_merge_errors().

◆ MSI_ViewFetch()

UINT MSI_ViewFetch	(	MSIQUERY *	query,
		MSIRECORD **	prec
	)

Definition at line 373 of file msiquery.c.

{
    MSIVIEW *view;
    UINT r;
 
    TRACE("%p %p\n", query, prec );
 
    view = query->view;
    if( !view )
        return ERROR_FUNCTION_FAILED;
 
    r = msi_view_get_row(query->db, view, query->row, prec);
    if (r == ERROR_SUCCESS)
    {
        query->row ++;
        (*prec)->cookie = (UINT64)(ULONG_PTR)query;
        MSI_RecordSetInteger(*prec, 0, 1);
    }
    else if (r == ERROR_NO_MORE_ITEMS)
    {
        /* end of view; reset cursor to first row */
        query->row = 0;
    }
 
    return r;
}

Referenced by add_records_to_table(), get_assembly_record(), get_property(), get_property_row(), is_uninstallable(), load_file_hash(), load_folder_persistence(), merge_diff_row(), msi_clone_properties(), MSI_IterateRecords(), MSI_QueryGetRecord(), MsiGetProductPropertyW(), MsiViewFetch(), patch_add_media(), patch_offset_get_filepatches(), patch_offset_get_files(), patch_offset_modify_db(), patch_set_media_source_prop(), patch_set_offsets(), and TransformView_Create().

◆ MSI_ViewGetColumnInfo()

UINT MSI_ViewGetColumnInfo	(	MSIQUERY *	query,
		MSICOLINFO	info,
		MSIRECORD **	prec
	)

Definition at line 598 of file msiquery.c.

{
    UINT r = ERROR_FUNCTION_FAILED, i, count = 0, type;
    MSIRECORD *rec;
    MSIVIEW *view = query->view;
    LPCWSTR name;
    BOOL temporary;
 
    if( !view )
        return ERROR_FUNCTION_FAILED;
 
    if( !view->ops->get_dimensions )
        return ERROR_FUNCTION_FAILED;
 
    r = view->ops->get_dimensions( view, NULL, &count );
    if( r != ERROR_SUCCESS )
        return r;
    if( !count )
        return ERROR_INVALID_PARAMETER;
 
    rec = MSI_CreateRecord( count );
    if( !rec )
        return ERROR_FUNCTION_FAILED;
 
    for( i=0; i<count; i++ )
    {
        name = NULL;
        r = view->ops->get_column_info( view, i+1, &name, &type, &temporary, NULL );
        if( r != ERROR_SUCCESS )
            continue;
        if (info == MSICOLINFO_NAMES)
            MSI_RecordSetStringW( rec, i+1, name );
        else
            set_record_type_string( rec, i+1, type, temporary );
    }
    *prec = rec;
    return ERROR_SUCCESS;
}

Referenced by get_key_value(), get_query_columns(), get_query_types(), merge_verify_colnames(), MSI_DatabaseExport(), and MsiViewGetColumnInfo().

◆ MSI_ViewModify()

UINT MSI_ViewModify	(	MSIQUERY *	query,
		MSIMODIFY	mode,
		MSIRECORD *	rec
	)

Definition at line 693 of file msiquery.c.

{
    MSIVIEW *view = NULL;
    UINT r;
 
    if ( !query || !rec )
        return ERROR_INVALID_HANDLE;
 
    view = query->view;
    if ( !view  || !view->ops->modify)
        return ERROR_FUNCTION_FAILED;
 
    if ( mode == MSIMODIFY_UPDATE && rec->cookie != (UINT64)(ULONG_PTR)query )
        return ERROR_FUNCTION_FAILED;
 
    r = view->ops->modify( view, mode, rec, query->row - 1 );
    if (mode == MSIMODIFY_DELETE && r == ERROR_SUCCESS)
        query->row--;
 
    return r;
}

Referenced by add_records_to_table(), MsiViewModify(), patch_set_offsets(), and patch_update_file_sequence().

◆ MsiCreateAndVerifyInstallerDirectory()

UINT WINAPI MsiCreateAndVerifyInstallerDirectory ( DWORD dwReserved )

Definition at line 3810 of file msi.c.

{
    WCHAR path[MAX_PATH];
 
    TRACE( "%#lx\n", dwReserved );
 
    if (dwReserved)
    {
        FIXME( "dwReserved = %#lx\n", dwReserved );
        return ERROR_INVALID_PARAMETER;
    }
 
    if (!GetWindowsDirectoryW(path, MAX_PATH))
        return ERROR_FUNCTION_FAILED;
 
    lstrcatW(path, L"\\Installer");
 
    if (!CreateDirectoryW(path, NULL) && GetLastError() != ERROR_ALREADY_EXISTS)
        return ERROR_FUNCTION_FAILED;
 
    return ERROR_SUCCESS;
}

◆ MsiDecomposeDescriptorA()

UINT WINAPI MsiDecomposeDescriptorA	(	LPCSTR	szDescriptor,
		LPSTR	szProduct,
		LPSTR	szFeature,
		LPSTR	szComponent,
		LPDWORD	pUsed
	)

Definition at line 984 of file registry.c.

{
    WCHAR product[MAX_FEATURE_CHARS+1];
    WCHAR feature[MAX_FEATURE_CHARS+1];
    WCHAR component[MAX_FEATURE_CHARS+1];
    LPWSTR str = NULL, p = NULL, f = NULL, c = NULL;
    UINT r;
 
    TRACE("%s %p %p %p %p\n", debugstr_a(szDescriptor), szProduct,
          szFeature, szComponent, pUsed);
 
    str = strdupAtoW( szDescriptor );
    if( szDescriptor && !str )
        return ERROR_OUTOFMEMORY;
 
    if (szProduct)
        p = product;
    if (szFeature)
        f = feature;
    if (szComponent)
        c = component;
 
    r = MsiDecomposeDescriptorW( str, p, f, c, pUsed );
 
    if (r == ERROR_SUCCESS)
    {
        WideCharToMultiByte( CP_ACP, 0, p, -1,
                             szProduct, MAX_FEATURE_CHARS+1, NULL, NULL );
        WideCharToMultiByte( CP_ACP, 0, f, -1,
                             szFeature, MAX_FEATURE_CHARS+1, NULL, NULL );
        WideCharToMultiByte( CP_ACP, 0, c, -1,
                             szComponent, MAX_FEATURE_CHARS+1, NULL, NULL );
    }
 
    free( str );
 
    return r;
}

◆ MsiDecomposeDescriptorW()

UINT WINAPI MsiDecomposeDescriptorW	(	LPCWSTR	szDescriptor,
		LPWSTR	szProduct,
		LPWSTR	szFeature,
		LPWSTR	szComponent,
		LPDWORD	pUsed
	)

Definition at line 927 of file registry.c.

{
    UINT len;
    const WCHAR *p;
    GUID product, component;
 
    TRACE("%s %p %p %p %p\n", debugstr_w(szDescriptor), szProduct,
          szFeature, szComponent, pUsed);
 
    if (!decode_base85_guid( szDescriptor, &product ))
        return ERROR_INVALID_PARAMETER;
 
    TRACE("product %s\n", debugstr_guid( &product ));
 
    if (!(p = wcschr( &szDescriptor[20], '>' )))
        p = wcschr( &szDescriptor[20], '<' );
    if (!p)
        return ERROR_INVALID_PARAMETER;
 
    len = (p - &szDescriptor[20]);
    if( len > MAX_FEATURE_CHARS )
        return ERROR_INVALID_PARAMETER;
 
    TRACE("feature %s\n", debugstr_wn( &szDescriptor[20], len ));
 
    if (*p == '>')
    {
        if (!decode_base85_guid( p+1, &component ))
            return ERROR_INVALID_PARAMETER;
        TRACE( "component %s\n", debugstr_guid(&component) );
    }
 
    if (szProduct)
        StringFromGUID2( &product, szProduct, MAX_FEATURE_CHARS+1 );
    if (szComponent)
    {
        if (*p == '>')
            StringFromGUID2( &component, szComponent, MAX_FEATURE_CHARS+1 );
        else
            szComponent[0] = 0;
    }
    if (szFeature)
    {
        memcpy( szFeature, &szDescriptor[20], len*sizeof(WCHAR) );
        szFeature[len] = 0;
    }
 
    len = p - szDescriptor + 1;
    if (*p == '>') len += 20;
 
    TRACE("length = %d\n", len);
    if (pUsed) *pUsed = len;
 
    return ERROR_SUCCESS;
}

Referenced by MSI_EnumComponentQualifiers(), MSI_ProvideQualifiedComponentEx(), MsiDecomposeDescriptorA(), and MsiGetShortcutTargetW().

◆ msihandle2msiinfo()

void * msihandle2msiinfo	(	MSIHANDLE	handle,
		UINT	type
	)

Definition at line 158 of file handle.c.

{
    MSIOBJECTHDR *ret = NULL;
 
    EnterCriticalSection( &handle_cs );
    handle--;
    if (handle >= handle_table_size)
        goto out;
    if (handle_table[handle].remote)
        goto out;
    if (!handle_table[handle].u.obj)
        goto out;
    if (handle_table[handle].u.obj->magic != MSIHANDLE_MAGIC)
        goto out;
    if (type && (handle_table[handle].u.obj->type != type))
        goto out;
    ret = handle_table[handle].u.obj;
    msiobj_addref( ret );
 
out:
    LeaveCriticalSection( &handle_cs );
 
    return ret;
}

Referenced by copy_remote_record(), marshal_record(), MSI_OpenPackageW(), MsiDatabaseApplyTransformW(), MsiDatabaseCommit(), MsiDatabaseExportW(), MsiDatabaseGetPrimaryKeysW(), MsiDatabaseImportW(), MsiDatabaseIsTablePersistentW(), MsiDatabaseMergeW(), MsiDatabaseOpenViewW(), MsiEnableUIPreview(), MsiEnumComponentCostsW(), MsiFormatRecordA(), MsiFormatRecordW(), MsiGetDatabaseState(), MsiGetFeatureInfoW(), MsiGetSummaryInformationW(), MsiPreviewDialogW(), MsiProcessMessage(), MsiRecordClearData(), MsiRecordDataSize(), MsiRecordGetFieldCount(), MsiRecordGetInteger(), MsiRecordGetStringA(), MsiRecordGetStringW(), MsiRecordIsNull(), MsiRecordReadStream(), MsiRecordSetInteger(), MsiRecordSetStreamW(), MsiRecordSetStringA(), MsiRecordSetStringW(), MsiSetFeatureAttributesW(), MsiSummaryInfoGetPropertyA(), MsiSummaryInfoGetPropertyCount(), MsiSummaryInfoGetPropertyW(), MsiSummaryInfoPersist(), MsiSummaryInfoSetPropertyA(), MsiSummaryInfoSetPropertyW(), MsiViewClose(), MsiViewExecute(), MsiViewFetch(), MsiViewGetColumnInfo(), MsiViewGetErrorA(), MsiViewGetErrorW(), and MsiViewModify().

◆ MsiLoadStringA()

LANGID WINAPI MsiLoadStringA	(	MSIHANDLE	handle,
		UINT	id,
		LPSTR	lpBuffer,
		int	nBufferMax,
		LANGID	lang
	)

Definition at line 2397 of file msi.c.

{
    LPWSTR bufW;
    LANGID r;
    INT len;
 
    bufW = malloc(nBufferMax * sizeof(WCHAR));
    r = MsiLoadStringW(handle, id, bufW, nBufferMax, lang);
    if( r )
    {
        len = WideCharToMultiByte(CP_ACP, 0, bufW, -1, NULL, 0, NULL, NULL );
        if( len <= nBufferMax )
            WideCharToMultiByte( CP_ACP, 0, bufW, -1,
                                 lpBuffer, nBufferMax, NULL, NULL );
        else
            r = 0;
    }
    free(bufW);
    return r;
}

◆ MsiLoadStringW()

LANGID WINAPI MsiLoadStringW	(	MSIHANDLE	,
		UINT	,
		LPWSTR	,
		int	,
		LANGID
	)

◆ msiobj_addref()

void msiobj_addref ( MSIOBJECTHDR * info )

Definition at line 217 of file handle.c.

{
    if( !info )
        return;
 
    if( info->magic != MSIHANDLE_MAGIC )
    {
        ERR("Invalid handle!\n");
        return;
    }
 
    InterlockedIncrement(&info->refcount);
}

Referenced by alloc_msihandle(), CREATE_CreateView(), DISTINCT_CreateView(), do_msidbCustomActionTypeDll(), do_msidbCustomActionTypeScript(), INSERT_CreateView(), MSI_CreatePackage(), MSI_DatabaseOpenViewW(), MSI_EnableUIPreview(), MSI_OpenDatabaseW(), msihandle2msiinfo(), UPDATE_CreateView(), and WHERE_CreateView().

◆ msiobj_lock()

void msiobj_lock ( MSIOBJECTHDR * info )

Definition at line 231 of file handle.c.

{
    EnterCriticalSection( &object_cs );
}

Referenced by MSI_RecordCopyField(), MSI_RecordStreamToFile(), MsiRecordClearData(), MsiRecordDataSize(), MsiRecordGetFieldCount(), MsiRecordGetInteger(), MsiRecordGetStringA(), MsiRecordGetStringW(), MsiRecordIsNull(), MsiRecordReadStream(), MsiRecordSetInteger(), MsiRecordSetStreamW(), MsiRecordSetStringA(), MsiRecordSetStringW(), and MsiViewExecute().

◆ msiobj_release()

int msiobj_release ( MSIOBJECTHDR * info )

Definition at line 241 of file handle.c.

{
    int ret;
 
    if( !info )
        return -1;
 
    if( info->magic != MSIHANDLE_MAGIC )
    {
        ERR("Invalid handle!\n");
        return -1;
    }
 
    ret = InterlockedDecrement( &info->refcount );
    if( ret==0 )
    {
        if( info->destructor )
            info->destructor( info );
        TRACE("object %p destroyed\n", info);
        free( info );
    }
 
    return ret;
}

Referenced by ACTION_AllocateRegistrySpace(), ACTION_AppSearch(), ACTION_BindImage(), ACTION_CCPSearch(), ACTION_CostFinalize(), ACTION_CreateFolders(), ACTION_CreateShortcuts(), ACTION_CustomAction(), ACTION_DeleteServices(), ACTION_DuplicateFiles(), ACTION_ExecuteAction(), ACTION_FindRelatedProducts(), ACTION_InstallAdminPackage(), ACTION_InstallODBC(), ACTION_InstallServices(), ACTION_InstallValidate(), ACTION_LaunchConditions(), ACTION_MigrateFeatureStates(), ACTION_MoveFiles(), ACTION_MsiPublishAssemblies(), ACTION_MsiUnpublishAssemblies(), ACTION_PerformEndAction(), ACTION_ProcessComponents(), ACTION_ProcessExecSequence(), ACTION_ProcessUISequence(), ACTION_PublishComponents(), ACTION_PublishFeatures(), ACTION_PublishProduct(), ACTION_RegisterClassInfo(), ACTION_RegisterExtensionInfo(), ACTION_RegisterFonts(), ACTION_RegisterMIMEInfo(), ACTION_RegisterProduct(), ACTION_RegisterProgIdInfo(), ACTION_RegisterTypeLibraries(), ACTION_RegisterUser(), ACTION_RemoveDuplicateFiles(), ACTION_RemoveEnvironmentStrings(), ACTION_RemoveExistingProducts(), ACTION_RemoveFiles(), ACTION_RemoveFolders(), ACTION_RemoveIniValues(), ACTION_RemoveODBC(), ACTION_RemoveRegistryValues(), ACTION_RemoveShortcuts(), ACTION_ResolveSource(), ACTION_SelfRegModules(), ACTION_SelfUnregModules(), ACTION_SetODBCFolders(), ACTION_ShowDialog(), ACTION_StartServices(), ACTION_StopServices(), ACTION_UnpublishComponents(), ACTION_UnregisterClassInfo(), ACTION_UnregisterExtensionInfo(), ACTION_UnregisterFonts(), ACTION_UnregisterMIMEInfo(), ACTION_UnregisterProgIdInfo(), ACTION_UnregisterTypeLibraries(), ACTION_WriteEnvironmentStrings(), ACTION_WriteIniValues(), ACTION_WriteRegistryValues(), add_records_to_table(), add_stream(), add_table_to_db(), admin_update_package_info(), apply_patch_package(), arrange_record(), change_media(), check_transform_applicable(), combobox_add_items(), construct_record(), copy_remote_record(), CREATE_delete(), create_diff_row_query(), create_temp_binary(), create_temp_property_table(), deformat_string(), dialog_build_font_list(), dialog_button_handler(), dialog_create(), dialog_evaluate_control_conditions(), dialog_fill_controls(), dialog_get_uitext(), dialog_map_events(), dialog_oncreate(), dialog_radiogroup_control(), dialog_seltree_handler(), DISTINCT_delete(), event_set_target_path(), file_update_ui(), free_custom_action_data(), gather_merge_data(), get_assembly_display_name(), get_assembly_record(), get_checkbox_value(), get_key_value(), get_merge_table(), get_property(), get_property_row(), get_query_columns(), get_query_types(), get_signature(), get_table_labels(), get_transform_record(), HANDLE_CustomType19(), HANDLE_CustomType5_6(), INSERT_delete(), INSERT_execute(), internal_ui_handler(), is_uninstallable(), ITERATE_AppSearch(), ITERATE_CreateFolders(), ITERATE_DeleteService(), ITERATE_DuplicateFiles(), ITERATE_FindRelatedProducts(), ITERATE_InstallODBCDataSource(), ITERATE_InstallODBCDriver(), ITERATE_InstallODBCTranslator(), ITERATE_InstallService(), ITERATE_MoveFiles(), iterate_properties(), ITERATE_PublishComponent(), ITERATE_RegisterFonts(), ITERATE_RemoveDuplicateFiles(), ITERATE_RemoveEnvironmentString(), ITERATE_RemoveFiles(), ITERATE_RemoveFolders(), ITERATE_RemoveIniValuesOnInstall(), ITERATE_RemoveIniValuesOnUninstall(), ITERATE_RemoveODBCDataSource(), ITERATE_RemoveODBCDriver(), ITERATE_RemoveODBCTranslator(), ITERATE_RemoveRegistryValuesOnInstall(), ITERATE_RemoveRegistryValuesOnUninstall(), ITERATE_SelfRegModules(), ITERATE_SelfUnregModules(), ITERATE_StartService(), ITERATE_StopService(), ITERATE_UnpublishComponent(), ITERATE_UnregisterFonts(), ITERATE_WriteEnvironmentString(), ITERATE_WriteIniValues(), ITERATE_WriteRegistryValues(), join_modify_update(), listbox_add_items(), listview_add_items(), load_all_classes(), load_all_drlocators(), load_all_extensions(), load_all_files(), load_all_folders(), load_all_media(), load_all_mimes(), load_all_patches(), load_all_progids(), load_all_verbs(), load_feature(), load_file_disk_id(), load_file_hash(), load_folder_persistence(), load_given_appid(), load_given_class(), load_given_extension(), load_given_mime(), load_given_progid(), load_image(), load_patch_disk_id(), load_picture(), mark_patched_components(), marshal_record(), media_get_disk_info(), merge_diff_row(), merge_diff_tables(), merge_free_rows(), merge_verify_colnames(), merge_verify_primary_keys(), msi_add_suminfo(), MSI_ApplicablePatchW(), msi_apply_registered_patch(), msi_clone_properties(), MSI_CloneRecord(), MSI_ClosePreview(), MSI_CloseView(), msi_create_table(), MSI_CreatePackage(), MSI_DatabaseExport(), MSI_DatabaseGetPrimaryKeys(), MSI_DatabaseOpenViewW(), MSI_EnableUIPreview(), msi_export_suminfo(), MSI_FormatRecordW(), MSI_FreePackage(), msi_get_db_suminfo(), msi_get_error_message(), msi_get_package_code(), msi_get_property(), msi_get_suminfo(), msi_get_suminfo_product(), MSI_IterateRecords(), msi_load_all_components(), msi_load_all_features(), msi_load_assembly(), msi_load_media_info(), msi_load_suminfo_properties(), MSI_OpenDatabaseW(), MSI_OpenPackageW(), msi_query_merge_record(), MSI_QueryGetRecord(), MSI_Sequence(), msi_set_property(), msi_table_apply_transform(), msi_ui_progress(), msi_view_get_row(), MsiCloseHandle(), MsiCollectUserInfoA(), MsiCollectUserInfoW(), MsiConfigureFeatureW(), MsiConfigureProductExW(), MsiCreateRecord(), MsiDatabaseApplyTransformW(), MsiDatabaseCommit(), MsiDatabaseExportW(), MsiDatabaseGetPrimaryKeysW(), MsiDatabaseImportW(), MsiDatabaseIsTablePersistentW(), MsiDatabaseMergeW(), MsiDatabaseOpenViewW(), MsiDetermineApplicablePatchesW(), MsiDeterminePatchSequenceW(), MsiDoActionW(), MsiEnableUIPreview(), MsiEnumComponentCostsW(), MsiFormatRecordA(), MsiFormatRecordW(), MsiGetActiveDatabase(), MsiGetComponentStateW(), MsiGetDatabaseState(), MsiGetFeatureCostW(), MsiGetFeatureInfoW(), MsiGetFeatureStateW(), MsiGetLanguage(), MsiGetMode(), MsiGetProductPropertyW(), MsiGetPropertyA(), MsiGetPropertyW(), MsiGetSourcePathA(), MsiGetSourcePathW(), MsiGetSummaryInformationW(), MsiGetTargetPathA(), MsiGetTargetPathW(), MsiInstallProductW(), MsiOpenDatabaseW(), MsiOpenPackageExW(), MsiOpenProductW(), MsiPreviewDialogW(), MsiProcessMessage(), MsiRecordClearData(), MsiRecordDataSize(), MsiRecordGetFieldCount(), MsiRecordGetInteger(), MsiRecordGetStringA(), MsiRecordGetStringW(), MsiRecordIsNull(), MsiRecordReadStream(), MsiRecordSetInteger(), MsiRecordSetStreamW(), MsiRecordSetStringA(), MsiRecordSetStringW(), MsiReinstallFeatureW(), MsiSequenceW(), MsiSetComponentStateW(), MsiSetFeatureAttributesW(), MsiSetFeatureStateW(), MsiSetInstallLevel(), MsiSetMode(), MsiSetPropertyW(), MsiSetTargetPathW(), MsiSummaryInfoGetPropertyA(), MsiSummaryInfoGetPropertyCount(), MsiSummaryInfoGetPropertyW(), MsiSummaryInfoPersist(), MsiSummaryInfoSetPropertyA(), MsiSummaryInfoSetPropertyW(), MsiViewClose(), MsiViewExecute(), MsiViewFetch(), MsiViewGetColumnInfo(), MsiViewGetErrorA(), MsiViewGetErrorW(), MsiViewModify(), patch_add_media(), patch_offset_get_filepatches(), patch_offset_get_files(), patch_offset_modify_db(), patch_set_media_source_prop(), patch_set_offsets(), patch_update_filepatch_sequence(), publish_icons(), refresh_record(), resolve_keypath(), search_components(), search_ini(), search_reg(), SELECT_insert_row(), SELECT_modify(), SELECT_set_row(), TABLE_add_column(), TABLE_drop(), table_load_transform(), TABLE_remove_column(), TransformView_add_column(), TransformView_Create(), TransformView_create_table(), TransformView_delete_row(), TransformView_drop_table(), TransformView_insert_row(), TransformView_set_row(), translate_record(), ui_actioninfo(), ui_actionstart(), ui_sequence_exists(), unimplemented_action_stub(), unpublish_feature(), unpublish_icons(), UPDATE_delete(), UPDATE_execute(), update_merge_errors(), WHERE_delete(), and WHERE_set_row().

◆ msiobj_unlock()

void msiobj_unlock ( MSIOBJECTHDR * info )

Definition at line 236 of file handle.c.

{
    LeaveCriticalSection( &object_cs );
}

Referenced by MSI_RecordCopyField(), MSI_RecordStreamToFile(), MsiRecordClearData(), MsiRecordDataSize(), MsiRecordGetFieldCount(), MsiRecordGetInteger(), MsiRecordGetStringA(), MsiRecordGetStringW(), MsiRecordIsNull(), MsiRecordReadStream(), MsiRecordSetInteger(), MsiRecordSetStreamW(), MsiRecordSetStringA(), MsiRecordSetStringW(), and MsiViewExecute().

◆ MSIREG_DeleteClassesUpgradeCodesKey()

UINT MSIREG_DeleteClassesUpgradeCodesKey ( LPCWSTR szUpgradeCode )

Definition at line 890 of file registry.c.

{
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR squashed_uc[SQUASHED_GUID_SIZE];
    HKEY hkey;
    LONG r;
 
    if (!squash_guid( szUpgradeCode, squashed_uc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szUpgradeCode), debugstr_w(squashed_uc));
 
    if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software\\Classes\\Installer\\UpgradeCodes", 0, access, &hkey))
        return ERROR_SUCCESS;
    r = RegDeleteTreeW( hkey, squashed_uc );
    RegCloseKey(hkey);
    return r;
}

Referenced by remove_product_upgrade_code().

◆ MSIREG_DeleteLocalClassesFeaturesKey()

UINT MSIREG_DeleteLocalClassesFeaturesKey ( LPCWSTR szProductCode )

Definition at line 858 of file registry.c.

{
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR squashed_pc[SQUASHED_GUID_SIZE];
    HKEY hkey;
    LONG r;
 
    if (!squash_guid( szProductCode, squashed_pc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szProductCode), debugstr_w(squashed_pc));
 
    if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software\\Classes\\Installer\\Features", 0, access, &hkey))
        return ERROR_SUCCESS;
    r = RegDeleteTreeW( hkey, squashed_pc );
    RegCloseKey(hkey);
    return r;
}

Referenced by ACTION_UnpublishProduct().

◆ MSIREG_DeleteLocalClassesProductKey()

UINT MSIREG_DeleteLocalClassesProductKey ( LPCWSTR szProductCode )

Definition at line 841 of file registry.c.

{
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR squashed_pc[SQUASHED_GUID_SIZE];
    HKEY hkey;
    LONG r;
 
    if (!squash_guid( szProductCode, squashed_pc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szProductCode), debugstr_w(squashed_pc));
 
    if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software\\Classes\\Installer\\Products", 0, access, &hkey))
        return ERROR_SUCCESS;
    r = RegDeleteTreeW( hkey, squashed_pc );
    RegCloseKey(hkey);
    return r;
}

Referenced by ACTION_UnpublishProduct().

◆ MSIREG_DeleteProductKey()

UINT MSIREG_DeleteProductKey ( LPCWSTR szProduct )

Definition at line 751 of file registry.c.

{
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR squashed_pc[SQUASHED_GUID_SIZE];
    HKEY hkey;
    LONG r;
 
    if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
 
    if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\Products",
                      0, access, &hkey)) return ERROR_SUCCESS;
    r = RegDeleteTreeW( hkey, squashed_pc );
    RegCloseKey(hkey);
    return r;
}

Referenced by ACTION_UnpublishProduct().

◆ MSIREG_DeleteUninstallKey()

UINT MSIREG_DeleteUninstallKey	(	const WCHAR *	,
		enum	platform
	)

Referenced by ACTION_UnpublishProduct().

◆ MSIREG_DeleteUpgradeCodesKey()

UINT MSIREG_DeleteUpgradeCodesKey ( const WCHAR * code )

Definition at line 812 of file registry.c.

{
    WCHAR squashed_code[SQUASHED_GUID_SIZE];
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    HKEY hkey;
    LONG ret;
 
    if (!squash_guid( code, squashed_code )) return ERROR_FUNCTION_FAILED;
    TRACE( "%s squashed %s\n", debugstr_w(code), debugstr_w(squashed_code) );
 
    if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\UpgradeCodes\\",
                       0, access, &hkey )) return ERROR_SUCCESS;
    ret = RegDeleteTreeW( hkey, squashed_code );
    RegCloseKey( hkey );
    return ret;
}

Referenced by remove_product_upgrade_code().

◆ MSIREG_DeleteUserDataComponentKey()

UINT MSIREG_DeleteUserDataComponentKey	(	LPCWSTR	szComponent,
		LPCWSTR	szUserSid
	)

Definition at line 552 of file registry.c.

{
    static const WCHAR fmtW[] =
        L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData\\%s\\Components";
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR *usersid, squashed_comp[SQUASHED_GUID_SIZE], keypath[0x200];
    HKEY hkey;
    LONG r;
 
    if (!squash_guid( szComponent, squashed_comp )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szComponent), debugstr_w(squashed_comp));
 
    if (!szUserSid)
    {
        if (!(usersid = get_user_sid()))
        {
            ERR("Failed to retrieve user SID\n");
            return ERROR_FUNCTION_FAILED;
        }
        swprintf(keypath, ARRAY_SIZE(keypath), fmtW, usersid);
        LocalFree(usersid);
    }
    else swprintf(keypath, ARRAY_SIZE(keypath), fmtW, szUserSid);
 
    if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, &hkey)) return ERROR_SUCCESS;
    r = RegDeleteTreeW( hkey, squashed_comp );
    RegCloseKey(hkey);
    return r;
}

Referenced by ACTION_ProcessComponents().

◆ MSIREG_DeleteUserDataPatchKey()

UINT MSIREG_DeleteUserDataPatchKey	(	LPCWSTR	patch,
		MSIINSTALLCONTEXT	context
	)

Definition at line 636 of file registry.c.

{
    static const WCHAR fmtW[] =
        L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData\\%s\\Patches";
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR *usersid, squashed_patch[SQUASHED_GUID_SIZE], keypath[0x200];
    HKEY hkey;
    LONG r;
 
    if (!squash_guid( patch, squashed_patch )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(patch), debugstr_w(squashed_patch));
 
    if (context == MSIINSTALLCONTEXT_MACHINE)
        swprintf(keypath, ARRAY_SIZE(keypath), fmtW, L"S-1-5-18");
    else
    {
        if (!(usersid = get_user_sid()))
        {
            ERR("Failed to retrieve user SID\n");
            return ERROR_FUNCTION_FAILED;
        }
        swprintf(keypath, ARRAY_SIZE(keypath), fmtW, usersid);
        LocalFree(usersid);
    }
    if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, &hkey)) return ERROR_SUCCESS;
    r = RegDeleteTreeW( hkey, squashed_patch );
    RegCloseKey(hkey);
    return r;
}

Referenced by ACTION_UnpublishProduct().

◆ MSIREG_DeleteUserDataProductKey()

UINT MSIREG_DeleteUserDataProductKey	(	LPCWSTR	szProduct,
		MSIINSTALLCONTEXT	context
	)

Definition at line 720 of file registry.c.

{
    static const WCHAR fmtW[] =
        L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData\\%s\\Products";
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR *usersid, squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
    HKEY hkey;
    LONG r;
 
    if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
 
    if (context == MSIINSTALLCONTEXT_MACHINE)
        swprintf(keypath, ARRAY_SIZE(keypath), fmtW, L"S-1-5-18");
    else
    {
        if (!(usersid = get_user_sid()))
        {
            ERR("Failed to retrieve user SID\n");
            return ERROR_FUNCTION_FAILED;
        }
        swprintf(keypath, ARRAY_SIZE(keypath), fmtW, usersid);
        LocalFree(usersid);
    }
 
    if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, &hkey)) return ERROR_SUCCESS;
    r = RegDeleteTreeW( hkey, squashed_pc );
    RegCloseKey(hkey);
    return r;
}

Referenced by ACTION_RegisterUser(), and ACTION_UnpublishProduct().

◆ MSIREG_DeleteUserFeaturesKey()

UINT MSIREG_DeleteUserFeaturesKey ( LPCWSTR szProduct )

Definition at line 445 of file registry.c.

{
    WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
 
    if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
 
    lstrcpyW( keypath, L"Software\\Microsoft\\Installer\\Features\\" );
    lstrcatW( keypath, squashed_pc );
    return RegDeleteTreeW(HKEY_CURRENT_USER, keypath);
}

Referenced by ACTION_UnpublishProduct().

◆ MSIREG_DeleteUserProductKey()

UINT MSIREG_DeleteUserProductKey ( LPCWSTR szProduct )

Definition at line 378 of file registry.c.

{
    WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
 
    if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
 
    lstrcpyW( keypath, L"Software\\Microsoft\\Installer\\Products\\" );
    lstrcatW( keypath, squashed_pc );
    return RegDeleteTreeW(HKEY_CURRENT_USER, keypath);
}

Referenced by ACTION_UnpublishProduct().

◆ MSIREG_DeleteUserUpgradeCodesKey()

UINT MSIREG_DeleteUserUpgradeCodesKey ( LPCWSTR szUpgradeCode )

Definition at line 829 of file registry.c.

{
    WCHAR squashed_uc[SQUASHED_GUID_SIZE], keypath[0x200];
 
    if (!squash_guid( szUpgradeCode, squashed_uc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szUpgradeCode), debugstr_w(squashed_uc));
 
    lstrcpyW(keypath, L"Software\\Microsoft\\Installer\\UpgradeCodes\\");
    lstrcatW( keypath, squashed_uc );
    return RegDeleteTreeW(HKEY_CURRENT_USER, keypath);
}

Referenced by remove_product_upgrade_code().

◆ MSIREG_OpenClassesUpgradeCodesKey()

UINT MSIREG_OpenClassesUpgradeCodesKey	(	LPCWSTR	szUpgradeCode,
		HKEY *	key,
		BOOL	create
	)

Definition at line 875 of file registry.c.

{
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR squashed_uc[SQUASHED_GUID_SIZE], keypath[0x200];
 
    if (!squash_guid( szUpgradeCode, squashed_uc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szUpgradeCode), debugstr_w(squashed_uc));
 
    lstrcpyW(keypath, L"Software\\Classes\\Installer\\UpgradeCodes\\");
    lstrcatW( keypath, squashed_uc );
 
    if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
    return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
}

Referenced by ITERATE_MigrateFeatureStates(), publish_upgrade_code(), and remove_product_upgrade_code().

◆ MSIREG_OpenFeaturesKey()

UINT MSIREG_OpenFeaturesKey	(	LPCWSTR	szProduct,
		LPCWSTR	szUserSid,
		MSIINSTALLCONTEXT	context,
		HKEY *	key,
		BOOL	create
	)

Definition at line 404 of file registry.c.

{
    HKEY root = HKEY_LOCAL_MACHINE;
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[MAX_PATH], *usersid = NULL;
 
    if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
 
    if (context == MSIINSTALLCONTEXT_MACHINE)
    {
        lstrcpyW(keypath, L"Software\\Classes\\Installer\\Features\\");
        lstrcatW( keypath, squashed_pc );
    }
    else if (context == MSIINSTALLCONTEXT_USERUNMANAGED)
    {
        root = HKEY_CURRENT_USER;
        lstrcpyW(keypath, L"Software\\Microsoft\\Installer\\Features\\");
        lstrcatW( keypath, squashed_pc );
    }
    else
    {
        if (!szUserSid)
        {
            if (!(usersid = get_user_sid()))
            {
                ERR("Failed to retrieve user SID\n");
                return ERROR_FUNCTION_FAILED;
            }
            szUserSid = usersid;
        }
        swprintf( keypath, ARRAY_SIZE(keypath),
                  L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\Managed\\%s\\Installer\\Features\\%s",
                  szUserSid, squashed_pc );
        LocalFree(usersid);
    }
    if (create) return RegCreateKeyExW(root, keypath, 0, NULL, 0, access, NULL, key, NULL);
    return RegOpenKeyExW(root, keypath, 0, access, key);
}

Referenced by ACTION_PublishFeatures(), query_feature_state(), and unpublish_feature().

◆ MSIREG_OpenInstallProps()

UINT MSIREG_OpenInstallProps	(	LPCWSTR	szProduct,
		MSIINSTALLCONTEXT	dwContext,
		LPCWSTR	szUserSid,
		HKEY *	key,
		BOOL	create
	)

Definition at line 692 of file registry.c.

{
    static const WCHAR fmtW[] =
        L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData\\%s\\Products\\%s\\InstallProperties";
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR *usersid, squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
 
    if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
 
    if (dwContext == MSIINSTALLCONTEXT_MACHINE)
        swprintf( keypath, ARRAY_SIZE(keypath), fmtW, L"S-1-5-18", squashed_pc );
    else if (szUserSid)
        swprintf( keypath, ARRAY_SIZE(keypath), fmtW, szUserSid, squashed_pc );
    else
    {
        if (!(usersid = get_user_sid()))
        {
            ERR("Failed to retrieve user SID\n");
            return ERROR_FUNCTION_FAILED;
        }
        swprintf( keypath, ARRAY_SIZE(keypath), fmtW, usersid, squashed_pc );
        LocalFree(usersid);
    }
    if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
    return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
}

Referenced by ACTION_RegisterProduct(), ACTION_RegisterUser(), comp_find_package(), get_install_location(), get_registered_local_package(), MSI_GetComponentPath(), MSI_GetProductInfo(), MSI_GetUserInfo(), MSI_OpenProductW(), MsiGetPatchInfoExW(), MsiGetProductInfoExW(), MsiQueryProductStateW(), and open_package().

◆ MSIREG_OpenPatchesKey()

UINT MSIREG_OpenPatchesKey	(	LPCWSTR	szPatch,
		HKEY *	key,
		BOOL	create
	)

Definition at line 768 of file registry.c.

{
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
 
    if (!squash_guid( szPatch, squashed_pc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szPatch), debugstr_w(squashed_pc));
 
    lstrcpyW( keypath, L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\Patches\\" );
    lstrcatW( keypath, squashed_pc );
 
    if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
    return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
}

Referenced by OpenSourceKey().

◆ MSIREG_OpenProductKey()

UINT MSIREG_OpenProductKey	(	LPCWSTR	szProduct,
		LPCWSTR	szUserSid,
		MSIINSTALLCONTEXT	context,
		HKEY *	key,
		BOOL	create
	)

Definition at line 338 of file registry.c.

{
    HKEY root = HKEY_LOCAL_MACHINE;
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR *usersid = NULL, squashed_pc[SQUASHED_GUID_SIZE], keypath[MAX_PATH];
 
    if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
 
    if (context == MSIINSTALLCONTEXT_MACHINE)
    {
        lstrcpyW(keypath, L"Software\\Classes\\Installer\\Products\\");
        lstrcatW( keypath, squashed_pc );
    }
    else if (context == MSIINSTALLCONTEXT_USERUNMANAGED)
    {
        root = HKEY_CURRENT_USER;
        lstrcpyW( keypath, L"Software\\Microsoft\\Installer\\Products\\" );
        lstrcatW( keypath, squashed_pc );
    }
    else
    {
        if (!szUserSid)
        {
            if (!(usersid = get_user_sid()))
            {
                ERR("Failed to retrieve user SID\n");
                return ERROR_FUNCTION_FAILED;
            }
            szUserSid = usersid;
        }
        swprintf( keypath, ARRAY_SIZE(keypath),
                  L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\Managed\\%s\\Installer\\Products\\%s",
                  szUserSid, squashed_pc );
        LocalFree(usersid);
    }
    if (create) return RegCreateKeyExW(root, keypath, 0, NULL, 0, access, NULL, key, NULL);
    return RegOpenKeyExW(root, keypath, 0, access, key);
}

Referenced by ACTION_PublishProduct(), check_product_patches(), comp_find_prod_key(), ITERATE_FindRelatedProducts(), MSI_GetComponentPath(), MSI_GetProductInfo(), MSI_GetUserInfo(), msi_locate_product(), MsiEnumPatchesW(), MsiGetPatchInfoExW(), MsiGetProductCodeW(), MsiGetProductInfoExW(), MsiQueryProductStateW(), MsiSourceListAddSourceW(), OpenSourceKey(), and publish_patches().

◆ MSIREG_OpenUninstallKey()

UINT MSIREG_OpenUninstallKey	(	const WCHAR *	,
		enum	platform,
		HKEY *	,
		BOOL
	)

Referenced by ACTION_RegisterProduct(), and set_installed_prop().

◆ MSIREG_OpenUpgradeCodesKey()

UINT MSIREG_OpenUpgradeCodesKey	(	LPCWSTR	szProduct,
		HKEY *	key,
		BOOL	create
	)

Definition at line 783 of file registry.c.

{
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR squashed_uc[SQUASHED_GUID_SIZE], keypath[0x200];
 
    if (!squash_guid( szUpgradeCode, squashed_uc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szUpgradeCode), debugstr_w(squashed_uc));
 
    lstrcpyW( keypath, L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\UpgradeCodes\\" );
    lstrcatW( keypath, squashed_uc );
 
    if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
    return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
}

Referenced by ACTION_RegisterProduct(), ITERATE_FindRelatedProducts(), MsiEnumRelatedProductsW(), and remove_product_upgrade_code().

◆ MSIREG_OpenUserComponentsKey()

UINT MSIREG_OpenUserComponentsKey	(	LPCWSTR	szComponent,
		HKEY *	key,
		BOOL	create
	)

Definition at line 505 of file registry.c.

{
    WCHAR squashed_cc[SQUASHED_GUID_SIZE], keypath[0x200];
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    UINT ret;
 
    if (!squash_guid( szComponent, squashed_cc)) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szComponent), debugstr_w(squashed_cc));
 
    lstrcpyW(keypath, L"Software\\Microsoft\\Installer\\Components\\");
    lstrcatW( keypath, squashed_cc );
 
    if (create) return RegCreateKeyW(HKEY_CURRENT_USER, keypath, key);
    ret = RegOpenKeyW(HKEY_CURRENT_USER, keypath, key);
    if (ret != ERROR_FILE_NOT_FOUND) return ret;
 
    lstrcpyW(keypath, L"Software\\Classes\\Installer\\Components\\");
    lstrcatW( keypath, squashed_cc );
    return RegOpenKeyExW( HKEY_LOCAL_MACHINE, keypath, 0, access, key );
}

Referenced by ITERATE_PublishComponent(), MSI_EnumComponentQualifiers(), and MSI_ProvideQualifiedComponentEx().

◆ MSIREG_OpenUserDataComponentKey()

UINT MSIREG_OpenUserDataComponentKey	(	LPCWSTR	szComponent,
		LPCWSTR	szUserSid,
		HKEY *	key,
		BOOL	create
	)

Definition at line 526 of file registry.c.

{
    static const WCHAR fmtW[] =
        L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData\\%s\\Components\\%s";
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR *usersid, squashed_comp[SQUASHED_GUID_SIZE], keypath[0x200];
 
    if (!squash_guid( szComponent, squashed_comp )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szComponent), debugstr_w(squashed_comp));
 
    if (!szUserSid)
    {
        if (!(usersid = get_user_sid()))
        {
            ERR("Failed to retrieve user SID\n");
            return ERROR_FUNCTION_FAILED;
        }
        swprintf( keypath, ARRAY_SIZE(keypath), fmtW, usersid, squashed_comp );
        LocalFree(usersid);
    }
    else swprintf( keypath, ARRAY_SIZE(keypath), fmtW, szUserSid, squashed_comp );
 
    if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
    return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
}

Referenced by ACTION_ProcessComponents(), comp_find_prodcode(), get_client_counts(), MsiEnumClientsW(), MsiGetProductCodeW(), open_userdata_comp_key(), and query_feature_state().

◆ MSIREG_OpenUserDataFeaturesKey()

UINT MSIREG_OpenUserDataFeaturesKey	(	LPCWSTR	szProduct,
		LPCWSTR	szUserSid,
		MSIINSTALLCONTEXT	context,
		HKEY *	key,
		BOOL	create
	)

Definition at line 472 of file registry.c.

{
    static const WCHAR fmtW[] =
        L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData\\%s\\Products\\%s\\Features";
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200], *usersid = NULL;
 
    if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
 
    if (context == MSIINSTALLCONTEXT_MACHINE)
    {
        swprintf( keypath, ARRAY_SIZE(keypath), fmtW, L"S-1-5-18", squashed_pc );
    }
    else
    {
        if (!szUserSid)
        {
            if (!(usersid = get_user_sid()))
            {
                ERR("Failed to retrieve user SID\n");
                return ERROR_FUNCTION_FAILED;
            }
            szUserSid = usersid;
        }
        swprintf( keypath, ARRAY_SIZE(keypath), fmtW, szUserSid, squashed_pc );
        LocalFree(usersid);
    }
    if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
    return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
}

Referenced by ACTION_PublishFeatures(), MSI_ProvideQualifiedComponentEx(), query_feature_state(), and unpublish_feature().

◆ MSIREG_OpenUserDataPatchKey()

UINT MSIREG_OpenUserDataPatchKey	(	LPCWSTR	szPatch,
		MSIINSTALLCONTEXT	dwContext,
		HKEY *	key,
		BOOL	create
	)

Definition at line 610 of file registry.c.

{
    static const WCHAR fmtW[] =
        L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData\\%s\\Patches\\%s";
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR *usersid, squashed_patch[SQUASHED_GUID_SIZE], keypath[0x200];
 
    if (!squash_guid( szPatch, squashed_patch )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szPatch), debugstr_w(squashed_patch));
 
    if (dwContext == MSIINSTALLCONTEXT_MACHINE)
        swprintf( keypath, ARRAY_SIZE(keypath), fmtW, L"S-1-5-18", squashed_patch );
    else
    {
        if (!(usersid = get_user_sid()))
        {
            ERR("Failed to retrieve user SID\n");
            return ERROR_FUNCTION_FAILED;
        }
        swprintf( keypath, ARRAY_SIZE(keypath), fmtW, usersid, squashed_patch );
        LocalFree(usersid);
    }
    if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
    return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
}

Referenced by check_product_patches(), MsiGetPatchInfoExW(), and publish_patches().

◆ MSIREG_OpenUserDataProductKey()

UINT MSIREG_OpenUserDataProductKey	(	LPCWSTR	szProduct,
		MSIINSTALLCONTEXT	dwContext,
		LPCWSTR	szUserSid,
		HKEY *	key,
		BOOL	create
	)

Definition at line 582 of file registry.c.

{
    static const WCHAR fmtW[] =
        L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData\\%s\\Products\\%s";
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR *usersid, squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
 
    if (!squash_guid( szProduct, squashed_pc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szProduct), debugstr_w(squashed_pc));
 
    if (dwContext == MSIINSTALLCONTEXT_MACHINE)
        swprintf( keypath, ARRAY_SIZE(keypath), fmtW, L"S-1-5-18", squashed_pc );
    else if (szUserSid)
        swprintf( keypath, ARRAY_SIZE(keypath), fmtW, szUserSid, squashed_pc );
    else
    {
        if (!(usersid = get_user_sid()))
        {
            ERR("Failed to retrieve user SID\n");
            return ERROR_FUNCTION_FAILED;
        }
        swprintf( keypath, ARRAY_SIZE(keypath), fmtW, usersid, squashed_pc );
        LocalFree(usersid);
    }
    if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
    return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
}

Referenced by ACTION_PublishProduct(), check_product_patches(), get_patch_state(), MSI_GetComponentPath(), and MsiGetPatchInfoExW().

◆ MSIREG_OpenUserDataProductPatchesKey()

UINT MSIREG_OpenUserDataProductPatchesKey	(	LPCWSTR	product,
		MSIINSTALLCONTEXT	context,
		HKEY *	key,
		BOOL	create
	)

Definition at line 666 of file registry.c.

{
    static const WCHAR fmtW[] =
        L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData\\%s\\Products\\%s\\Patches";
    REGSAM access = KEY_WOW64_64KEY | KEY_ALL_ACCESS;
    WCHAR *usersid, squashed_product[SQUASHED_GUID_SIZE], keypath[0x200];
 
    if (!squash_guid( product, squashed_product )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(product), debugstr_w(squashed_product));
 
    if (context == MSIINSTALLCONTEXT_MACHINE)
        swprintf( keypath, ARRAY_SIZE(keypath), fmtW, L"S-1-5-18", squashed_product );
    else
    {
        if (!(usersid = get_user_sid()))
        {
            ERR("Failed to retrieve user SID\n");
            return ERROR_FUNCTION_FAILED;
        }
        swprintf( keypath, ARRAY_SIZE(keypath), fmtW, usersid, squashed_product );
        LocalFree(usersid);
    }
    if (create) return RegCreateKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, NULL, 0, access, NULL, key, NULL);
    return RegOpenKeyExW(HKEY_LOCAL_MACHINE, keypath, 0, access, key);
}

Referenced by publish_patches().

◆ MSIREG_OpenUserPatchesKey()

UINT MSIREG_OpenUserPatchesKey	(	LPCWSTR	szPatch,
		HKEY *	key,
		BOOL	create
	)

Definition at line 390 of file registry.c.

{
    WCHAR squashed_pc[SQUASHED_GUID_SIZE], keypath[0x200];
 
    if (!squash_guid( szPatch, squashed_pc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szPatch), debugstr_w(squashed_pc));
 
    lstrcpyW( keypath, L"Software\\Microsoft\\Installer\\Patches\\" );
    lstrcatW( keypath, squashed_pc );
 
    if (create) return RegCreateKeyW(HKEY_CURRENT_USER, keypath, key);
    return RegOpenKeyW(HKEY_CURRENT_USER, keypath, key);
}

Referenced by OpenSourceKey().

◆ MSIREG_OpenUserUpgradeCodesKey()

UINT MSIREG_OpenUserUpgradeCodesKey	(	LPCWSTR	szProduct,
		HKEY *	key,
		BOOL	create
	)

Definition at line 798 of file registry.c.

{
    WCHAR squashed_uc[SQUASHED_GUID_SIZE], keypath[0x200];
 
    if (!squash_guid( szUpgradeCode, squashed_uc )) return ERROR_FUNCTION_FAILED;
    TRACE("%s squashed %s\n", debugstr_w(szUpgradeCode), debugstr_w(squashed_uc));
 
    lstrcpyW(keypath, L"Software\\Microsoft\\Installer\\UpgradeCodes\\");
    lstrcatW( keypath, squashed_uc );
 
    if (create) return RegCreateKeyW(HKEY_CURRENT_USER, keypath, key);
    return RegOpenKeyW(HKEY_CURRENT_USER, keypath, key);
}

Referenced by ITERATE_MigrateFeatureStates(), publish_upgrade_code(), and remove_product_upgrade_code().

◆ read_stream_data()

UINT read_stream_data	(	IStorage *	stg,
		LPCWSTR	stname,
		BOOL	table,
		BYTE **	pdata,
		UINT *	psz
	)

Definition at line 234 of file table.c.

{
    HRESULT r;
    UINT ret = ERROR_FUNCTION_FAILED;
    VOID *data;
    ULONG sz, count;
    IStream *stm = NULL;
    STATSTG stat;
    LPWSTR encname;
 
    encname = encode_streamname(table, stname);
 
    TRACE("%s -> %s\n",debugstr_w(stname),debugstr_w(encname));
 
    r = IStorage_OpenStream(stg, encname, NULL,
            STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
    free(encname);
    if( FAILED( r ) )
    {
        WARN( "open stream failed r = %#lx - empty table?\n", r );
        return ret;
    }
 
    r = IStream_Stat(stm, &stat, STATFLAG_NONAME );
    if( FAILED( r ) )
    {
        WARN( "open stream failed r = %#lx!\n", r );
        goto end;
    }
 
    if( stat.cbSize.QuadPart >> 32 )
    {
        WARN("Too big!\n");
        goto end;
    }
 
    sz = stat.cbSize.QuadPart;
    data = malloc(sz);
    if( !data )
    {
        WARN( "couldn't allocate memory r = %#lx!\n", r );
        ret = ERROR_NOT_ENOUGH_MEMORY;
        goto end;
    }
 
    r = IStream_Read(stm, data, sz, &count );
    if( FAILED( r ) || ( count != sz ) )
    {
        free(data);
        WARN("read stream failed r = %#lx!\n", r);
        goto end;
    }
 
    *pdata = data;
    *psz = sz;
    ret = ERROR_SUCCESS;
 
end:
    IStream_Release( stm );
 
    return ret;
}

Referenced by read_table_from_storage(), and table_load_transform().

◆ ready_media()

UINT ready_media	(	MSIPACKAGE *	package,
		BOOL	compressed,
		MSIMEDIAINFO *	mi
	)

Definition at line 838 of file media.c.

{
    UINT rc;
    WCHAR *cabinet_file = NULL;
 
    /* media info for continuous cabinet is already loaded */
    if (mi->is_continuous) return ERROR_SUCCESS;
 
    if (mi->cabinet)
    {
        WCHAR *base_url;
 
        /* cabinet is internal, no checks needed */
        if (mi->cabinet[0] == '#') return ERROR_SUCCESS;
 
        if (!(cabinet_file = get_cabinet_filename( mi ))) return ERROR_OUTOFMEMORY;
 
        /* package should be downloaded */
        if (compressed && GetFileAttributesW( cabinet_file ) == INVALID_FILE_ATTRIBUTES &&
            (base_url = get_base_url( package->db )))
        {
            WCHAR temppath[MAX_PATH], *p, *url;
 
            free( cabinet_file );
            if (!(url = realloc( base_url, (wcslen( base_url ) + wcslen( mi->cabinet ) + 1) * sizeof(WCHAR) )))
            {
                free( base_url );
                return ERROR_OUTOFMEMORY;
            }
            lstrcatW( url, mi->cabinet );
            if ((rc = msi_download_file( url, temppath )) != ERROR_SUCCESS)
            {
                ERR("failed to download %s (%u)\n", debugstr_w(url), rc);
                free( url );
                return rc;
            }
            if ((p = wcsrchr( temppath, '\\' ))) *p = 0;
            lstrcpyW( mi->sourcedir, temppath );
            PathAddBackslashW( mi->sourcedir );
            free( mi->cabinet );
            mi->cabinet = wcsdup( p + 1 );
 
            free( url );
            return ERROR_SUCCESS;
        }
    }
    /* check volume matches, change media if not */
    if (mi->volume_label)
    {
        /* assume first volume is in the drive */
        if (mi->last_volume && wcsicmp( mi->last_volume, mi->volume_label ))
        {
            WCHAR *source = msi_dup_property( package->db, L"SourceDir" );
            BOOL match = source_matches_volume( mi, source );
            free( source );
 
            if (!match && (mi->type == DRIVE_CDROM || mi->type == DRIVE_REMOVABLE))
            {
                if ((rc = change_media( package, mi )) != ERROR_SUCCESS)
                {
                    free( cabinet_file );
                    return rc;
                }
            }
        }
 
        free(mi->last_volume);
        mi->last_volume = wcsdup(mi->volume_label);
    }
    if (mi->cabinet)
    {
        if (compressed && GetFileAttributesW( cabinet_file ) == INVALID_FILE_ATTRIBUTES)
        {
            if ((rc = find_published_source( package, mi )) != ERROR_SUCCESS)
            {
                ERR("cabinet not found: %s\n", debugstr_w(cabinet_file));
                free( cabinet_file );
                return ERROR_INSTALL_FAILURE;
            }
        }
    }
    free( cabinet_file );
    return ERROR_SUCCESS;
}

Referenced by ACTION_InstallFiles(), and ACTION_PatchFiles().

◆ release_typelib()

void release_typelib ( void )

Definition at line 160 of file apps.c.

{
    unsigned i;
 
    for (i = 0; i < ARRAY_SIZE(typeinfo); i++)
        if (typeinfo[i])
            ITypeInfo_Release(typeinfo[i]);
 
    if (typelib)
        ITypeLib_Release(typelib);
}

◆ rpc_filter()

LONG WINAPI rpc_filter ( EXCEPTION_POINTERS * eptr )

Definition at line 84 of file custom.c.

{
    return I_RpcExceptionFilter(eptr->ExceptionRecord->ExceptionCode);
}

◆ squash_guid()

BOOL squash_guid	(	LPCWSTR	in,
		LPWSTR	out
	)

Definition at line 74 of file registry.c.

{
    DWORD i,n=1;
    GUID guid;
 
    out[0] = 0;
 
    if (FAILED(CLSIDFromString((LPCOLESTR)in, &guid)))
        return FALSE;
 
    for(i=0; i<8; i++)
        out[7-i] = in[n++];
    n++;
    for(i=0; i<4; i++)
        out[11-i] = in[n++];
    n++;
    for(i=0; i<4; i++)
        out[15-i] = in[n++];
    n++;
    for(i=0; i<2; i++)
    {
        out[17+i*2] = in[n++];
        out[16+i*2] = in[n++];
    }
    n++;
    for( ; i<8; i++)
    {
        out[17+i*2] = in[n++];
        out[16+i*2] = in[n++];
    }
    out[32]=0;
    return TRUE;
}

Referenced by ACTION_ForceReboot(), ACTION_ProcessComponents(), ACTION_PublishProduct(), ACTION_RegisterProduct(), compose_base85_guid(), create_test_guid(), ITERATE_UnpublishComponent(), MSI_GetComponentPath(), MSI_GetProductInfo(), MSI_GetUserInfo(), MsiEnumPatchesExW(), MsiEnumPatchesW(), MsiGetPatchInfoExW(), MsiGetProductCodeW(), MsiGetProductInfoExW(), MsiOpenProductW(), MsiQueryComponentStateW(), MsiQueryFeatureStateExW(), MsiQueryFeatureStateW(), MSIREG_DeleteClassesUpgradeCodesKey(), MSIREG_DeleteLocalClassesFeaturesKey(), MSIREG_DeleteLocalClassesProductKey(), MSIREG_DeleteProductKey(), MSIREG_DeleteUpgradeCodesKey(), MSIREG_DeleteUserDataComponentKey(), MSIREG_DeleteUserDataPatchKey(), MSIREG_DeleteUserDataProductKey(), MSIREG_DeleteUserFeaturesKey(), MSIREG_DeleteUserProductKey(), MSIREG_DeleteUserUpgradeCodesKey(), MSIREG_OpenClassesUpgradeCodesKey(), MSIREG_OpenFeaturesKey(), MSIREG_OpenInstallerFeaturesKey(), MSIREG_OpenInstallProps(), MSIREG_OpenPatchesKey(), MSIREG_OpenProductKey(), MSIREG_OpenUpgradeCodesKey(), MSIREG_OpenUserComponentsKey(), MSIREG_OpenUserDataComponentKey(), MSIREG_OpenUserDataFeaturesKey(), MSIREG_OpenUserDataPatchKey(), MSIREG_OpenUserDataProductKey(), MSIREG_OpenUserDataProductPatchesKey(), MSIREG_OpenUserPatchesKey(), MSIREG_OpenUserUpgradeCodesKey(), MsiSourceListAddMediaDiskW(), MsiSourceListAddSourceExW(), MsiSourceListAddSourceW(), MsiSourceListEnumMediaDisksW(), MsiSourceListEnumSourcesW(), MsiSourceListGetInfoW(), MsiSourceListSetInfoW(), publish_patches(), publish_product_properties(), publish_upgrade_code(), and remove_product_upgrade_code().

◆ strdupAtoW()

static LPWSTR strdupAtoW ( LPCSTR str )

inlinestatic

Definition at line 1187 of file msipriv.h.

{
    LPWSTR ret = NULL;
    DWORD len;
 
    if (!str) return ret;
    len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
    ret = malloc( len * sizeof(WCHAR) );
    if (ret)
        MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len );
    return ret;
}

◆ strdupUtoW()

static LPWSTR strdupUtoW ( LPCSTR str )

inlinestatic

Definition at line 1213 of file msipriv.h.

{
    LPWSTR ret = NULL;
    DWORD len;
 
    if (!str) return ret;
    len = MultiByteToWideChar( CP_UTF8, 0, str, -1, NULL, 0 );
    ret = malloc( len * sizeof(WCHAR) );
    if (ret)
        MultiByteToWideChar( CP_UTF8, 0, str, -1, ret, len );
    return ret;
}

Referenced by cabinet_open().

◆ strdupWtoA()

static char * strdupWtoA ( LPCWSTR str )

inlinestatic

Definition at line 1174 of file msipriv.h.

{
    LPSTR ret = NULL;
    DWORD len;
 
    if (!str) return ret;
    len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL);
    ret = malloc( len );
    if (ret)
        WideCharToMultiByte( CP_ACP, 0, str, -1, ret, len, NULL, NULL );
    return ret;
}

◆ strdupWtoU()

static char * strdupWtoU ( LPCWSTR str )

inlinestatic

Definition at line 1200 of file msipriv.h.

{
    LPSTR ret = NULL;
    DWORD len;
 
    if (!str) return ret;
    len = WideCharToMultiByte( CP_UTF8, 0, str, -1, NULL, 0, NULL, NULL);
    ret = malloc( len );
    if (ret)
        WideCharToMultiByte( CP_UTF8, 0, str, -1, ret, len, NULL, NULL );
    return ret;
}

Referenced by extract_cabinet().

◆ TABLE_Exists()

BOOL TABLE_Exists	(	MSIDATABASE *	db,
		LPCWSTR	name
	)

Definition at line 962 of file table.c.

{
    UINT r, table_id, i;
    MSITABLE *table;
 
    if( !wcscmp( name, L"_Tables" ) || !wcscmp( name, L"_Columns" ) ||
        !wcscmp( name, L"_Streams" ) || !wcscmp( name, L"_Storages" ) )
        return TRUE;
 
    r = msi_string2id( db->strings, name, -1, &table_id );
    if( r != ERROR_SUCCESS )
    {
        TRACE("Couldn't find id for %s\n", debugstr_w(name));
        return FALSE;
    }
 
    r = get_table( db, L"_Tables", &table );
    if( r != ERROR_SUCCESS )
    {
        ERR("table _Tables not available\n");
        return FALSE;
    }
 
    for( i = 0; i < table->row_count; i++ )
    {
        if( read_table_int( table->data, i, 0, LONG_STR_BYTES ) == table_id )
            return TRUE;
    }
 
    return FALSE;
}

Referenced by ACTION_ShowDialog(), merge_diff_row(), merge_diff_tables(), merge_table(), msi_create_table(), MSI_DatabaseGetPrimaryKeys(), MSI_DatabaseImport(), and update_merge_errors().

◆ unmarshal_record()

UINT unmarshal_record	(	const struct wire_record *	in,
		MSIHANDLE *	out
	)

Definition at line 1095 of file record.c.

{
    if (!in)
    {
        *out = 0;
        return ERROR_SUCCESS;
    }
 
    *out = MsiCreateRecord(in->count);
    if (!*out) return ERROR_OUTOFMEMORY;
 
    return copy_remote_record(in, *out);
}

Referenced by MsiDatabaseGetPrimaryKeysW(), MsiViewFetch(), MsiViewGetColumnInfo(), s_remote_FormatRecord(), s_remote_ProcessMessage(), s_remote_ViewExecute(), and s_remote_ViewModify().

◆ unsquash_guid()

BOOL unsquash_guid	(	LPCWSTR	in,
		LPWSTR	out
	)

Definition at line 41 of file registry.c.

{
    DWORD i,n=0;
 
    if (lstrlenW(in) != 32)
        return FALSE;
 
    out[n++]='{';
    for(i=0; i<8; i++)
        out[n++] = in[7-i];
    out[n++]='-';
    for(i=0; i<4; i++)
        out[n++] = in[11-i];
    out[n++]='-';
    for(i=0; i<4; i++)
        out[n++] = in[15-i];
    out[n++]='-';
    for(i=0; i<2; i++)
    {
        out[n++] = in[17+i*2];
        out[n++] = in[16+i*2];
    }
    out[n++]='-';
    for( ; i<8; i++)
    {
        out[n++] = in[17+i*2];
        out[n++] = in[16+i*2];
    }
    out[n++]='}';
    out[n]=0;
    return TRUE;
}

Referenced by check_product_patches(), fetch_machine_component(), fetch_machine_product(), fetch_user_component(), fetch_user_product(), ITERATE_FindRelatedProducts(), MSI_GetProductInfo(), MsiEnumClientsW(), MsiEnumRelatedProductsW(), and MsiGetProductCodeW().

◆ VIEW_find_column()

UINT VIEW_find_column	(	MSIVIEW *	table,
		LPCWSTR	name,
		LPCWSTR	table_name,
		UINT *	n
	)

Definition at line 59 of file msiquery.c.

{
    LPCWSTR col_name, haystack_table_name;
    UINT i, count, r;
 
    r = table->ops->get_dimensions( table, NULL, &count );
    if( r != ERROR_SUCCESS )
        return r;
 
    for( i=1; i<=count; i++ )
    {
        INT x;
 
        r = table->ops->get_column_info( table, i, &col_name, NULL,
                                         NULL, &haystack_table_name );
        if( r != ERROR_SUCCESS )
            return r;
        x = wcscmp( name, col_name );
        if( table_name )
            x |= wcscmp( table_name, haystack_table_name );
        if( !x )
        {
            *n = i;
            return ERROR_SUCCESS;
        }
    }
    return ERROR_INVALID_PARAMETER;
}

Referenced by SELECT_AddColumn().

◆ write_stream_data()

UINT write_stream_data	(	IStorage *	stg,
		LPCWSTR	stname,
		LPCVOID	data,
		UINT	sz,
		BOOL	bTable
	)

Definition at line 298 of file table.c.

{
    HRESULT r;
    UINT ret = ERROR_FUNCTION_FAILED;
    ULONG count;
    IStream *stm = NULL;
    ULARGE_INTEGER size;
    LARGE_INTEGER pos;
    LPWSTR encname;
 
    encname = encode_streamname(bTable, stname );
    r = IStorage_OpenStream( stg, encname, NULL,
            STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, &stm);
    if( FAILED(r) )
    {
        r = IStorage_CreateStream( stg, encname,
                STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
    }
    free( encname );
    if( FAILED( r ) )
    {
        WARN( "open stream failed r = %#lx\n", r );
        return ret;
    }
 
    size.QuadPart = sz;
    r = IStream_SetSize( stm, size );
    if( FAILED( r ) )
    {
        WARN("Failed to SetSize\n");
        goto end;
    }
 
    pos.QuadPart = 0;
    r = IStream_Seek( stm, pos, STREAM_SEEK_SET, NULL );
    if( FAILED( r ) )
    {
        WARN("Failed to Seek\n");
        goto end;
    }
 
    if (sz)
    {
        r = IStream_Write(stm, data, sz, &count );
        if( FAILED( r ) || ( count != sz ) )
        {
            WARN("Failed to Write\n");
            goto end;
        }
    }
 
    ret = ERROR_SUCCESS;
 
end:
    IStream_Release( stm );
 
    return ret;
}

Referenced by db_initialize(), msi_init_string_table(), msi_save_string_table(), and save_table().

Variable Documentation

◆ gszLogFile

WCHAR* gszLogFile

extern

Definition at line 50 of file msi_main.c.

Referenced by DllMain(), MSI_OpenPackageW(), and MsiEnableLogW().

◆ gUIContext

LPVOID gUIContext

extern

Definition at line 48 of file msi_main.c.

Referenced by MSI_ProcessMessageVerbatim(), MsiSetExternalUIA(), and MsiSetExternalUIW().

◆ gUIContextRecord

LPVOID gUIContextRecord

extern

Definition at line 49 of file msi_main.c.

Referenced by MSI_ProcessMessageVerbatim(), and MsiSetExternalUIRecord().

◆ gUIFilter

DWORD gUIFilter

extern

Definition at line 46 of file msi_main.c.

Referenced by MSI_ProcessMessageVerbatim(), MsiSetExternalUIA(), and MsiSetExternalUIW().

◆ gUIFilterRecord

DWORD gUIFilterRecord

extern

Definition at line 47 of file msi_main.c.

Referenced by MSI_ProcessMessageVerbatim(), and MsiSetExternalUIRecord().

◆ gUIHandlerA

INSTALLUI_HANDLERA gUIHandlerA

extern

Definition at line 43 of file msi_main.c.

Referenced by MSI_ProcessMessageVerbatim(), MsiSetExternalUIA(), and MsiSetExternalUIW().

◆ gUIHandlerRecord

INSTALLUI_HANDLER_RECORD gUIHandlerRecord

extern

Definition at line 45 of file msi_main.c.

Referenced by MSI_ProcessMessageVerbatim(), and MsiSetExternalUIRecord().

◆ gUIHandlerW

INSTALLUI_HANDLERW gUIHandlerW

extern

Definition at line 44 of file msi_main.c.

Referenced by MSI_ProcessMessageVerbatim(), MsiSetExternalUIA(), and MsiSetExternalUIW().

◆ gUIhwnd

HWND gUIhwnd

extern

Definition at line 42 of file msi_main.c.

Referenced by internal_ui_handler(), and MsiSetInternalUI().

◆ gUILevel

INSTALLUILEVEL gUILevel

extern

Definition at line 41 of file msi_main.c.

Referenced by MSI_CreatePackage(), and MsiSetInternalUI().

◆ is_64bit

const BOOL is_64bit = sizeof(void *) > sizeof(int)

static

Definition at line 44 of file msipriv.h.

Referenced by get_registry_view(), test_appsearch_reglocator(), test_publish(), test_publish_assemblies(), test_register_class_info(), test_register_product(), test_register_progid_info(), and validate_package_platform().

◆ is_wow64

BOOL is_wow64

extern

◆ msi_hInstance

HINSTANCE msi_hInstance

extern

Definition at line 51 of file msi_main.c.

Referenced by DllMain().

Variables
static const BOOL	is_64bit = sizeof(void *) > sizeof(int)

BOOL	is_wow64

INSTALLUILEVEL	gUILevel

HWND	gUIhwnd

INSTALLUI_HANDLERA	gUIHandlerA

INSTALLUI_HANDLERW	gUIHandlerW

INSTALLUI_HANDLER_RECORD	gUIHandlerRecord

DWORD	gUIFilter

DWORD	gUIFilterRecord

LPVOID	gUIContext

LPVOID	gUIContextRecord

WCHAR *	gszLogFile

HINSTANCE	msi_hInstance

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ GUID_SIZE

◆ INSTALLUILEVEL_MASK

◆ LONG_STR_BYTES

◆ MAX_STREAM_NAME_LEN

◆ MSI_BUILDNUMBER

◆ MSI_DATASIZEMASK

◆ MSI_INITIAL_MEDIA_TRANSFORM_DISKID

◆ MSI_INITIAL_MEDIA_TRANSFORM_OFFSET

◆ MSI_MAJORVERSION

◆ MSI_MAX_PROPS

◆ MSI_MINORVERSION

◆ MSI_OPEN_CREATE

◆ MSI_OPEN_CREATEDIRECT

◆ MSI_OPEN_DIRECT

◆ MSI_OPEN_PATCHFILE

◆ MSI_OPEN_READONLY

◆ MSI_OPEN_TRANSACT

◆ MSICABEXTRACT_BEGINEXTRACT

◆ MSICABEXTRACT_FILEEXTRACTED

◆ MSIHANDLE_MAGIC

◆ MSIHANDLETYPE_ANY

◆ MSIHANDLETYPE_DATABASE

◆ MSIHANDLETYPE_PACKAGE

◆ MSIHANDLETYPE_PREVIEW

◆ MSIHANDLETYPE_RECORD

◆ MSIHANDLETYPE_SUMMARYINFO

◆ MSIHANDLETYPE_VIEW

◆ MSITYPE_IS_BINARY

◆ MSITYPE_KEY

◆ MSITYPE_LOCALIZABLE

◆ MSITYPE_NULLABLE

◆ MSITYPE_STRING

◆ MSITYPE_TEMPORARY

◆ MSITYPE_UNKNOWN

◆ MSITYPE_VALID

◆ SEQUENCE_EXEC

◆ SEQUENCE_UI

◆ SQUASHED_GUID_SIZE

◆ WINE_OPENPACKAGEFLAGS_RECACHE

Typedef Documentation

◆ column_info

◆ ComponentList

◆ FeatureList

◆ FolderList

◆ msi_dialog

◆ msi_file_state

◆ MSIAPPID

◆ MSIASSEMBLY

◆ MSIBINARY

◆ MSICABINETSTREAM

◆ MSICLASS

◆ MSICOMPONENT

◆ MSIDATABASE

◆ MSIEXTENSION

◆ MSIFEATURE

◆ MSIFIELD

◆ MSIFILE

◆ MSIFILEPATCH

◆ MSIFOLDER

◆ msihandledestructor

◆ MSIITERHANDLE

◆ MSIMEDIADISK

◆ MSIMEDIAINFO

◆ MSIMIME

◆ MSIOBJECTHDR

◆ MSIPACKAGE

◆ MSIPATCHINFO

◆ MSIPREVIEW

◆ MSIPROGID

◆ MSIQUERY

◆ MSIRECORD

◆ MSISOURCELISTINFO

◆ MSISTREAM