#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_s.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	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 4

#define	MSI_MINORVERSION 5

#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 , LAST_tid }

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

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

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)

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)

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)

INT	msi_suminfo_get_int32 (MSISUMMARYINFO *si, UINT uiProperty)

WCHAR *	msi_get_suminfo_product (IStorage *stg)

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

WCHAR *	msi_dup_property (MSIDATABASE db, const WCHAR prop)

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)

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

WCHAR *	msi_normalize_path (const WCHAR *)

WCHAR *	msi_resolve_file_source (MSIPACKAGE package, MSIFILE file)

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)

void	msi_free_action_script (MSIPACKAGE *package, UINT script)

WCHAR *	msi_build_icon_path (MSIPACKAGE , const WCHAR )

WCHAR *WINAPIV	msi_build_directory_name (DWORD,...)

void	msi_reduce_to_long_filename (WCHAR *)

WCHAR *	msi_create_component_advertise_string (MSIPACKAGE , MSICOMPONENT , const WCHAR *)

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 )

WCHAR **	msi_split_string (const WCHAR *, WCHAR)

UINT	msi_set_original_database_property (MSIDATABASE , const WCHAR )

WCHAR *	msi_get_error_message (MSIDATABASE *, int)

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)

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

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 733 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 731 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 4

Definition at line 729 of file msipriv.h.

◆ MSI_MAX_PROPS

#define MSI_MAX_PROPS 20

Definition at line 482 of file msipriv.h.

◆ MSI_MINORVERSION

#define MSI_MINORVERSION 5

Definition at line 730 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 1101 of file msipriv.h.

◆ MSICABEXTRACT_FILEEXTRACTED

#define MSICABEXTRACT_FILEEXTRACTED 0x02

Definition at line 1102 of file msipriv.h.

◆ MSIHANDLE_MAGIC

#define MSIHANDLE_MAGIC 0x4d434923

Definition at line 736 of file msipriv.h.

◆ MSIHANDLETYPE_ANY

#define MSIHANDLETYPE_ANY 0

Definition at line 721 of file msipriv.h.

◆ MSIHANDLETYPE_DATABASE

#define MSIHANDLETYPE_DATABASE 1

Definition at line 722 of file msipriv.h.

◆ MSIHANDLETYPE_PACKAGE

#define MSIHANDLETYPE_PACKAGE 5

Definition at line 726 of file msipriv.h.

◆ MSIHANDLETYPE_PREVIEW

#define MSIHANDLETYPE_PREVIEW 6

Definition at line 727 of file msipriv.h.

◆ MSIHANDLETYPE_RECORD

#define MSIHANDLETYPE_RECORD 4

Definition at line 725 of file msipriv.h.

◆ MSIHANDLETYPE_SUMMARYINFO

#define MSIHANDLETYPE_SUMMARYINFO 2

Definition at line 723 of file msipriv.h.

◆ MSIHANDLETYPE_VIEW

#define MSIHANDLETYPE_VIEW 3

Definition at line 724 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 719 of file msipriv.h.

◆ SEQUENCE_UI

#define SEQUENCE_UI 0x1

Definition at line 718 of file msipriv.h.

◆ SQUASHED_GUID_SIZE

#define SQUASHED_GUID_SIZE 33

Definition at line 734 of file msipriv.h.

◆ WINE_OPENPACKAGEFLAGS_RECACHE

#define WINE_OPENPACKAGEFLAGS_RECACHE 0x80000000

Definition at line 884 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 670 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 647 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 1099 of file msipriv.h.

◆ record_func

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

Definition at line 866 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 593 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 373 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 563 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 382 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
LAST_tid

Definition at line 1124 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 1078 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 1125 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 1485 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 1629 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 5219 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 7640 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_PerformActionSequence(), 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 1198 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 2442 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 682 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 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", debu

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