694 lines
24 KiB
C
694 lines
24 KiB
C
//-------------------------------------------------------------------------------------------------
|
|
// <copyright file="IBootstrapperApplication.h" company="Outercurve Foundation">
|
|
// Copyright (c) 2004, Outercurve Foundation.
|
|
// This software is released under Microsoft Reciprocal License (MS-RL).
|
|
// The license and further copyright text can be found in the file
|
|
// LICENSE.TXT at the root directory of the distribution.
|
|
// </copyright>
|
|
//
|
|
// <summary>
|
|
// IBootstrapperApplication implemented by a bootstrapper application and used by bootstrapper engine.
|
|
// </summary>
|
|
//-------------------------------------------------------------------------------------------------
|
|
|
|
#pragma once
|
|
|
|
|
|
enum BOOTSTRAPPER_DISPLAY
|
|
{
|
|
BOOTSTRAPPER_DISPLAY_UNKNOWN,
|
|
BOOTSTRAPPER_DISPLAY_EMBEDDED,
|
|
BOOTSTRAPPER_DISPLAY_NONE,
|
|
BOOTSTRAPPER_DISPLAY_PASSIVE,
|
|
BOOTSTRAPPER_DISPLAY_FULL,
|
|
};
|
|
|
|
|
|
enum BOOTSTRAPPER_RESTART
|
|
{
|
|
BOOTSTRAPPER_RESTART_UNKNOWN,
|
|
BOOTSTRAPPER_RESTART_NEVER,
|
|
BOOTSTRAPPER_RESTART_PROMPT,
|
|
BOOTSTRAPPER_RESTART_AUTOMATIC,
|
|
BOOTSTRAPPER_RESTART_ALWAYS,
|
|
};
|
|
|
|
|
|
enum BOOTSTRAPPER_RESUME_TYPE
|
|
{
|
|
BOOTSTRAPPER_RESUME_TYPE_NONE,
|
|
BOOTSTRAPPER_RESUME_TYPE_INVALID, // resume information is present but invalid
|
|
BOOTSTRAPPER_RESUME_TYPE_INTERRUPTED, // relaunched after an unexpected interruption
|
|
BOOTSTRAPPER_RESUME_TYPE_REBOOT_PENDING, // reboot has not taken place yet
|
|
BOOTSTRAPPER_RESUME_TYPE_REBOOT, // relaunched after reboot
|
|
BOOTSTRAPPER_RESUME_TYPE_SUSPEND, // relaunched after suspend
|
|
BOOTSTRAPPER_RESUME_TYPE_ARP, // launched from ARP
|
|
};
|
|
|
|
|
|
enum BOOTSTRAPPER_ERROR_TYPE
|
|
{
|
|
BOOTSTRAPPER_ERROR_TYPE_ELEVATE, // error occurred trying to elevate.
|
|
BOOTSTRAPPER_ERROR_TYPE_WINDOWS_INSTALLER, // error came from windows installer.
|
|
BOOTSTRAPPER_ERROR_TYPE_EXE_PACKAGE, // error came from an exe package.
|
|
BOOTSTRAPPER_ERROR_TYPE_HTTP_AUTH_SERVER, // error occurred trying to authenticate with HTTP server.
|
|
BOOTSTRAPPER_ERROR_TYPE_HTTP_AUTH_PROXY, // error occurred trying to authenticate with HTTP proxy.
|
|
BOOTSTRAPPER_ERROR_TYPE_APPLY, // error occurred during apply.
|
|
};
|
|
|
|
|
|
enum BOOTSTRAPPER_RELATED_OPERATION
|
|
{
|
|
BOOTSTRAPPER_RELATED_OPERATION_NONE,
|
|
BOOTSTRAPPER_RELATED_OPERATION_DOWNGRADE,
|
|
BOOTSTRAPPER_RELATED_OPERATION_MINOR_UPDATE,
|
|
BOOTSTRAPPER_RELATED_OPERATION_MAJOR_UPGRADE,
|
|
BOOTSTRAPPER_RELATED_OPERATION_REMOVE,
|
|
BOOTSTRAPPER_RELATED_OPERATION_INSTALL,
|
|
BOOTSTRAPPER_RELATED_OPERATION_REPAIR,
|
|
};
|
|
|
|
|
|
enum BOOTSTRAPPER_CACHE_OPERATION
|
|
{
|
|
BOOTSTRAPPER_CACHE_OPERATION_COPY,
|
|
BOOTSTRAPPER_CACHE_OPERATION_DOWNLOAD,
|
|
BOOTSTRAPPER_CACHE_OPERATION_EXTRACT,
|
|
};
|
|
|
|
|
|
enum BOOTSTRAPPER_APPLY_RESTART
|
|
{
|
|
BOOTSTRAPPER_APPLY_RESTART_NONE,
|
|
BOOTSTRAPPER_APPLY_RESTART_REQUIRED,
|
|
BOOTSTRAPPER_APPLY_RESTART_INITIATED,
|
|
};
|
|
|
|
|
|
enum BOOTSTRAPPER_RELATION_TYPE
|
|
{
|
|
BOOTSTRAPPER_RELATION_NONE,
|
|
BOOTSTRAPPER_RELATION_DETECT,
|
|
BOOTSTRAPPER_RELATION_UPGRADE,
|
|
BOOTSTRAPPER_RELATION_ADDON,
|
|
BOOTSTRAPPER_RELATION_PATCH,
|
|
BOOTSTRAPPER_RELATION_DEPENDENT,
|
|
BOOTSTRAPPER_RELATION_UPDATE,
|
|
};
|
|
|
|
|
|
struct BOOTSTRAPPER_COMMAND
|
|
{
|
|
BOOTSTRAPPER_ACTION action;
|
|
BOOTSTRAPPER_DISPLAY display;
|
|
BOOTSTRAPPER_RESTART restart;
|
|
|
|
LPWSTR wzCommandLine;
|
|
int nCmdShow;
|
|
|
|
BOOTSTRAPPER_RESUME_TYPE resumeType;
|
|
HWND hwndSplashScreen;
|
|
|
|
// If this was run from a related bundle, specifies the relation type
|
|
BOOTSTRAPPER_RELATION_TYPE relationType;
|
|
BOOL fPassthrough;
|
|
|
|
LPWSTR wzLayoutDirectory;
|
|
};
|
|
|
|
|
|
DECLARE_INTERFACE_IID_(IBootstrapperApplication, IUnknown, "53C31D56-49C0-426B-AB06-099D717C67FE")
|
|
{
|
|
// OnStartup - called when the engine is ready for the bootstrapper application to start.
|
|
//
|
|
STDMETHOD(OnStartup)() = 0;
|
|
|
|
// OnShutdown - called after the bootstrapper application quits the engine.
|
|
//
|
|
// Return:
|
|
// IDRESTART instructs the engine to restart. The engine will not launch again after the machine
|
|
// is rebooted. Ignored if reboot was already initiated by OnExecutePackageComplete().
|
|
//
|
|
// IDRELOAD_BOOTSTRAPPER instructs the engine to unload the bootstrapper application and restart
|
|
// the engine which will load the bootstrapper application again. Typically
|
|
// used to switch from a native bootstrapper application to a managed one.
|
|
//
|
|
// All other return codes are ignored.
|
|
STDMETHOD_(int, OnShutdown)() = 0;
|
|
|
|
// OnSystemShutdown - called when the operating system is instructed to shutdown the machine.
|
|
//
|
|
// Return:
|
|
// IDCANCEL instructs the engine to block the shutdown of the machine.
|
|
//
|
|
// All other return codes allow the shutdown to commence.
|
|
STDMETHOD_(int, OnSystemShutdown)(
|
|
__in DWORD dwEndSession,
|
|
__in int nRecommendation
|
|
) = 0;
|
|
|
|
// OnDetectBegin - called when the engine begins detection.
|
|
//
|
|
// Return:
|
|
// IDCANCEL instructs the engine to stop detection.
|
|
//
|
|
// IDNOACTION instructs the engine to continue.
|
|
STDMETHOD_(int, OnDetectBegin)(
|
|
__in BOOL fInstalled,
|
|
__in DWORD cPackages
|
|
) = 0;
|
|
|
|
// OnDetectForwardCompatibleBundle - called when the engine detects a forward compatible bundle.
|
|
//
|
|
// Return:
|
|
// IDOK instructs the engine to use the forward compatible bundle.
|
|
//
|
|
// IDCANCEL instructs the engine to stop detection.
|
|
//
|
|
// IDNOACTION instructs the engine to not use the forward compatible bundle.
|
|
STDMETHOD_(int, OnDetectForwardCompatibleBundle)(
|
|
__in_z LPCWSTR wzBundleId,
|
|
__in BOOTSTRAPPER_RELATION_TYPE relationType,
|
|
__in_z LPCWSTR wzBundleTag,
|
|
__in BOOL fPerMachine,
|
|
__in DWORD64 dw64Version,
|
|
__in int nRecommendation
|
|
) = 0;
|
|
|
|
// OnDetectUpdateBegin - called when the engine begins detection for bundle update.
|
|
//
|
|
// Return:
|
|
// IDOK instructs the engine to attempt update detection.
|
|
//
|
|
// IDCANCEL instructs the engine to stop detection.
|
|
//
|
|
// IDNOACTION instructs the engine to skip update detection.
|
|
STDMETHOD_(int, OnDetectUpdateBegin)(
|
|
__in_z LPCWSTR wzUpdateLocation,
|
|
__in int nRecommendation
|
|
) = 0;
|
|
|
|
// OnDetectUpdateComplete - called when the engine completes detection for bundle update.
|
|
//
|
|
// Remarks:
|
|
// wzUpdateLocation is null if no update was available.
|
|
STDMETHOD_(void, OnDetectUpdateComplete)(
|
|
__in HRESULT hrStatus,
|
|
__in_z_opt LPCWSTR wzUpdateLocation
|
|
) = 0;
|
|
|
|
// OnDetectRelatedBundle - called when the engine detects a related bundle.
|
|
//
|
|
// Return:
|
|
// IDCANCEL instructs the engine to stop detection.
|
|
//
|
|
// IDNOACTION instructs the engine to continue.
|
|
STDMETHOD_(int, OnDetectRelatedBundle)(
|
|
__in_z LPCWSTR wzBundleId,
|
|
__in BOOTSTRAPPER_RELATION_TYPE relationType,
|
|
__in_z LPCWSTR wzBundleTag,
|
|
__in BOOL fPerMachine,
|
|
__in DWORD64 dw64Version,
|
|
__in BOOTSTRAPPER_RELATED_OPERATION operation
|
|
) = 0;
|
|
|
|
// OnDetectPackageBegin - called when the engine begins detecting a package.
|
|
//
|
|
// Return:
|
|
// IDCANCEL instructs the engine to stop detection.
|
|
//
|
|
// IDNOACTION instructs the engine to continue.
|
|
STDMETHOD_(int, OnDetectPackageBegin)(
|
|
__in_z LPCWSTR wzPackageId
|
|
) = 0;
|
|
|
|
// OnDetectRelatedMsiPackage - called when the engine begins detects a related package.
|
|
//
|
|
// Return:
|
|
// IDCANCEL instructs the engine to stop detection.
|
|
//
|
|
// IDNOACTION instructs the engine to continue.
|
|
STDMETHOD_(int, OnDetectRelatedMsiPackage)(
|
|
__in_z LPCWSTR wzPackageId,
|
|
__in_z LPCWSTR wzProductCode,
|
|
__in BOOL fPerMachine,
|
|
__in DWORD64 dw64Version,
|
|
__in BOOTSTRAPPER_RELATED_OPERATION operation
|
|
) = 0;
|
|
|
|
// OnDetectTargetMsiPackage - called when the engine detects a target MSI package for
|
|
// an MSP package.
|
|
//
|
|
// Return:
|
|
// IDCANCEL instructs the engine to stop detection.
|
|
//
|
|
// IDNOACTION instructs the engine to continue.
|
|
STDMETHOD_(int, OnDetectTargetMsiPackage)(
|
|
__in_z LPCWSTR wzPackageId,
|
|
__in_z LPCWSTR wzProductCode,
|
|
__in BOOTSTRAPPER_PACKAGE_STATE patchState
|
|
) = 0;
|
|
|
|
// OnDetectMsiFeature - called when the engine detects a feature in an MSI package.
|
|
//
|
|
// Return:
|
|
// IDCANCEL instructs the engine to stop detection.
|
|
//
|
|
// IDNOACTION instructs the engine to continue.
|
|
STDMETHOD_(int, OnDetectMsiFeature)(
|
|
__in_z LPCWSTR wzPackageId,
|
|
__in_z LPCWSTR wzFeatureId,
|
|
__in BOOTSTRAPPER_FEATURE_STATE state
|
|
) = 0;
|
|
|
|
// OnDetectPackageComplete - called after the engine detects a package.
|
|
//
|
|
STDMETHOD_(void, OnDetectPackageComplete)(
|
|
__in_z LPCWSTR wzPackageId,
|
|
__in HRESULT hrStatus,
|
|
__in BOOTSTRAPPER_PACKAGE_STATE state
|
|
) = 0;
|
|
|
|
// OnDetectPackageComplete - called after the engine completes detection.
|
|
//
|
|
STDMETHOD_(void, OnDetectComplete)(
|
|
__in HRESULT hrStatus
|
|
) = 0;
|
|
|
|
// OnPlanBegin - called when the engine begins planning.
|
|
//
|
|
// Return:
|
|
// IDCANCEL instructs the engine to stop planning.
|
|
//
|
|
// IDNOACTION instructs the engine to continue.
|
|
STDMETHOD_(int, OnPlanBegin)(
|
|
__in DWORD cPackages
|
|
) = 0;
|
|
|
|
// OnPlanRelatedBundle - called when the engine begins planning a related bundle.
|
|
//
|
|
// Return:
|
|
// IDCANCEL instructs the engine to stop planning.
|
|
//
|
|
// IDNOACTION instructs the engine to continue.
|
|
STDMETHOD_(int, OnPlanRelatedBundle)(
|
|
__in_z LPCWSTR wzBundleId,
|
|
__inout BOOTSTRAPPER_REQUEST_STATE* pRequestedState
|
|
) = 0;
|
|
|
|
// OnPlanPackageBegin - called when the engine begins planning a package.
|
|
//
|
|
// Return:
|
|
// IDCANCEL instructs the engine to stop planning.
|
|
//
|
|
// IDNOACTION instructs the engine to continue.
|
|
STDMETHOD_(int, OnPlanPackageBegin)(
|
|
__in_z LPCWSTR wzPackageId,
|
|
__inout BOOTSTRAPPER_REQUEST_STATE* pRequestedState
|
|
) = 0;
|
|
|
|
// OnPlanTargetMsiPackage - called when the engine plans an MSP package
|
|
// to apply to an MSI package.
|
|
//
|
|
// Return:
|
|
// IDCANCEL instructs the engine to stop planning.
|
|
//
|
|
// IDNOACTION instructs the engine to continue.
|
|
STDMETHOD_(int, OnPlanTargetMsiPackage)(
|
|
__in_z LPCWSTR wzPackageId,
|
|
__in_z LPCWSTR wzProductCode,
|
|
__inout BOOTSTRAPPER_REQUEST_STATE* pRequestedState
|
|
) = 0;
|
|
|
|
// OnPlanMsiFeature - called when the engine plans a feature in an
|
|
// MSI package.
|
|
//
|
|
// Return:
|
|
// IDCANCEL instructs the engine to stop planning.
|
|
//
|
|
// IDNOACTION instructs the engine to continue.
|
|
STDMETHOD_(int, OnPlanMsiFeature)(
|
|
__in_z LPCWSTR wzPackageId,
|
|
__in_z LPCWSTR wzFeatureId,
|
|
__inout BOOTSTRAPPER_FEATURE_STATE* pRequestedState
|
|
) = 0;
|
|
|
|
// OnPlanPackageComplete - called after the engine plans a package.
|
|
//
|
|
STDMETHOD_(void, OnPlanPackageComplete)(
|
|
__in_z LPCWSTR wzPackageId,
|
|
__in HRESULT hrStatus,
|
|
__in BOOTSTRAPPER_PACKAGE_STATE state,
|
|
__in BOOTSTRAPPER_REQUEST_STATE requested,
|
|
__in BOOTSTRAPPER_ACTION_STATE execute,
|
|
__in BOOTSTRAPPER_ACTION_STATE rollback
|
|
) = 0;
|
|
|
|
// OnPlanComplete - called when the engine completes planning.
|
|
//
|
|
STDMETHOD_(void, OnPlanComplete)(
|
|
__in HRESULT hrStatus
|
|
) = 0;
|
|
|
|
// OnApplyBegin - called when the engine begins applying the plan.
|
|
//
|
|
// Return:
|
|
// IDCANCEL instructs the engine to stop applying.
|
|
//
|
|
// IDNOACTION instructs the engine to continue.
|
|
STDMETHOD_(int, OnApplyBegin)() = 0;
|
|
|
|
// OnElevate - called before the engine displays an elevation prompt.
|
|
// Will only happen once per execution of the engine.
|
|
//
|
|
// Return:
|
|
// IDCANCEL instructs the engine to abort elevation and stop applying.
|
|
//
|
|
// IDNOACTION instructs the engine to continue.
|
|
STDMETHOD_(int, OnElevate)() = 0;
|
|
|
|
// OnProgress - called when the engine makes progress.
|
|
//
|
|
// Return:
|
|
// IDCANCEL instructs the engine to stop applying.
|
|
//
|
|
// IDNOACTION instructs the engine to continue.
|
|
STDMETHOD_(int, OnProgress)(
|
|
__in DWORD dwProgressPercentage,
|
|
__in DWORD dwOverallPercentage
|
|
) = 0;
|
|
|
|
// OnError - called when the engine encounters an error.
|
|
//
|
|
// Return:
|
|
// uiFlags is a combination of valid ID* return values appropriate for
|
|
// the error.
|
|
//
|
|
// IDNOACTION instructs the engine to pass the error through to default
|
|
// handling which usually results in the apply failing.
|
|
STDMETHOD_(int, OnError)(
|
|
__in BOOTSTRAPPER_ERROR_TYPE errorType,
|
|
__in_z_opt LPCWSTR wzPackageId,
|
|
__in DWORD dwCode,
|
|
__in_z_opt LPCWSTR wzError,
|
|
__in DWORD uiFlags,
|
|
__in DWORD cData,
|
|
__in_ecount_z_opt(cData) LPCWSTR* rgwzData,
|
|
__in int nRecommendation
|
|
) = 0;
|
|
|
|
// OnRegisterBegin - called when the engine registers the bundle.
|
|
//
|
|
// Return:
|
|
// IDCANCEL instructs the engine to stop applying.
|
|
//
|
|
// IDNOACTION instructs the engine to continue.
|
|
STDMETHOD_(int, OnRegisterBegin)() = 0;
|
|
|
|
// OnRegisterComplete - called when the engine registration is
|
|
// complete.
|
|
//
|
|
STDMETHOD_(void, OnRegisterComplete)(
|
|
__in HRESULT hrStatus
|
|
) = 0;
|
|
|
|
// OnCacheBegin - called when the engine begins caching.
|
|
//
|
|
// Return:
|
|
// IDCANCEL instructs the engine to stop caching.
|
|
//
|
|
// IDNOACTION instructs the engine to continue.
|
|
STDMETHOD_(int, OnCacheBegin)() = 0;
|
|
|
|
// OnCachePackageBegin - called when the engine begins caching
|
|
// a package.
|
|
//
|
|
// Return:
|
|
// IDCANCEL instructs the engine to stop caching.
|
|
//
|
|
// IDNOACTION instructs the engine to continue.
|
|
STDMETHOD_(int, OnCachePackageBegin)(
|
|
__in_z LPCWSTR wzPackageId,
|
|
__in DWORD cCachePayloads,
|
|
__in DWORD64 dw64PackageCacheSize
|
|
) = 0;
|
|
|
|
// OnCacheAcquireBegin - called when the engine begins copying or
|
|
// downloading a payload to the working folder.
|
|
//
|
|
// Return:
|
|
// IDCANCEL instructs the engine to stop caching.
|
|
//
|
|
// IDNOACTION instructs the engine to continue.
|
|
STDMETHOD_(int, OnCacheAcquireBegin)(
|
|
__in_z_opt LPCWSTR wzPackageOrContainerId,
|
|
__in_z_opt LPCWSTR wzPayloadId,
|
|
__in BOOTSTRAPPER_CACHE_OPERATION operation,
|
|
__in_z LPCWSTR wzSource
|
|
) = 0;
|
|
|
|
// OnCacheAcquireProgress - called when the engine makes progresss copying
|
|
// or downloading a payload to the working folder.
|
|
//
|
|
// Return:
|
|
// IDCANCEL instructs the engine to stop caching.
|
|
//
|
|
// IDNOACTION instructs the engine to continue.
|
|
STDMETHOD_(int, OnCacheAcquireProgress)(
|
|
__in_z_opt LPCWSTR wzPackageOrContainerId,
|
|
__in_z_opt LPCWSTR wzPayloadId,
|
|
__in DWORD64 dw64Progress,
|
|
__in DWORD64 dw64Total,
|
|
__in DWORD dwOverallPercentage
|
|
) = 0;
|
|
|
|
// OnResolveSource - called when a payload or container cannot be found locally.
|
|
//
|
|
// Parameters:
|
|
// wzPayloadId will be NULL when resolving a container.
|
|
// wzDownloadSource will be NULL if the container or payload does not provide a DownloadURL.
|
|
//
|
|
// Return:
|
|
// IDRETRY instructs the engine to try the local source again.
|
|
//
|
|
// IDDOWNLOAD instructs the engine to try the download source.
|
|
//
|
|
// All other return codes result in an error.
|
|
//
|
|
// Notes:
|
|
// It is expected the BA may call IBurnCore::SetLocalSource() or IBurnCore::SetDownloadSource()
|
|
// to update the source location before returning IDRETRY or IDDOWNLOAD.
|
|
STDMETHOD_(int, OnResolveSource)(
|
|
__in_z LPCWSTR wzPackageOrContainerId,
|
|
__in_z_opt LPCWSTR wzPayloadId,
|
|
__in_z LPCWSTR wzLocalSource,
|
|
__in_z_opt LPCWSTR wzDownloadSource
|
|
) = 0;
|
|
|
|
// OnCacheAcquireComplete - called after the engine copied or downloaded
|
|
// a payload to the working folder.
|
|
//
|
|
// Return:
|
|
// IDRETRY instructs the engine to try the copy or download of the payload again.
|
|
//
|
|
// All other return codes are ignored.
|
|
STDMETHOD_(int, OnCacheAcquireComplete)(
|
|
__in_z_opt LPCWSTR wzPackageOrContainerId,
|
|
__in_z_opt LPCWSTR wzPayloadId,
|
|
__in HRESULT hrStatus,
|
|
__in int nRecommendation
|
|
) = 0;
|
|
|
|
// OnCacheVerifyBegin - called when the engine begins to verify then copy
|
|
// a payload or container to the package cache folder.
|
|
//
|
|
// Return:
|
|
// IDCANCEL instructs the engine to stop caching.
|
|
//
|
|
// IDNOACTION instructs the engine to continue.
|
|
STDMETHOD_(int, OnCacheVerifyBegin)(
|
|
__in_z_opt LPCWSTR wzPackageOrContainerId,
|
|
__in_z_opt LPCWSTR wzPayloadId
|
|
) = 0;
|
|
|
|
// OnCacheVerifyComplete - called after the engine verifies and copies
|
|
// a payload or container to the package cache folder.
|
|
//
|
|
// Return:
|
|
// IDRETRY instructs the engine to try the verification of the payload again.
|
|
// Ignored if hrStatus is success.
|
|
//
|
|
// IDTRYAGAIN instructs the engine to acquire the payload again. Ignored if
|
|
// hrStatus is success.
|
|
//
|
|
// All other return codes are ignored.
|
|
STDMETHOD_(int, OnCacheVerifyComplete)(
|
|
__in_z_opt LPCWSTR wzPackageOrContainerId,
|
|
__in_z_opt LPCWSTR wzPayloadId,
|
|
__in HRESULT hrStatus,
|
|
__in int nRecommendation
|
|
) = 0;
|
|
|
|
// OnCachePackageComplete - called after the engine attempts to copy or download all
|
|
// payloads of a package into the package cache folder.
|
|
//
|
|
// Return:
|
|
// IDIGNORE instructs the engine to ignore non-vital package failures and continue with the
|
|
// caching. Ignored if hrStatus is a success or the package is vital.
|
|
//
|
|
// IDRETRY instructs the engine to try the acquisition and verification of the package
|
|
// again. Ignored if hrStatus is a success.
|
|
//
|
|
// All other return codes are ignored.
|
|
STDMETHOD_(int, OnCachePackageComplete)(
|
|
__in_z LPCWSTR wzPackageId,
|
|
__in HRESULT hrStatus,
|
|
__in int nRecommendation
|
|
) = 0;
|
|
|
|
// OnCacheComplete - called when the engine caching is complete.
|
|
//
|
|
STDMETHOD_(void, OnCacheComplete)(
|
|
__in HRESULT hrStatus
|
|
) = 0;
|
|
|
|
// OnExecuteBegin - called when the engine begins executing the plan.
|
|
//
|
|
// Return:
|
|
// IDCANCEL instructs the engine to stop applying.
|
|
//
|
|
// IDNOACTION instructs the engine to continue.
|
|
STDMETHOD_(int, OnExecuteBegin)(
|
|
__in DWORD cExecutingPackages
|
|
) = 0;
|
|
|
|
// OnExecuteBegin - called when the engine begins executing a package.
|
|
//
|
|
// Return:
|
|
// IDCANCEL instructs the engine to stop applying.
|
|
//
|
|
// IDNOACTION instructs the engine to continue.
|
|
STDMETHOD_(int, OnExecutePackageBegin)(
|
|
__in_z LPCWSTR wzPackageId,
|
|
__in BOOL fExecute
|
|
) = 0;
|
|
|
|
// OnExecutePatchTarget - called when the engine executes one or more patches targeting
|
|
// a product.
|
|
//
|
|
// Return:
|
|
// IDCANCEL instructs the engine to stop applying.
|
|
//
|
|
// IDNOACTION instructs the engine to continue.
|
|
STDMETHOD_(int, OnExecutePatchTarget)(
|
|
__in_z LPCWSTR wzPackageId,
|
|
__in_z LPCWSTR wzTargetProductCode
|
|
) = 0;
|
|
|
|
// OnExecuteProgress - called when the engine makes progress executing a package.
|
|
//
|
|
// Return:
|
|
// IDCANCEL instructs the engine to stop applying.
|
|
//
|
|
// IDNOACTION instructs the engine to continue.
|
|
STDMETHOD_(int, OnExecuteProgress)(
|
|
__in_z LPCWSTR wzPackageId,
|
|
__in DWORD dwProgressPercentage,
|
|
__in DWORD dwOverallPercentage
|
|
) = 0;
|
|
|
|
// OnExecuteMsiMessage - called when the engine receives an MSI package message.
|
|
//
|
|
// Return:
|
|
// uiFlags is a combination of valid ID* return values appropriate for
|
|
// the message.
|
|
//
|
|
// IDNOACTION instructs the engine to pass the message through to default
|
|
// handling which usually results in the execution continuing.
|
|
STDMETHOD_(int, OnExecuteMsiMessage)(
|
|
__in_z LPCWSTR wzPackageId,
|
|
__in INSTALLMESSAGE mt,
|
|
__in UINT uiFlags,
|
|
__in_z LPCWSTR wzMessage,
|
|
__in DWORD cData,
|
|
__in_ecount_z_opt(cData) LPCWSTR* rgwzData,
|
|
__in int nRecommendation
|
|
) = 0;
|
|
|
|
// OnExecuteFilesInUse - called when the engine encounters files in use while
|
|
// executing a package.
|
|
//
|
|
// Return:
|
|
// IDNOACTION instructs the engine to pass the message through to default
|
|
// handling which usually results in the execution continuing.
|
|
STDMETHOD_(int, OnExecuteFilesInUse)(
|
|
__in_z LPCWSTR wzPackageId,
|
|
__in DWORD cFiles,
|
|
__in_ecount_z(cFiles) LPCWSTR* rgwzFiles
|
|
) = 0;
|
|
|
|
// OnExecutePackageComplete - called when a package execution is complete.
|
|
//
|
|
// Parameters:
|
|
// restart will indicate whether this package requires a reboot or initiated the reboot already.
|
|
//
|
|
// Return:
|
|
// IDIGNORE instructs the engine to ignore non-vital package failures and continue with the
|
|
// install. Ignored if hrStatus is a success or the package is vital.
|
|
//
|
|
// IDRETRY instructs the engine to try the execution of the package again. Ignored if hrStatus
|
|
// is a success.
|
|
//
|
|
// IDRESTART instructs the engine to stop processing the chain and restart. The engine will
|
|
// launch again after the machine is restarted.
|
|
//
|
|
// IDSUSPEND instructs the engine to stop processing the chain and suspend the current state.
|
|
//
|
|
// All other return codes are ignored.
|
|
STDMETHOD_(int, OnExecutePackageComplete)(
|
|
__in_z LPCWSTR wzPackageId,
|
|
__in HRESULT hrStatus,
|
|
__in BOOTSTRAPPER_APPLY_RESTART restart,
|
|
__in int nRecommendation
|
|
) = 0;
|
|
|
|
// OnExecuteComplete - called when the engine execution is complete.
|
|
//
|
|
STDMETHOD_(void, OnExecuteComplete)(
|
|
__in HRESULT hrStatus
|
|
) = 0;
|
|
|
|
// OnUnregisterBegin - called when the engine unregisters the bundle.
|
|
//
|
|
STDMETHOD_(void, OnUnregisterBegin)() = 0;
|
|
|
|
// OnUnregisterComplete - called when the engine unregistration is complete.
|
|
//
|
|
STDMETHOD_(void, OnUnregisterComplete)(
|
|
__in HRESULT hrStatus
|
|
) = 0;
|
|
|
|
// OnApplyComplete - called after the plan has been applied.
|
|
//
|
|
// Parameters:
|
|
// restart will indicate whether any package required a reboot or initiated the reboot already.
|
|
//
|
|
// Return:
|
|
// IDRESTART instructs the engine to restart. The engine will not launch again after the machine
|
|
// is rebooted. Ignored if reboot was already initiated by OnExecutePackageComplete().
|
|
//
|
|
// All other return codes are ignored.
|
|
STDMETHOD_(int, OnApplyComplete)(
|
|
__in HRESULT hrStatus,
|
|
__in BOOTSTRAPPER_APPLY_RESTART restart
|
|
) = 0;
|
|
};
|
|
|
|
|
|
extern "C" typedef HRESULT (WINAPI *PFN_BOOTSTRAPPER_APPLICATION_CREATE)(
|
|
__in IBootstrapperEngine* pEngine,
|
|
__in const BOOTSTRAPPER_COMMAND* pCommand,
|
|
__out IBootstrapperApplication** ppApplication
|
|
);
|
|
|
|
extern "C" typedef void (WINAPI *PFN_BOOTSTRAPPER_APPLICATION_DESTROY)();
|