diff options
author | Rob Mensching <rob@firegiant.com> | 2021-05-11 07:42:09 -0700 |
---|---|---|
committer | Rob Mensching <rob@firegiant.com> | 2021-05-11 07:42:09 -0700 |
commit | 8e1207c4c5e451ba1a087f0fa11b63964ac35f3c (patch) | |
tree | 8cdfc18d38f25a5fb8e63f115d3447b11172e1e5 /src/api/burn/balutil/inc | |
parent | 6fa3bf7fe67e25650d5a2b6bec09a9813b1a4722 (diff) | |
parent | c00516901e6b67e398396b14fe7682d0376f8643 (diff) | |
download | wix-8e1207c4c5e451ba1a087f0fa11b63964ac35f3c.tar.gz wix-8e1207c4c5e451ba1a087f0fa11b63964ac35f3c.tar.bz2 wix-8e1207c4c5e451ba1a087f0fa11b63964ac35f3c.zip |
Merge balutil
Diffstat (limited to 'src/api/burn/balutil/inc')
-rw-r--r-- | src/api/burn/balutil/inc/BAFunctions.h | 147 | ||||
-rw-r--r-- | src/api/burn/balutil/inc/BalBaseBAFunctions.h | 867 | ||||
-rw-r--r-- | src/api/burn/balutil/inc/BalBaseBAFunctionsProc.h | 124 | ||||
-rw-r--r-- | src/api/burn/balutil/inc/BalBaseBootstrapperApplication.h | 1076 | ||||
-rw-r--r-- | src/api/burn/balutil/inc/BalBaseBootstrapperApplicationProc.h | 901 | ||||
-rw-r--r-- | src/api/burn/balutil/inc/BalBootstrapperEngine.h | 17 | ||||
-rw-r--r-- | src/api/burn/balutil/inc/IBAFunctions.h | 34 | ||||
-rw-r--r-- | src/api/burn/balutil/inc/IBootstrapperApplication.h | 649 | ||||
-rw-r--r-- | src/api/burn/balutil/inc/IBootstrapperApplicationFactory.h | 13 | ||||
-rw-r--r-- | src/api/burn/balutil/inc/IBootstrapperEngine.h | 140 | ||||
-rw-r--r-- | src/api/burn/balutil/inc/balcondition.h | 58 | ||||
-rw-r--r-- | src/api/burn/balutil/inc/balinfo.h | 105 | ||||
-rw-r--r-- | src/api/burn/balutil/inc/balretry.h | 74 | ||||
-rw-r--r-- | src/api/burn/balutil/inc/balutil.h | 199 |
14 files changed, 4404 insertions, 0 deletions
diff --git a/src/api/burn/balutil/inc/BAFunctions.h b/src/api/burn/balutil/inc/BAFunctions.h new file mode 100644 index 00000000..2970478f --- /dev/null +++ b/src/api/burn/balutil/inc/BAFunctions.h | |||
@@ -0,0 +1,147 @@ | |||
1 | #pragma once | ||
2 | // Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. | ||
3 | |||
4 | |||
5 | #ifdef __cplusplus | ||
6 | extern "C" { | ||
7 | #endif | ||
8 | |||
9 | // The first 1024 messages are reserved so that the BA messages have the same value here. | ||
10 | enum BA_FUNCTIONS_MESSAGE | ||
11 | { | ||
12 | BA_FUNCTIONS_MESSAGE_ONDETECTBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTBEGIN, | ||
13 | BA_FUNCTIONS_MESSAGE_ONDETECTCOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTCOMPLETE, | ||
14 | BA_FUNCTIONS_MESSAGE_ONPLANBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANBEGIN, | ||
15 | BA_FUNCTIONS_MESSAGE_ONPLANCOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANCOMPLETE, | ||
16 | BA_FUNCTIONS_MESSAGE_ONSTARTUP = BOOTSTRAPPER_APPLICATION_MESSAGE_ONSTARTUP, | ||
17 | BA_FUNCTIONS_MESSAGE_ONSHUTDOWN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONSHUTDOWN, | ||
18 | BA_FUNCTIONS_MESSAGE_ONSYSTEMSHUTDOWN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONSYSTEMSHUTDOWN, | ||
19 | BA_FUNCTIONS_MESSAGE_ONDETECTFORWARDCOMPATIBLEBUNDLE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTFORWARDCOMPATIBLEBUNDLE, | ||
20 | BA_FUNCTIONS_MESSAGE_ONDETECTUPDATEBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTUPDATEBEGIN, | ||
21 | BA_FUNCTIONS_MESSAGE_ONDETECTUPDATE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTUPDATE, | ||
22 | BA_FUNCTIONS_MESSAGE_ONDETECTUPDATECOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTUPDATECOMPLETE, | ||
23 | BA_FUNCTIONS_MESSAGE_ONDETECTRELATEDBUNDLE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTRELATEDBUNDLE, | ||
24 | BA_FUNCTIONS_MESSAGE_ONDETECTPACKAGEBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTPACKAGEBEGIN, | ||
25 | BA_FUNCTIONS_MESSAGE_ONDETECTRELATEDMSIPACKAGE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTRELATEDMSIPACKAGE, | ||
26 | BA_FUNCTIONS_MESSAGE_ONDETECTPATCHTARGET = BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTPATCHTARGET, | ||
27 | BA_FUNCTIONS_MESSAGE_ONDETECTMSIFEATURE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTMSIFEATURE, | ||
28 | BA_FUNCTIONS_MESSAGE_ONDETECTPACKAGECOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTPACKAGECOMPLETE, | ||
29 | BA_FUNCTIONS_MESSAGE_ONPLANRELATEDBUNDLE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANRELATEDBUNDLE, | ||
30 | BA_FUNCTIONS_MESSAGE_ONPLANPACKAGEBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANPACKAGEBEGIN, | ||
31 | BA_FUNCTIONS_MESSAGE_ONPLANPATCHTARGET = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANPATCHTARGET, | ||
32 | BA_FUNCTIONS_MESSAGE_ONPLANMSIFEATURE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANMSIFEATURE, | ||
33 | BA_FUNCTIONS_MESSAGE_ONPLANPACKAGECOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANPACKAGECOMPLETE, | ||
34 | BA_FUNCTIONS_MESSAGE_ONAPPLYBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONAPPLYBEGIN, | ||
35 | BA_FUNCTIONS_MESSAGE_ONELEVATEBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONELEVATEBEGIN, | ||
36 | BA_FUNCTIONS_MESSAGE_ONELEVATECOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONELEVATECOMPLETE, | ||
37 | BA_FUNCTIONS_MESSAGE_ONPROGRESS = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPROGRESS, | ||
38 | BA_FUNCTIONS_MESSAGE_ONERROR = BOOTSTRAPPER_APPLICATION_MESSAGE_ONERROR, | ||
39 | BA_FUNCTIONS_MESSAGE_ONREGISTERBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONREGISTERBEGIN, | ||
40 | BA_FUNCTIONS_MESSAGE_ONREGISTERCOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONREGISTERCOMPLETE, | ||
41 | BA_FUNCTIONS_MESSAGE_ONCACHEBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEBEGIN, | ||
42 | BA_FUNCTIONS_MESSAGE_ONCACHEPACKAGEBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEPACKAGEBEGIN, | ||
43 | BA_FUNCTIONS_MESSAGE_ONCACHEACQUIREBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEACQUIREBEGIN, | ||
44 | BA_FUNCTIONS_MESSAGE_ONCACHEACQUIREPROGRESS = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEACQUIREPROGRESS, | ||
45 | BA_FUNCTIONS_MESSAGE_ONCACHEACQUIRERESOLVING = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEACQUIRERESOLVING, | ||
46 | BA_FUNCTIONS_MESSAGE_ONCACHEACQUIRECOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEACQUIRECOMPLETE, | ||
47 | BA_FUNCTIONS_MESSAGE_ONCACHEVERIFYBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEVERIFYBEGIN, | ||
48 | BA_FUNCTIONS_MESSAGE_ONCACHEVERIFYCOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEVERIFYCOMPLETE, | ||
49 | BA_FUNCTIONS_MESSAGE_ONCACHEPACKAGECOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEPACKAGECOMPLETE, | ||
50 | BA_FUNCTIONS_MESSAGE_ONCACHECOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHECOMPLETE, | ||
51 | BA_FUNCTIONS_MESSAGE_ONEXECUTEBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEBEGIN, | ||
52 | BA_FUNCTIONS_MESSAGE_ONEXECUTEPACKAGEBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEPACKAGEBEGIN, | ||
53 | BA_FUNCTIONS_MESSAGE_ONEXECUTEPATCHTARGET = BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEPATCHTARGET, | ||
54 | BA_FUNCTIONS_MESSAGE_ONEXECUTEPROGRESS = BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEPROGRESS, | ||
55 | BA_FUNCTIONS_MESSAGE_ONEXECUTEMSIMESSAGE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEMSIMESSAGE, | ||
56 | BA_FUNCTIONS_MESSAGE_ONEXECUTEFILESINUSE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEFILESINUSE, | ||
57 | BA_FUNCTIONS_MESSAGE_ONEXECUTEPACKAGECOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEPACKAGECOMPLETE, | ||
58 | BA_FUNCTIONS_MESSAGE_ONEXECUTECOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTECOMPLETE, | ||
59 | BA_FUNCTIONS_MESSAGE_ONUNREGISTERBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONUNREGISTERBEGIN, | ||
60 | BA_FUNCTIONS_MESSAGE_ONUNREGISTERCOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONUNREGISTERCOMPLETE, | ||
61 | BA_FUNCTIONS_MESSAGE_ONAPPLYCOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONAPPLYCOMPLETE, | ||
62 | BA_FUNCTIONS_MESSAGE_ONLAUNCHAPPROVEDEXEBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONLAUNCHAPPROVEDEXEBEGIN, | ||
63 | BA_FUNCTIONS_MESSAGE_ONLAUNCHAPPROVEDEXECOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONLAUNCHAPPROVEDEXECOMPLETE, | ||
64 | BA_FUNCTIONS_MESSAGE_ONPLANMSIPACKAGE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANMSIPACKAGE, | ||
65 | BA_FUNCTIONS_MESSAGE_ONBEGINMSITRANSACTIONBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONBEGINMSITRANSACTIONBEGIN, | ||
66 | BA_FUNCTIONS_MESSAGE_ONBEGINMSITRANSACTIONCOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONBEGINMSITRANSACTIONCOMPLETE, | ||
67 | BA_FUNCTIONS_MESSAGE_ONCOMMITMSITRANSACTIONBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCOMMITMSITRANSACTIONBEGIN, | ||
68 | BA_FUNCTIONS_MESSAGE_ONCOMMITMSITRANSACTIONCOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCOMMITMSITRANSACTIONCOMPLETE, | ||
69 | BA_FUNCTIONS_MESSAGE_ONROLLBACKMSITRANSACTIONBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONROLLBACKMSITRANSACTIONBEGIN, | ||
70 | BA_FUNCTIONS_MESSAGE_ONROLLBACKMSITRANSACTIONCOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONROLLBACKMSITRANSACTIONCOMPLETE, | ||
71 | BA_FUNCTIONS_MESSAGE_ONPAUSEAUTOMATICUPDATESBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPAUSEAUTOMATICUPDATESBEGIN, | ||
72 | BA_FUNCTIONS_MESSAGE_ONPAUSEAUTOMATICUPDATESCOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPAUSEAUTOMATICUPDATESCOMPLETE, | ||
73 | BA_FUNCTIONS_MESSAGE_ONSYSTEMRESTOREPOINTBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONSYSTEMRESTOREPOINTBEGIN, | ||
74 | BA_FUNCTIONS_MESSAGE_ONSYSTEMRESTOREPOINTCOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONSYSTEMRESTOREPOINTCOMPLETE, | ||
75 | BA_FUNCTIONS_MESSAGE_ONPLANNEDPACKAGE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANNEDPACKAGE, | ||
76 | BA_FUNCTIONS_MESSAGE_ONPLANFORWARDCOMPATIBLEBUNDLE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANFORWARDCOMPATIBLEBUNDLE, | ||
77 | BA_FUNCTIONS_MESSAGE_ONCACHEVERIFYPROGRESS = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEVERIFYPROGRESS, | ||
78 | BA_FUNCTIONS_MESSAGE_ONCACHECONTAINERORPAYLOADVERIFYBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHECONTAINERORPAYLOADVERIFYBEGIN, | ||
79 | BA_FUNCTIONS_MESSAGE_ONCACHECONTAINERORPAYLOADVERIFYCOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHECONTAINERORPAYLOADVERIFYCOMPLETE, | ||
80 | BA_FUNCTIONS_MESSAGE_ONCACHECONTAINERORPAYLOADVERIFYPROGRESS = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHECONTAINERORPAYLOADVERIFYPROGRESS, | ||
81 | BA_FUNCTIONS_MESSAGE_ONCACHEPAYLOADEXTRACTBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEPAYLOADEXTRACTBEGIN, | ||
82 | BA_FUNCTIONS_MESSAGE_ONCACHEPAYLOADEXTRACTCOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEPAYLOADEXTRACTCOMPLETE, | ||
83 | BA_FUNCTIONS_MESSAGE_ONCACHEPAYLOADEXTRACTPROGRESS = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEPAYLOADEXTRACTPROGRESS, | ||
84 | |||
85 | BA_FUNCTIONS_MESSAGE_ONTHEMELOADED = 1024, | ||
86 | BA_FUNCTIONS_MESSAGE_WNDPROC, | ||
87 | }; | ||
88 | |||
89 | typedef HRESULT(WINAPI *PFN_BA_FUNCTIONS_PROC)( | ||
90 | __in BA_FUNCTIONS_MESSAGE message, | ||
91 | __in const LPVOID pvArgs, | ||
92 | __inout LPVOID pvResults, | ||
93 | __in_opt LPVOID pvContext | ||
94 | ); | ||
95 | |||
96 | struct BA_FUNCTIONS_CREATE_ARGS | ||
97 | { | ||
98 | DWORD cbSize; | ||
99 | DWORD64 qwBAFunctionsAPIVersion; | ||
100 | BOOTSTRAPPER_CREATE_ARGS* pBootstrapperCreateArgs; | ||
101 | }; | ||
102 | |||
103 | struct BA_FUNCTIONS_CREATE_RESULTS | ||
104 | { | ||
105 | DWORD cbSize; | ||
106 | PFN_BA_FUNCTIONS_PROC pfnBAFunctionsProc; | ||
107 | LPVOID pvBAFunctionsProcContext; | ||
108 | }; | ||
109 | |||
110 | struct BA_FUNCTIONS_ONTHEMELOADED_ARGS | ||
111 | { | ||
112 | DWORD cbSize; | ||
113 | THEME* pTheme; | ||
114 | WIX_LOCALIZATION* pWixLoc; | ||
115 | }; | ||
116 | |||
117 | struct BA_FUNCTIONS_ONTHEMELOADED_RESULTS | ||
118 | { | ||
119 | DWORD cbSize; | ||
120 | }; | ||
121 | |||
122 | struct BA_FUNCTIONS_WNDPROC_ARGS | ||
123 | { | ||
124 | DWORD cbSize; | ||
125 | THEME* pTheme; | ||
126 | HWND hWnd; | ||
127 | UINT uMsg; | ||
128 | WPARAM wParam; | ||
129 | LPARAM lParam; | ||
130 | }; | ||
131 | |||
132 | struct BA_FUNCTIONS_WNDPROC_RESULTS | ||
133 | { | ||
134 | DWORD cbSize; | ||
135 | LRESULT lres; | ||
136 | }; | ||
137 | |||
138 | typedef HRESULT(WINAPI *PFN_BA_FUNCTIONS_CREATE)( | ||
139 | __in const BA_FUNCTIONS_CREATE_ARGS* pArgs, | ||
140 | __inout BA_FUNCTIONS_CREATE_RESULTS* pResults | ||
141 | ); | ||
142 | |||
143 | typedef void (WINAPI *PFN_BA_FUNCTIONS_DESTROY)(); | ||
144 | |||
145 | #ifdef __cplusplus | ||
146 | } | ||
147 | #endif | ||
diff --git a/src/api/burn/balutil/inc/BalBaseBAFunctions.h b/src/api/burn/balutil/inc/BalBaseBAFunctions.h new file mode 100644 index 00000000..ee2e452f --- /dev/null +++ b/src/api/burn/balutil/inc/BalBaseBAFunctions.h | |||
@@ -0,0 +1,867 @@ | |||
1 | #pragma once | ||
2 | // Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. | ||
3 | |||
4 | |||
5 | #include <windows.h> | ||
6 | #include <msiquery.h> | ||
7 | |||
8 | #include "dutil.h" | ||
9 | #include "locutil.h" | ||
10 | #include "thmutil.h" | ||
11 | #include "BAFunctions.h" | ||
12 | #include "IBAFunctions.h" | ||
13 | #include "BootstrapperEngine.h" | ||
14 | #include "BootstrapperApplication.h" | ||
15 | #include "IBootstrapperEngine.h" | ||
16 | #include "IBootstrapperApplication.h" | ||
17 | |||
18 | class CBalBaseBAFunctions : public IBAFunctions | ||
19 | { | ||
20 | public: // IUnknown | ||
21 | virtual STDMETHODIMP QueryInterface( | ||
22 | __in REFIID riid, | ||
23 | __out LPVOID *ppvObject | ||
24 | ) | ||
25 | { | ||
26 | if (!ppvObject) | ||
27 | { | ||
28 | return E_INVALIDARG; | ||
29 | } | ||
30 | |||
31 | *ppvObject = NULL; | ||
32 | |||
33 | if (::IsEqualIID(__uuidof(IBAFunctions), riid)) | ||
34 | { | ||
35 | *ppvObject = static_cast<IBAFunctions*>(this); | ||
36 | } | ||
37 | else if (::IsEqualIID(__uuidof(IBootstrapperApplication), riid)) | ||
38 | { | ||
39 | *ppvObject = static_cast<IBootstrapperApplication*>(this); | ||
40 | } | ||
41 | else if (::IsEqualIID(IID_IUnknown, riid)) | ||
42 | { | ||
43 | *ppvObject = static_cast<IUnknown*>(this); | ||
44 | } | ||
45 | else // no interface for requested iid | ||
46 | { | ||
47 | return E_NOINTERFACE; | ||
48 | } | ||
49 | |||
50 | AddRef(); | ||
51 | return S_OK; | ||
52 | } | ||
53 | |||
54 | virtual STDMETHODIMP_(ULONG) AddRef() | ||
55 | { | ||
56 | return ::InterlockedIncrement(&this->m_cReferences); | ||
57 | } | ||
58 | |||
59 | virtual STDMETHODIMP_(ULONG) Release() | ||
60 | { | ||
61 | long l = ::InterlockedDecrement(&this->m_cReferences); | ||
62 | if (0 < l) | ||
63 | { | ||
64 | return l; | ||
65 | } | ||
66 | |||
67 | delete this; | ||
68 | return 0; | ||
69 | } | ||
70 | |||
71 | public: // IBootstrapperApplication | ||
72 | virtual STDMETHODIMP_(HRESULT) BAProc( | ||
73 | __in BOOTSTRAPPER_APPLICATION_MESSAGE /*message*/, | ||
74 | __in const LPVOID /*pvArgs*/, | ||
75 | __inout LPVOID /*pvResults*/, | ||
76 | __in_opt LPVOID /*pvContext*/ | ||
77 | ) | ||
78 | { | ||
79 | return E_NOTIMPL; | ||
80 | } | ||
81 | |||
82 | virtual STDMETHODIMP_(void) BAProcFallback( | ||
83 | __in BOOTSTRAPPER_APPLICATION_MESSAGE /*message*/, | ||
84 | __in const LPVOID /*pvArgs*/, | ||
85 | __inout LPVOID /*pvResults*/, | ||
86 | __inout HRESULT* /*phr*/, | ||
87 | __in_opt LPVOID /*pvContext*/ | ||
88 | ) | ||
89 | { | ||
90 | } | ||
91 | |||
92 | virtual STDMETHODIMP OnStartup() | ||
93 | { | ||
94 | return S_OK; | ||
95 | } | ||
96 | |||
97 | virtual STDMETHODIMP OnShutdown( | ||
98 | __inout BOOTSTRAPPER_SHUTDOWN_ACTION* /*pAction*/ | ||
99 | ) | ||
100 | { | ||
101 | return S_OK; | ||
102 | } | ||
103 | |||
104 | virtual STDMETHODIMP OnSystemShutdown( | ||
105 | __in DWORD /*dwEndSession*/, | ||
106 | __inout BOOL* /*pfCancel*/ | ||
107 | ) | ||
108 | { | ||
109 | return S_OK; | ||
110 | } | ||
111 | |||
112 | virtual STDMETHODIMP OnDetectBegin( | ||
113 | __in BOOL /*fCached*/, | ||
114 | __in BOOL /*fInstalled*/, | ||
115 | __in DWORD /*cPackages*/, | ||
116 | __inout BOOL* /*pfCancel*/ | ||
117 | ) | ||
118 | { | ||
119 | return S_OK; | ||
120 | } | ||
121 | |||
122 | virtual STDMETHODIMP OnDetectForwardCompatibleBundle( | ||
123 | __in_z LPCWSTR /*wzBundleId*/, | ||
124 | __in BOOTSTRAPPER_RELATION_TYPE /*relationType*/, | ||
125 | __in_z LPCWSTR /*wzBundleTag*/, | ||
126 | __in BOOL /*fPerMachine*/, | ||
127 | __in LPCWSTR /*wzVersion*/, | ||
128 | __in BOOL /*fMissingFromCache*/, | ||
129 | __inout BOOL* /*pfCancel*/ | ||
130 | ) | ||
131 | { | ||
132 | return S_OK; | ||
133 | } | ||
134 | |||
135 | virtual STDMETHODIMP OnDetectUpdateBegin( | ||
136 | __in_z LPCWSTR /*wzUpdateLocation*/, | ||
137 | __inout BOOL* /*pfCancel*/, | ||
138 | __inout BOOL* /*pfSkip*/ | ||
139 | ) | ||
140 | { | ||
141 | return S_OK; | ||
142 | } | ||
143 | |||
144 | virtual STDMETHODIMP OnDetectUpdate( | ||
145 | __in_z LPCWSTR /*wzUpdateLocation*/, | ||
146 | __in DWORD64 /*dw64Size*/, | ||
147 | __in LPCWSTR /*wzVersion*/, | ||
148 | __in_z LPCWSTR /*wzTitle*/, | ||
149 | __in_z LPCWSTR /*wzSummary*/, | ||
150 | __in_z LPCWSTR /*wzContentType*/, | ||
151 | __in_z LPCWSTR /*wzContent*/, | ||
152 | __inout BOOL* /*pfCancel*/, | ||
153 | __inout BOOL* /*pfStopProcessingUpdates*/ | ||
154 | ) | ||
155 | { | ||
156 | return S_OK; | ||
157 | } | ||
158 | |||
159 | virtual STDMETHODIMP OnDetectUpdateComplete( | ||
160 | __in HRESULT /*hrStatus*/, | ||
161 | __inout BOOL* /*pfIgnoreError*/ | ||
162 | ) | ||
163 | { | ||
164 | return S_OK; | ||
165 | } | ||
166 | |||
167 | virtual STDMETHODIMP OnDetectRelatedBundle( | ||
168 | __in_z LPCWSTR /*wzBundleId*/, | ||
169 | __in BOOTSTRAPPER_RELATION_TYPE /*relationType*/, | ||
170 | __in_z LPCWSTR /*wzBundleTag*/, | ||
171 | __in BOOL /*fPerMachine*/, | ||
172 | __in LPCWSTR /*wzVersion*/, | ||
173 | __in BOOTSTRAPPER_RELATED_OPERATION /*operation*/, | ||
174 | __in BOOL /*fMissingFromCache*/, | ||
175 | __inout BOOL* /*pfCancel*/ | ||
176 | ) | ||
177 | { | ||
178 | return S_OK; | ||
179 | } | ||
180 | |||
181 | virtual STDMETHODIMP OnDetectPackageBegin( | ||
182 | __in_z LPCWSTR /*wzPackageId*/, | ||
183 | __inout BOOL* /*pfCancel*/ | ||
184 | ) | ||
185 | { | ||
186 | return S_OK; | ||
187 | } | ||
188 | |||
189 | virtual STDMETHODIMP OnDetectRelatedMsiPackage( | ||
190 | __in_z LPCWSTR /*wzPackageId*/, | ||
191 | __in_z LPCWSTR /*wzUpgradeCode*/, | ||
192 | __in_z LPCWSTR /*wzProductCode*/, | ||
193 | __in BOOL /*fPerMachine*/, | ||
194 | __in LPCWSTR /*wzVersion*/, | ||
195 | __in BOOTSTRAPPER_RELATED_OPERATION /*operation*/, | ||
196 | __inout BOOL* /*pfCancel*/ | ||
197 | ) | ||
198 | { | ||
199 | return S_OK; | ||
200 | } | ||
201 | |||
202 | virtual STDMETHODIMP OnDetectPatchTarget( | ||
203 | __in_z LPCWSTR /*wzPackageId*/, | ||
204 | __in_z LPCWSTR /*wzProductCode*/, | ||
205 | __in BOOTSTRAPPER_PACKAGE_STATE /*patchState*/, | ||
206 | __inout BOOL* /*pfCancel*/ | ||
207 | ) | ||
208 | { | ||
209 | return S_OK; | ||
210 | } | ||
211 | |||
212 | virtual STDMETHODIMP OnDetectMsiFeature( | ||
213 | __in_z LPCWSTR /*wzPackageId*/, | ||
214 | __in_z LPCWSTR /*wzFeatureId*/, | ||
215 | __in BOOTSTRAPPER_FEATURE_STATE /*state*/, | ||
216 | __inout BOOL* /*pfCancel*/ | ||
217 | ) | ||
218 | { | ||
219 | return S_OK; | ||
220 | } | ||
221 | |||
222 | virtual STDMETHODIMP OnDetectPackageComplete( | ||
223 | __in_z LPCWSTR /*wzPackageId*/, | ||
224 | __in HRESULT /*hrStatus*/, | ||
225 | __in BOOTSTRAPPER_PACKAGE_STATE /*state*/, | ||
226 | __in BOOL /*fCached*/ | ||
227 | ) | ||
228 | { | ||
229 | return S_OK; | ||
230 | } | ||
231 | |||
232 | virtual STDMETHODIMP OnDetectComplete( | ||
233 | __in HRESULT /*hrStatus*/, | ||
234 | __in BOOL /*fEligibleForCleanup*/ | ||
235 | ) | ||
236 | { | ||
237 | return S_OK; | ||
238 | } | ||
239 | |||
240 | virtual STDMETHODIMP OnPlanBegin( | ||
241 | __in DWORD /*cPackages*/, | ||
242 | __inout BOOL* /*pfCancel*/ | ||
243 | ) | ||
244 | { | ||
245 | return S_OK; | ||
246 | } | ||
247 | |||
248 | virtual STDMETHODIMP OnPlanRelatedBundle( | ||
249 | __in_z LPCWSTR /*wzBundleId*/, | ||
250 | __in BOOTSTRAPPER_REQUEST_STATE /*recommendedState*/, | ||
251 | __inout BOOTSTRAPPER_REQUEST_STATE* /*pRequestedState*/, | ||
252 | __inout BOOL* /*pfCancel*/ | ||
253 | ) | ||
254 | { | ||
255 | return S_OK; | ||
256 | } | ||
257 | |||
258 | virtual STDMETHODIMP OnPlanPackageBegin( | ||
259 | __in_z LPCWSTR /*wzPackageId*/, | ||
260 | __in BOOTSTRAPPER_PACKAGE_STATE /*state*/, | ||
261 | __in BOOL /*fCached*/, | ||
262 | __in BOOTSTRAPPER_PACKAGE_CONDITION_RESULT /*installCondition*/, | ||
263 | __in BOOTSTRAPPER_REQUEST_STATE /*recommendedState*/, | ||
264 | __in BOOTSTRAPPER_CACHE_TYPE /*recommendedCacheType*/, | ||
265 | __inout BOOTSTRAPPER_REQUEST_STATE* /*pRequestState*/, | ||
266 | __inout BOOTSTRAPPER_CACHE_TYPE* /*pRequestedCacheType*/, | ||
267 | __inout BOOL* /*pfCancel*/ | ||
268 | ) | ||
269 | { | ||
270 | return S_OK; | ||
271 | } | ||
272 | |||
273 | virtual STDMETHODIMP OnPlanPatchTarget( | ||
274 | __in_z LPCWSTR /*wzPackageId*/, | ||
275 | __in_z LPCWSTR /*wzProductCode*/, | ||
276 | __in BOOTSTRAPPER_REQUEST_STATE /*recommendedState*/, | ||
277 | __inout BOOTSTRAPPER_REQUEST_STATE* /*pRequestedState*/, | ||
278 | __inout BOOL* /*pfCancel*/ | ||
279 | ) | ||
280 | { | ||
281 | return S_OK; | ||
282 | } | ||
283 | |||
284 | virtual STDMETHODIMP OnPlanMsiFeature( | ||
285 | __in_z LPCWSTR /*wzPackageId*/, | ||
286 | __in_z LPCWSTR /*wzFeatureId*/, | ||
287 | __in BOOTSTRAPPER_FEATURE_STATE /*recommendedState*/, | ||
288 | __inout BOOTSTRAPPER_FEATURE_STATE* /*pRequestedState*/, | ||
289 | __inout BOOL* /*pfCancel*/ | ||
290 | ) | ||
291 | { | ||
292 | return S_OK; | ||
293 | } | ||
294 | |||
295 | virtual STDMETHODIMP OnPlanMsiPackage( | ||
296 | __in_z LPCWSTR /*wzPackageId*/, | ||
297 | __in BOOL /*fExecute*/, | ||
298 | __in BOOTSTRAPPER_ACTION_STATE /*action*/, | ||
299 | __inout BOOL* /*pfCancel*/, | ||
300 | __inout BURN_MSI_PROPERTY* /*pActionMsiProperty*/, | ||
301 | __inout INSTALLUILEVEL* /*pUiLevel*/, | ||
302 | __inout BOOL* /*pfDisableExternalUiHandler*/ | ||
303 | ) | ||
304 | { | ||
305 | return S_OK; | ||
306 | } | ||
307 | |||
308 | virtual STDMETHODIMP OnPlanPackageComplete( | ||
309 | __in_z LPCWSTR /*wzPackageId*/, | ||
310 | __in HRESULT /*hrStatus*/, | ||
311 | __in BOOTSTRAPPER_REQUEST_STATE /*requested*/ | ||
312 | ) | ||
313 | { | ||
314 | return S_OK; | ||
315 | } | ||
316 | |||
317 | virtual STDMETHODIMP OnPlannedPackage( | ||
318 | __in_z LPCWSTR /*wzPackageId*/, | ||
319 | __in BOOTSTRAPPER_ACTION_STATE /*execute*/, | ||
320 | __in BOOTSTRAPPER_ACTION_STATE /*rollback*/, | ||
321 | __in BOOL /*fPlannedCache*/, | ||
322 | __in BOOL /*fPlannedUncache*/ | ||
323 | ) | ||
324 | { | ||
325 | return S_OK; | ||
326 | } | ||
327 | |||
328 | virtual STDMETHODIMP OnPlanComplete( | ||
329 | __in HRESULT /*hrStatus*/ | ||
330 | ) | ||
331 | { | ||
332 | return S_OK; | ||
333 | } | ||
334 | |||
335 | virtual STDMETHODIMP OnApplyBegin( | ||
336 | __in DWORD /*dwPhaseCount*/, | ||
337 | __inout BOOL* /*pfCancel*/ | ||
338 | ) | ||
339 | { | ||
340 | return S_OK; | ||
341 | } | ||
342 | |||
343 | virtual STDMETHODIMP OnElevateBegin( | ||
344 | __inout BOOL* /*pfCancel*/ | ||
345 | ) | ||
346 | { | ||
347 | return S_OK; | ||
348 | } | ||
349 | |||
350 | virtual STDMETHODIMP OnElevateComplete( | ||
351 | __in HRESULT /*hrStatus*/ | ||
352 | ) | ||
353 | { | ||
354 | return S_OK; | ||
355 | } | ||
356 | |||
357 | virtual STDMETHODIMP OnProgress( | ||
358 | __in DWORD /*dwProgressPercentage*/, | ||
359 | __in DWORD /*dwOverallProgressPercentage*/, | ||
360 | __inout BOOL* /*pfCancel*/ | ||
361 | ) | ||
362 | { | ||
363 | return IDNOACTION; | ||
364 | } | ||
365 | |||
366 | virtual STDMETHODIMP OnError( | ||
367 | __in BOOTSTRAPPER_ERROR_TYPE /*errorType*/, | ||
368 | __in_z LPCWSTR /*wzPackageId*/, | ||
369 | __in DWORD /*dwCode*/, | ||
370 | __in_z LPCWSTR /*wzError*/, | ||
371 | __in DWORD /*dwUIHint*/, | ||
372 | __in DWORD /*cData*/, | ||
373 | __in_ecount_z_opt(cData) LPCWSTR* /*rgwzData*/, | ||
374 | __in int /*nRecommendation*/, | ||
375 | __inout int* /*pResult*/ | ||
376 | ) | ||
377 | { | ||
378 | return S_OK; | ||
379 | } | ||
380 | |||
381 | virtual STDMETHODIMP OnRegisterBegin( | ||
382 | __inout BOOL* /*pfCancel*/ | ||
383 | ) | ||
384 | { | ||
385 | return S_OK; | ||
386 | } | ||
387 | |||
388 | virtual STDMETHODIMP OnRegisterComplete( | ||
389 | __in HRESULT /*hrStatus*/ | ||
390 | ) | ||
391 | { | ||
392 | return S_OK; | ||
393 | } | ||
394 | |||
395 | virtual STDMETHODIMP OnCacheBegin( | ||
396 | __inout BOOL* /*pfCancel*/ | ||
397 | ) | ||
398 | { | ||
399 | return S_OK; | ||
400 | } | ||
401 | |||
402 | virtual STDMETHODIMP OnCachePackageBegin( | ||
403 | __in_z LPCWSTR /*wzPackageId*/, | ||
404 | __in DWORD /*cCachePayloads*/, | ||
405 | __in DWORD64 /*dw64PackageCacheSize*/, | ||
406 | __inout BOOL* /*pfCancel*/ | ||
407 | ) | ||
408 | { | ||
409 | return S_OK; | ||
410 | } | ||
411 | |||
412 | virtual STDMETHODIMP OnCacheAcquireBegin( | ||
413 | __in_z LPCWSTR /*wzPackageOrContainerId*/, | ||
414 | __in_z_opt LPCWSTR /*wzPayloadId*/, | ||
415 | __in_z LPCWSTR /*wzSource*/, | ||
416 | __in_z_opt LPCWSTR /*wzDownloadUrl*/, | ||
417 | __in_z_opt LPCWSTR /*wzPayloadContainerId*/, | ||
418 | __in BOOTSTRAPPER_CACHE_OPERATION /*recommendation*/, | ||
419 | __inout BOOTSTRAPPER_CACHE_OPERATION* /*pAction*/, | ||
420 | __inout BOOL* /*pfCancel*/ | ||
421 | ) | ||
422 | { | ||
423 | return S_OK; | ||
424 | } | ||
425 | |||
426 | virtual STDMETHODIMP OnCacheAcquireProgress( | ||
427 | __in_z LPCWSTR /*wzPackageOrContainerId*/, | ||
428 | __in_z_opt LPCWSTR /*wzPayloadId*/, | ||
429 | __in DWORD64 /*dw64Progress*/, | ||
430 | __in DWORD64 /*dw64Total*/, | ||
431 | __in DWORD /*dwOverallPercentage*/, | ||
432 | __inout BOOL* /*pfCancel*/ | ||
433 | ) | ||
434 | { | ||
435 | return S_OK; | ||
436 | } | ||
437 | |||
438 | virtual STDMETHODIMP OnCacheAcquireResolving( | ||
439 | __in_z_opt LPCWSTR /*wzPackageOrContainerId*/, | ||
440 | __in_z_opt LPCWSTR /*wzPayloadId*/, | ||
441 | __in_z LPCWSTR* /*rgSearchPaths*/, | ||
442 | __in DWORD /*cSearchPaths*/, | ||
443 | __in BOOL /*fFoundLocal*/, | ||
444 | __in DWORD /*dwRecommendedSearchPath*/, | ||
445 | __in_z_opt LPCWSTR /*wzDownloadUrl*/, | ||
446 | __in_z_opt LPCWSTR /*wzPayloadContainerId*/, | ||
447 | __in BOOTSTRAPPER_CACHE_RESOLVE_OPERATION /*recommendation*/, | ||
448 | __inout DWORD* /*pdwChosenSearchPath*/, | ||
449 | __inout BOOTSTRAPPER_CACHE_RESOLVE_OPERATION* /*pAction*/, | ||
450 | __inout BOOL* /*pfCancel*/ | ||
451 | ) | ||
452 | { | ||
453 | return S_OK; | ||
454 | } | ||
455 | |||
456 | virtual STDMETHODIMP OnCacheAcquireComplete( | ||
457 | __in_z LPCWSTR /*wzPackageOrContainerId*/, | ||
458 | __in_z_opt LPCWSTR /*wzPayloadId*/, | ||
459 | __in HRESULT /*hrStatus*/, | ||
460 | __in BOOTSTRAPPER_CACHEACQUIRECOMPLETE_ACTION /*recommendation*/, | ||
461 | __inout BOOTSTRAPPER_CACHEACQUIRECOMPLETE_ACTION* /*pAction*/ | ||
462 | ) | ||
463 | { | ||
464 | return S_OK; | ||
465 | } | ||
466 | |||
467 | virtual STDMETHODIMP OnCacheVerifyBegin( | ||
468 | __in_z LPCWSTR /*wzPackageOrContainerId*/, | ||
469 | __in_z LPCWSTR /*wzPayloadId*/, | ||
470 | __inout BOOL* /*pfCancel*/ | ||
471 | ) | ||
472 | { | ||
473 | return S_OK; | ||
474 | } | ||
475 | |||
476 | virtual STDMETHODIMP OnCacheVerifyProgress( | ||
477 | __in_z_opt LPCWSTR /*wzPackageOrContainerId*/, | ||
478 | __in_z_opt LPCWSTR /*wzPayloadId*/, | ||
479 | __in DWORD64 /*dw64Progress*/, | ||
480 | __in DWORD64 /*dw64Total*/, | ||
481 | __in DWORD /*dwOverallPercentage*/, | ||
482 | __in BOOTSTRAPPER_CACHE_VERIFY_STEP /*verifyStep*/, | ||
483 | __inout BOOL* /*pfCancel*/ | ||
484 | ) | ||
485 | { | ||
486 | return S_OK; | ||
487 | } | ||
488 | |||
489 | virtual STDMETHODIMP OnCacheVerifyComplete( | ||
490 | __in_z LPCWSTR /*wzPackageOrContainerId*/, | ||
491 | __in_z LPCWSTR /*wzPayloadId*/, | ||
492 | __in HRESULT /*hrStatus*/, | ||
493 | __in BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION /*recommendation*/, | ||
494 | __inout BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION* /*pAction*/ | ||
495 | ) | ||
496 | { | ||
497 | return S_OK; | ||
498 | } | ||
499 | |||
500 | virtual STDMETHODIMP OnCachePackageComplete( | ||
501 | __in_z LPCWSTR /*wzPackageId*/, | ||
502 | __in HRESULT /*hrStatus*/, | ||
503 | __in BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION /*recommendation*/, | ||
504 | __inout BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION* /*pAction*/ | ||
505 | ) | ||
506 | { | ||
507 | return S_OK; | ||
508 | } | ||
509 | |||
510 | virtual STDMETHODIMP OnCacheComplete( | ||
511 | __in HRESULT /*hrStatus*/ | ||
512 | ) | ||
513 | { | ||
514 | return S_OK; | ||
515 | } | ||
516 | |||
517 | virtual STDMETHODIMP OnExecuteBegin( | ||
518 | __in DWORD /*cExecutingPackages*/, | ||
519 | __inout BOOL* /*pfCancel*/ | ||
520 | ) | ||
521 | { | ||
522 | return S_OK; | ||
523 | } | ||
524 | |||
525 | virtual STDMETHODIMP OnExecutePackageBegin( | ||
526 | __in_z LPCWSTR /*wzPackageId*/, | ||
527 | __in BOOL /*fExecute*/, | ||
528 | __in BOOTSTRAPPER_ACTION_STATE /*action*/, | ||
529 | __in INSTALLUILEVEL /*uiLevel*/, | ||
530 | __in BOOL /*fDisableExternalUiHandler*/, | ||
531 | __inout BOOL* /*pfCancel*/ | ||
532 | ) | ||
533 | { | ||
534 | return S_OK; | ||
535 | } | ||
536 | |||
537 | virtual STDMETHODIMP OnExecutePatchTarget( | ||
538 | __in_z LPCWSTR /*wzPackageId*/, | ||
539 | __in_z LPCWSTR /*wzTargetProductCode*/, | ||
540 | __inout BOOL* /*pfCancel*/ | ||
541 | ) | ||
542 | { | ||
543 | return S_OK; | ||
544 | } | ||
545 | |||
546 | virtual STDMETHODIMP OnExecuteProgress( | ||
547 | __in_z LPCWSTR /*wzPackageId*/, | ||
548 | __in DWORD /*dwProgressPercentage*/, | ||
549 | __in DWORD /*dwOverallProgressPercentage*/, | ||
550 | __inout BOOL* /*pfCancel*/ | ||
551 | ) | ||
552 | { | ||
553 | return S_OK; | ||
554 | } | ||
555 | |||
556 | virtual STDMETHODIMP OnExecuteMsiMessage( | ||
557 | __in_z LPCWSTR /*wzPackageId*/, | ||
558 | __in INSTALLMESSAGE /*messageType*/, | ||
559 | __in DWORD /*dwUIHint*/, | ||
560 | __in_z LPCWSTR /*wzMessage*/, | ||
561 | __in DWORD /*cData*/, | ||
562 | __in_ecount_z_opt(cData) LPCWSTR* /*rgwzData*/, | ||
563 | __in int /*nRecommendation*/, | ||
564 | __inout int* /*pResult*/ | ||
565 | ) | ||
566 | { | ||
567 | return S_OK; | ||
568 | } | ||
569 | |||
570 | virtual STDMETHODIMP OnExecuteFilesInUse( | ||
571 | __in_z LPCWSTR /*wzPackageId*/, | ||
572 | __in DWORD /*cFiles*/, | ||
573 | __in_ecount_z(cFiles) LPCWSTR* /*rgwzFiles*/, | ||
574 | __in int /*nRecommendation*/, | ||
575 | __inout int* /*pResult*/ | ||
576 | ) | ||
577 | { | ||
578 | return S_OK; | ||
579 | } | ||
580 | |||
581 | virtual STDMETHODIMP OnExecutePackageComplete( | ||
582 | __in_z LPCWSTR /*wzPackageId*/, | ||
583 | __in HRESULT /*hrStatus*/, | ||
584 | __in BOOTSTRAPPER_APPLY_RESTART /*restart*/, | ||
585 | __in BOOTSTRAPPER_EXECUTEPACKAGECOMPLETE_ACTION /*recommendation*/, | ||
586 | __inout BOOTSTRAPPER_EXECUTEPACKAGECOMPLETE_ACTION* /*pAction*/ | ||
587 | ) | ||
588 | { | ||
589 | return S_OK; | ||
590 | } | ||
591 | |||
592 | virtual STDMETHODIMP OnExecuteComplete( | ||
593 | __in HRESULT /*hrStatus*/ | ||
594 | ) | ||
595 | { | ||
596 | return S_OK; | ||
597 | } | ||
598 | |||
599 | virtual STDMETHODIMP OnUnregisterBegin( | ||
600 | __in BOOL /*fKeepRegistration*/, | ||
601 | __inout BOOL* /*pfForceKeepRegistration*/ | ||
602 | ) | ||
603 | { | ||
604 | return S_OK; | ||
605 | } | ||
606 | |||
607 | virtual STDMETHODIMP OnUnregisterComplete( | ||
608 | __in HRESULT /*hrStatus*/ | ||
609 | ) | ||
610 | { | ||
611 | return S_OK; | ||
612 | } | ||
613 | |||
614 | virtual STDMETHODIMP OnApplyComplete( | ||
615 | __in HRESULT /*hrStatus*/, | ||
616 | __in BOOTSTRAPPER_APPLY_RESTART /*restart*/, | ||
617 | __in BOOTSTRAPPER_APPLYCOMPLETE_ACTION /*recommendation*/, | ||
618 | __inout BOOTSTRAPPER_APPLYCOMPLETE_ACTION* /*pAction*/ | ||
619 | ) | ||
620 | { | ||
621 | return S_OK; | ||
622 | } | ||
623 | |||
624 | virtual STDMETHODIMP OnLaunchApprovedExeBegin( | ||
625 | __inout BOOL* /*pfCancel*/ | ||
626 | ) | ||
627 | { | ||
628 | return S_OK; | ||
629 | } | ||
630 | |||
631 | virtual STDMETHODIMP OnLaunchApprovedExeComplete( | ||
632 | __in HRESULT /*hrStatus*/, | ||
633 | __in DWORD /*dwProcessId*/ | ||
634 | ) | ||
635 | { | ||
636 | return S_OK; | ||
637 | } | ||
638 | |||
639 | virtual STDMETHODIMP OnBeginMsiTransactionBegin( | ||
640 | __in_z LPCWSTR /*wzTransactionId*/, | ||
641 | __inout BOOL* /*pfCancel*/ | ||
642 | ) | ||
643 | { | ||
644 | return S_OK; | ||
645 | } | ||
646 | |||
647 | virtual STDMETHODIMP OnBeginMsiTransactionComplete( | ||
648 | __in_z LPCWSTR /*wzTransactionId*/, | ||
649 | __in HRESULT /*hrStatus*/ | ||
650 | ) | ||
651 | { | ||
652 | return S_OK; | ||
653 | } | ||
654 | |||
655 | virtual STDMETHODIMP OnCommitMsiTransactionBegin( | ||
656 | __in_z LPCWSTR /*wzTransactionId*/, | ||
657 | __inout BOOL* /*pfCancel*/ | ||
658 | ) | ||
659 | { | ||
660 | return S_OK; | ||
661 | } | ||
662 | |||
663 | virtual STDMETHODIMP OnCommitMsiTransactionComplete( | ||
664 | __in_z LPCWSTR /*wzTransactionId*/, | ||
665 | __in HRESULT /*hrStatus*/ | ||
666 | ) | ||
667 | { | ||
668 | return S_OK; | ||
669 | } | ||
670 | |||
671 | virtual STDMETHODIMP OnRollbackMsiTransactionBegin( | ||
672 | __in_z LPCWSTR /*wzTransactionId*/ | ||
673 | ) | ||
674 | { | ||
675 | return S_OK; | ||
676 | } | ||
677 | |||
678 | virtual STDMETHODIMP OnRollbackMsiTransactionComplete( | ||
679 | __in_z LPCWSTR /*wzTransactionId*/, | ||
680 | __in HRESULT /*hrStatus*/ | ||
681 | ) | ||
682 | { | ||
683 | return S_OK; | ||
684 | } | ||
685 | |||
686 | virtual STDMETHODIMP OnPauseAutomaticUpdatesBegin( | ||
687 | ) | ||
688 | { | ||
689 | return S_OK; | ||
690 | } | ||
691 | |||
692 | virtual STDMETHODIMP OnPauseAutomaticUpdatesComplete( | ||
693 | __in HRESULT /*hrStatus*/ | ||
694 | ) | ||
695 | { | ||
696 | return S_OK; | ||
697 | } | ||
698 | |||
699 | virtual STDMETHODIMP OnSystemRestorePointBegin( | ||
700 | ) | ||
701 | { | ||
702 | return S_OK; | ||
703 | } | ||
704 | |||
705 | virtual STDMETHODIMP OnSystemRestorePointComplete( | ||
706 | __in HRESULT /*hrStatus*/ | ||
707 | ) | ||
708 | { | ||
709 | return S_OK; | ||
710 | } | ||
711 | |||
712 | virtual STDMETHODIMP OnPlanForwardCompatibleBundle( | ||
713 | __in_z LPCWSTR /*wzBundleId*/, | ||
714 | __in BOOTSTRAPPER_RELATION_TYPE /*relationType*/, | ||
715 | __in_z LPCWSTR /*wzBundleTag*/, | ||
716 | __in BOOL /*fPerMachine*/, | ||
717 | __in LPCWSTR /*wzVersion*/, | ||
718 | __in BOOL /*fRecommendedIgnoreBundle*/, | ||
719 | __inout BOOL* /*pfCancel*/, | ||
720 | __inout BOOL* /*pfIgnoreBundle*/ | ||
721 | ) | ||
722 | { | ||
723 | return S_OK; | ||
724 | } | ||
725 | |||
726 | virtual STDMETHODIMP OnCacheContainerOrPayloadVerifyBegin( | ||
727 | __in_z_opt LPCWSTR /*wzPackageOrContainerId*/, | ||
728 | __in_z_opt LPCWSTR /*wzPayloadId*/, | ||
729 | __inout BOOL* /*pfCancel*/ | ||
730 | ) | ||
731 | { | ||
732 | return S_OK; | ||
733 | } | ||
734 | |||
735 | virtual STDMETHODIMP OnCacheContainerOrPayloadVerifyProgress( | ||
736 | __in_z_opt LPCWSTR /*wzPackageOrContainerId*/, | ||
737 | __in_z_opt LPCWSTR /*wzPayloadId*/, | ||
738 | __in DWORD64 /*dw64Progress*/, | ||
739 | __in DWORD64 /*dw64Total*/, | ||
740 | __in DWORD /*dwOverallPercentage*/, | ||
741 | __inout BOOL* /*pfCancel*/ | ||
742 | ) | ||
743 | { | ||
744 | return S_OK; | ||
745 | } | ||
746 | |||
747 | virtual STDMETHODIMP OnCacheContainerOrPayloadVerifyComplete( | ||
748 | __in_z_opt LPCWSTR /*wzPackageOrContainerId*/, | ||
749 | __in_z_opt LPCWSTR /*wzPayloadId*/, | ||
750 | __in HRESULT /*hrStatus*/ | ||
751 | ) | ||
752 | { | ||
753 | return S_OK; | ||
754 | } | ||
755 | |||
756 | virtual STDMETHODIMP OnCachePayloadExtractBegin( | ||
757 | __in_z_opt LPCWSTR /*wzPackageOrContainerId*/, | ||
758 | __in_z_opt LPCWSTR /*wzPayloadId*/, | ||
759 | __inout BOOL* /*pfCancel*/ | ||
760 | ) | ||
761 | { | ||
762 | return S_OK; | ||
763 | } | ||
764 | |||
765 | virtual STDMETHODIMP OnCachePayloadExtractProgress( | ||
766 | __in_z_opt LPCWSTR /*wzPackageOrContainerId*/, | ||
767 | __in_z_opt LPCWSTR /*wzPayloadId*/, | ||
768 | __in DWORD64 /*dw64Progress*/, | ||
769 | __in DWORD64 /*dw64Total*/, | ||
770 | __in DWORD /*dwOverallPercentage*/, | ||
771 | __inout BOOL* /*pfCancel*/ | ||
772 | ) | ||
773 | { | ||
774 | return S_OK; | ||
775 | } | ||
776 | |||
777 | virtual STDMETHODIMP OnCachePayloadExtractComplete( | ||
778 | __in_z_opt LPCWSTR /*wzPackageOrContainerId*/, | ||
779 | __in_z_opt LPCWSTR /*wzPayloadId*/, | ||
780 | __in HRESULT /*hrStatus*/ | ||
781 | ) | ||
782 | { | ||
783 | return S_OK; | ||
784 | } | ||
785 | |||
786 | public: // IBAFunctions | ||
787 | virtual STDMETHODIMP OnPlan( | ||
788 | ) | ||
789 | { | ||
790 | return S_OK; | ||
791 | } | ||
792 | |||
793 | virtual STDMETHODIMP OnThemeLoaded( | ||
794 | THEME* pTheme, | ||
795 | WIX_LOCALIZATION* pWixLoc | ||
796 | ) | ||
797 | { | ||
798 | HRESULT hr = S_OK; | ||
799 | |||
800 | m_pTheme = pTheme; | ||
801 | m_pWixLoc = pWixLoc; | ||
802 | |||
803 | return hr; | ||
804 | } | ||
805 | |||
806 | virtual STDMETHODIMP WndProc( | ||
807 | __in THEME* pTheme, | ||
808 | __in HWND hWnd, | ||
809 | __in UINT uMsg, | ||
810 | __in WPARAM wParam, | ||
811 | __in LPARAM lParam, | ||
812 | __inout LRESULT* plRes | ||
813 | ) | ||
814 | { | ||
815 | HRESULT hr = S_OK; | ||
816 | |||
817 | *plRes = ThemeDefWindowProc(pTheme, hWnd, uMsg, wParam, lParam); | ||
818 | |||
819 | return hr; | ||
820 | } | ||
821 | |||
822 | virtual STDMETHODIMP BAFunctionsProc( | ||
823 | __in BA_FUNCTIONS_MESSAGE /*message*/, | ||
824 | __in const LPVOID /*pvArgs*/, | ||
825 | __inout LPVOID /*pvResults*/, | ||
826 | __in_opt LPVOID /*pvContext*/ | ||
827 | ) | ||
828 | { | ||
829 | return E_NOTIMPL; | ||
830 | } | ||
831 | |||
832 | protected: | ||
833 | CBalBaseBAFunctions( | ||
834 | __in HMODULE hModule, | ||
835 | __in IBootstrapperEngine* pEngine, | ||
836 | __in const BA_FUNCTIONS_CREATE_ARGS* pArgs | ||
837 | ) | ||
838 | { | ||
839 | m_cReferences = 1; | ||
840 | m_hModule = hModule; | ||
841 | pEngine->AddRef(); | ||
842 | m_pEngine = pEngine; | ||
843 | |||
844 | memcpy_s(&m_command, sizeof(m_command), pArgs->pBootstrapperCreateArgs->pCommand, sizeof(BOOTSTRAPPER_COMMAND)); | ||
845 | memcpy_s(&m_baCreateArgs, sizeof(m_baCreateArgs), pArgs->pBootstrapperCreateArgs, sizeof(BOOTSTRAPPER_CREATE_ARGS)); | ||
846 | memcpy_s(&m_bafCreateArgs, sizeof(m_bafCreateArgs), pArgs, sizeof(BA_FUNCTIONS_CREATE_ARGS)); | ||
847 | m_baCreateArgs.pCommand = &m_command; | ||
848 | m_bafCreateArgs.pBootstrapperCreateArgs = &m_baCreateArgs; | ||
849 | } | ||
850 | |||
851 | virtual ~CBalBaseBAFunctions() | ||
852 | { | ||
853 | ReleaseNullObject(m_pEngine); | ||
854 | } | ||
855 | |||
856 | private: | ||
857 | long m_cReferences; | ||
858 | |||
859 | protected: | ||
860 | IBootstrapperEngine* m_pEngine; | ||
861 | HMODULE m_hModule; | ||
862 | BA_FUNCTIONS_CREATE_ARGS m_bafCreateArgs; | ||
863 | BOOTSTRAPPER_CREATE_ARGS m_baCreateArgs; | ||
864 | BOOTSTRAPPER_COMMAND m_command; | ||
865 | THEME* m_pTheme; | ||
866 | WIX_LOCALIZATION* m_pWixLoc; | ||
867 | }; | ||
diff --git a/src/api/burn/balutil/inc/BalBaseBAFunctionsProc.h b/src/api/burn/balutil/inc/BalBaseBAFunctionsProc.h new file mode 100644 index 00000000..7e89fe83 --- /dev/null +++ b/src/api/burn/balutil/inc/BalBaseBAFunctionsProc.h | |||
@@ -0,0 +1,124 @@ | |||
1 | #pragma once | ||
2 | // Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. | ||
3 | |||
4 | |||
5 | #include "BalBaseBootstrapperApplicationProc.h" | ||
6 | #include "BAFunctions.h" | ||
7 | #include "IBAFunctions.h" | ||
8 | |||
9 | static HRESULT BalBaseBAFunctionsProcOnThemeLoaded( | ||
10 | __in IBAFunctions* pBAFunctions, | ||
11 | __in BA_FUNCTIONS_ONTHEMELOADED_ARGS* pArgs, | ||
12 | __inout BA_FUNCTIONS_ONTHEMELOADED_RESULTS* /*pResults*/ | ||
13 | ) | ||
14 | { | ||
15 | return pBAFunctions->OnThemeLoaded(pArgs->pTheme, pArgs->pWixLoc); | ||
16 | } | ||
17 | |||
18 | static HRESULT BalBaseBAFunctionsProcWndProc( | ||
19 | __in IBAFunctions* pBAFunctions, | ||
20 | __in BA_FUNCTIONS_WNDPROC_ARGS* pArgs, | ||
21 | __inout BA_FUNCTIONS_WNDPROC_RESULTS* pResults | ||
22 | ) | ||
23 | { | ||
24 | return pBAFunctions->WndProc(pArgs->pTheme, pArgs->hWnd, pArgs->uMsg, pArgs->wParam, pArgs->lParam, &pResults->lres); | ||
25 | } | ||
26 | |||
27 | /******************************************************************* | ||
28 | BalBaseBAFunctionsProc - requires pvContext to be of type IBAFunctions. | ||
29 | Provides a default mapping between the message based BAFunctions interface and | ||
30 | the COM-based BAFunctions interface. | ||
31 | |||
32 | *******************************************************************/ | ||
33 | static HRESULT WINAPI BalBaseBAFunctionsProc( | ||
34 | __in BA_FUNCTIONS_MESSAGE message, | ||
35 | __in const LPVOID pvArgs, | ||
36 | __inout LPVOID pvResults, | ||
37 | __in_opt LPVOID pvContext | ||
38 | ) | ||
39 | { | ||
40 | IBAFunctions* pBAFunctions = reinterpret_cast<IBAFunctions*>(pvContext); | ||
41 | HRESULT hr = pBAFunctions->BAFunctionsProc(message, pvArgs, pvResults, pvContext); | ||
42 | |||
43 | if (E_NOTIMPL == hr) | ||
44 | { | ||
45 | switch (message) | ||
46 | { | ||
47 | case BA_FUNCTIONS_MESSAGE_ONDETECTBEGIN: | ||
48 | case BA_FUNCTIONS_MESSAGE_ONDETECTCOMPLETE: | ||
49 | case BA_FUNCTIONS_MESSAGE_ONPLANBEGIN: | ||
50 | case BA_FUNCTIONS_MESSAGE_ONPLANCOMPLETE: | ||
51 | case BA_FUNCTIONS_MESSAGE_ONSTARTUP: | ||
52 | case BA_FUNCTIONS_MESSAGE_ONSHUTDOWN: | ||
53 | case BA_FUNCTIONS_MESSAGE_ONSYSTEMSHUTDOWN: | ||
54 | case BA_FUNCTIONS_MESSAGE_ONDETECTFORWARDCOMPATIBLEBUNDLE: | ||
55 | case BA_FUNCTIONS_MESSAGE_ONDETECTUPDATEBEGIN: | ||
56 | case BA_FUNCTIONS_MESSAGE_ONDETECTUPDATE: | ||
57 | case BA_FUNCTIONS_MESSAGE_ONDETECTUPDATECOMPLETE: | ||
58 | case BA_FUNCTIONS_MESSAGE_ONDETECTRELATEDBUNDLE: | ||
59 | case BA_FUNCTIONS_MESSAGE_ONDETECTPACKAGEBEGIN: | ||
60 | case BA_FUNCTIONS_MESSAGE_ONDETECTRELATEDMSIPACKAGE: | ||
61 | case BA_FUNCTIONS_MESSAGE_ONDETECTPATCHTARGET: | ||
62 | case BA_FUNCTIONS_MESSAGE_ONDETECTMSIFEATURE: | ||
63 | case BA_FUNCTIONS_MESSAGE_ONDETECTPACKAGECOMPLETE: | ||
64 | case BA_FUNCTIONS_MESSAGE_ONPLANRELATEDBUNDLE: | ||
65 | case BA_FUNCTIONS_MESSAGE_ONPLANPACKAGEBEGIN: | ||
66 | case BA_FUNCTIONS_MESSAGE_ONPLANPATCHTARGET: | ||
67 | case BA_FUNCTIONS_MESSAGE_ONPLANMSIFEATURE: | ||
68 | case BA_FUNCTIONS_MESSAGE_ONPLANPACKAGECOMPLETE: | ||
69 | case BA_FUNCTIONS_MESSAGE_ONAPPLYBEGIN: | ||
70 | case BA_FUNCTIONS_MESSAGE_ONELEVATEBEGIN: | ||
71 | case BA_FUNCTIONS_MESSAGE_ONELEVATECOMPLETE: | ||
72 | case BA_FUNCTIONS_MESSAGE_ONPROGRESS: | ||
73 | case BA_FUNCTIONS_MESSAGE_ONERROR: | ||
74 | case BA_FUNCTIONS_MESSAGE_ONREGISTERBEGIN: | ||
75 | case BA_FUNCTIONS_MESSAGE_ONREGISTERCOMPLETE: | ||
76 | case BA_FUNCTIONS_MESSAGE_ONCACHEBEGIN: | ||
77 | case BA_FUNCTIONS_MESSAGE_ONCACHEPACKAGEBEGIN: | ||
78 | case BA_FUNCTIONS_MESSAGE_ONCACHEACQUIREBEGIN: | ||
79 | case BA_FUNCTIONS_MESSAGE_ONCACHEACQUIREPROGRESS: | ||
80 | case BA_FUNCTIONS_MESSAGE_ONCACHEACQUIRERESOLVING: | ||
81 | case BA_FUNCTIONS_MESSAGE_ONCACHEACQUIRECOMPLETE: | ||
82 | case BA_FUNCTIONS_MESSAGE_ONCACHEVERIFYBEGIN: | ||
83 | case BA_FUNCTIONS_MESSAGE_ONCACHEVERIFYCOMPLETE: | ||
84 | case BA_FUNCTIONS_MESSAGE_ONCACHEPACKAGECOMPLETE: | ||
85 | case BA_FUNCTIONS_MESSAGE_ONCACHECOMPLETE: | ||
86 | case BA_FUNCTIONS_MESSAGE_ONEXECUTEBEGIN: | ||
87 | case BA_FUNCTIONS_MESSAGE_ONEXECUTEPACKAGEBEGIN: | ||
88 | case BA_FUNCTIONS_MESSAGE_ONEXECUTEPATCHTARGET: | ||
89 | case BA_FUNCTIONS_MESSAGE_ONEXECUTEPROGRESS: | ||
90 | case BA_FUNCTIONS_MESSAGE_ONEXECUTEMSIMESSAGE: | ||
91 | case BA_FUNCTIONS_MESSAGE_ONEXECUTEFILESINUSE: | ||
92 | case BA_FUNCTIONS_MESSAGE_ONEXECUTEPACKAGECOMPLETE: | ||
93 | case BA_FUNCTIONS_MESSAGE_ONEXECUTECOMPLETE: | ||
94 | case BA_FUNCTIONS_MESSAGE_ONUNREGISTERBEGIN: | ||
95 | case BA_FUNCTIONS_MESSAGE_ONUNREGISTERCOMPLETE: | ||
96 | case BA_FUNCTIONS_MESSAGE_ONAPPLYCOMPLETE: | ||
97 | case BA_FUNCTIONS_MESSAGE_ONLAUNCHAPPROVEDEXEBEGIN: | ||
98 | case BA_FUNCTIONS_MESSAGE_ONLAUNCHAPPROVEDEXECOMPLETE: | ||
99 | case BA_FUNCTIONS_MESSAGE_ONPLANMSIPACKAGE: | ||
100 | case BA_FUNCTIONS_MESSAGE_ONBEGINMSITRANSACTIONBEGIN: | ||
101 | case BA_FUNCTIONS_MESSAGE_ONBEGINMSITRANSACTIONCOMPLETE: | ||
102 | case BA_FUNCTIONS_MESSAGE_ONCOMMITMSITRANSACTIONBEGIN: | ||
103 | case BA_FUNCTIONS_MESSAGE_ONCOMMITMSITRANSACTIONCOMPLETE: | ||
104 | case BA_FUNCTIONS_MESSAGE_ONROLLBACKMSITRANSACTIONBEGIN: | ||
105 | case BA_FUNCTIONS_MESSAGE_ONROLLBACKMSITRANSACTIONCOMPLETE: | ||
106 | case BA_FUNCTIONS_MESSAGE_ONPAUSEAUTOMATICUPDATESBEGIN: | ||
107 | case BA_FUNCTIONS_MESSAGE_ONPAUSEAUTOMATICUPDATESCOMPLETE: | ||
108 | case BA_FUNCTIONS_MESSAGE_ONSYSTEMRESTOREPOINTBEGIN: | ||
109 | case BA_FUNCTIONS_MESSAGE_ONSYSTEMRESTOREPOINTCOMPLETE: | ||
110 | case BA_FUNCTIONS_MESSAGE_ONPLANNEDPACKAGE: | ||
111 | case BA_FUNCTIONS_MESSAGE_ONPLANFORWARDCOMPATIBLEBUNDLE: | ||
112 | hr = BalBaseBootstrapperApplicationProc((BOOTSTRAPPER_APPLICATION_MESSAGE)message, pvArgs, pvResults, pvContext); | ||
113 | break; | ||
114 | case BA_FUNCTIONS_MESSAGE_ONTHEMELOADED: | ||
115 | hr = BalBaseBAFunctionsProcOnThemeLoaded(pBAFunctions, reinterpret_cast<BA_FUNCTIONS_ONTHEMELOADED_ARGS*>(pvArgs), reinterpret_cast<BA_FUNCTIONS_ONTHEMELOADED_RESULTS*>(pvResults)); | ||
116 | break; | ||
117 | case BA_FUNCTIONS_MESSAGE_WNDPROC: | ||
118 | hr = BalBaseBAFunctionsProcWndProc(pBAFunctions, reinterpret_cast<BA_FUNCTIONS_WNDPROC_ARGS*>(pvArgs), reinterpret_cast<BA_FUNCTIONS_WNDPROC_RESULTS*>(pvResults)); | ||
119 | break; | ||
120 | } | ||
121 | } | ||
122 | |||
123 | return hr; | ||
124 | } | ||
diff --git a/src/api/burn/balutil/inc/BalBaseBootstrapperApplication.h b/src/api/burn/balutil/inc/BalBaseBootstrapperApplication.h new file mode 100644 index 00000000..bf21c4a5 --- /dev/null +++ b/src/api/burn/balutil/inc/BalBaseBootstrapperApplication.h | |||
@@ -0,0 +1,1076 @@ | |||
1 | // Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. | ||
2 | |||
3 | #include <windows.h> | ||
4 | #include <msiquery.h> | ||
5 | |||
6 | #include "BootstrapperEngine.h" | ||
7 | #include "BootstrapperApplication.h" | ||
8 | #include "IBootstrapperEngine.h" | ||
9 | #include "IBootstrapperApplication.h" | ||
10 | |||
11 | #include "balutil.h" | ||
12 | #include "balretry.h" | ||
13 | |||
14 | class CBalBaseBootstrapperApplication : public IBootstrapperApplication | ||
15 | { | ||
16 | public: // IUnknown | ||
17 | virtual STDMETHODIMP QueryInterface( | ||
18 | __in REFIID riid, | ||
19 | __out LPVOID *ppvObject | ||
20 | ) | ||
21 | { | ||
22 | if (!ppvObject) | ||
23 | { | ||
24 | return E_INVALIDARG; | ||
25 | } | ||
26 | |||
27 | *ppvObject = NULL; | ||
28 | |||
29 | if (::IsEqualIID(__uuidof(IBootstrapperApplication), riid)) | ||
30 | { | ||
31 | *ppvObject = static_cast<IBootstrapperApplication*>(this); | ||
32 | } | ||
33 | else if (::IsEqualIID(IID_IUnknown, riid)) | ||
34 | { | ||
35 | *ppvObject = static_cast<IUnknown*>(this); | ||
36 | } | ||
37 | else // no interface for requested iid | ||
38 | { | ||
39 | return E_NOINTERFACE; | ||
40 | } | ||
41 | |||
42 | AddRef(); | ||
43 | return S_OK; | ||
44 | } | ||
45 | |||
46 | virtual STDMETHODIMP_(ULONG) AddRef() | ||
47 | { | ||
48 | return ::InterlockedIncrement(&this->m_cReferences); | ||
49 | } | ||
50 | |||
51 | virtual STDMETHODIMP_(ULONG) Release() | ||
52 | { | ||
53 | long l = ::InterlockedDecrement(&this->m_cReferences); | ||
54 | if (0 < l) | ||
55 | { | ||
56 | return l; | ||
57 | } | ||
58 | |||
59 | delete this; | ||
60 | return 0; | ||
61 | } | ||
62 | |||
63 | public: // IBootstrapperApplication | ||
64 | virtual STDMETHODIMP_(HRESULT) BAProc( | ||
65 | __in BOOTSTRAPPER_APPLICATION_MESSAGE /*message*/, | ||
66 | __in const LPVOID /*pvArgs*/, | ||
67 | __inout LPVOID /*pvResults*/, | ||
68 | __in_opt LPVOID /*pvContext*/ | ||
69 | ) | ||
70 | { | ||
71 | return E_NOTIMPL; | ||
72 | } | ||
73 | |||
74 | virtual STDMETHODIMP_(void) BAProcFallback( | ||
75 | __in BOOTSTRAPPER_APPLICATION_MESSAGE /*message*/, | ||
76 | __in const LPVOID /*pvArgs*/, | ||
77 | __inout LPVOID /*pvResults*/, | ||
78 | __inout HRESULT* /*phr*/, | ||
79 | __in_opt LPVOID /*pvContext*/ | ||
80 | ) | ||
81 | { | ||
82 | } | ||
83 | |||
84 | virtual STDMETHODIMP OnStartup() | ||
85 | { | ||
86 | return S_OK; | ||
87 | } | ||
88 | |||
89 | virtual STDMETHODIMP OnShutdown( | ||
90 | __inout BOOTSTRAPPER_SHUTDOWN_ACTION* /*pAction*/ | ||
91 | ) | ||
92 | { | ||
93 | return S_OK; | ||
94 | } | ||
95 | |||
96 | virtual STDMETHODIMP OnSystemShutdown( | ||
97 | __in DWORD dwEndSession, | ||
98 | __inout BOOL* pfCancel | ||
99 | ) | ||
100 | { | ||
101 | HRESULT hr = S_OK; | ||
102 | |||
103 | // Allow requests to shut down when critical or not applying. | ||
104 | *pfCancel = !(ENDSESSION_CRITICAL & dwEndSession || !m_fApplying); | ||
105 | |||
106 | return hr; | ||
107 | } | ||
108 | |||
109 | virtual STDMETHODIMP OnDetectBegin( | ||
110 | __in BOOL /*fCached*/, | ||
111 | __in BOOL /*fInstalled*/, | ||
112 | __in DWORD /*cPackages*/, | ||
113 | __inout BOOL* pfCancel | ||
114 | ) | ||
115 | { | ||
116 | *pfCancel |= CheckCanceled(); | ||
117 | return S_OK; | ||
118 | } | ||
119 | |||
120 | virtual STDMETHODIMP OnDetectForwardCompatibleBundle( | ||
121 | __in_z LPCWSTR /*wzBundleId*/, | ||
122 | __in BOOTSTRAPPER_RELATION_TYPE /*relationType*/, | ||
123 | __in_z LPCWSTR /*wzBundleTag*/, | ||
124 | __in BOOL /*fPerMachine*/, | ||
125 | __in LPCWSTR /*wzVersion*/, | ||
126 | __in BOOL /*fMissingFromCache*/, | ||
127 | __inout BOOL* pfCancel | ||
128 | ) | ||
129 | { | ||
130 | *pfCancel |= CheckCanceled(); | ||
131 | return S_OK; | ||
132 | } | ||
133 | |||
134 | virtual STDMETHODIMP OnDetectUpdateBegin( | ||
135 | __in_z LPCWSTR /*wzUpdateLocation*/, | ||
136 | __inout BOOL* pfCancel, | ||
137 | __inout BOOL* /*pfSkip*/ | ||
138 | ) | ||
139 | { | ||
140 | *pfCancel |= CheckCanceled(); | ||
141 | return S_OK; | ||
142 | } | ||
143 | |||
144 | virtual STDMETHODIMP OnDetectUpdate( | ||
145 | __in_z LPCWSTR /*wzUpdateLocation*/, | ||
146 | __in DWORD64 /*dw64Size*/, | ||
147 | __in LPCWSTR /*wzVersion*/, | ||
148 | __in_z LPCWSTR /*wzTitle*/, | ||
149 | __in_z LPCWSTR /*wzSummary*/, | ||
150 | __in_z LPCWSTR /*wzContentType*/, | ||
151 | __in_z LPCWSTR /*wzContent*/, | ||
152 | __inout BOOL* pfCancel, | ||
153 | __inout BOOL* /*pfStopProcessingUpdates*/ | ||
154 | ) | ||
155 | { | ||
156 | *pfCancel |= CheckCanceled(); | ||
157 | return S_OK; | ||
158 | } | ||
159 | |||
160 | virtual STDMETHODIMP OnDetectUpdateComplete( | ||
161 | __in HRESULT /*hrStatus*/, | ||
162 | __inout BOOL* /*pfIgnoreError*/ | ||
163 | ) | ||
164 | { | ||
165 | return S_OK; | ||
166 | } | ||
167 | |||
168 | virtual STDMETHODIMP OnDetectRelatedBundle( | ||
169 | __in_z LPCWSTR /*wzBundleId*/, | ||
170 | __in BOOTSTRAPPER_RELATION_TYPE /*relationType*/, | ||
171 | __in_z LPCWSTR /*wzBundleTag*/, | ||
172 | __in BOOL /*fPerMachine*/, | ||
173 | __in LPCWSTR /*wzVersion*/, | ||
174 | __in BOOTSTRAPPER_RELATED_OPERATION /*operation*/, | ||
175 | __in BOOL /*fMissingFromCache*/, | ||
176 | __inout BOOL* pfCancel | ||
177 | ) | ||
178 | { | ||
179 | *pfCancel |= CheckCanceled(); | ||
180 | return S_OK; | ||
181 | } | ||
182 | |||
183 | virtual STDMETHODIMP OnDetectPackageBegin( | ||
184 | __in_z LPCWSTR /*wzPackageId*/, | ||
185 | __inout BOOL* pfCancel | ||
186 | ) | ||
187 | { | ||
188 | *pfCancel |= CheckCanceled(); | ||
189 | return S_OK; | ||
190 | } | ||
191 | |||
192 | virtual STDMETHODIMP OnDetectRelatedMsiPackage( | ||
193 | __in_z LPCWSTR /*wzPackageId*/, | ||
194 | __in_z LPCWSTR /*wzUpgradeCode*/, | ||
195 | __in_z LPCWSTR /*wzProductCode*/, | ||
196 | __in BOOL /*fPerMachine*/, | ||
197 | __in LPCWSTR /*wzVersion*/, | ||
198 | __in BOOTSTRAPPER_RELATED_OPERATION /*operation*/, | ||
199 | __inout BOOL* pfCancel | ||
200 | ) | ||
201 | { | ||
202 | *pfCancel |= CheckCanceled(); | ||
203 | return S_OK; | ||
204 | } | ||
205 | |||
206 | virtual STDMETHODIMP OnDetectPatchTarget( | ||
207 | __in_z LPCWSTR /*wzPackageId*/, | ||
208 | __in_z LPCWSTR /*wzProductCode*/, | ||
209 | __in BOOTSTRAPPER_PACKAGE_STATE /*patchState*/, | ||
210 | __inout BOOL* pfCancel | ||
211 | ) | ||
212 | { | ||
213 | *pfCancel |= CheckCanceled(); | ||
214 | return S_OK; | ||
215 | } | ||
216 | |||
217 | virtual STDMETHODIMP OnDetectMsiFeature( | ||
218 | __in_z LPCWSTR /*wzPackageId*/, | ||
219 | __in_z LPCWSTR /*wzFeatureId*/, | ||
220 | __in BOOTSTRAPPER_FEATURE_STATE /*state*/, | ||
221 | __inout BOOL* pfCancel | ||
222 | ) | ||
223 | { | ||
224 | *pfCancel |= CheckCanceled(); | ||
225 | return S_OK; | ||
226 | } | ||
227 | |||
228 | virtual STDMETHODIMP OnDetectPackageComplete( | ||
229 | __in_z LPCWSTR /*wzPackageId*/, | ||
230 | __in HRESULT /*hrStatus*/, | ||
231 | __in BOOTSTRAPPER_PACKAGE_STATE /*state*/, | ||
232 | __in BOOL /*fCached*/ | ||
233 | ) | ||
234 | { | ||
235 | return S_OK; | ||
236 | } | ||
237 | |||
238 | virtual STDMETHODIMP OnDetectComplete( | ||
239 | __in HRESULT /*hrStatus*/, | ||
240 | __in BOOL /*fEligibleForCleanup*/ | ||
241 | ) | ||
242 | { | ||
243 | return S_OK; | ||
244 | } | ||
245 | |||
246 | virtual STDMETHODIMP OnPlanBegin( | ||
247 | __in DWORD /*cPackages*/, | ||
248 | __inout BOOL* pfCancel | ||
249 | ) | ||
250 | { | ||
251 | *pfCancel |= CheckCanceled(); | ||
252 | return S_OK; | ||
253 | } | ||
254 | |||
255 | virtual STDMETHODIMP OnPlanRelatedBundle( | ||
256 | __in_z LPCWSTR /*wzBundleId*/, | ||
257 | __in BOOTSTRAPPER_REQUEST_STATE /*recommendedState*/, | ||
258 | __inout BOOTSTRAPPER_REQUEST_STATE* /*pRequestedState*/, | ||
259 | __inout BOOL* pfCancel | ||
260 | ) | ||
261 | { | ||
262 | *pfCancel |= CheckCanceled(); | ||
263 | return S_OK; | ||
264 | } | ||
265 | |||
266 | virtual STDMETHODIMP OnPlanPackageBegin( | ||
267 | __in_z LPCWSTR /*wzPackageId*/, | ||
268 | __in BOOTSTRAPPER_PACKAGE_STATE /*state*/, | ||
269 | __in BOOL /*fCached*/, | ||
270 | __in BOOTSTRAPPER_PACKAGE_CONDITION_RESULT /*installCondition*/, | ||
271 | __in BOOTSTRAPPER_REQUEST_STATE /*recommendedState*/, | ||
272 | __in BOOTSTRAPPER_CACHE_TYPE /*recommendedCacheType*/, | ||
273 | __inout BOOTSTRAPPER_REQUEST_STATE* /*pRequestState*/, | ||
274 | __inout BOOTSTRAPPER_CACHE_TYPE* /*pRequestedCacheType*/, | ||
275 | __inout BOOL* pfCancel | ||
276 | ) | ||
277 | { | ||
278 | *pfCancel |= CheckCanceled(); | ||
279 | return S_OK; | ||
280 | } | ||
281 | |||
282 | virtual STDMETHODIMP OnPlanPatchTarget( | ||
283 | __in_z LPCWSTR /*wzPackageId*/, | ||
284 | __in_z LPCWSTR /*wzProductCode*/, | ||
285 | __in BOOTSTRAPPER_REQUEST_STATE /*recommendedState*/, | ||
286 | __inout BOOTSTRAPPER_REQUEST_STATE* /*pRequestedState*/, | ||
287 | __inout BOOL* pfCancel | ||
288 | ) | ||
289 | { | ||
290 | *pfCancel |= CheckCanceled(); | ||
291 | return S_OK; | ||
292 | } | ||
293 | |||
294 | virtual STDMETHODIMP OnPlanMsiFeature( | ||
295 | __in_z LPCWSTR /*wzPackageId*/, | ||
296 | __in_z LPCWSTR /*wzFeatureId*/, | ||
297 | __in BOOTSTRAPPER_FEATURE_STATE /*recommendedState*/, | ||
298 | __inout BOOTSTRAPPER_FEATURE_STATE* /*pRequestedState*/, | ||
299 | __inout BOOL* pfCancel | ||
300 | ) | ||
301 | { | ||
302 | *pfCancel |= CheckCanceled(); | ||
303 | return S_OK; | ||
304 | } | ||
305 | |||
306 | virtual STDMETHODIMP OnPlanMsiPackage( | ||
307 | __in_z LPCWSTR /*wzPackageId*/, | ||
308 | __in BOOL /*fExecute*/, | ||
309 | __in BOOTSTRAPPER_ACTION_STATE /*action*/, | ||
310 | __inout BOOL* pfCancel, | ||
311 | __inout BURN_MSI_PROPERTY* /*pActionMsiProperty*/, | ||
312 | __inout INSTALLUILEVEL* /*pUiLevel*/, | ||
313 | __inout BOOL* /*pfDisableExternalUiHandler*/ | ||
314 | ) | ||
315 | { | ||
316 | *pfCancel |= CheckCanceled(); | ||
317 | return S_OK; | ||
318 | } | ||
319 | |||
320 | virtual STDMETHODIMP OnPlanPackageComplete( | ||
321 | __in_z LPCWSTR /*wzPackageId*/, | ||
322 | __in HRESULT /*hrStatus*/, | ||
323 | __in BOOTSTRAPPER_REQUEST_STATE /*requested*/ | ||
324 | ) | ||
325 | { | ||
326 | return S_OK; | ||
327 | } | ||
328 | |||
329 | virtual STDMETHODIMP OnPlannedPackage( | ||
330 | __in_z LPCWSTR /*wzPackageId*/, | ||
331 | __in BOOTSTRAPPER_ACTION_STATE /*execute*/, | ||
332 | __in BOOTSTRAPPER_ACTION_STATE /*rollback*/, | ||
333 | __in BOOL /*fPlannedCache*/, | ||
334 | __in BOOL /*fPlannedUncache*/ | ||
335 | ) | ||
336 | { | ||
337 | return S_OK; | ||
338 | } | ||
339 | |||
340 | virtual STDMETHODIMP OnPlanComplete( | ||
341 | __in HRESULT /*hrStatus*/ | ||
342 | ) | ||
343 | { | ||
344 | return S_OK; | ||
345 | } | ||
346 | |||
347 | virtual STDMETHODIMP OnApplyBegin( | ||
348 | __in DWORD /*dwPhaseCount*/, | ||
349 | __inout BOOL* pfCancel | ||
350 | ) | ||
351 | { | ||
352 | m_fApplying = TRUE; | ||
353 | |||
354 | m_dwProgressPercentage = 0; | ||
355 | m_dwOverallProgressPercentage = 0; | ||
356 | |||
357 | *pfCancel |= CheckCanceled(); | ||
358 | return S_OK; | ||
359 | } | ||
360 | |||
361 | virtual STDMETHODIMP OnElevateBegin( | ||
362 | __inout BOOL* pfCancel | ||
363 | ) | ||
364 | { | ||
365 | *pfCancel |= CheckCanceled(); | ||
366 | return S_OK; | ||
367 | } | ||
368 | |||
369 | virtual STDMETHODIMP OnElevateComplete( | ||
370 | __in HRESULT /*hrStatus*/ | ||
371 | ) | ||
372 | { | ||
373 | return S_OK; | ||
374 | } | ||
375 | |||
376 | virtual STDMETHODIMP OnProgress( | ||
377 | __in DWORD dwProgressPercentage, | ||
378 | __in DWORD dwOverallProgressPercentage, | ||
379 | __inout BOOL* pfCancel | ||
380 | ) | ||
381 | { | ||
382 | HRESULT hr = S_OK; | ||
383 | int nResult = IDNOACTION; | ||
384 | |||
385 | m_dwProgressPercentage = dwProgressPercentage; | ||
386 | m_dwOverallProgressPercentage = dwOverallProgressPercentage; | ||
387 | |||
388 | if (BOOTSTRAPPER_DISPLAY_EMBEDDED == m_display) | ||
389 | { | ||
390 | hr = m_pEngine->SendEmbeddedProgress(m_dwProgressPercentage, m_dwOverallProgressPercentage, &nResult); | ||
391 | BalExitOnFailure(hr, "Failed to send embedded overall progress."); | ||
392 | |||
393 | if (IDERROR == nResult) | ||
394 | { | ||
395 | hr = E_FAIL; | ||
396 | } | ||
397 | else if (IDCANCEL == nResult) | ||
398 | { | ||
399 | *pfCancel = TRUE; | ||
400 | } | ||
401 | } | ||
402 | |||
403 | LExit: | ||
404 | *pfCancel |= CheckCanceled(); | ||
405 | return hr; | ||
406 | } | ||
407 | |||
408 | virtual STDMETHODIMP OnError( | ||
409 | __in BOOTSTRAPPER_ERROR_TYPE errorType, | ||
410 | __in_z LPCWSTR wzPackageId, | ||
411 | __in DWORD dwCode, | ||
412 | __in_z LPCWSTR /*wzError*/, | ||
413 | __in DWORD /*dwUIHint*/, | ||
414 | __in DWORD /*cData*/, | ||
415 | __in_ecount_z_opt(cData) LPCWSTR* /*rgwzData*/, | ||
416 | __in int /*nRecommendation*/, | ||
417 | __inout int* pResult | ||
418 | ) | ||
419 | { | ||
420 | BalRetryErrorOccurred(wzPackageId, dwCode); | ||
421 | |||
422 | if (CheckCanceled()) | ||
423 | { | ||
424 | *pResult = IDCANCEL; | ||
425 | } | ||
426 | else if (BOOTSTRAPPER_DISPLAY_FULL == m_display) | ||
427 | { | ||
428 | if (BOOTSTRAPPER_ERROR_TYPE_HTTP_AUTH_SERVER == errorType || BOOTSTRAPPER_ERROR_TYPE_HTTP_AUTH_PROXY == errorType) | ||
429 | { | ||
430 | *pResult = IDTRYAGAIN; | ||
431 | } | ||
432 | } | ||
433 | |||
434 | return S_OK; | ||
435 | } | ||
436 | |||
437 | virtual STDMETHODIMP OnRegisterBegin( | ||
438 | __inout BOOL* pfCancel | ||
439 | ) | ||
440 | { | ||
441 | *pfCancel |= CheckCanceled(); | ||
442 | return S_OK; | ||
443 | } | ||
444 | |||
445 | virtual STDMETHODIMP OnRegisterComplete( | ||
446 | __in HRESULT /*hrStatus*/ | ||
447 | ) | ||
448 | { | ||
449 | return S_OK; | ||
450 | } | ||
451 | |||
452 | virtual STDMETHODIMP OnCacheBegin( | ||
453 | __inout BOOL* pfCancel | ||
454 | ) | ||
455 | { | ||
456 | *pfCancel |= CheckCanceled(); | ||
457 | return S_OK; | ||
458 | } | ||
459 | |||
460 | virtual STDMETHODIMP OnCachePackageBegin( | ||
461 | __in_z LPCWSTR /*wzPackageId*/, | ||
462 | __in DWORD /*cCachePayloads*/, | ||
463 | __in DWORD64 /*dw64PackageCacheSize*/, | ||
464 | __inout BOOL* pfCancel | ||
465 | ) | ||
466 | { | ||
467 | *pfCancel |= CheckCanceled(); | ||
468 | return S_OK; | ||
469 | } | ||
470 | |||
471 | virtual STDMETHODIMP OnCacheAcquireBegin( | ||
472 | __in_z_opt LPCWSTR wzPackageOrContainerId, | ||
473 | __in_z_opt LPCWSTR wzPayloadId, | ||
474 | __in_z LPCWSTR /*wzSource*/, | ||
475 | __in_z_opt LPCWSTR /*wzDownloadUrl*/, | ||
476 | __in_z_opt LPCWSTR /*wzPayloadContainerId*/, | ||
477 | __in BOOTSTRAPPER_CACHE_OPERATION /*recommendation*/, | ||
478 | __inout BOOTSTRAPPER_CACHE_OPERATION* /*pAction*/, | ||
479 | __inout BOOL* pfCancel | ||
480 | ) | ||
481 | { | ||
482 | BalRetryStartContainerOrPayload(wzPackageOrContainerId, wzPayloadId); | ||
483 | *pfCancel |= CheckCanceled(); | ||
484 | return S_OK; | ||
485 | } | ||
486 | |||
487 | virtual STDMETHODIMP OnCacheAcquireProgress( | ||
488 | __in_z LPCWSTR /*wzPackageOrContainerId*/, | ||
489 | __in_z_opt LPCWSTR /*wzPayloadId*/, | ||
490 | __in DWORD64 /*dw64Progress*/, | ||
491 | __in DWORD64 /*dw64Total*/, | ||
492 | __in DWORD /*dwOverallPercentage*/, | ||
493 | __inout BOOL* pfCancel | ||
494 | ) | ||
495 | { | ||
496 | HRESULT hr = S_OK; | ||
497 | int nResult = IDNOACTION; | ||
498 | |||
499 | // Send progress even though we don't update the numbers to at least give the caller an opportunity | ||
500 | // to cancel. | ||
501 | if (BOOTSTRAPPER_DISPLAY_EMBEDDED == m_display) | ||
502 | { | ||
503 | hr = m_pEngine->SendEmbeddedProgress(m_dwProgressPercentage, m_dwOverallProgressPercentage, &nResult); | ||
504 | BalExitOnFailure(hr, "Failed to send embedded cache progress."); | ||
505 | |||
506 | if (IDERROR == nResult) | ||
507 | { | ||
508 | hr = E_FAIL; | ||
509 | } | ||
510 | else if (IDCANCEL == nResult) | ||
511 | { | ||
512 | *pfCancel = TRUE; | ||
513 | } | ||
514 | } | ||
515 | |||
516 | LExit: | ||
517 | *pfCancel |= CheckCanceled(); | ||
518 | return hr; | ||
519 | } | ||
520 | |||
521 | virtual STDMETHODIMP OnCacheAcquireResolving( | ||
522 | __in_z_opt LPCWSTR /*wzPackageOrContainerId*/, | ||
523 | __in_z_opt LPCWSTR /*wzPayloadId*/, | ||
524 | __in_z LPCWSTR* /*rgSearchPaths*/, | ||
525 | __in DWORD /*cSearchPaths*/, | ||
526 | __in BOOL /*fFoundLocal*/, | ||
527 | __in DWORD /*dwRecommendedSearchPath*/, | ||
528 | __in_z_opt LPCWSTR /*wzDownloadUrl*/, | ||
529 | __in_z_opt LPCWSTR /*wzPayloadContainerId*/, | ||
530 | __in BOOTSTRAPPER_CACHE_RESOLVE_OPERATION /*recommendation*/, | ||
531 | __inout DWORD* /*pdwChosenSearchPath*/, | ||
532 | __inout BOOTSTRAPPER_CACHE_RESOLVE_OPERATION* /*pAction*/, | ||
533 | __inout BOOL* pfCancel | ||
534 | ) | ||
535 | { | ||
536 | *pfCancel |= CheckCanceled(); | ||
537 | return S_OK; | ||
538 | } | ||
539 | |||
540 | virtual STDMETHODIMP OnCacheAcquireComplete( | ||
541 | __in_z LPCWSTR wzPackageOrContainerId, | ||
542 | __in_z_opt LPCWSTR wzPayloadId, | ||
543 | __in HRESULT hrStatus, | ||
544 | __in BOOTSTRAPPER_CACHEACQUIRECOMPLETE_ACTION /*recommendation*/, | ||
545 | __inout BOOTSTRAPPER_CACHEACQUIRECOMPLETE_ACTION* pAction | ||
546 | ) | ||
547 | { | ||
548 | HRESULT hr = S_OK; | ||
549 | BOOL fRetry = FALSE; | ||
550 | |||
551 | if (CheckCanceled()) | ||
552 | { | ||
553 | ExitFunction1(hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT)); | ||
554 | } | ||
555 | |||
556 | hr = BalRetryEndContainerOrPayload(wzPackageOrContainerId, wzPayloadId, hrStatus, &fRetry); | ||
557 | ExitOnFailure(hr, "BalRetryEndPackage for cache failed"); | ||
558 | |||
559 | if (fRetry) | ||
560 | { | ||
561 | *pAction = BOOTSTRAPPER_CACHEACQUIRECOMPLETE_ACTION_RETRY; | ||
562 | } | ||
563 | |||
564 | LExit: | ||
565 | return hr; | ||
566 | } | ||
567 | |||
568 | virtual STDMETHODIMP OnCacheVerifyBegin( | ||
569 | __in_z LPCWSTR /*wzPackageOrContainerId*/, | ||
570 | __in_z LPCWSTR /*wzPayloadId*/, | ||
571 | __inout BOOL* pfCancel | ||
572 | ) | ||
573 | { | ||
574 | *pfCancel |= CheckCanceled(); | ||
575 | return S_OK; | ||
576 | } | ||
577 | |||
578 | virtual STDMETHODIMP OnCacheVerifyProgress( | ||
579 | __in_z_opt LPCWSTR /*wzPackageOrContainerId*/, | ||
580 | __in_z_opt LPCWSTR /*wzPayloadId*/, | ||
581 | __in DWORD64 /*dw64Progress*/, | ||
582 | __in DWORD64 /*dw64Total*/, | ||
583 | __in DWORD /*dwOverallPercentage*/, | ||
584 | __in BOOTSTRAPPER_CACHE_VERIFY_STEP /*verifyStep*/, | ||
585 | __inout BOOL* pfCancel | ||
586 | ) | ||
587 | { | ||
588 | *pfCancel |= CheckCanceled(); | ||
589 | return S_OK; | ||
590 | } | ||
591 | |||
592 | virtual STDMETHODIMP OnCacheVerifyComplete( | ||
593 | __in_z LPCWSTR /*wzPackageOrContainerId*/, | ||
594 | __in_z LPCWSTR /*wzPayloadId*/, | ||
595 | __in HRESULT /*hrStatus*/, | ||
596 | __in BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION /*recommendation*/, | ||
597 | __inout BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION* pAction | ||
598 | ) | ||
599 | { | ||
600 | if (CheckCanceled()) | ||
601 | { | ||
602 | *pAction = BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION_NONE; | ||
603 | } | ||
604 | |||
605 | return S_OK; | ||
606 | } | ||
607 | |||
608 | virtual STDMETHODIMP OnCachePackageComplete( | ||
609 | __in_z LPCWSTR /*wzPackageId*/, | ||
610 | __in HRESULT /*hrStatus*/, | ||
611 | __in BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION /*recommendation*/, | ||
612 | __inout BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION* pAction | ||
613 | ) | ||
614 | { | ||
615 | if (CheckCanceled()) | ||
616 | { | ||
617 | *pAction = BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION_NONE; | ||
618 | } | ||
619 | |||
620 | return S_OK; | ||
621 | } | ||
622 | |||
623 | virtual STDMETHODIMP OnCacheComplete( | ||
624 | __in HRESULT /*hrStatus*/ | ||
625 | ) | ||
626 | { | ||
627 | return S_OK; | ||
628 | } | ||
629 | |||
630 | virtual STDMETHODIMP OnExecuteBegin( | ||
631 | __in DWORD /*cExecutingPackages*/, | ||
632 | __inout BOOL* pfCancel | ||
633 | ) | ||
634 | { | ||
635 | *pfCancel |= CheckCanceled(); | ||
636 | return S_OK; | ||
637 | } | ||
638 | |||
639 | virtual STDMETHODIMP OnExecutePackageBegin( | ||
640 | __in_z LPCWSTR wzPackageId, | ||
641 | __in BOOL fExecute, | ||
642 | __in BOOTSTRAPPER_ACTION_STATE /*action*/, | ||
643 | __in INSTALLUILEVEL /*uiLevel*/, | ||
644 | __in BOOL /*fDisableExternalUiHandler*/, | ||
645 | __inout BOOL* pfCancel | ||
646 | ) | ||
647 | { | ||
648 | // Only track retry on execution (not rollback). | ||
649 | if (fExecute) | ||
650 | { | ||
651 | BalRetryStartPackage(wzPackageId); | ||
652 | } | ||
653 | |||
654 | m_fRollingBack = !fExecute; | ||
655 | *pfCancel |= CheckCanceled(); | ||
656 | return S_OK; | ||
657 | } | ||
658 | |||
659 | virtual STDMETHODIMP OnExecutePatchTarget( | ||
660 | __in_z LPCWSTR /*wzPackageId*/, | ||
661 | __in_z LPCWSTR /*wzTargetProductCode*/, | ||
662 | __inout BOOL* pfCancel | ||
663 | ) | ||
664 | { | ||
665 | *pfCancel |= CheckCanceled(); | ||
666 | return S_OK; | ||
667 | } | ||
668 | |||
669 | virtual STDMETHODIMP OnExecuteProgress( | ||
670 | __in_z LPCWSTR /*wzPackageId*/, | ||
671 | __in DWORD /*dwProgressPercentage*/, | ||
672 | __in DWORD /*dwOverallProgressPercentage*/, | ||
673 | __inout BOOL* pfCancel | ||
674 | ) | ||
675 | { | ||
676 | HRESULT hr = S_OK; | ||
677 | int nResult = IDNOACTION; | ||
678 | |||
679 | // Send progress even though we don't update the numbers to at least give the caller an opportunity | ||
680 | // to cancel. | ||
681 | if (BOOTSTRAPPER_DISPLAY_EMBEDDED == m_display) | ||
682 | { | ||
683 | hr = m_pEngine->SendEmbeddedProgress(m_dwProgressPercentage, m_dwOverallProgressPercentage, &nResult); | ||
684 | BalExitOnFailure(hr, "Failed to send embedded execute progress."); | ||
685 | |||
686 | if (IDERROR == nResult) | ||
687 | { | ||
688 | hr = E_FAIL; | ||
689 | } | ||
690 | else if (IDCANCEL == nResult) | ||
691 | { | ||
692 | *pfCancel = TRUE; | ||
693 | } | ||
694 | } | ||
695 | |||
696 | LExit: | ||
697 | *pfCancel |= CheckCanceled(); | ||
698 | return hr; | ||
699 | } | ||
700 | |||
701 | virtual STDMETHODIMP OnExecuteMsiMessage( | ||
702 | __in_z LPCWSTR /*wzPackageId*/, | ||
703 | __in INSTALLMESSAGE /*messageType*/, | ||
704 | __in DWORD /*dwUIHint*/, | ||
705 | __in_z LPCWSTR /*wzMessage*/, | ||
706 | __in DWORD /*cData*/, | ||
707 | __in_ecount_z_opt(cData) LPCWSTR* /*rgwzData*/, | ||
708 | __in int /*nRecommendation*/, | ||
709 | __inout int* pResult | ||
710 | ) | ||
711 | { | ||
712 | if (CheckCanceled()) | ||
713 | { | ||
714 | *pResult = IDCANCEL; | ||
715 | } | ||
716 | |||
717 | return S_OK; | ||
718 | } | ||
719 | |||
720 | virtual STDMETHODIMP OnExecuteFilesInUse( | ||
721 | __in_z LPCWSTR /*wzPackageId*/, | ||
722 | __in DWORD /*cFiles*/, | ||
723 | __in_ecount_z(cFiles) LPCWSTR* /*rgwzFiles*/, | ||
724 | __in int /*nRecommendation*/, | ||
725 | __inout int* pResult | ||
726 | ) | ||
727 | { | ||
728 | if (CheckCanceled()) | ||
729 | { | ||
730 | *pResult = IDCANCEL; | ||
731 | } | ||
732 | |||
733 | return S_OK; | ||
734 | } | ||
735 | |||
736 | virtual STDMETHODIMP OnExecutePackageComplete( | ||
737 | __in_z LPCWSTR wzPackageId, | ||
738 | __in HRESULT hrStatus, | ||
739 | __in BOOTSTRAPPER_APPLY_RESTART /*restart*/, | ||
740 | __in BOOTSTRAPPER_EXECUTEPACKAGECOMPLETE_ACTION /*recommendation*/, | ||
741 | __inout BOOTSTRAPPER_EXECUTEPACKAGECOMPLETE_ACTION* pAction | ||
742 | ) | ||
743 | { | ||
744 | HRESULT hr = S_OK; | ||
745 | BOOL fRetry = FALSE; | ||
746 | |||
747 | if (CheckCanceled()) | ||
748 | { | ||
749 | ExitFunction1(hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT)); | ||
750 | } | ||
751 | |||
752 | hr = BalRetryEndPackage(wzPackageId, hrStatus, &fRetry); | ||
753 | ExitOnFailure(hr, "BalRetryEndPackage for execute failed"); | ||
754 | |||
755 | if (fRetry) | ||
756 | { | ||
757 | *pAction = BOOTSTRAPPER_EXECUTEPACKAGECOMPLETE_ACTION_RETRY; | ||
758 | } | ||
759 | |||
760 | LExit: | ||
761 | return hr; | ||
762 | } | ||
763 | |||
764 | virtual STDMETHODIMP OnExecuteComplete( | ||
765 | __in HRESULT /*hrStatus*/ | ||
766 | ) | ||
767 | { | ||
768 | return S_OK; | ||
769 | } | ||
770 | |||
771 | virtual STDMETHODIMP OnUnregisterBegin( | ||
772 | __in BOOL /*fKeepRegistration*/, | ||
773 | __inout BOOL* /*pfForceKeepRegistration*/ | ||
774 | ) | ||
775 | { | ||
776 | return S_OK; | ||
777 | } | ||
778 | |||
779 | virtual STDMETHODIMP OnUnregisterComplete( | ||
780 | __in HRESULT /*hrStatus*/ | ||
781 | ) | ||
782 | { | ||
783 | return S_OK; | ||
784 | } | ||
785 | |||
786 | virtual STDMETHODIMP OnApplyComplete( | ||
787 | __in HRESULT /*hrStatus*/, | ||
788 | __in BOOTSTRAPPER_APPLY_RESTART restart, | ||
789 | __in BOOTSTRAPPER_APPLYCOMPLETE_ACTION /*recommendation*/, | ||
790 | __inout BOOTSTRAPPER_APPLYCOMPLETE_ACTION* pAction | ||
791 | ) | ||
792 | { | ||
793 | HRESULT hr = S_OK; | ||
794 | BOOL fRestartRequired = BOOTSTRAPPER_APPLY_RESTART_REQUIRED == restart; | ||
795 | BOOL fShouldBlockRestart = BOOTSTRAPPER_DISPLAY_FULL <= m_display && BOOTSTRAPPER_RESTART_PROMPT >= m_restart; | ||
796 | |||
797 | if (fRestartRequired && !fShouldBlockRestart) | ||
798 | { | ||
799 | *pAction = BOOTSTRAPPER_APPLYCOMPLETE_ACTION_RESTART; | ||
800 | } | ||
801 | |||
802 | m_fApplying = FALSE; | ||
803 | |||
804 | return hr; | ||
805 | } | ||
806 | |||
807 | virtual STDMETHODIMP OnLaunchApprovedExeBegin( | ||
808 | __inout BOOL* pfCancel | ||
809 | ) | ||
810 | { | ||
811 | *pfCancel |= CheckCanceled(); | ||
812 | return S_OK; | ||
813 | } | ||
814 | |||
815 | virtual STDMETHODIMP OnLaunchApprovedExeComplete( | ||
816 | __in HRESULT /*hrStatus*/, | ||
817 | __in DWORD /*dwProcessId*/ | ||
818 | ) | ||
819 | { | ||
820 | return S_OK; | ||
821 | } | ||
822 | |||
823 | virtual STDMETHODIMP OnBeginMsiTransactionBegin( | ||
824 | __in_z LPCWSTR /*wzTransactionId*/, | ||
825 | __inout BOOL* pfCancel | ||
826 | ) | ||
827 | { | ||
828 | *pfCancel |= CheckCanceled(); | ||
829 | return S_OK; | ||
830 | } | ||
831 | |||
832 | virtual STDMETHODIMP OnBeginMsiTransactionComplete( | ||
833 | __in_z LPCWSTR /*wzTransactionId*/, | ||
834 | __in HRESULT /*hrStatus*/ | ||
835 | ) | ||
836 | { | ||
837 | return S_OK; | ||
838 | } | ||
839 | |||
840 | virtual STDMETHODIMP OnCommitMsiTransactionBegin( | ||
841 | __in_z LPCWSTR /*wzTransactionId*/, | ||
842 | __inout BOOL* pfCancel | ||
843 | ) | ||
844 | { | ||
845 | *pfCancel |= CheckCanceled(); | ||
846 | return S_OK; | ||
847 | } | ||
848 | |||
849 | virtual STDMETHODIMP OnCommitMsiTransactionComplete( | ||
850 | __in_z LPCWSTR /*wzTransactionId*/, | ||
851 | __in HRESULT /*hrStatus*/ | ||
852 | ) | ||
853 | { | ||
854 | return S_OK; | ||
855 | } | ||
856 | |||
857 | virtual STDMETHODIMP OnRollbackMsiTransactionBegin( | ||
858 | __in_z LPCWSTR /*wzTransactionId*/ | ||
859 | ) | ||
860 | { | ||
861 | return S_OK; | ||
862 | } | ||
863 | |||
864 | virtual STDMETHODIMP OnRollbackMsiTransactionComplete( | ||
865 | __in_z LPCWSTR /*wzTransactionId*/, | ||
866 | __in HRESULT /*hrStatus*/ | ||
867 | ) | ||
868 | { | ||
869 | return S_OK; | ||
870 | } | ||
871 | |||
872 | virtual STDMETHODIMP OnPauseAutomaticUpdatesBegin( | ||
873 | ) | ||
874 | { | ||
875 | return S_OK; | ||
876 | } | ||
877 | |||
878 | virtual STDMETHODIMP OnPauseAutomaticUpdatesComplete( | ||
879 | __in HRESULT /*hrStatus*/ | ||
880 | ) | ||
881 | { | ||
882 | return S_OK; | ||
883 | } | ||
884 | |||
885 | virtual STDMETHODIMP OnSystemRestorePointBegin( | ||
886 | ) | ||
887 | { | ||
888 | return S_OK; | ||
889 | } | ||
890 | |||
891 | virtual STDMETHODIMP OnSystemRestorePointComplete( | ||
892 | __in HRESULT /*hrStatus*/ | ||
893 | ) | ||
894 | { | ||
895 | return S_OK; | ||
896 | } | ||
897 | |||
898 | virtual STDMETHODIMP OnPlanForwardCompatibleBundle( | ||
899 | __in_z LPCWSTR /*wzBundleId*/, | ||
900 | __in BOOTSTRAPPER_RELATION_TYPE /*relationType*/, | ||
901 | __in_z LPCWSTR /*wzBundleTag*/, | ||
902 | __in BOOL /*fPerMachine*/, | ||
903 | __in LPCWSTR /*wzVersion*/, | ||
904 | __in BOOL /*fRecommendedIgnoreBundle*/, | ||
905 | __inout BOOL* pfCancel, | ||
906 | __inout BOOL* /*pfIgnoreBundle*/ | ||
907 | ) | ||
908 | { | ||
909 | *pfCancel |= CheckCanceled(); | ||
910 | return S_OK; | ||
911 | } | ||
912 | |||
913 | virtual STDMETHODIMP OnCacheContainerOrPayloadVerifyBegin( | ||
914 | __in_z_opt LPCWSTR /*wzPackageOrContainerId*/, | ||
915 | __in_z_opt LPCWSTR /*wzPayloadId*/, | ||
916 | __inout BOOL* pfCancel | ||
917 | ) | ||
918 | { | ||
919 | *pfCancel |= CheckCanceled(); | ||
920 | return S_OK; | ||
921 | } | ||
922 | |||
923 | virtual STDMETHODIMP OnCacheContainerOrPayloadVerifyProgress( | ||
924 | __in_z_opt LPCWSTR /*wzPackageOrContainerId*/, | ||
925 | __in_z_opt LPCWSTR /*wzPayloadId*/, | ||
926 | __in DWORD64 /*dw64Progress*/, | ||
927 | __in DWORD64 /*dw64Total*/, | ||
928 | __in DWORD /*dwOverallPercentage*/, | ||
929 | __inout BOOL* pfCancel | ||
930 | ) | ||
931 | { | ||
932 | *pfCancel |= CheckCanceled(); | ||
933 | return S_OK; | ||
934 | } | ||
935 | |||
936 | virtual STDMETHODIMP OnCacheContainerOrPayloadVerifyComplete( | ||
937 | __in_z_opt LPCWSTR /*wzPackageOrContainerId*/, | ||
938 | __in_z_opt LPCWSTR /*wzPayloadId*/, | ||
939 | __in HRESULT /*hrStatus*/ | ||
940 | ) | ||
941 | { | ||
942 | return S_OK; | ||
943 | } | ||
944 | |||
945 | virtual STDMETHODIMP OnCachePayloadExtractBegin( | ||
946 | __in_z_opt LPCWSTR /*wzPackageOrContainerId*/, | ||
947 | __in_z_opt LPCWSTR /*wzPayloadId*/, | ||
948 | __inout BOOL* pfCancel | ||
949 | ) | ||
950 | { | ||
951 | *pfCancel |= CheckCanceled(); | ||
952 | return S_OK; | ||
953 | } | ||
954 | |||
955 | virtual STDMETHODIMP OnCachePayloadExtractProgress( | ||
956 | __in_z_opt LPCWSTR /*wzPackageOrContainerId*/, | ||
957 | __in_z_opt LPCWSTR /*wzPayloadId*/, | ||
958 | __in DWORD64 /*dw64Progress*/, | ||
959 | __in DWORD64 /*dw64Total*/, | ||
960 | __in DWORD /*dwOverallPercentage*/, | ||
961 | __inout BOOL* pfCancel | ||
962 | ) | ||
963 | { | ||
964 | *pfCancel |= CheckCanceled(); | ||
965 | return S_OK; | ||
966 | } | ||
967 | |||
968 | virtual STDMETHODIMP OnCachePayloadExtractComplete( | ||
969 | __in_z_opt LPCWSTR /*wzPackageOrContainerId*/, | ||
970 | __in_z_opt LPCWSTR /*wzPayloadId*/, | ||
971 | __in HRESULT /*hrStatus*/ | ||
972 | ) | ||
973 | { | ||
974 | return S_OK; | ||
975 | } | ||
976 | |||
977 | protected: | ||
978 | // | ||
979 | // PromptCancel - prompts the user to close (if not forced). | ||
980 | // | ||
981 | virtual BOOL PromptCancel( | ||
982 | __in HWND hWnd, | ||
983 | __in BOOL fForceCancel, | ||
984 | __in_z_opt LPCWSTR wzMessage, | ||
985 | __in_z_opt LPCWSTR wzCaption | ||
986 | ) | ||
987 | { | ||
988 | ::EnterCriticalSection(&m_csCanceled); | ||
989 | |||
990 | // Only prompt the user to close if we have not canceled already. | ||
991 | if (!m_fCanceled) | ||
992 | { | ||
993 | if (fForceCancel) | ||
994 | { | ||
995 | m_fCanceled = TRUE; | ||
996 | } | ||
997 | else | ||
998 | { | ||
999 | m_fCanceled = (IDYES == ::MessageBoxW(hWnd, wzMessage, wzCaption, MB_YESNO | MB_ICONEXCLAMATION)); | ||
1000 | } | ||
1001 | } | ||
1002 | |||
1003 | ::LeaveCriticalSection(&m_csCanceled); | ||
1004 | |||
1005 | return m_fCanceled; | ||
1006 | } | ||
1007 | |||
1008 | // | ||
1009 | // CheckCanceled - waits if the cancel dialog is up and checks to see if the user canceled the operation. | ||
1010 | // | ||
1011 | BOOL CheckCanceled() | ||
1012 | { | ||
1013 | ::EnterCriticalSection(&m_csCanceled); | ||
1014 | ::LeaveCriticalSection(&m_csCanceled); | ||
1015 | return m_fRollingBack ? FALSE : m_fCanceled; | ||
1016 | } | ||
1017 | |||
1018 | BOOL IsRollingBack() | ||
1019 | { | ||
1020 | return m_fRollingBack; | ||
1021 | } | ||
1022 | |||
1023 | BOOL IsCanceled() | ||
1024 | { | ||
1025 | return m_fCanceled; | ||
1026 | } | ||
1027 | |||
1028 | CBalBaseBootstrapperApplication( | ||
1029 | __in IBootstrapperEngine* pEngine, | ||
1030 | __in const BOOTSTRAPPER_CREATE_ARGS* pArgs, | ||
1031 | __in DWORD dwRetryCount = 0, | ||
1032 | __in DWORD dwRetryTimeout = 1000 | ||
1033 | ) | ||
1034 | { | ||
1035 | m_cReferences = 1; | ||
1036 | m_display = pArgs->pCommand->display; | ||
1037 | m_restart = pArgs->pCommand->restart; | ||
1038 | |||
1039 | pEngine->AddRef(); | ||
1040 | m_pEngine = pEngine; | ||
1041 | |||
1042 | ::InitializeCriticalSection(&m_csCanceled); | ||
1043 | m_fCanceled = FALSE; | ||
1044 | m_fApplying = FALSE; | ||
1045 | m_fRollingBack = FALSE; | ||
1046 | |||
1047 | m_dwProgressPercentage = 0; | ||
1048 | m_dwOverallProgressPercentage = 0; | ||
1049 | |||
1050 | BalRetryInitialize(dwRetryCount, dwRetryTimeout); | ||
1051 | } | ||
1052 | |||
1053 | virtual ~CBalBaseBootstrapperApplication() | ||
1054 | { | ||
1055 | BalRetryUninitialize(); | ||
1056 | ::DeleteCriticalSection(&m_csCanceled); | ||
1057 | |||
1058 | ReleaseNullObject(m_pEngine); | ||
1059 | } | ||
1060 | |||
1061 | protected: | ||
1062 | CRITICAL_SECTION m_csCanceled; | ||
1063 | BOOL m_fCanceled; | ||
1064 | |||
1065 | private: | ||
1066 | long m_cReferences; | ||
1067 | BOOTSTRAPPER_DISPLAY m_display; | ||
1068 | BOOTSTRAPPER_RESTART m_restart; | ||
1069 | IBootstrapperEngine* m_pEngine; | ||
1070 | |||
1071 | BOOL m_fApplying; | ||
1072 | BOOL m_fRollingBack; | ||
1073 | |||
1074 | DWORD m_dwProgressPercentage; | ||
1075 | DWORD m_dwOverallProgressPercentage; | ||
1076 | }; | ||
diff --git a/src/api/burn/balutil/inc/BalBaseBootstrapperApplicationProc.h b/src/api/burn/balutil/inc/BalBaseBootstrapperApplicationProc.h new file mode 100644 index 00000000..7fe3ffd8 --- /dev/null +++ b/src/api/burn/balutil/inc/BalBaseBootstrapperApplicationProc.h | |||
@@ -0,0 +1,901 @@ | |||
1 | #pragma once | ||
2 | // Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. | ||
3 | |||
4 | |||
5 | #include <windows.h> | ||
6 | |||
7 | #include "BootstrapperEngine.h" | ||
8 | #include "BootstrapperApplication.h" | ||
9 | #include "IBootstrapperEngine.h" | ||
10 | #include "IBootstrapperApplication.h" | ||
11 | |||
12 | static HRESULT BalBaseBAProcOnDetectBegin( | ||
13 | __in IBootstrapperApplication* pBA, | ||
14 | __in BA_ONDETECTBEGIN_ARGS* pArgs, | ||
15 | __inout BA_ONDETECTBEGIN_RESULTS* pResults | ||
16 | ) | ||
17 | { | ||
18 | return pBA->OnDetectBegin(pArgs->fCached, pArgs->fInstalled, pArgs->cPackages, &pResults->fCancel); | ||
19 | } | ||
20 | |||
21 | static HRESULT BalBaseBAProcOnDetectComplete( | ||
22 | __in IBootstrapperApplication* pBA, | ||
23 | __in BA_ONDETECTCOMPLETE_ARGS* pArgs, | ||
24 | __inout BA_ONDETECTCOMPLETE_RESULTS* /*pResults*/ | ||
25 | ) | ||
26 | { | ||
27 | return pBA->OnDetectComplete(pArgs->hrStatus, pArgs->fEligibleForCleanup); | ||
28 | } | ||
29 | |||
30 | static HRESULT BalBaseBAProcOnPlanBegin( | ||
31 | __in IBootstrapperApplication* pBA, | ||
32 | __in BA_ONPLANBEGIN_ARGS* pArgs, | ||
33 | __inout BA_ONPLANBEGIN_RESULTS* pResults | ||
34 | ) | ||
35 | { | ||
36 | return pBA->OnPlanBegin(pArgs->cPackages, &pResults->fCancel); | ||
37 | } | ||
38 | |||
39 | static HRESULT BalBaseBAProcOnPlanComplete( | ||
40 | __in IBootstrapperApplication* pBA, | ||
41 | __in BA_ONPLANCOMPLETE_ARGS* pArgs, | ||
42 | __inout BA_ONPLANCOMPLETE_RESULTS* /*pResults*/ | ||
43 | ) | ||
44 | { | ||
45 | return pBA->OnPlanComplete(pArgs->hrStatus); | ||
46 | } | ||
47 | |||
48 | static HRESULT BalBaseBAProcOnStartup( | ||
49 | __in IBootstrapperApplication* pBA, | ||
50 | __in BA_ONSTARTUP_ARGS* /*pArgs*/, | ||
51 | __inout BA_ONSTARTUP_RESULTS* /*pResults*/ | ||
52 | ) | ||
53 | { | ||
54 | return pBA->OnStartup(); | ||
55 | } | ||
56 | |||
57 | static HRESULT BalBaseBAProcOnShutdown( | ||
58 | __in IBootstrapperApplication* pBA, | ||
59 | __in BA_ONSHUTDOWN_ARGS* /*pArgs*/, | ||
60 | __inout BA_ONSHUTDOWN_RESULTS* pResults | ||
61 | ) | ||
62 | { | ||
63 | return pBA->OnShutdown(&pResults->action); | ||
64 | } | ||
65 | |||
66 | static HRESULT BalBaseBAProcOnSystemShutdown( | ||
67 | __in IBootstrapperApplication* pBA, | ||
68 | __in BA_ONSYSTEMSHUTDOWN_ARGS* pArgs, | ||
69 | __inout BA_ONSYSTEMSHUTDOWN_RESULTS* pResults | ||
70 | ) | ||
71 | { | ||
72 | return pBA->OnSystemShutdown(pArgs->dwEndSession, &pResults->fCancel); | ||
73 | } | ||
74 | |||
75 | static HRESULT BalBaseBAProcOnDetectForwardCompatibleBundle( | ||
76 | __in IBootstrapperApplication* pBA, | ||
77 | __in BA_ONDETECTFORWARDCOMPATIBLEBUNDLE_ARGS* pArgs, | ||
78 | __inout BA_ONDETECTFORWARDCOMPATIBLEBUNDLE_RESULTS* pResults | ||
79 | ) | ||
80 | { | ||
81 | return pBA->OnDetectForwardCompatibleBundle(pArgs->wzBundleId, pArgs->relationType, pArgs->wzBundleTag, pArgs->fPerMachine, pArgs->wzVersion, pArgs->fMissingFromCache, &pResults->fCancel); | ||
82 | } | ||
83 | |||
84 | static HRESULT BalBaseBAProcOnDetectUpdateBegin( | ||
85 | __in IBootstrapperApplication* pBA, | ||
86 | __in BA_ONDETECTUPDATEBEGIN_ARGS* pArgs, | ||
87 | __inout BA_ONDETECTUPDATEBEGIN_RESULTS* pResults | ||
88 | ) | ||
89 | { | ||
90 | return pBA->OnDetectUpdateBegin(pArgs->wzUpdateLocation, &pResults->fCancel, &pResults->fSkip); | ||
91 | } | ||
92 | |||
93 | static HRESULT BalBaseBAProcOnDetectUpdate( | ||
94 | __in IBootstrapperApplication* pBA, | ||
95 | __in BA_ONDETECTUPDATE_ARGS* pArgs, | ||
96 | __inout BA_ONDETECTUPDATE_RESULTS* pResults | ||
97 | ) | ||
98 | { | ||
99 | return pBA->OnDetectUpdate(pArgs->wzUpdateLocation, pArgs->dw64Size, pArgs->wzVersion, pArgs->wzTitle, pArgs->wzSummary, pArgs->wzContentType, pArgs->wzContent, &pResults->fCancel, &pResults->fStopProcessingUpdates); | ||
100 | } | ||
101 | |||
102 | static HRESULT BalBaseBAProcOnDetectUpdateComplete( | ||
103 | __in IBootstrapperApplication* pBA, | ||
104 | __in BA_ONDETECTUPDATECOMPLETE_ARGS* pArgs, | ||
105 | __inout BA_ONDETECTUPDATECOMPLETE_RESULTS* pResults | ||
106 | ) | ||
107 | { | ||
108 | return pBA->OnDetectUpdateComplete(pArgs->hrStatus, &pResults->fIgnoreError); | ||
109 | } | ||
110 | |||
111 | static HRESULT BalBaseBAProcOnDetectRelatedBundle( | ||
112 | __in IBootstrapperApplication* pBA, | ||
113 | __in BA_ONDETECTRELATEDBUNDLE_ARGS* pArgs, | ||
114 | __inout BA_ONDETECTRELATEDBUNDLE_RESULTS* pResults | ||
115 | ) | ||
116 | { | ||
117 | return pBA->OnDetectRelatedBundle(pArgs->wzBundleId, pArgs->relationType, pArgs->wzBundleTag, pArgs->fPerMachine, pArgs->wzVersion, pArgs->operation, pArgs->fMissingFromCache, &pResults->fCancel); | ||
118 | } | ||
119 | |||
120 | static HRESULT BalBaseBAProcOnDetectPackageBegin( | ||
121 | __in IBootstrapperApplication* pBA, | ||
122 | __in BA_ONDETECTPACKAGEBEGIN_ARGS* pArgs, | ||
123 | __inout BA_ONDETECTPACKAGEBEGIN_RESULTS* pResults | ||
124 | ) | ||
125 | { | ||
126 | return pBA->OnDetectPackageBegin(pArgs->wzPackageId, &pResults->fCancel); | ||
127 | } | ||
128 | |||
129 | static HRESULT BalBaseBAProcOnDetectRelatedMsiPackage( | ||
130 | __in IBootstrapperApplication* pBA, | ||
131 | __in BA_ONDETECTRELATEDMSIPACKAGE_ARGS* pArgs, | ||
132 | __inout BA_ONDETECTRELATEDMSIPACKAGE_RESULTS* pResults | ||
133 | ) | ||
134 | { | ||
135 | return pBA->OnDetectRelatedMsiPackage(pArgs->wzPackageId, pArgs->wzUpgradeCode, pArgs->wzProductCode, pArgs->fPerMachine, pArgs->wzVersion, pArgs->operation, &pResults->fCancel); | ||
136 | } | ||
137 | |||
138 | static HRESULT BalBaseBAProcOnDetectPatchTarget( | ||
139 | __in IBootstrapperApplication* pBA, | ||
140 | __in BA_ONDETECTPATCHTARGET_ARGS* pArgs, | ||
141 | __inout BA_ONDETECTPATCHTARGET_RESULTS* pResults | ||
142 | ) | ||
143 | { | ||
144 | return pBA->OnDetectPatchTarget(pArgs->wzPackageId, pArgs->wzProductCode, pArgs->patchState, &pResults->fCancel); | ||
145 | } | ||
146 | |||
147 | static HRESULT BalBaseBAProcOnDetectMsiFeature( | ||
148 | __in IBootstrapperApplication* pBA, | ||
149 | __in BA_ONDETECTMSIFEATURE_ARGS* pArgs, | ||
150 | __inout BA_ONDETECTMSIFEATURE_RESULTS* pResults | ||
151 | ) | ||
152 | { | ||
153 | return pBA->OnDetectMsiFeature(pArgs->wzPackageId, pArgs->wzFeatureId, pArgs->state, &pResults->fCancel); | ||
154 | } | ||
155 | |||
156 | static HRESULT BalBaseBAProcOnDetectPackageComplete( | ||
157 | __in IBootstrapperApplication* pBA, | ||
158 | __in BA_ONDETECTPACKAGECOMPLETE_ARGS* pArgs, | ||
159 | __inout BA_ONDETECTPACKAGECOMPLETE_RESULTS* /*pResults*/ | ||
160 | ) | ||
161 | { | ||
162 | return pBA->OnDetectPackageComplete(pArgs->wzPackageId, pArgs->hrStatus, pArgs->state, pArgs->fCached); | ||
163 | } | ||
164 | |||
165 | static HRESULT BalBaseBAProcOnPlanRelatedBundle( | ||
166 | __in IBootstrapperApplication* pBA, | ||
167 | __in BA_ONPLANRELATEDBUNDLE_ARGS* pArgs, | ||
168 | __inout BA_ONPLANRELATEDBUNDLE_RESULTS* pResults | ||
169 | ) | ||
170 | { | ||
171 | return pBA->OnPlanRelatedBundle(pArgs->wzBundleId, pArgs->recommendedState, &pResults->requestedState, &pResults->fCancel); | ||
172 | } | ||
173 | |||
174 | static HRESULT BalBaseBAProcOnPlanPackageBegin( | ||
175 | __in IBootstrapperApplication* pBA, | ||
176 | __in BA_ONPLANPACKAGEBEGIN_ARGS* pArgs, | ||
177 | __inout BA_ONPLANPACKAGEBEGIN_RESULTS* pResults | ||
178 | ) | ||
179 | { | ||
180 | return pBA->OnPlanPackageBegin(pArgs->wzPackageId, pArgs->state, pArgs->fCached, pArgs->installCondition, pArgs->recommendedState, pArgs->recommendedCacheType, &pResults->requestedState, &pResults->requestedCacheType, &pResults->fCancel); | ||
181 | } | ||
182 | |||
183 | static HRESULT BalBaseBAProcOnPlanPatchTarget( | ||
184 | __in IBootstrapperApplication* pBA, | ||
185 | __in BA_ONPLANPATCHTARGET_ARGS* pArgs, | ||
186 | __inout BA_ONPLANPATCHTARGET_RESULTS* pResults | ||
187 | ) | ||
188 | { | ||
189 | return pBA->OnPlanPatchTarget(pArgs->wzPackageId, pArgs->wzProductCode, pArgs->recommendedState, &pResults->requestedState, &pResults->fCancel); | ||
190 | } | ||
191 | |||
192 | static HRESULT BalBaseBAProcOnPlanMsiFeature( | ||
193 | __in IBootstrapperApplication* pBA, | ||
194 | __in BA_ONPLANMSIFEATURE_ARGS* pArgs, | ||
195 | __inout BA_ONPLANMSIFEATURE_RESULTS* pResults | ||
196 | ) | ||
197 | { | ||
198 | return pBA->OnPlanMsiFeature(pArgs->wzPackageId, pArgs->wzFeatureId, pArgs->recommendedState, &pResults->requestedState, &pResults->fCancel); | ||
199 | } | ||
200 | |||
201 | static HRESULT BalBaseBAProcOnPlanPackageComplete( | ||
202 | __in IBootstrapperApplication* pBA, | ||
203 | __in BA_ONPLANPACKAGECOMPLETE_ARGS* pArgs, | ||
204 | __inout BA_ONPLANPACKAGECOMPLETE_RESULTS* /*pResults*/ | ||
205 | ) | ||
206 | { | ||
207 | return pBA->OnPlanPackageComplete(pArgs->wzPackageId, pArgs->hrStatus, pArgs->requested); | ||
208 | } | ||
209 | |||
210 | static HRESULT BalBaseBAProcOnPlannedPackage( | ||
211 | __in IBootstrapperApplication* pBA, | ||
212 | __in BA_ONPLANNEDPACKAGE_ARGS* pArgs, | ||
213 | __inout BA_ONPLANNEDPACKAGE_RESULTS* /*pResults*/ | ||
214 | ) | ||
215 | { | ||
216 | return pBA->OnPlannedPackage(pArgs->wzPackageId, pArgs->execute, pArgs->rollback, pArgs->fPlannedCache, pArgs->fPlannedUncache); | ||
217 | } | ||
218 | |||
219 | static HRESULT BalBaseBAProcOnApplyBegin( | ||
220 | __in IBootstrapperApplication* pBA, | ||
221 | __in BA_ONAPPLYBEGIN_ARGS* pArgs, | ||
222 | __inout BA_ONAPPLYBEGIN_RESULTS* pResults | ||
223 | ) | ||
224 | { | ||
225 | return pBA->OnApplyBegin(pArgs->dwPhaseCount, &pResults->fCancel); | ||
226 | } | ||
227 | |||
228 | static HRESULT BalBaseBAProcOnElevateBegin( | ||
229 | __in IBootstrapperApplication* pBA, | ||
230 | __in BA_ONELEVATEBEGIN_ARGS* /*pArgs*/, | ||
231 | __inout BA_ONELEVATEBEGIN_RESULTS* pResults | ||
232 | ) | ||
233 | { | ||
234 | return pBA->OnElevateBegin(&pResults->fCancel); | ||
235 | } | ||
236 | |||
237 | static HRESULT BalBaseBAProcOnElevateComplete( | ||
238 | __in IBootstrapperApplication* pBA, | ||
239 | __in BA_ONELEVATECOMPLETE_ARGS* pArgs, | ||
240 | __inout BA_ONELEVATECOMPLETE_RESULTS* /*pResults*/ | ||
241 | ) | ||
242 | { | ||
243 | return pBA->OnElevateComplete(pArgs->hrStatus); | ||
244 | } | ||
245 | |||
246 | static HRESULT BalBaseBAProcOnProgress( | ||
247 | __in IBootstrapperApplication* pBA, | ||
248 | __in BA_ONPROGRESS_ARGS* pArgs, | ||
249 | __inout BA_ONPROGRESS_RESULTS* pResults | ||
250 | ) | ||
251 | { | ||
252 | return pBA->OnProgress(pArgs->dwProgressPercentage, pArgs->dwOverallPercentage, &pResults->fCancel); | ||
253 | } | ||
254 | |||
255 | static HRESULT BalBaseBAProcOnError( | ||
256 | __in IBootstrapperApplication* pBA, | ||
257 | __in BA_ONERROR_ARGS* pArgs, | ||
258 | __inout BA_ONERROR_RESULTS* pResults | ||
259 | ) | ||
260 | { | ||
261 | return pBA->OnError(pArgs->errorType, pArgs->wzPackageId, pArgs->dwCode, pArgs->wzError, pArgs->dwUIHint, pArgs->cData, pArgs->rgwzData, pArgs->nRecommendation, &pResults->nResult); | ||
262 | } | ||
263 | |||
264 | static HRESULT BalBaseBAProcOnRegisterBegin( | ||
265 | __in IBootstrapperApplication* pBA, | ||
266 | __in BA_ONREGISTERBEGIN_ARGS* /*pArgs*/, | ||
267 | __inout BA_ONREGISTERBEGIN_RESULTS* pResults | ||
268 | ) | ||
269 | { | ||
270 | return pBA->OnRegisterBegin(&pResults->fCancel); | ||
271 | } | ||
272 | |||
273 | static HRESULT BalBaseBAProcOnRegisterComplete( | ||
274 | __in IBootstrapperApplication* pBA, | ||
275 | __in BA_ONREGISTERCOMPLETE_ARGS* pArgs, | ||
276 | __inout BA_ONREGISTERCOMPLETE_RESULTS* /*pResults*/ | ||
277 | ) | ||
278 | { | ||
279 | return pBA->OnRegisterComplete(pArgs->hrStatus); | ||
280 | } | ||
281 | |||
282 | static HRESULT BalBaseBAProcOnCacheBegin( | ||
283 | __in IBootstrapperApplication* pBA, | ||
284 | __in BA_ONCACHEBEGIN_ARGS* /*pArgs*/, | ||
285 | __inout BA_ONCACHEBEGIN_RESULTS* pResults | ||
286 | ) | ||
287 | { | ||
288 | return pBA->OnCacheBegin(&pResults->fCancel); | ||
289 | } | ||
290 | |||
291 | static HRESULT BalBaseBAProcOnCachePackageBegin( | ||
292 | __in IBootstrapperApplication* pBA, | ||
293 | __in BA_ONCACHEPACKAGEBEGIN_ARGS* pArgs, | ||
294 | __inout BA_ONCACHEPACKAGEBEGIN_RESULTS* pResults | ||
295 | ) | ||
296 | { | ||
297 | return pBA->OnCachePackageBegin(pArgs->wzPackageId, pArgs->cCachePayloads, pArgs->dw64PackageCacheSize, &pResults->fCancel); | ||
298 | } | ||
299 | |||
300 | static HRESULT BalBaseBAProcOnCacheAcquireBegin( | ||
301 | __in IBootstrapperApplication* pBA, | ||
302 | __in BA_ONCACHEACQUIREBEGIN_ARGS* pArgs, | ||
303 | __inout BA_ONCACHEACQUIREBEGIN_RESULTS* pResults | ||
304 | ) | ||
305 | { | ||
306 | return pBA->OnCacheAcquireBegin(pArgs->wzPackageOrContainerId, pArgs->wzPayloadId, pArgs->wzSource, pArgs->wzDownloadUrl, pArgs->wzPayloadContainerId, pArgs->recommendation, &pResults->action, &pResults->fCancel); | ||
307 | } | ||
308 | |||
309 | static HRESULT BalBaseBAProcOnCacheAcquireProgress( | ||
310 | __in IBootstrapperApplication* pBA, | ||
311 | __in BA_ONCACHEACQUIREPROGRESS_ARGS* pArgs, | ||
312 | __inout BA_ONCACHEACQUIREPROGRESS_RESULTS* pResults | ||
313 | ) | ||
314 | { | ||
315 | return pBA->OnCacheAcquireProgress(pArgs->wzPackageOrContainerId, pArgs->wzPayloadId, pArgs->dw64Progress, pArgs->dw64Total, pArgs->dwOverallPercentage, &pResults->fCancel); | ||
316 | } | ||
317 | |||
318 | static HRESULT BalBaseBAProcOnCacheAcquireResolving( | ||
319 | __in IBootstrapperApplication* pBA, | ||
320 | __in BA_ONCACHEACQUIRERESOLVING_ARGS* pArgs, | ||
321 | __inout BA_ONCACHEACQUIRERESOLVING_RESULTS* pResults | ||
322 | ) | ||
323 | { | ||
324 | return pBA->OnCacheAcquireResolving(pArgs->wzPackageOrContainerId, pArgs->wzPayloadId, pArgs->rgSearchPaths, pArgs->cSearchPaths, pArgs->fFoundLocal, pArgs->dwRecommendedSearchPath, pArgs->wzDownloadUrl, pArgs->wzPayloadContainerId, pArgs->recommendation, &pResults->dwChosenSearchPath, &pResults->action, &pResults->fCancel); | ||
325 | } | ||
326 | |||
327 | static HRESULT BalBaseBAProcOnCacheAcquireComplete( | ||
328 | __in IBootstrapperApplication* pBA, | ||
329 | __in BA_ONCACHEACQUIRECOMPLETE_ARGS* pArgs, | ||
330 | __inout BA_ONCACHEACQUIRECOMPLETE_RESULTS* pResults | ||
331 | ) | ||
332 | { | ||
333 | return pBA->OnCacheAcquireComplete(pArgs->wzPackageOrContainerId, pArgs->wzPayloadId, pArgs->hrStatus, pArgs->recommendation, &pResults->action); | ||
334 | } | ||
335 | |||
336 | static HRESULT BalBaseBAProcOnCacheVerifyBegin( | ||
337 | __in IBootstrapperApplication* pBA, | ||
338 | __in BA_ONCACHEVERIFYBEGIN_ARGS* pArgs, | ||
339 | __inout BA_ONCACHEVERIFYBEGIN_RESULTS* pResults | ||
340 | ) | ||
341 | { | ||
342 | return pBA->OnCacheVerifyBegin(pArgs->wzPackageOrContainerId, pArgs->wzPayloadId, &pResults->fCancel); | ||
343 | } | ||
344 | |||
345 | static HRESULT BalBaseBAProcOnCacheVerifyProgress( | ||
346 | __in IBootstrapperApplication* pBA, | ||
347 | __in BA_ONCACHEVERIFYPROGRESS_ARGS* pArgs, | ||
348 | __inout BA_ONCACHEVERIFYPROGRESS_RESULTS* pResults | ||
349 | ) | ||
350 | { | ||
351 | return pBA->OnCacheVerifyProgress(pArgs->wzPackageOrContainerId, pArgs->wzPayloadId, pArgs->dw64Progress, pArgs->dw64Total, pArgs->dwOverallPercentage, pArgs->verifyStep, &pResults->fCancel); | ||
352 | } | ||
353 | |||
354 | static HRESULT BalBaseBAProcOnCacheVerifyComplete( | ||
355 | __in IBootstrapperApplication* pBA, | ||
356 | __in BA_ONCACHEVERIFYCOMPLETE_ARGS* pArgs, | ||
357 | __inout BA_ONCACHEVERIFYCOMPLETE_RESULTS* pResults | ||
358 | ) | ||
359 | { | ||
360 | return pBA->OnCacheVerifyComplete(pArgs->wzPackageOrContainerId, pArgs->wzPayloadId, pArgs->hrStatus, pArgs->recommendation, &pResults->action); | ||
361 | } | ||
362 | |||
363 | static HRESULT BalBaseBAProcOnCachePackageComplete( | ||
364 | __in IBootstrapperApplication* pBA, | ||
365 | __in BA_ONCACHEPACKAGECOMPLETE_ARGS* pArgs, | ||
366 | __inout BA_ONCACHEPACKAGECOMPLETE_RESULTS* pResults | ||
367 | ) | ||
368 | { | ||
369 | return pBA->OnCachePackageComplete(pArgs->wzPackageId, pArgs->hrStatus, pArgs->recommendation, &pResults->action); | ||
370 | } | ||
371 | |||
372 | static HRESULT BalBaseBAProcOnCacheComplete( | ||
373 | __in IBootstrapperApplication* pBA, | ||
374 | __in BA_ONCACHECOMPLETE_ARGS* pArgs, | ||
375 | __inout BA_ONCACHECOMPLETE_RESULTS* /*pResults*/ | ||
376 | ) | ||
377 | { | ||
378 | return pBA->OnCacheComplete(pArgs->hrStatus); | ||
379 | } | ||
380 | |||
381 | static HRESULT BalBaseBAProcOnExecuteBegin( | ||
382 | __in IBootstrapperApplication* pBA, | ||
383 | __in BA_ONEXECUTEBEGIN_ARGS* pArgs, | ||
384 | __inout BA_ONEXECUTEBEGIN_RESULTS* pResults | ||
385 | ) | ||
386 | { | ||
387 | return pBA->OnExecuteBegin(pArgs->cExecutingPackages, &pResults->fCancel); | ||
388 | } | ||
389 | |||
390 | static HRESULT BalBaseBAProcOnExecutePackageBegin( | ||
391 | __in IBootstrapperApplication* pBA, | ||
392 | __in BA_ONEXECUTEPACKAGEBEGIN_ARGS* pArgs, | ||
393 | __inout BA_ONEXECUTEPACKAGEBEGIN_RESULTS* pResults | ||
394 | ) | ||
395 | { | ||
396 | return pBA->OnExecutePackageBegin(pArgs->wzPackageId, pArgs->fExecute, pArgs->action, pArgs->uiLevel, pArgs->fDisableExternalUiHandler, &pResults->fCancel); | ||
397 | } | ||
398 | |||
399 | static HRESULT BalBaseBAProcOnExecutePatchTarget( | ||
400 | __in IBootstrapperApplication* pBA, | ||
401 | __in BA_ONEXECUTEPATCHTARGET_ARGS* pArgs, | ||
402 | __inout BA_ONEXECUTEPATCHTARGET_RESULTS* pResults | ||
403 | ) | ||
404 | { | ||
405 | return pBA->OnExecutePatchTarget(pArgs->wzPackageId, pArgs->wzTargetProductCode, &pResults->fCancel); | ||
406 | } | ||
407 | |||
408 | static HRESULT BalBaseBAProcOnExecuteProgress( | ||
409 | __in IBootstrapperApplication* pBA, | ||
410 | __in BA_ONEXECUTEPROGRESS_ARGS* pArgs, | ||
411 | __inout BA_ONEXECUTEPROGRESS_RESULTS* pResults | ||
412 | ) | ||
413 | { | ||
414 | return pBA->OnExecuteProgress(pArgs->wzPackageId, pArgs->dwProgressPercentage, pArgs->dwOverallPercentage, &pResults->fCancel); | ||
415 | } | ||
416 | |||
417 | static HRESULT BalBaseBAProcOnExecuteMsiMessage( | ||
418 | __in IBootstrapperApplication* pBA, | ||
419 | __in BA_ONEXECUTEMSIMESSAGE_ARGS* pArgs, | ||
420 | __inout BA_ONEXECUTEMSIMESSAGE_RESULTS* pResults | ||
421 | ) | ||
422 | { | ||
423 | return pBA->OnExecuteMsiMessage(pArgs->wzPackageId, pArgs->messageType, pArgs->dwUIHint, pArgs->wzMessage, pArgs->cData, pArgs->rgwzData, pArgs->nRecommendation, &pResults->nResult); | ||
424 | } | ||
425 | |||
426 | static HRESULT BalBaseBAProcOnExecuteFilesInUse( | ||
427 | __in IBootstrapperApplication* pBA, | ||
428 | __in BA_ONEXECUTEFILESINUSE_ARGS* pArgs, | ||
429 | __inout BA_ONEXECUTEFILESINUSE_RESULTS* pResults | ||
430 | ) | ||
431 | { | ||
432 | return pBA->OnExecuteFilesInUse(pArgs->wzPackageId, pArgs->cFiles, pArgs->rgwzFiles, pArgs->nRecommendation, &pResults->nResult); | ||
433 | } | ||
434 | |||
435 | static HRESULT BalBaseBAProcOnExecutePackageComplete( | ||
436 | __in IBootstrapperApplication* pBA, | ||
437 | __in BA_ONEXECUTEPACKAGECOMPLETE_ARGS* pArgs, | ||
438 | __inout BA_ONEXECUTEPACKAGECOMPLETE_RESULTS* pResults | ||
439 | ) | ||
440 | { | ||
441 | return pBA->OnExecutePackageComplete(pArgs->wzPackageId, pArgs->hrStatus, pArgs->restart, pArgs->recommendation, &pResults->action); | ||
442 | } | ||
443 | |||
444 | static HRESULT BalBaseBAProcOnExecuteComplete( | ||
445 | __in IBootstrapperApplication* pBA, | ||
446 | __in BA_ONEXECUTECOMPLETE_ARGS* pArgs, | ||
447 | __inout BA_ONEXECUTECOMPLETE_RESULTS* /*pResults*/ | ||
448 | ) | ||
449 | { | ||
450 | return pBA->OnExecuteComplete(pArgs->hrStatus); | ||
451 | } | ||
452 | |||
453 | static HRESULT BalBaseBAProcOnUnregisterBegin( | ||
454 | __in IBootstrapperApplication* pBA, | ||
455 | __in BA_ONUNREGISTERBEGIN_ARGS* pArgs, | ||
456 | __inout BA_ONUNREGISTERBEGIN_RESULTS* pResults | ||
457 | ) | ||
458 | { | ||
459 | return pBA->OnUnregisterBegin(pArgs->fKeepRegistration, &pResults->fForceKeepRegistration); | ||
460 | } | ||
461 | |||
462 | static HRESULT BalBaseBAProcOnUnregisterComplete( | ||
463 | __in IBootstrapperApplication* pBA, | ||
464 | __in BA_ONUNREGISTERCOMPLETE_ARGS* pArgs, | ||
465 | __inout BA_ONUNREGISTERCOMPLETE_RESULTS* /*pResults*/ | ||
466 | ) | ||
467 | { | ||
468 | return pBA->OnUnregisterComplete(pArgs->hrStatus); | ||
469 | } | ||
470 | |||
471 | static HRESULT BalBaseBAProcOnApplyComplete( | ||
472 | __in IBootstrapperApplication* pBA, | ||
473 | __in BA_ONAPPLYCOMPLETE_ARGS* pArgs, | ||
474 | __inout BA_ONAPPLYCOMPLETE_RESULTS* pResults | ||
475 | ) | ||
476 | { | ||
477 | return pBA->OnApplyComplete(pArgs->hrStatus, pArgs->restart, pArgs->recommendation, &pResults->action); | ||
478 | } | ||
479 | |||
480 | static HRESULT BalBaseBAProcOnLaunchApprovedExeBegin( | ||
481 | __in IBootstrapperApplication* pBA, | ||
482 | __in BA_ONLAUNCHAPPROVEDEXEBEGIN_ARGS* /*pArgs*/, | ||
483 | __inout BA_ONLAUNCHAPPROVEDEXEBEGIN_RESULTS* pResults | ||
484 | ) | ||
485 | { | ||
486 | return pBA->OnLaunchApprovedExeBegin(&pResults->fCancel); | ||
487 | } | ||
488 | |||
489 | static HRESULT BalBaseBAProcOnLaunchApprovedExeComplete( | ||
490 | __in IBootstrapperApplication* pBA, | ||
491 | __in BA_ONLAUNCHAPPROVEDEXECOMPLETE_ARGS* pArgs, | ||
492 | __inout BA_ONLAUNCHAPPROVEDEXECOMPLETE_RESULTS* /*pResults*/ | ||
493 | ) | ||
494 | { | ||
495 | return pBA->OnLaunchApprovedExeComplete(pArgs->hrStatus, pArgs->dwProcessId); | ||
496 | } | ||
497 | |||
498 | static HRESULT BalBaseBAProcOnPlanMsiPackage( | ||
499 | __in IBootstrapperApplication* pBA, | ||
500 | __in BA_ONPLANMSIPACKAGE_ARGS* pArgs, | ||
501 | __inout BA_ONPLANMSIPACKAGE_RESULTS* pResults | ||
502 | ) | ||
503 | { | ||
504 | return pBA->OnPlanMsiPackage(pArgs->wzPackageId, pArgs->fExecute, pArgs->action, &pResults->fCancel, &pResults->actionMsiProperty, &pResults->uiLevel, &pResults->fDisableExternalUiHandler); | ||
505 | } | ||
506 | |||
507 | static HRESULT BalBaseBAProcOnBeginMsiTransactionBegin( | ||
508 | __in IBootstrapperApplication* pBA, | ||
509 | __in BA_ONBEGINMSITRANSACTIONBEGIN_ARGS* pArgs, | ||
510 | __inout BA_ONBEGINMSITRANSACTIONBEGIN_RESULTS* pResults | ||
511 | ) | ||
512 | { | ||
513 | return pBA->OnBeginMsiTransactionBegin(pArgs->wzTransactionId, &pResults->fCancel); | ||
514 | } | ||
515 | |||
516 | static HRESULT BalBaseBAProcOnBeginMsiTransactionComplete( | ||
517 | __in IBootstrapperApplication* pBA, | ||
518 | __in BA_ONBEGINMSITRANSACTIONCOMPLETE_ARGS* pArgs, | ||
519 | __inout BA_ONBEGINMSITRANSACTIONCOMPLETE_RESULTS* /*pResults*/ | ||
520 | ) | ||
521 | { | ||
522 | return pBA->OnBeginMsiTransactionComplete(pArgs->wzTransactionId, pArgs->hrStatus); | ||
523 | } | ||
524 | |||
525 | static HRESULT BalBaseBAProcOnCommitMsiTransactionBegin( | ||
526 | __in IBootstrapperApplication* pBA, | ||
527 | __in BA_ONCOMMITMSITRANSACTIONBEGIN_ARGS* pArgs, | ||
528 | __inout BA_ONCOMMITMSITRANSACTIONBEGIN_RESULTS* pResults | ||
529 | ) | ||
530 | { | ||
531 | return pBA->OnCommitMsiTransactionBegin(pArgs->wzTransactionId, &pResults->fCancel); | ||
532 | } | ||
533 | |||
534 | static HRESULT BalBaseBAProcOnCommitMsiTransactionComplete( | ||
535 | __in IBootstrapperApplication* pBA, | ||
536 | __in BA_ONCOMMITMSITRANSACTIONCOMPLETE_ARGS* pArgs, | ||
537 | __inout BA_ONCOMMITMSITRANSACTIONCOMPLETE_RESULTS* /*pResults*/ | ||
538 | ) | ||
539 | { | ||
540 | return pBA->OnCommitMsiTransactionComplete(pArgs->wzTransactionId, pArgs->hrStatus); | ||
541 | } | ||
542 | |||
543 | static HRESULT BalBaseBAProcOnRollbackMsiTransactionBegin( | ||
544 | __in IBootstrapperApplication* pBA, | ||
545 | __in BA_ONROLLBACKMSITRANSACTIONBEGIN_ARGS* pArgs, | ||
546 | __inout BA_ONROLLBACKMSITRANSACTIONBEGIN_RESULTS* /*pResults*/ | ||
547 | ) | ||
548 | { | ||
549 | return pBA->OnRollbackMsiTransactionBegin(pArgs->wzTransactionId); | ||
550 | } | ||
551 | |||
552 | static HRESULT BalBaseBAProcOnRollbackMsiTransactionComplete( | ||
553 | __in IBootstrapperApplication* pBA, | ||
554 | __in BA_ONROLLBACKMSITRANSACTIONCOMPLETE_ARGS* pArgs, | ||
555 | __inout BA_ONROLLBACKMSITRANSACTIONCOMPLETE_RESULTS* /*pResults*/ | ||
556 | ) | ||
557 | { | ||
558 | return pBA->OnRollbackMsiTransactionComplete(pArgs->wzTransactionId, pArgs->hrStatus); | ||
559 | } | ||
560 | |||
561 | static HRESULT BalBaseBAProcOnPauseAutomaticUpdatesBegin( | ||
562 | __in IBootstrapperApplication* pBA, | ||
563 | __in BA_ONPAUSEAUTOMATICUPDATESBEGIN_ARGS* /*pArgs*/, | ||
564 | __inout BA_ONPAUSEAUTOMATICUPDATESBEGIN_RESULTS* /*pResults*/ | ||
565 | ) | ||
566 | { | ||
567 | return pBA->OnPauseAutomaticUpdatesBegin(); | ||
568 | } | ||
569 | |||
570 | static HRESULT BalBaseBAProcOnPauseAutomaticUpdatesComplete( | ||
571 | __in IBootstrapperApplication* pBA, | ||
572 | __in BA_ONPAUSEAUTOMATICUPDATESCOMPLETE_ARGS* pArgs, | ||
573 | __inout BA_ONPAUSEAUTOMATICUPDATESCOMPLETE_RESULTS* /*pResults*/ | ||
574 | ) | ||
575 | { | ||
576 | return pBA->OnPauseAutomaticUpdatesComplete(pArgs->hrStatus); | ||
577 | } | ||
578 | |||
579 | static HRESULT BalBaseBAProcOnSystemRestorePointBegin( | ||
580 | __in IBootstrapperApplication* pBA, | ||
581 | __in BA_ONSYSTEMRESTOREPOINTBEGIN_ARGS* /*pArgs*/, | ||
582 | __inout BA_ONSYSTEMRESTOREPOINTBEGIN_RESULTS* /*pResults*/ | ||
583 | ) | ||
584 | { | ||
585 | return pBA->OnSystemRestorePointBegin(); | ||
586 | } | ||
587 | |||
588 | static HRESULT BalBaseBAProcOnSystemRestorePointComplete( | ||
589 | __in IBootstrapperApplication* pBA, | ||
590 | __in BA_ONSYSTEMRESTOREPOINTCOMPLETE_ARGS* pArgs, | ||
591 | __inout BA_ONSYSTEMRESTOREPOINTCOMPLETE_RESULTS* /*pResults*/ | ||
592 | ) | ||
593 | { | ||
594 | return pBA->OnSystemRestorePointComplete(pArgs->hrStatus); | ||
595 | } | ||
596 | |||
597 | static HRESULT BalBaseBAProcOnPlanForwardCompatibleBundle( | ||
598 | __in IBootstrapperApplication* pBA, | ||
599 | __in BA_ONPLANFORWARDCOMPATIBLEBUNDLE_ARGS* pArgs, | ||
600 | __inout BA_ONPLANFORWARDCOMPATIBLEBUNDLE_RESULTS* pResults | ||
601 | ) | ||
602 | { | ||
603 | return pBA->OnPlanForwardCompatibleBundle(pArgs->wzBundleId, pArgs->relationType, pArgs->wzBundleTag, pArgs->fPerMachine, pArgs->wzVersion, pArgs->fRecommendedIgnoreBundle, &pResults->fCancel, &pResults->fIgnoreBundle); | ||
604 | } | ||
605 | |||
606 | static HRESULT BalBaseBAProcOnCacheContainerOrPayloadVerifyBegin( | ||
607 | __in IBootstrapperApplication* pBA, | ||
608 | __in BA_ONCACHECONTAINERORPAYLOADVERIFYBEGIN_ARGS* pArgs, | ||
609 | __inout BA_ONCACHECONTAINERORPAYLOADVERIFYBEGIN_RESULTS* pResults | ||
610 | ) | ||
611 | { | ||
612 | return pBA->OnCacheContainerOrPayloadVerifyBegin(pArgs->wzPackageOrContainerId, pArgs->wzPayloadId, &pResults->fCancel); | ||
613 | } | ||
614 | |||
615 | static HRESULT BalBaseBAProcOnCacheContainerOrPayloadVerifyProgress( | ||
616 | __in IBootstrapperApplication* pBA, | ||
617 | __in BA_ONCACHECONTAINERORPAYLOADVERIFYPROGRESS_ARGS* pArgs, | ||
618 | __inout BA_ONCACHECONTAINERORPAYLOADVERIFYPROGRESS_RESULTS* pResults | ||
619 | ) | ||
620 | { | ||
621 | return pBA->OnCacheContainerOrPayloadVerifyProgress(pArgs->wzPackageOrContainerId, pArgs->wzPayloadId, pArgs->dw64Progress, pArgs->dw64Total, pArgs->dwOverallPercentage, &pResults->fCancel); | ||
622 | } | ||
623 | |||
624 | static HRESULT BalBaseBAProcOnCacheContainerOrPayloadVerifyComplete( | ||
625 | __in IBootstrapperApplication* pBA, | ||
626 | __in BA_ONCACHECONTAINERORPAYLOADVERIFYCOMPLETE_ARGS* pArgs, | ||
627 | __inout BA_ONCACHECONTAINERORPAYLOADVERIFYCOMPLETE_RESULTS* /*pResults*/ | ||
628 | ) | ||
629 | { | ||
630 | return pBA->OnCacheContainerOrPayloadVerifyComplete(pArgs->wzPackageOrContainerId, pArgs->wzPayloadId, pArgs->hrStatus); | ||
631 | } | ||
632 | |||
633 | static HRESULT BalBaseBAProcOnCachePayloadExtractBegin( | ||
634 | __in IBootstrapperApplication* pBA, | ||
635 | __in BA_ONCACHEPAYLOADEXTRACTBEGIN_ARGS* pArgs, | ||
636 | __inout BA_ONCACHEPAYLOADEXTRACTBEGIN_RESULTS* pResults | ||
637 | ) | ||
638 | { | ||
639 | return pBA->OnCachePayloadExtractBegin(pArgs->wzContainerId, pArgs->wzPayloadId, &pResults->fCancel); | ||
640 | } | ||
641 | |||
642 | static HRESULT BalBaseBAProcOnCachePayloadExtractProgress( | ||
643 | __in IBootstrapperApplication* pBA, | ||
644 | __in BA_ONCACHEPAYLOADEXTRACTPROGRESS_ARGS* pArgs, | ||
645 | __inout BA_ONCACHEPAYLOADEXTRACTPROGRESS_RESULTS* pResults | ||
646 | ) | ||
647 | { | ||
648 | return pBA->OnCachePayloadExtractProgress(pArgs->wzContainerId, pArgs->wzPayloadId, pArgs->dw64Progress, pArgs->dw64Total, pArgs->dwOverallPercentage, &pResults->fCancel); | ||
649 | } | ||
650 | |||
651 | static HRESULT BalBaseBAProcOnCachePayloadExtractComplete( | ||
652 | __in IBootstrapperApplication* pBA, | ||
653 | __in BA_ONCACHEPAYLOADEXTRACTCOMPLETE_ARGS* pArgs, | ||
654 | __inout BA_ONCACHEPAYLOADEXTRACTCOMPLETE_RESULTS* /*pResults*/ | ||
655 | ) | ||
656 | { | ||
657 | return pBA->OnCachePayloadExtractComplete(pArgs->wzContainerId, pArgs->wzPayloadId, pArgs->hrStatus); | ||
658 | } | ||
659 | |||
660 | /******************************************************************* | ||
661 | BalBaseBootstrapperApplicationProc - requires pvContext to be of type IBootstrapperApplication. | ||
662 | Provides a default mapping between the new message based BA interface and | ||
663 | the old COM-based BA interface. | ||
664 | |||
665 | *******************************************************************/ | ||
666 | static HRESULT WINAPI BalBaseBootstrapperApplicationProc( | ||
667 | __in BOOTSTRAPPER_APPLICATION_MESSAGE message, | ||
668 | __in const LPVOID pvArgs, | ||
669 | __inout LPVOID pvResults, | ||
670 | __in_opt LPVOID pvContext | ||
671 | ) | ||
672 | { | ||
673 | IBootstrapperApplication* pBA = reinterpret_cast<IBootstrapperApplication*>(pvContext); | ||
674 | HRESULT hr = pBA->BAProc(message, pvArgs, pvResults, pvContext); | ||
675 | |||
676 | if (E_NOTIMPL == hr) | ||
677 | { | ||
678 | switch (message) | ||
679 | { | ||
680 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTBEGIN: | ||
681 | hr = BalBaseBAProcOnDetectBegin(pBA, reinterpret_cast<BA_ONDETECTBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONDETECTBEGIN_RESULTS*>(pvResults)); | ||
682 | break; | ||
683 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTCOMPLETE: | ||
684 | hr = BalBaseBAProcOnDetectComplete(pBA, reinterpret_cast<BA_ONDETECTCOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONDETECTCOMPLETE_RESULTS*>(pvResults)); | ||
685 | break; | ||
686 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANBEGIN: | ||
687 | hr = BalBaseBAProcOnPlanBegin(pBA, reinterpret_cast<BA_ONPLANBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONPLANBEGIN_RESULTS*>(pvResults)); | ||
688 | break; | ||
689 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANCOMPLETE: | ||
690 | hr = BalBaseBAProcOnPlanComplete(pBA, reinterpret_cast<BA_ONPLANCOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONPLANCOMPLETE_RESULTS*>(pvResults)); | ||
691 | break; | ||
692 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONSTARTUP: | ||
693 | hr = BalBaseBAProcOnStartup(pBA, reinterpret_cast<BA_ONSTARTUP_ARGS*>(pvArgs), reinterpret_cast<BA_ONSTARTUP_RESULTS*>(pvResults)); | ||
694 | break; | ||
695 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONSHUTDOWN: | ||
696 | hr = BalBaseBAProcOnShutdown(pBA, reinterpret_cast<BA_ONSHUTDOWN_ARGS*>(pvArgs), reinterpret_cast<BA_ONSHUTDOWN_RESULTS*>(pvResults)); | ||
697 | break; | ||
698 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONSYSTEMSHUTDOWN: | ||
699 | hr = BalBaseBAProcOnSystemShutdown(pBA, reinterpret_cast<BA_ONSYSTEMSHUTDOWN_ARGS*>(pvArgs), reinterpret_cast<BA_ONSYSTEMSHUTDOWN_RESULTS*>(pvResults)); | ||
700 | break; | ||
701 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTFORWARDCOMPATIBLEBUNDLE: | ||
702 | hr = BalBaseBAProcOnDetectForwardCompatibleBundle(pBA, reinterpret_cast<BA_ONDETECTFORWARDCOMPATIBLEBUNDLE_ARGS*>(pvArgs), reinterpret_cast<BA_ONDETECTFORWARDCOMPATIBLEBUNDLE_RESULTS*>(pvResults)); | ||
703 | break; | ||
704 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTUPDATEBEGIN: | ||
705 | hr = BalBaseBAProcOnDetectUpdateBegin(pBA, reinterpret_cast<BA_ONDETECTUPDATEBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONDETECTUPDATEBEGIN_RESULTS*>(pvResults)); | ||
706 | break; | ||
707 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTUPDATE: | ||
708 | hr = BalBaseBAProcOnDetectUpdate(pBA, reinterpret_cast<BA_ONDETECTUPDATE_ARGS*>(pvArgs), reinterpret_cast<BA_ONDETECTUPDATE_RESULTS*>(pvResults)); | ||
709 | break; | ||
710 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTUPDATECOMPLETE: | ||
711 | hr = BalBaseBAProcOnDetectUpdateComplete(pBA, reinterpret_cast<BA_ONDETECTUPDATECOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONDETECTUPDATECOMPLETE_RESULTS*>(pvResults)); | ||
712 | break; | ||
713 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTRELATEDBUNDLE: | ||
714 | hr = BalBaseBAProcOnDetectRelatedBundle(pBA, reinterpret_cast<BA_ONDETECTRELATEDBUNDLE_ARGS*>(pvArgs), reinterpret_cast<BA_ONDETECTRELATEDBUNDLE_RESULTS*>(pvResults)); | ||
715 | break; | ||
716 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTPACKAGEBEGIN: | ||
717 | hr = BalBaseBAProcOnDetectPackageBegin(pBA, reinterpret_cast<BA_ONDETECTPACKAGEBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONDETECTPACKAGEBEGIN_RESULTS*>(pvResults)); | ||
718 | break; | ||
719 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTRELATEDMSIPACKAGE: | ||
720 | hr = BalBaseBAProcOnDetectRelatedMsiPackage(pBA, reinterpret_cast<BA_ONDETECTRELATEDMSIPACKAGE_ARGS*>(pvArgs), reinterpret_cast<BA_ONDETECTRELATEDMSIPACKAGE_RESULTS*>(pvResults)); | ||
721 | break; | ||
722 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTPATCHTARGET: | ||
723 | hr = BalBaseBAProcOnDetectPatchTarget(pBA, reinterpret_cast<BA_ONDETECTPATCHTARGET_ARGS*>(pvArgs), reinterpret_cast<BA_ONDETECTPATCHTARGET_RESULTS*>(pvResults)); | ||
724 | break; | ||
725 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTMSIFEATURE: | ||
726 | hr = BalBaseBAProcOnDetectMsiFeature(pBA, reinterpret_cast<BA_ONDETECTMSIFEATURE_ARGS*>(pvArgs), reinterpret_cast<BA_ONDETECTMSIFEATURE_RESULTS*>(pvResults)); | ||
727 | break; | ||
728 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTPACKAGECOMPLETE: | ||
729 | hr = BalBaseBAProcOnDetectPackageComplete(pBA, reinterpret_cast<BA_ONDETECTPACKAGECOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONDETECTPACKAGECOMPLETE_RESULTS*>(pvResults)); | ||
730 | break; | ||
731 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANRELATEDBUNDLE: | ||
732 | hr = BalBaseBAProcOnPlanRelatedBundle(pBA, reinterpret_cast<BA_ONPLANRELATEDBUNDLE_ARGS*>(pvArgs), reinterpret_cast<BA_ONPLANRELATEDBUNDLE_RESULTS*>(pvResults)); | ||
733 | break; | ||
734 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANPACKAGEBEGIN: | ||
735 | hr = BalBaseBAProcOnPlanPackageBegin(pBA, reinterpret_cast<BA_ONPLANPACKAGEBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONPLANPACKAGEBEGIN_RESULTS*>(pvResults)); | ||
736 | break; | ||
737 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANPATCHTARGET: | ||
738 | hr = BalBaseBAProcOnPlanPatchTarget(pBA, reinterpret_cast<BA_ONPLANPATCHTARGET_ARGS*>(pvArgs), reinterpret_cast<BA_ONPLANPATCHTARGET_RESULTS*>(pvResults)); | ||
739 | break; | ||
740 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANMSIFEATURE: | ||
741 | hr = BalBaseBAProcOnPlanMsiFeature(pBA, reinterpret_cast<BA_ONPLANMSIFEATURE_ARGS*>(pvArgs), reinterpret_cast<BA_ONPLANMSIFEATURE_RESULTS*>(pvResults)); | ||
742 | break; | ||
743 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANPACKAGECOMPLETE: | ||
744 | hr = BalBaseBAProcOnPlanPackageComplete(pBA, reinterpret_cast<BA_ONPLANPACKAGECOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONPLANPACKAGECOMPLETE_RESULTS*>(pvResults)); | ||
745 | break; | ||
746 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONAPPLYBEGIN: | ||
747 | hr = BalBaseBAProcOnApplyBegin(pBA, reinterpret_cast<BA_ONAPPLYBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONAPPLYBEGIN_RESULTS*>(pvResults)); | ||
748 | break; | ||
749 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONELEVATEBEGIN: | ||
750 | hr = BalBaseBAProcOnElevateBegin(pBA, reinterpret_cast<BA_ONELEVATEBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONELEVATEBEGIN_RESULTS*>(pvResults)); | ||
751 | break; | ||
752 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONELEVATECOMPLETE: | ||
753 | hr = BalBaseBAProcOnElevateComplete(pBA, reinterpret_cast<BA_ONELEVATECOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONELEVATECOMPLETE_RESULTS*>(pvResults)); | ||
754 | break; | ||
755 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONPROGRESS: | ||
756 | hr = BalBaseBAProcOnProgress(pBA, reinterpret_cast<BA_ONPROGRESS_ARGS*>(pvArgs), reinterpret_cast<BA_ONPROGRESS_RESULTS*>(pvResults)); | ||
757 | break; | ||
758 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONERROR: | ||
759 | hr = BalBaseBAProcOnError(pBA, reinterpret_cast<BA_ONERROR_ARGS*>(pvArgs), reinterpret_cast<BA_ONERROR_RESULTS*>(pvResults)); | ||
760 | break; | ||
761 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONREGISTERBEGIN: | ||
762 | hr = BalBaseBAProcOnRegisterBegin(pBA, reinterpret_cast<BA_ONREGISTERBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONREGISTERBEGIN_RESULTS*>(pvResults)); | ||
763 | break; | ||
764 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONREGISTERCOMPLETE: | ||
765 | hr = BalBaseBAProcOnRegisterComplete(pBA, reinterpret_cast<BA_ONREGISTERCOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONREGISTERCOMPLETE_RESULTS*>(pvResults)); | ||
766 | break; | ||
767 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEBEGIN: | ||
768 | hr = BalBaseBAProcOnCacheBegin(pBA, reinterpret_cast<BA_ONCACHEBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHEBEGIN_RESULTS*>(pvResults)); | ||
769 | break; | ||
770 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEPACKAGEBEGIN: | ||
771 | hr = BalBaseBAProcOnCachePackageBegin(pBA, reinterpret_cast<BA_ONCACHEPACKAGEBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHEPACKAGEBEGIN_RESULTS*>(pvResults)); | ||
772 | break; | ||
773 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEACQUIREBEGIN: | ||
774 | hr = BalBaseBAProcOnCacheAcquireBegin(pBA, reinterpret_cast<BA_ONCACHEACQUIREBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHEACQUIREBEGIN_RESULTS*>(pvResults)); | ||
775 | break; | ||
776 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEACQUIREPROGRESS: | ||
777 | hr = BalBaseBAProcOnCacheAcquireProgress(pBA, reinterpret_cast<BA_ONCACHEACQUIREPROGRESS_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHEACQUIREPROGRESS_RESULTS*>(pvResults)); | ||
778 | break; | ||
779 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEACQUIRERESOLVING: | ||
780 | hr = BalBaseBAProcOnCacheAcquireResolving(pBA, reinterpret_cast<BA_ONCACHEACQUIRERESOLVING_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHEACQUIRERESOLVING_RESULTS*>(pvResults)); | ||
781 | break; | ||
782 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEACQUIRECOMPLETE: | ||
783 | hr = BalBaseBAProcOnCacheAcquireComplete(pBA, reinterpret_cast<BA_ONCACHEACQUIRECOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHEACQUIRECOMPLETE_RESULTS*>(pvResults)); | ||
784 | break; | ||
785 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEVERIFYBEGIN: | ||
786 | hr = BalBaseBAProcOnCacheVerifyBegin(pBA, reinterpret_cast<BA_ONCACHEVERIFYBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHEVERIFYBEGIN_RESULTS*>(pvResults)); | ||
787 | break; | ||
788 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEVERIFYPROGRESS: | ||
789 | hr = BalBaseBAProcOnCacheVerifyProgress(pBA, reinterpret_cast<BA_ONCACHEVERIFYPROGRESS_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHEVERIFYPROGRESS_RESULTS*>(pvResults)); | ||
790 | break; | ||
791 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEVERIFYCOMPLETE: | ||
792 | hr = BalBaseBAProcOnCacheVerifyComplete(pBA, reinterpret_cast<BA_ONCACHEVERIFYCOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHEVERIFYCOMPLETE_RESULTS*>(pvResults)); | ||
793 | break; | ||
794 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEPACKAGECOMPLETE: | ||
795 | hr = BalBaseBAProcOnCachePackageComplete(pBA, reinterpret_cast<BA_ONCACHEPACKAGECOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHEPACKAGECOMPLETE_RESULTS*>(pvResults)); | ||
796 | break; | ||
797 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHECOMPLETE: | ||
798 | hr = BalBaseBAProcOnCacheComplete(pBA, reinterpret_cast<BA_ONCACHECOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHECOMPLETE_RESULTS*>(pvResults)); | ||
799 | break; | ||
800 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEBEGIN: | ||
801 | hr = BalBaseBAProcOnExecuteBegin(pBA, reinterpret_cast<BA_ONEXECUTEBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONEXECUTEBEGIN_RESULTS*>(pvResults)); | ||
802 | break; | ||
803 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEPACKAGEBEGIN: | ||
804 | hr = BalBaseBAProcOnExecutePackageBegin(pBA, reinterpret_cast<BA_ONEXECUTEPACKAGEBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONEXECUTEPACKAGEBEGIN_RESULTS*>(pvResults)); | ||
805 | break; | ||
806 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEPATCHTARGET: | ||
807 | hr = BalBaseBAProcOnExecutePatchTarget(pBA, reinterpret_cast<BA_ONEXECUTEPATCHTARGET_ARGS*>(pvArgs), reinterpret_cast<BA_ONEXECUTEPATCHTARGET_RESULTS*>(pvResults)); | ||
808 | break; | ||
809 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEPROGRESS: | ||
810 | hr = BalBaseBAProcOnExecuteProgress(pBA, reinterpret_cast<BA_ONEXECUTEPROGRESS_ARGS*>(pvArgs), reinterpret_cast<BA_ONEXECUTEPROGRESS_RESULTS*>(pvResults)); | ||
811 | break; | ||
812 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEMSIMESSAGE: | ||
813 | hr = BalBaseBAProcOnExecuteMsiMessage(pBA, reinterpret_cast<BA_ONEXECUTEMSIMESSAGE_ARGS*>(pvArgs), reinterpret_cast<BA_ONEXECUTEMSIMESSAGE_RESULTS*>(pvResults)); | ||
814 | break; | ||
815 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEFILESINUSE: | ||
816 | hr = BalBaseBAProcOnExecuteFilesInUse(pBA, reinterpret_cast<BA_ONEXECUTEFILESINUSE_ARGS*>(pvArgs), reinterpret_cast<BA_ONEXECUTEFILESINUSE_RESULTS*>(pvResults)); | ||
817 | break; | ||
818 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEPACKAGECOMPLETE: | ||
819 | hr = BalBaseBAProcOnExecutePackageComplete(pBA, reinterpret_cast<BA_ONEXECUTEPACKAGECOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONEXECUTEPACKAGECOMPLETE_RESULTS*>(pvResults)); | ||
820 | break; | ||
821 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTECOMPLETE: | ||
822 | hr = BalBaseBAProcOnExecuteComplete(pBA, reinterpret_cast<BA_ONEXECUTECOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONEXECUTECOMPLETE_RESULTS*>(pvResults)); | ||
823 | break; | ||
824 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONUNREGISTERBEGIN: | ||
825 | hr = BalBaseBAProcOnUnregisterBegin(pBA, reinterpret_cast<BA_ONUNREGISTERBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONUNREGISTERBEGIN_RESULTS*>(pvResults)); | ||
826 | break; | ||
827 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONUNREGISTERCOMPLETE: | ||
828 | hr = BalBaseBAProcOnUnregisterComplete(pBA, reinterpret_cast<BA_ONUNREGISTERCOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONUNREGISTERCOMPLETE_RESULTS*>(pvResults)); | ||
829 | break; | ||
830 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONAPPLYCOMPLETE: | ||
831 | hr = BalBaseBAProcOnApplyComplete(pBA, reinterpret_cast<BA_ONAPPLYCOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONAPPLYCOMPLETE_RESULTS*>(pvResults)); | ||
832 | break; | ||
833 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONLAUNCHAPPROVEDEXEBEGIN: | ||
834 | hr = BalBaseBAProcOnLaunchApprovedExeBegin(pBA, reinterpret_cast<BA_ONLAUNCHAPPROVEDEXEBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONLAUNCHAPPROVEDEXEBEGIN_RESULTS*>(pvResults)); | ||
835 | break; | ||
836 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONLAUNCHAPPROVEDEXECOMPLETE: | ||
837 | hr = BalBaseBAProcOnLaunchApprovedExeComplete(pBA, reinterpret_cast<BA_ONLAUNCHAPPROVEDEXECOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONLAUNCHAPPROVEDEXECOMPLETE_RESULTS*>(pvResults)); | ||
838 | break; | ||
839 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANMSIPACKAGE: | ||
840 | hr = BalBaseBAProcOnPlanMsiPackage(pBA, reinterpret_cast<BA_ONPLANMSIPACKAGE_ARGS*>(pvArgs), reinterpret_cast<BA_ONPLANMSIPACKAGE_RESULTS*>(pvResults)); | ||
841 | break; | ||
842 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONBEGINMSITRANSACTIONBEGIN: | ||
843 | hr = BalBaseBAProcOnBeginMsiTransactionBegin(pBA, reinterpret_cast<BA_ONBEGINMSITRANSACTIONBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONBEGINMSITRANSACTIONBEGIN_RESULTS*>(pvResults)); | ||
844 | break; | ||
845 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONBEGINMSITRANSACTIONCOMPLETE: | ||
846 | hr = BalBaseBAProcOnBeginMsiTransactionComplete(pBA, reinterpret_cast<BA_ONBEGINMSITRANSACTIONCOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONBEGINMSITRANSACTIONCOMPLETE_RESULTS*>(pvResults)); | ||
847 | break; | ||
848 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONCOMMITMSITRANSACTIONBEGIN: | ||
849 | hr = BalBaseBAProcOnCommitMsiTransactionBegin(pBA, reinterpret_cast<BA_ONCOMMITMSITRANSACTIONBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONCOMMITMSITRANSACTIONBEGIN_RESULTS*>(pvResults)); | ||
850 | break; | ||
851 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONCOMMITMSITRANSACTIONCOMPLETE: | ||
852 | hr = BalBaseBAProcOnCommitMsiTransactionComplete(pBA, reinterpret_cast<BA_ONCOMMITMSITRANSACTIONCOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONCOMMITMSITRANSACTIONCOMPLETE_RESULTS*>(pvResults)); | ||
853 | break; | ||
854 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONROLLBACKMSITRANSACTIONBEGIN: | ||
855 | hr = BalBaseBAProcOnRollbackMsiTransactionBegin(pBA, reinterpret_cast<BA_ONROLLBACKMSITRANSACTIONBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONROLLBACKMSITRANSACTIONBEGIN_RESULTS*>(pvResults)); | ||
856 | break; | ||
857 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONROLLBACKMSITRANSACTIONCOMPLETE: | ||
858 | hr = BalBaseBAProcOnRollbackMsiTransactionComplete(pBA, reinterpret_cast<BA_ONROLLBACKMSITRANSACTIONCOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONROLLBACKMSITRANSACTIONCOMPLETE_RESULTS*>(pvResults)); | ||
859 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONPAUSEAUTOMATICUPDATESBEGIN: | ||
860 | hr = BalBaseBAProcOnPauseAutomaticUpdatesBegin(pBA, reinterpret_cast<BA_ONPAUSEAUTOMATICUPDATESBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONPAUSEAUTOMATICUPDATESBEGIN_RESULTS*>(pvResults)); | ||
861 | break; | ||
862 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONPAUSEAUTOMATICUPDATESCOMPLETE: | ||
863 | hr = BalBaseBAProcOnPauseAutomaticUpdatesComplete(pBA, reinterpret_cast<BA_ONPAUSEAUTOMATICUPDATESCOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONPAUSEAUTOMATICUPDATESCOMPLETE_RESULTS*>(pvResults)); | ||
864 | break; | ||
865 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONSYSTEMRESTOREPOINTBEGIN: | ||
866 | hr = BalBaseBAProcOnSystemRestorePointBegin(pBA, reinterpret_cast<BA_ONSYSTEMRESTOREPOINTBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONSYSTEMRESTOREPOINTBEGIN_RESULTS*>(pvResults)); | ||
867 | break; | ||
868 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONSYSTEMRESTOREPOINTCOMPLETE: | ||
869 | hr = BalBaseBAProcOnSystemRestorePointComplete(pBA, reinterpret_cast<BA_ONSYSTEMRESTOREPOINTCOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONSYSTEMRESTOREPOINTCOMPLETE_RESULTS*>(pvResults)); | ||
870 | break; | ||
871 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANNEDPACKAGE: | ||
872 | hr = BalBaseBAProcOnPlannedPackage(pBA, reinterpret_cast<BA_ONPLANNEDPACKAGE_ARGS*>(pvArgs), reinterpret_cast<BA_ONPLANNEDPACKAGE_RESULTS*>(pvResults)); | ||
873 | break; | ||
874 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANFORWARDCOMPATIBLEBUNDLE: | ||
875 | hr = BalBaseBAProcOnPlanForwardCompatibleBundle(pBA, reinterpret_cast<BA_ONPLANFORWARDCOMPATIBLEBUNDLE_ARGS*>(pvArgs), reinterpret_cast<BA_ONPLANFORWARDCOMPATIBLEBUNDLE_RESULTS*>(pvResults)); | ||
876 | break; | ||
877 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHECONTAINERORPAYLOADVERIFYBEGIN: | ||
878 | hr = BalBaseBAProcOnCacheContainerOrPayloadVerifyBegin(pBA, reinterpret_cast<BA_ONCACHECONTAINERORPAYLOADVERIFYBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHECONTAINERORPAYLOADVERIFYBEGIN_RESULTS*>(pvResults)); | ||
879 | break; | ||
880 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHECONTAINERORPAYLOADVERIFYPROGRESS: | ||
881 | hr = BalBaseBAProcOnCacheContainerOrPayloadVerifyProgress(pBA, reinterpret_cast<BA_ONCACHECONTAINERORPAYLOADVERIFYPROGRESS_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHECONTAINERORPAYLOADVERIFYPROGRESS_RESULTS*>(pvResults)); | ||
882 | break; | ||
883 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHECONTAINERORPAYLOADVERIFYCOMPLETE: | ||
884 | hr = BalBaseBAProcOnCacheContainerOrPayloadVerifyComplete(pBA, reinterpret_cast<BA_ONCACHECONTAINERORPAYLOADVERIFYCOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHECONTAINERORPAYLOADVERIFYCOMPLETE_RESULTS*>(pvResults)); | ||
885 | break; | ||
886 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEPAYLOADEXTRACTBEGIN: | ||
887 | hr = BalBaseBAProcOnCachePayloadExtractBegin(pBA, reinterpret_cast<BA_ONCACHEPAYLOADEXTRACTBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHEPAYLOADEXTRACTBEGIN_RESULTS*>(pvResults)); | ||
888 | break; | ||
889 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEPAYLOADEXTRACTPROGRESS: | ||
890 | hr = BalBaseBAProcOnCachePayloadExtractProgress(pBA, reinterpret_cast<BA_ONCACHEPAYLOADEXTRACTPROGRESS_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHEPAYLOADEXTRACTPROGRESS_RESULTS*>(pvResults)); | ||
891 | break; | ||
892 | case BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEPAYLOADEXTRACTCOMPLETE: | ||
893 | hr = BalBaseBAProcOnCachePayloadExtractComplete(pBA, reinterpret_cast<BA_ONCACHEPAYLOADEXTRACTCOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHEPAYLOADEXTRACTCOMPLETE_RESULTS*>(pvResults)); | ||
894 | break; | ||
895 | } | ||
896 | } | ||
897 | |||
898 | pBA->BAProcFallback(message, pvArgs, pvResults, &hr, pvContext); | ||
899 | |||
900 | return hr; | ||
901 | } | ||
diff --git a/src/api/burn/balutil/inc/BalBootstrapperEngine.h b/src/api/burn/balutil/inc/BalBootstrapperEngine.h new file mode 100644 index 00000000..45131d98 --- /dev/null +++ b/src/api/burn/balutil/inc/BalBootstrapperEngine.h | |||
@@ -0,0 +1,17 @@ | |||
1 | // Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. | ||
2 | |||
3 | #ifdef __cplusplus | ||
4 | extern "C" { | ||
5 | #endif | ||
6 | |||
7 | // function declarations | ||
8 | |||
9 | HRESULT BalBootstrapperEngineCreate( | ||
10 | __in PFN_BOOTSTRAPPER_ENGINE_PROC pfnBAEngineProc, | ||
11 | __in_opt LPVOID pvBAEngineProcContext, | ||
12 | __out IBootstrapperEngine** ppEngineForApplication | ||
13 | ); | ||
14 | |||
15 | #ifdef __cplusplus | ||
16 | } | ||
17 | #endif | ||
diff --git a/src/api/burn/balutil/inc/IBAFunctions.h b/src/api/burn/balutil/inc/IBAFunctions.h new file mode 100644 index 00000000..7d8a07fa --- /dev/null +++ b/src/api/burn/balutil/inc/IBAFunctions.h | |||
@@ -0,0 +1,34 @@ | |||
1 | #pragma once | ||
2 | // Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. | ||
3 | |||
4 | |||
5 | DECLARE_INTERFACE_IID_(IBAFunctions, IBootstrapperApplication, "0FB445ED-17BD-49C7-BE19-479776F8AE96") | ||
6 | { | ||
7 | // OnThemeLoaded - Called after the BA finished loading all the controls for the theme. | ||
8 | // | ||
9 | STDMETHOD(OnThemeLoaded)( | ||
10 | THEME* pTheme, | ||
11 | WIX_LOCALIZATION* pWixLoc | ||
12 | ) = 0; | ||
13 | |||
14 | // WndProc - Called if the BA hasn't handled the message. | ||
15 | // The implementation must either return E_NOTIMPL or call ThemeDefWindowProc for unhandled messages. | ||
16 | // | ||
17 | STDMETHOD(WndProc)( | ||
18 | __in THEME* pTheme, | ||
19 | __in HWND hWnd, | ||
20 | __in UINT uMsg, | ||
21 | __in WPARAM wParam, | ||
22 | __in LPARAM lParam, | ||
23 | __inout LRESULT* plRes | ||
24 | ) = 0; | ||
25 | |||
26 | // BAFunctionsProc - The PFN_BA_FUNCTIONS_PROC can call this method to give the BAFunctions raw access to the callback from WixStdBA. | ||
27 | // This might be used to help the BAFunctions support more than one version of the engine/WixStdBA. | ||
28 | STDMETHOD(BAFunctionsProc)( | ||
29 | __in BA_FUNCTIONS_MESSAGE message, | ||
30 | __in const LPVOID pvArgs, | ||
31 | __inout LPVOID pvResults, | ||
32 | __in_opt LPVOID pvContext | ||
33 | ) = 0; | ||
34 | }; | ||
diff --git a/src/api/burn/balutil/inc/IBootstrapperApplication.h b/src/api/burn/balutil/inc/IBootstrapperApplication.h new file mode 100644 index 00000000..c284cb49 --- /dev/null +++ b/src/api/burn/balutil/inc/IBootstrapperApplication.h | |||
@@ -0,0 +1,649 @@ | |||
1 | #pragma once | ||
2 | // Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. | ||
3 | |||
4 | |||
5 | DECLARE_INTERFACE_IID_(IBootstrapperApplication, IUnknown, "53C31D56-49C0-426B-AB06-099D717C67FE") | ||
6 | { | ||
7 | // BAProc - The PFN_BOOTSTRAPPER_APPLICATION_PROC can call this method to give the BA raw access to the callback from the engine. | ||
8 | // This might be used to help the BA support more than one version of the engine. | ||
9 | STDMETHOD(BAProc)( | ||
10 | __in BOOTSTRAPPER_APPLICATION_MESSAGE message, | ||
11 | __in const LPVOID pvArgs, | ||
12 | __inout LPVOID pvResults, | ||
13 | __in_opt LPVOID pvContext | ||
14 | ) = 0; | ||
15 | |||
16 | // BAProcFallback - The PFN_BOOTSTRAPPER_APPLICATION_PROC can call this method | ||
17 | // to give the BA the ability to use default behavior | ||
18 | // and then forward the message to extensions. | ||
19 | STDMETHOD_(void, BAProcFallback)( | ||
20 | __in BOOTSTRAPPER_APPLICATION_MESSAGE message, | ||
21 | __in const LPVOID pvArgs, | ||
22 | __inout LPVOID pvResults, | ||
23 | __inout HRESULT* phr, | ||
24 | __in_opt LPVOID pvContext | ||
25 | ) = 0; | ||
26 | |||
27 | // OnStartup - called when the engine is ready for the bootstrapper application to start. | ||
28 | // | ||
29 | STDMETHOD(OnStartup)() = 0; | ||
30 | |||
31 | // OnShutdown - called after the bootstrapper application quits the engine. | ||
32 | STDMETHOD(OnShutdown)( | ||
33 | __inout BOOTSTRAPPER_SHUTDOWN_ACTION* pAction | ||
34 | ) = 0; | ||
35 | |||
36 | // OnSystemShutdown - called when the operating system is instructed to shutdown the machine. | ||
37 | STDMETHOD(OnSystemShutdown)( | ||
38 | __in DWORD dwEndSession, | ||
39 | __inout BOOL* pfCancel | ||
40 | ) = 0; | ||
41 | |||
42 | // OnDetectBegin - called when the engine begins detection. | ||
43 | STDMETHOD(OnDetectBegin)( | ||
44 | __in BOOL fCached, | ||
45 | __in BOOL fInstalled, | ||
46 | __in DWORD cPackages, | ||
47 | __inout BOOL* pfCancel | ||
48 | ) = 0; | ||
49 | |||
50 | // OnDetectForwardCompatibleBundle - called when the engine detects a forward compatible bundle. | ||
51 | STDMETHOD(OnDetectForwardCompatibleBundle)( | ||
52 | __in_z LPCWSTR wzBundleId, | ||
53 | __in BOOTSTRAPPER_RELATION_TYPE relationType, | ||
54 | __in_z LPCWSTR wzBundleTag, | ||
55 | __in BOOL fPerMachine, | ||
56 | __in_z LPCWSTR wzVersion, | ||
57 | __in BOOL fMissingFromCache, | ||
58 | __inout BOOL* pfCancel | ||
59 | ) = 0; | ||
60 | |||
61 | // OnDetectUpdateBegin - called when the engine begins detection for bundle update. | ||
62 | STDMETHOD(OnDetectUpdateBegin)( | ||
63 | __in_z LPCWSTR wzUpdateLocation, | ||
64 | __inout BOOL* pfCancel, | ||
65 | __inout BOOL* pfSkip | ||
66 | ) = 0; | ||
67 | |||
68 | // OnDetectUpdate - called when the engine has an update candidate for bundle update. | ||
69 | STDMETHOD(OnDetectUpdate)( | ||
70 | __in_z_opt LPCWSTR wzUpdateLocation, | ||
71 | __in DWORD64 dw64Size, | ||
72 | __in_z LPCWSTR wzVersion, | ||
73 | __in_z_opt LPCWSTR wzTitle, | ||
74 | __in_z_opt LPCWSTR wzSummary, | ||
75 | __in_z_opt LPCWSTR wzContentType, | ||
76 | __in_z_opt LPCWSTR wzContent, | ||
77 | __inout BOOL* pfCancel, | ||
78 | __inout BOOL* pfStopProcessingUpdates | ||
79 | ) = 0; | ||
80 | |||
81 | // OnDetectUpdateComplete - called when the engine completes detection for bundle update. | ||
82 | STDMETHOD(OnDetectUpdateComplete)( | ||
83 | __in HRESULT hrStatus, | ||
84 | __inout BOOL* pfIgnoreError | ||
85 | ) = 0; | ||
86 | |||
87 | // OnDetectRelatedBundle - called when the engine detects a related bundle. | ||
88 | STDMETHOD(OnDetectRelatedBundle)( | ||
89 | __in_z LPCWSTR wzBundleId, | ||
90 | __in BOOTSTRAPPER_RELATION_TYPE relationType, | ||
91 | __in_z LPCWSTR wzBundleTag, | ||
92 | __in BOOL fPerMachine, | ||
93 | __in_z LPCWSTR wzVersion, | ||
94 | __in BOOTSTRAPPER_RELATED_OPERATION operation, | ||
95 | __in BOOL fMissingFromCache, | ||
96 | __inout BOOL* pfCancel | ||
97 | ) = 0; | ||
98 | |||
99 | // OnDetectPackageBegin - called when the engine begins detecting a package. | ||
100 | STDMETHOD(OnDetectPackageBegin)( | ||
101 | __in_z LPCWSTR wzPackageId, | ||
102 | __inout BOOL* pfCancel | ||
103 | ) = 0; | ||
104 | |||
105 | // OnDetectRelatedMsiPackage - called when the engine begins detects a related package. | ||
106 | STDMETHOD(OnDetectRelatedMsiPackage)( | ||
107 | __in_z LPCWSTR wzPackageId, | ||
108 | __in_z LPCWSTR wzUpgradeCode, | ||
109 | __in_z LPCWSTR wzProductCode, | ||
110 | __in BOOL fPerMachine, | ||
111 | __in_z LPCWSTR wzVersion, | ||
112 | __in BOOTSTRAPPER_RELATED_OPERATION operation, | ||
113 | __inout BOOL* pfCancel | ||
114 | ) = 0; | ||
115 | |||
116 | // OnDetectPatchTarget - called when the engine detects a target product | ||
117 | // for an MSP package. | ||
118 | STDMETHOD(OnDetectPatchTarget)( | ||
119 | __in_z LPCWSTR wzPackageId, | ||
120 | __in_z LPCWSTR wzProductCode, | ||
121 | __in BOOTSTRAPPER_PACKAGE_STATE patchState, | ||
122 | __inout BOOL* pfCancel | ||
123 | ) = 0; | ||
124 | |||
125 | // OnDetectMsiFeature - called when the engine detects a feature in an MSI package. | ||
126 | STDMETHOD(OnDetectMsiFeature)( | ||
127 | __in_z LPCWSTR wzPackageId, | ||
128 | __in_z LPCWSTR wzFeatureId, | ||
129 | __in BOOTSTRAPPER_FEATURE_STATE state, | ||
130 | __inout BOOL* pfCancel | ||
131 | ) = 0; | ||
132 | |||
133 | // OnDetectPackageComplete - called after the engine detects a package. | ||
134 | // | ||
135 | STDMETHOD(OnDetectPackageComplete)( | ||
136 | __in_z LPCWSTR wzPackageId, | ||
137 | __in HRESULT hrStatus, | ||
138 | __in BOOTSTRAPPER_PACKAGE_STATE state, | ||
139 | __in BOOL fCached | ||
140 | ) = 0; | ||
141 | |||
142 | // OnDetectPackageComplete - called after the engine completes detection. | ||
143 | // | ||
144 | STDMETHOD(OnDetectComplete)( | ||
145 | __in HRESULT hrStatus, | ||
146 | __in BOOL fEligibleForCleanup | ||
147 | ) = 0; | ||
148 | |||
149 | // OnPlanBegin - called when the engine begins planning. | ||
150 | STDMETHOD(OnPlanBegin)( | ||
151 | __in DWORD cPackages, | ||
152 | __inout BOOL* pfCancel | ||
153 | ) = 0; | ||
154 | |||
155 | // OnPlanRelatedBundle - called when the engine begins planning a related bundle. | ||
156 | STDMETHOD(OnPlanRelatedBundle)( | ||
157 | __in_z LPCWSTR wzBundleId, | ||
158 | __in BOOTSTRAPPER_REQUEST_STATE recommendedState, | ||
159 | __inout BOOTSTRAPPER_REQUEST_STATE* pRequestedState, | ||
160 | __inout BOOL* pfCancel | ||
161 | ) = 0; | ||
162 | |||
163 | // OnPlanPackageBegin - called when the engine has begun getting the BA's input | ||
164 | // for planning a package. | ||
165 | STDMETHOD(OnPlanPackageBegin)( | ||
166 | __in_z LPCWSTR wzPackageId, | ||
167 | __in BOOTSTRAPPER_PACKAGE_STATE state, | ||
168 | __in BOOL fCached, | ||
169 | __in BOOTSTRAPPER_PACKAGE_CONDITION_RESULT installCondition, | ||
170 | __in BOOTSTRAPPER_REQUEST_STATE recommendedState, | ||
171 | __in BOOTSTRAPPER_CACHE_TYPE recommendedCacheType, | ||
172 | __inout BOOTSTRAPPER_REQUEST_STATE* pRequestedState, | ||
173 | __inout BOOTSTRAPPER_CACHE_TYPE* pRequestedCacheType, | ||
174 | __inout BOOL* pfCancel | ||
175 | ) = 0; | ||
176 | |||
177 | // OnPlanPatchTarget - called when the engine is about to plan a target | ||
178 | // of an MSP package. | ||
179 | STDMETHOD(OnPlanPatchTarget)( | ||
180 | __in_z LPCWSTR wzPackageId, | ||
181 | __in_z LPCWSTR wzProductCode, | ||
182 | __in BOOTSTRAPPER_REQUEST_STATE recommendedState, | ||
183 | __inout BOOTSTRAPPER_REQUEST_STATE* pRequestedState, | ||
184 | __inout BOOL* pfCancel | ||
185 | ) = 0; | ||
186 | |||
187 | // OnPlanMsiFeature - called when the engine plans a feature in an | ||
188 | // MSI package. | ||
189 | STDMETHOD(OnPlanMsiFeature)( | ||
190 | __in_z LPCWSTR wzPackageId, | ||
191 | __in_z LPCWSTR wzFeatureId, | ||
192 | __in BOOTSTRAPPER_FEATURE_STATE recommendedState, | ||
193 | __inout BOOTSTRAPPER_FEATURE_STATE* pRequestedState, | ||
194 | __inout BOOL* pfCancel | ||
195 | ) = 0; | ||
196 | |||
197 | // OnPlanMsiPackage - called when the engine plans an MSI or MSP package. | ||
198 | // | ||
199 | STDMETHOD(OnPlanMsiPackage)( | ||
200 | __in_z LPCWSTR wzPackageId, | ||
201 | __in BOOL fExecute, // false means rollback. | ||
202 | __in BOOTSTRAPPER_ACTION_STATE action, | ||
203 | __inout BOOL* pfCancel, | ||
204 | __inout BURN_MSI_PROPERTY* pActionMsiProperty, | ||
205 | __inout INSTALLUILEVEL* pUiLevel, | ||
206 | __inout BOOL* pfDisableExternalUiHandler | ||
207 | ) = 0; | ||
208 | |||
209 | // OnPlanPackageComplete - called after the engine has completed getting the BA's input | ||
210 | // for planning a package. | ||
211 | STDMETHOD(OnPlanPackageComplete)( | ||
212 | __in_z LPCWSTR wzPackageId, | ||
213 | __in HRESULT hrStatus, | ||
214 | __in BOOTSTRAPPER_REQUEST_STATE requested | ||
215 | ) = 0; | ||
216 | |||
217 | // OnPlannedPackage - called after the engine has completed planning a package. | ||
218 | STDMETHOD(OnPlannedPackage)( | ||
219 | __in_z LPCWSTR wzPackageId, | ||
220 | __in BOOTSTRAPPER_ACTION_STATE execute, | ||
221 | __in BOOTSTRAPPER_ACTION_STATE rollback, | ||
222 | __in BOOL fPlannedCache, | ||
223 | __in BOOL fPlannedUncache | ||
224 | ) = 0; | ||
225 | |||
226 | // OnPlanComplete - called when the engine completes planning. | ||
227 | // | ||
228 | STDMETHOD(OnPlanComplete)( | ||
229 | __in HRESULT hrStatus | ||
230 | ) = 0; | ||
231 | |||
232 | // OnApplyBegin - called when the engine begins applying the plan. | ||
233 | // | ||
234 | STDMETHOD(OnApplyBegin)( | ||
235 | __in DWORD dwPhaseCount, | ||
236 | __inout BOOL* pfCancel | ||
237 | ) = 0; | ||
238 | |||
239 | // OnElevateBegin - called before the engine displays an elevation prompt. | ||
240 | // Will only happen once per execution of the engine, | ||
241 | // assuming the elevation was successful. | ||
242 | STDMETHOD(OnElevateBegin)( | ||
243 | __inout BOOL* pfCancel | ||
244 | ) = 0; | ||
245 | |||
246 | // OnElevateComplete - called after the engine attempted to elevate. | ||
247 | // | ||
248 | STDMETHOD(OnElevateComplete)( | ||
249 | __in HRESULT hrStatus | ||
250 | ) = 0; | ||
251 | |||
252 | // OnProgress - called when the engine makes progress. | ||
253 | // | ||
254 | STDMETHOD(OnProgress)( | ||
255 | __in DWORD dwProgressPercentage, | ||
256 | __in DWORD dwOverallPercentage, | ||
257 | __inout BOOL* pfCancel | ||
258 | ) = 0; | ||
259 | |||
260 | // OnError - called when the engine encounters an error. | ||
261 | // | ||
262 | // nResult: | ||
263 | // uiFlags is a combination of valid ID* return values appropriate for | ||
264 | // the error. | ||
265 | // | ||
266 | // IDNOACTION instructs the engine to pass the error through to default | ||
267 | // handling which usually results in the apply failing. | ||
268 | STDMETHOD(OnError)( | ||
269 | __in BOOTSTRAPPER_ERROR_TYPE errorType, | ||
270 | __in_z_opt LPCWSTR wzPackageId, | ||
271 | __in DWORD dwCode, | ||
272 | __in_z_opt LPCWSTR wzError, | ||
273 | __in DWORD dwUIHint, | ||
274 | __in DWORD cData, | ||
275 | __in_ecount_z_opt(cData) LPCWSTR* rgwzData, | ||
276 | __in int nRecommendation, | ||
277 | __inout int* pResult | ||
278 | ) = 0; | ||
279 | |||
280 | // OnRegisterBegin - called when the engine registers the bundle. | ||
281 | // | ||
282 | STDMETHOD(OnRegisterBegin)( | ||
283 | __inout BOOL* pfCancel | ||
284 | ) = 0; | ||
285 | |||
286 | // OnRegisterComplete - called when the engine registration is | ||
287 | // complete. | ||
288 | // | ||
289 | STDMETHOD(OnRegisterComplete)( | ||
290 | __in HRESULT hrStatus | ||
291 | ) = 0; | ||
292 | |||
293 | // OnCacheBegin - called when the engine begins caching. | ||
294 | // | ||
295 | STDMETHOD(OnCacheBegin)( | ||
296 | __inout BOOL* pfCancel | ||
297 | ) = 0; | ||
298 | |||
299 | // OnCachePackageBegin - called when the engine begins caching | ||
300 | // a package. | ||
301 | // | ||
302 | STDMETHOD(OnCachePackageBegin)( | ||
303 | __in_z LPCWSTR wzPackageId, | ||
304 | __in DWORD cCachePayloads, | ||
305 | __in DWORD64 dw64PackageCacheSize, | ||
306 | __inout BOOL* pfCancel | ||
307 | ) = 0; | ||
308 | |||
309 | // OnCacheAcquireBegin - called when the engine begins acquiring a payload or container. | ||
310 | // | ||
311 | // Notes: | ||
312 | // It is expected the BA may call IBootstrapperEngine::SetLocalSource() or IBootstrapperEngine::SetDownloadSource() | ||
313 | // to update the source location before returning. | ||
314 | // | ||
315 | STDMETHOD(OnCacheAcquireBegin)( | ||
316 | __in_z_opt LPCWSTR wzPackageOrContainerId, | ||
317 | __in_z_opt LPCWSTR wzPayloadId, | ||
318 | __in_z LPCWSTR wzSource, | ||
319 | __in_z_opt LPCWSTR wzDownloadUrl, | ||
320 | __in_z_opt LPCWSTR wzPayloadContainerId, | ||
321 | __in BOOTSTRAPPER_CACHE_OPERATION recommendation, | ||
322 | __inout BOOTSTRAPPER_CACHE_OPERATION* pAction, | ||
323 | __inout BOOL* pfCancel | ||
324 | ) = 0; | ||
325 | |||
326 | // OnCacheAcquireProgress - called when the engine makes progress acquiring the payload or container. | ||
327 | // | ||
328 | STDMETHOD(OnCacheAcquireProgress)( | ||
329 | __in_z_opt LPCWSTR wzPackageOrContainerId, | ||
330 | __in_z_opt LPCWSTR wzPayloadId, | ||
331 | __in DWORD64 dw64Progress, | ||
332 | __in DWORD64 dw64Total, | ||
333 | __in DWORD dwOverallPercentage, | ||
334 | __inout BOOL* pfCancel | ||
335 | ) = 0; | ||
336 | |||
337 | // OnCacheAcquireResolving - called to allow the BA to override the acquisition action for the payload or container. | ||
338 | // | ||
339 | // Parameters: | ||
340 | // wzPackageOrContainerId will be NULL when resolving a layout-only payload. | ||
341 | // wzPayloadId will be NULL when resolving a container. | ||
342 | // wzDownloadUrl will be NULL if the container or payload does not provide a DownloadURL. | ||
343 | // wzPayloadContainerId will not be NULL if acquiring a payload that is in a container. | ||
344 | // | ||
345 | // rgSearchPaths are the search paths used for source resolution. | ||
346 | // fFoundLocal is TRUE when dwRecommendedSearchPath indicates that the file was found. | ||
347 | // dwRecommendedSearchPath is the index into rgSearchPaths for the recommended local file. | ||
348 | // | ||
349 | STDMETHOD(OnCacheAcquireResolving)( | ||
350 | __in_z_opt LPCWSTR wzPackageOrContainerId, | ||
351 | __in_z_opt LPCWSTR wzPayloadId, | ||
352 | __in_z LPCWSTR* rgSearchPaths, | ||
353 | __in DWORD cSearchPaths, | ||
354 | __in BOOL fFoundLocal, | ||
355 | __in DWORD dwRecommendedSearchPath, | ||
356 | __in_z_opt LPCWSTR wzDownloadUrl, | ||
357 | __in_z_opt LPCWSTR wzPayloadContainerId, | ||
358 | __in BOOTSTRAPPER_CACHE_RESOLVE_OPERATION recommendation, | ||
359 | __inout DWORD* pdwChosenSearchPath, | ||
360 | __inout BOOTSTRAPPER_CACHE_RESOLVE_OPERATION* pAction, | ||
361 | __inout BOOL* pfCancel | ||
362 | ) = 0; | ||
363 | |||
364 | // OnCacheAcquireComplete - called after the engine acquired the payload or container. | ||
365 | // | ||
366 | // Notes: | ||
367 | // It is expected the BA may call IBootstrapperEngine::SetLocalSource() or IBootstrapperEngine::SetDownloadSource() | ||
368 | // to update the source location before returning BOOTSTRAPPER_CACHEACQUIRECOMPLETE_ACTION_RETRY. | ||
369 | // | ||
370 | STDMETHOD(OnCacheAcquireComplete)( | ||
371 | __in_z_opt LPCWSTR wzPackageOrContainerId, | ||
372 | __in_z_opt LPCWSTR wzPayloadId, | ||
373 | __in HRESULT hrStatus, | ||
374 | __in BOOTSTRAPPER_CACHEACQUIRECOMPLETE_ACTION recommendation, | ||
375 | __inout BOOTSTRAPPER_CACHEACQUIRECOMPLETE_ACTION* pAction | ||
376 | ) = 0; | ||
377 | |||
378 | // OnCacheVerifyBegin - called when the engine begins to verify then copy | ||
379 | // a payload or container to the package cache folder. | ||
380 | // | ||
381 | STDMETHOD(OnCacheVerifyBegin)( | ||
382 | __in_z_opt LPCWSTR wzPackageOrContainerId, | ||
383 | __in_z_opt LPCWSTR wzPayloadId, | ||
384 | __inout BOOL* pfCancel | ||
385 | ) = 0; | ||
386 | |||
387 | STDMETHOD(OnCacheVerifyProgress)( | ||
388 | __in_z_opt LPCWSTR wzPackageOrContainerId, | ||
389 | __in_z_opt LPCWSTR wzPayloadId, | ||
390 | __in DWORD64 dw64Progress, | ||
391 | __in DWORD64 dw64Total, | ||
392 | __in DWORD dwOverallPercentage, | ||
393 | __in BOOTSTRAPPER_CACHE_VERIFY_STEP verifyStep, | ||
394 | __inout BOOL* pfCancel | ||
395 | ) = 0; | ||
396 | |||
397 | // OnCacheVerifyComplete - called after the engine verifies and copies | ||
398 | // a payload or container to the package cache folder. | ||
399 | // | ||
400 | STDMETHOD(OnCacheVerifyComplete)( | ||
401 | __in_z_opt LPCWSTR wzPackageOrContainerId, | ||
402 | __in_z_opt LPCWSTR wzPayloadId, | ||
403 | __in HRESULT hrStatus, | ||
404 | __in BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION recommendation, | ||
405 | __inout BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION* pAction | ||
406 | ) = 0; | ||
407 | |||
408 | // OnCachePackageComplete - called after the engine attempts to copy or download all | ||
409 | // payloads of a package into the package cache folder. | ||
410 | // | ||
411 | STDMETHOD(OnCachePackageComplete)( | ||
412 | __in_z LPCWSTR wzPackageId, | ||
413 | __in HRESULT hrStatus, | ||
414 | __in BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION recommendation, | ||
415 | __inout BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION* pAction | ||
416 | ) = 0; | ||
417 | |||
418 | // OnCacheComplete - called when the engine caching is complete. | ||
419 | // | ||
420 | STDMETHOD(OnCacheComplete)( | ||
421 | __in HRESULT hrStatus | ||
422 | ) = 0; | ||
423 | |||
424 | // OnExecuteBegin - called when the engine begins executing the plan. | ||
425 | // | ||
426 | STDMETHOD(OnExecuteBegin)( | ||
427 | __in DWORD cExecutingPackages, | ||
428 | __inout BOOL* pfCancel | ||
429 | ) = 0; | ||
430 | |||
431 | // OnExecutePackageBegin - called when the engine begins executing a package. | ||
432 | // | ||
433 | STDMETHOD(OnExecutePackageBegin)( | ||
434 | __in_z LPCWSTR wzPackageId, | ||
435 | __in BOOL fExecute, // false means rollback. | ||
436 | __in BOOTSTRAPPER_ACTION_STATE action, | ||
437 | __in INSTALLUILEVEL uiLevel, | ||
438 | __in BOOL fDisableExternalUiHandler, | ||
439 | __inout BOOL* pfCancel | ||
440 | ) = 0; | ||
441 | |||
442 | // OnExecutePatchTarget - called for each patch in an MspPackage targeting the product | ||
443 | // when the engine begins executing the MspPackage. | ||
444 | // | ||
445 | STDMETHOD(OnExecutePatchTarget)( | ||
446 | __in_z LPCWSTR wzPackageId, | ||
447 | __in_z LPCWSTR wzTargetProductCode, | ||
448 | __inout BOOL* pfCancel | ||
449 | ) = 0; | ||
450 | |||
451 | // OnExecuteProgress - called when the engine makes progress executing a package. | ||
452 | // | ||
453 | STDMETHOD(OnExecuteProgress)( | ||
454 | __in_z LPCWSTR wzPackageId, | ||
455 | __in DWORD dwProgressPercentage, | ||
456 | __in DWORD dwOverallPercentage, | ||
457 | __inout BOOL* pfCancel | ||
458 | ) = 0; | ||
459 | |||
460 | // OnExecuteMsiMessage - called when the engine receives an MSI package message. | ||
461 | // | ||
462 | // Return: | ||
463 | // uiFlags is a combination of valid ID* return values appropriate for | ||
464 | // the message. | ||
465 | // | ||
466 | // IDNOACTION instructs the engine to pass the message through to default | ||
467 | // handling which usually results in the execution continuing. | ||
468 | STDMETHOD(OnExecuteMsiMessage)( | ||
469 | __in_z LPCWSTR wzPackageId, | ||
470 | __in INSTALLMESSAGE messageType, | ||
471 | __in DWORD dwUIHint, | ||
472 | __in_z LPCWSTR wzMessage, | ||
473 | __in DWORD cData, | ||
474 | __in_ecount_z_opt(cData) LPCWSTR* rgwzData, | ||
475 | __in int nRecommendation, | ||
476 | __inout int* pResult | ||
477 | ) = 0; | ||
478 | |||
479 | // OnExecuteFilesInUse - called when the engine encounters files in use while | ||
480 | // executing a package. | ||
481 | // | ||
482 | // Return: | ||
483 | // IDOK instructs the engine to let the Restart Manager attempt to close the | ||
484 | // applications to avoid a restart. | ||
485 | // | ||
486 | // IDCANCEL instructs the engine to abort the execution and start rollback. | ||
487 | // | ||
488 | // IDIGNORE instructs the engine to ignore the running applications. A restart will be | ||
489 | // required. | ||
490 | // | ||
491 | // IDRETRY instructs the engine to check if the applications are still running again. | ||
492 | // | ||
493 | // IDNOACTION is equivalent to ignoring the running applications. A restart will be | ||
494 | // required. | ||
495 | STDMETHOD(OnExecuteFilesInUse)( | ||
496 | __in_z LPCWSTR wzPackageId, | ||
497 | __in DWORD cFiles, | ||
498 | __in_ecount_z(cFiles) LPCWSTR* rgwzFiles, | ||
499 | __in int nRecommendation, | ||
500 | __inout int* pResult | ||
501 | ) = 0; | ||
502 | |||
503 | // OnExecutePackageComplete - called when a package execution is complete. | ||
504 | // | ||
505 | STDMETHOD(OnExecutePackageComplete)( | ||
506 | __in_z LPCWSTR wzPackageId, | ||
507 | __in HRESULT hrStatus, | ||
508 | __in BOOTSTRAPPER_APPLY_RESTART restart, | ||
509 | __in BOOTSTRAPPER_EXECUTEPACKAGECOMPLETE_ACTION recommendation, | ||
510 | __inout BOOTSTRAPPER_EXECUTEPACKAGECOMPLETE_ACTION* pAction | ||
511 | ) = 0; | ||
512 | |||
513 | // OnExecuteComplete - called when the engine execution is complete. | ||
514 | // | ||
515 | STDMETHOD(OnExecuteComplete)( | ||
516 | __in HRESULT hrStatus | ||
517 | ) = 0; | ||
518 | |||
519 | // OnUnregisterBegin - called when the engine unregisters the bundle. | ||
520 | // | ||
521 | STDMETHOD(OnUnregisterBegin)( | ||
522 | __in BOOL fKeepRegistration, | ||
523 | __inout BOOL* pfForceKeepRegistration | ||
524 | ) = 0; | ||
525 | |||
526 | // OnUnregisterComplete - called when the engine unregistration is complete. | ||
527 | // | ||
528 | STDMETHOD(OnUnregisterComplete)( | ||
529 | __in HRESULT hrStatus | ||
530 | ) = 0; | ||
531 | |||
532 | // OnApplyComplete - called after the plan has been applied. | ||
533 | // | ||
534 | STDMETHOD(OnApplyComplete)( | ||
535 | __in HRESULT hrStatus, | ||
536 | __in BOOTSTRAPPER_APPLY_RESTART restart, | ||
537 | __in BOOTSTRAPPER_APPLYCOMPLETE_ACTION recommendation, | ||
538 | __inout BOOTSTRAPPER_APPLYCOMPLETE_ACTION* pAction | ||
539 | ) = 0; | ||
540 | |||
541 | // OnLaunchApprovedExeBegin - called before trying to launch the preapproved executable. | ||
542 | // | ||
543 | STDMETHOD(OnLaunchApprovedExeBegin)( | ||
544 | __inout BOOL* pfCancel | ||
545 | ) = 0; | ||
546 | |||
547 | // OnLaunchApprovedExeComplete - called after trying to launch the preapproved executable. | ||
548 | // | ||
549 | STDMETHOD(OnLaunchApprovedExeComplete)( | ||
550 | __in HRESULT hrStatus, | ||
551 | __in DWORD dwProcessId | ||
552 | ) = 0; | ||
553 | |||
554 | STDMETHOD(OnBeginMsiTransactionBegin)( | ||
555 | __in_z LPCWSTR wzTransactionId, | ||
556 | __inout BOOL* pfCancel | ||
557 | ) = 0; | ||
558 | |||
559 | STDMETHOD(OnBeginMsiTransactionComplete)( | ||
560 | __in_z LPCWSTR wzTransactionId, | ||
561 | __in HRESULT hrStatus | ||
562 | ) = 0; | ||
563 | |||
564 | STDMETHOD(OnCommitMsiTransactionBegin)( | ||
565 | __in_z LPCWSTR wzTransactionId, | ||
566 | __inout BOOL* pfCancel | ||
567 | ) = 0; | ||
568 | |||
569 | STDMETHOD(OnCommitMsiTransactionComplete)( | ||
570 | __in_z LPCWSTR wzTransactionId, | ||
571 | __in HRESULT hrStatus | ||
572 | ) = 0; | ||
573 | |||
574 | STDMETHOD(OnRollbackMsiTransactionBegin)( | ||
575 | __in_z LPCWSTR wzTransactionId | ||
576 | ) = 0; | ||
577 | |||
578 | STDMETHOD(OnRollbackMsiTransactionComplete)( | ||
579 | __in_z LPCWSTR wzTransactionId, | ||
580 | __in HRESULT hrStatus | ||
581 | ) = 0; | ||
582 | |||
583 | STDMETHOD(OnPauseAutomaticUpdatesBegin)( | ||
584 | ) = 0; | ||
585 | |||
586 | STDMETHOD(OnPauseAutomaticUpdatesComplete)( | ||
587 | __in HRESULT hrStatus | ||
588 | ) = 0; | ||
589 | |||
590 | STDMETHOD(OnSystemRestorePointBegin)( | ||
591 | ) = 0; | ||
592 | |||
593 | STDMETHOD(OnSystemRestorePointComplete)( | ||
594 | __in HRESULT hrStatus | ||
595 | ) = 0; | ||
596 | |||
597 | STDMETHOD(OnPlanForwardCompatibleBundle)( | ||
598 | __in_z LPCWSTR wzBundleId, | ||
599 | __in BOOTSTRAPPER_RELATION_TYPE relationType, | ||
600 | __in_z LPCWSTR wzBundleTag, | ||
601 | __in BOOL fPerMachine, | ||
602 | __in_z LPCWSTR wzVersion, | ||
603 | __in BOOL fRecommendedIgnoreBundle, | ||
604 | __inout BOOL* pfCancel, | ||
605 | __inout BOOL* pfIgnoreBundle | ||
606 | ) = 0; | ||
607 | |||
608 | STDMETHOD(OnCacheContainerOrPayloadVerifyBegin)( | ||
609 | __in_z_opt LPCWSTR wzPackageOrContainerId, | ||
610 | __in_z_opt LPCWSTR wzPayloadId, | ||
611 | __inout BOOL* pfCancel | ||
612 | ) = 0; | ||
613 | |||
614 | STDMETHOD(OnCacheContainerOrPayloadVerifyProgress)( | ||
615 | __in_z_opt LPCWSTR wzPackageOrContainerId, | ||
616 | __in_z_opt LPCWSTR wzPayloadId, | ||
617 | __in DWORD64 dw64Progress, | ||
618 | __in DWORD64 dw64Total, | ||
619 | __in DWORD dwOverallPercentage, | ||
620 | __inout BOOL* pfCancel | ||
621 | ) = 0; | ||
622 | |||
623 | STDMETHOD(OnCacheContainerOrPayloadVerifyComplete)( | ||
624 | __in_z_opt LPCWSTR wzPackageOrContainerId, | ||
625 | __in_z_opt LPCWSTR wzPayloadId, | ||
626 | __in HRESULT hrStatus | ||
627 | ) = 0; | ||
628 | |||
629 | STDMETHOD(OnCachePayloadExtractBegin)( | ||
630 | __in_z_opt LPCWSTR wzContainerId, | ||
631 | __in_z_opt LPCWSTR wzPayloadId, | ||
632 | __inout BOOL* pfCancel | ||
633 | ) = 0; | ||
634 | |||
635 | STDMETHOD(OnCachePayloadExtractProgress)( | ||
636 | __in_z_opt LPCWSTR wzContainerId, | ||
637 | __in_z_opt LPCWSTR wzPayloadId, | ||
638 | __in DWORD64 dw64Progress, | ||
639 | __in DWORD64 dw64Total, | ||
640 | __in DWORD dwOverallPercentage, | ||
641 | __inout BOOL* pfCancel | ||
642 | ) = 0; | ||
643 | |||
644 | STDMETHOD(OnCachePayloadExtractComplete)( | ||
645 | __in_z_opt LPCWSTR wzContainerId, | ||
646 | __in_z_opt LPCWSTR wzPayloadId, | ||
647 | __in HRESULT hrStatus | ||
648 | ) = 0; | ||
649 | }; | ||
diff --git a/src/api/burn/balutil/inc/IBootstrapperApplicationFactory.h b/src/api/burn/balutil/inc/IBootstrapperApplicationFactory.h new file mode 100644 index 00000000..fd603e50 --- /dev/null +++ b/src/api/burn/balutil/inc/IBootstrapperApplicationFactory.h | |||
@@ -0,0 +1,13 @@ | |||
1 | #pragma once | ||
2 | // Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. | ||
3 | |||
4 | |||
5 | #include "precomp.h" | ||
6 | |||
7 | DECLARE_INTERFACE_IID_(IBootstrapperApplicationFactory, IUnknown, "2965A12F-AC7B-43A0-85DF-E4B2168478A4") | ||
8 | { | ||
9 | STDMETHOD(Create)( | ||
10 | __in const BOOTSTRAPPER_CREATE_ARGS* pArgs, | ||
11 | __inout BOOTSTRAPPER_CREATE_RESULTS *pResults | ||
12 | ); | ||
13 | }; | ||
diff --git a/src/api/burn/balutil/inc/IBootstrapperEngine.h b/src/api/burn/balutil/inc/IBootstrapperEngine.h new file mode 100644 index 00000000..ccb07f4f --- /dev/null +++ b/src/api/burn/balutil/inc/IBootstrapperEngine.h | |||
@@ -0,0 +1,140 @@ | |||
1 | #pragma once | ||
2 | // Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. | ||
3 | |||
4 | |||
5 | DECLARE_INTERFACE_IID_(IBootstrapperEngine, IUnknown, "6480D616-27A0-44D7-905B-81512C29C2FB") | ||
6 | { | ||
7 | STDMETHOD(GetPackageCount)( | ||
8 | __out DWORD* pcPackages | ||
9 | ) = 0; | ||
10 | |||
11 | STDMETHOD(GetVariableNumeric)( | ||
12 | __in_z LPCWSTR wzVariable, | ||
13 | __out LONGLONG* pllValue | ||
14 | ) = 0; | ||
15 | |||
16 | STDMETHOD(GetVariableString)( | ||
17 | __in_z LPCWSTR wzVariable, | ||
18 | __out_ecount_opt(*pcchValue) LPWSTR wzValue, | ||
19 | __inout SIZE_T* pcchValue | ||
20 | ) = 0; | ||
21 | |||
22 | STDMETHOD(GetVariableVersion)( | ||
23 | __in_z LPCWSTR wzVariable, | ||
24 | __out_ecount_opt(*pcchValue) LPWSTR wzValue, | ||
25 | __inout SIZE_T * pcchValue | ||
26 | ) = 0; | ||
27 | |||
28 | STDMETHOD(FormatString)( | ||
29 | __in_z LPCWSTR wzIn, | ||
30 | __out_ecount_opt(*pcchOut) LPWSTR wzOut, | ||
31 | __inout SIZE_T * pcchOut | ||
32 | ) = 0; | ||
33 | |||
34 | STDMETHOD(EscapeString)( | ||
35 | __in_z LPCWSTR wzIn, | ||
36 | __out_ecount_opt(*pcchOut) LPWSTR wzOut, | ||
37 | __inout SIZE_T * pcchOut | ||
38 | ) = 0; | ||
39 | |||
40 | STDMETHOD(EvaluateCondition)( | ||
41 | __in_z LPCWSTR wzCondition, | ||
42 | __out BOOL* pf | ||
43 | ) = 0; | ||
44 | |||
45 | STDMETHOD(Log)( | ||
46 | __in BOOTSTRAPPER_LOG_LEVEL level, | ||
47 | __in_z LPCWSTR wzMessage | ||
48 | ) = 0; | ||
49 | |||
50 | STDMETHOD(SendEmbeddedError)( | ||
51 | __in DWORD dwErrorCode, | ||
52 | __in_z_opt LPCWSTR wzMessage, | ||
53 | __in DWORD dwUIHint, | ||
54 | __out int* pnResult | ||
55 | ) = 0; | ||
56 | |||
57 | STDMETHOD(SendEmbeddedProgress)( | ||
58 | __in DWORD dwProgressPercentage, | ||
59 | __in DWORD dwOverallProgressPercentage, | ||
60 | __out int* pnResult | ||
61 | ) = 0; | ||
62 | |||
63 | STDMETHOD(SetUpdate)( | ||
64 | __in_z_opt LPCWSTR wzLocalSource, | ||
65 | __in_z_opt LPCWSTR wzDownloadSource, | ||
66 | __in DWORD64 qwSize, | ||
67 | __in BOOTSTRAPPER_UPDATE_HASH_TYPE hashType, | ||
68 | __in_bcount_opt(cbHash) BYTE* rgbHash, | ||
69 | __in DWORD cbHash | ||
70 | ) = 0; | ||
71 | |||
72 | STDMETHOD(SetLocalSource)( | ||
73 | __in_z LPCWSTR wzPackageOrContainerId, | ||
74 | __in_z_opt LPCWSTR wzPayloadId, | ||
75 | __in_z LPCWSTR wzPath | ||
76 | ) = 0; | ||
77 | |||
78 | STDMETHOD(SetDownloadSource)( | ||
79 | __in_z LPCWSTR wzPackageOrContainerId, | ||
80 | __in_z_opt LPCWSTR wzPayloadId, | ||
81 | __in_z LPCWSTR wzUrl, | ||
82 | __in_z_opt LPCWSTR wzUser, | ||
83 | __in_z_opt LPCWSTR wzPassword | ||
84 | ) = 0; | ||
85 | |||
86 | STDMETHOD(SetVariableNumeric)( | ||
87 | __in_z LPCWSTR wzVariable, | ||
88 | __in LONGLONG llValue | ||
89 | ) = 0; | ||
90 | |||
91 | STDMETHOD(SetVariableString)( | ||
92 | __in_z LPCWSTR wzVariable, | ||
93 | __in_z_opt LPCWSTR wzValue, | ||
94 | __in BOOL fFormatted | ||
95 | ) = 0; | ||
96 | |||
97 | STDMETHOD(SetVariableVersion)( | ||
98 | __in_z LPCWSTR wzVariable, | ||
99 | __in_z_opt LPCWSTR wzValue | ||
100 | ) = 0; | ||
101 | |||
102 | STDMETHOD(CloseSplashScreen)() = 0; | ||
103 | |||
104 | STDMETHOD(Detect)( | ||
105 | __in_opt HWND hwndParent = NULL | ||
106 | ) = 0; | ||
107 | |||
108 | STDMETHOD(Plan)( | ||
109 | __in BOOTSTRAPPER_ACTION action | ||
110 | ) = 0; | ||
111 | |||
112 | STDMETHOD(Elevate)( | ||
113 | __in_opt HWND hwndParent | ||
114 | ) = 0; | ||
115 | |||
116 | STDMETHOD(Apply)( | ||
117 | __in HWND hwndParent | ||
118 | ) = 0; | ||
119 | |||
120 | STDMETHOD(Quit)( | ||
121 | __in DWORD dwExitCode | ||
122 | ) = 0; | ||
123 | |||
124 | STDMETHOD(LaunchApprovedExe)( | ||
125 | __in_opt HWND hwndParent, | ||
126 | __in_z LPCWSTR wzApprovedExeForElevationId, | ||
127 | __in_z_opt LPCWSTR wzArguments, | ||
128 | __in DWORD dwWaitForInputIdleTimeout | ||
129 | ) = 0; | ||
130 | |||
131 | STDMETHOD(SetUpdateSource)( | ||
132 | __in_z LPCWSTR wzUrl | ||
133 | ) = 0; | ||
134 | |||
135 | STDMETHOD(CompareVersions)( | ||
136 | __in_z LPCWSTR wzVersion1, | ||
137 | __in_z LPCWSTR wzVersion2, | ||
138 | __out int* pnResult | ||
139 | ) = 0; | ||
140 | }; | ||
diff --git a/src/api/burn/balutil/inc/balcondition.h b/src/api/burn/balutil/inc/balcondition.h new file mode 100644 index 00000000..677c593f --- /dev/null +++ b/src/api/burn/balutil/inc/balcondition.h | |||
@@ -0,0 +1,58 @@ | |||
1 | #pragma once | ||
2 | // Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. | ||
3 | |||
4 | |||
5 | #ifdef __cplusplus | ||
6 | extern "C" { | ||
7 | #endif | ||
8 | |||
9 | typedef struct _BAL_CONDITION | ||
10 | { | ||
11 | LPWSTR sczCondition; | ||
12 | LPWSTR sczMessage; | ||
13 | } BAL_CONDITION; | ||
14 | |||
15 | |||
16 | typedef struct _BAL_CONDITIONS | ||
17 | { | ||
18 | BAL_CONDITION* rgConditions; | ||
19 | DWORD cConditions; | ||
20 | } BAL_CONDITIONS; | ||
21 | |||
22 | |||
23 | /******************************************************************* | ||
24 | BalConditionsParseFromXml - loads the conditions from the UX manifest. | ||
25 | |||
26 | ********************************************************************/ | ||
27 | DAPI_(HRESULT) BalConditionsParseFromXml( | ||
28 | __in BAL_CONDITIONS* pConditions, | ||
29 | __in IXMLDOMDocument* pixdManifest, | ||
30 | __in_opt WIX_LOCALIZATION* pWixLoc | ||
31 | ); | ||
32 | |||
33 | |||
34 | /******************************************************************* | ||
35 | BalConditionEvaluate - evaluates condition against the provided IBurnCore. | ||
36 | |||
37 | NOTE: psczMessage is optional. | ||
38 | ********************************************************************/ | ||
39 | DAPI_(HRESULT) BalConditionEvaluate( | ||
40 | __in BAL_CONDITION* pCondition, | ||
41 | __in IBootstrapperEngine* pEngine, | ||
42 | __out BOOL* pfResult, | ||
43 | __out_z_opt LPWSTR* psczMessage | ||
44 | ); | ||
45 | |||
46 | |||
47 | /******************************************************************* | ||
48 | BalConditionsUninitialize - uninitializes any conditions previously loaded. | ||
49 | |||
50 | ********************************************************************/ | ||
51 | DAPI_(void) BalConditionsUninitialize( | ||
52 | __in BAL_CONDITIONS* pConditions | ||
53 | ); | ||
54 | |||
55 | |||
56 | #ifdef __cplusplus | ||
57 | } | ||
58 | #endif | ||
diff --git a/src/api/burn/balutil/inc/balinfo.h b/src/api/burn/balutil/inc/balinfo.h new file mode 100644 index 00000000..8c2155e9 --- /dev/null +++ b/src/api/burn/balutil/inc/balinfo.h | |||
@@ -0,0 +1,105 @@ | |||
1 | #pragma once | ||
2 | // Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. | ||
3 | |||
4 | |||
5 | #ifdef __cplusplus | ||
6 | extern "C" { | ||
7 | #endif | ||
8 | |||
9 | typedef enum BAL_INFO_PACKAGE_TYPE | ||
10 | { | ||
11 | BAL_INFO_PACKAGE_TYPE_UNKNOWN, | ||
12 | BAL_INFO_PACKAGE_TYPE_EXE, | ||
13 | BAL_INFO_PACKAGE_TYPE_MSI, | ||
14 | BAL_INFO_PACKAGE_TYPE_MSP, | ||
15 | BAL_INFO_PACKAGE_TYPE_MSU, | ||
16 | BAL_INFO_PACKAGE_TYPE_BUNDLE_UPGRADE, | ||
17 | BAL_INFO_PACKAGE_TYPE_BUNDLE_ADDON, | ||
18 | BAL_INFO_PACKAGE_TYPE_BUNDLE_PATCH, | ||
19 | } BAL_INFO_PACKAGE_TYPE; | ||
20 | |||
21 | |||
22 | typedef struct _BAL_INFO_PACKAGE | ||
23 | { | ||
24 | LPWSTR sczId; | ||
25 | LPWSTR sczDisplayName; | ||
26 | LPWSTR sczDescription; | ||
27 | BAL_INFO_PACKAGE_TYPE type; | ||
28 | BOOL fPermanent; | ||
29 | BOOL fVital; | ||
30 | LPWSTR sczDisplayInternalUICondition; | ||
31 | LPWSTR sczProductCode; | ||
32 | LPWSTR sczUpgradeCode; | ||
33 | LPWSTR sczVersion; | ||
34 | LPWSTR sczInstallCondition; | ||
35 | BOOTSTRAPPER_CACHE_TYPE cacheType; | ||
36 | BOOL fPrereqPackage; | ||
37 | LPWSTR sczPrereqLicenseFile; | ||
38 | LPWSTR sczPrereqLicenseUrl; | ||
39 | LPVOID pvCustomData; | ||
40 | } BAL_INFO_PACKAGE; | ||
41 | |||
42 | |||
43 | typedef struct _BAL_INFO_PACKAGES | ||
44 | { | ||
45 | BAL_INFO_PACKAGE* rgPackages; | ||
46 | DWORD cPackages; | ||
47 | } BAL_INFO_PACKAGES; | ||
48 | |||
49 | |||
50 | typedef struct _BAL_INFO_BUNDLE | ||
51 | { | ||
52 | BOOL fPerMachine; | ||
53 | LPWSTR sczName; | ||
54 | LPWSTR sczLogVariable; | ||
55 | BAL_INFO_PACKAGES packages; | ||
56 | } BAL_INFO_BUNDLE; | ||
57 | |||
58 | |||
59 | /******************************************************************* | ||
60 | BalInfoParseFromXml - loads the bundle and package info from the UX | ||
61 | manifest. | ||
62 | |||
63 | ********************************************************************/ | ||
64 | DAPI_(HRESULT) BalInfoParseFromXml( | ||
65 | __in BAL_INFO_BUNDLE* pBundle, | ||
66 | __in IXMLDOMDocument* pixdManifest | ||
67 | ); | ||
68 | |||
69 | |||
70 | /******************************************************************* | ||
71 | BalInfoAddRelatedBundleAsPackage - adds a related bundle as a package. | ||
72 | |||
73 | ********************************************************************/ | ||
74 | DAPI_(HRESULT) BalInfoAddRelatedBundleAsPackage( | ||
75 | __in BAL_INFO_PACKAGES* pPackages, | ||
76 | __in LPCWSTR wzId, | ||
77 | __in BOOTSTRAPPER_RELATION_TYPE relationType, | ||
78 | __in BOOL fPerMachine, | ||
79 | __out_opt BAL_INFO_PACKAGE** ppPackage | ||
80 | ); | ||
81 | |||
82 | |||
83 | /******************************************************************* | ||
84 | BalInfoFindPackageById - finds a package by its id. | ||
85 | |||
86 | ********************************************************************/ | ||
87 | DAPI_(HRESULT) BalInfoFindPackageById( | ||
88 | __in BAL_INFO_PACKAGES* pPackages, | ||
89 | __in LPCWSTR wzId, | ||
90 | __out BAL_INFO_PACKAGE** ppPackage | ||
91 | ); | ||
92 | |||
93 | |||
94 | /******************************************************************* | ||
95 | BalInfoUninitialize - uninitializes any info previously loaded. | ||
96 | |||
97 | ********************************************************************/ | ||
98 | DAPI_(void) BalInfoUninitialize( | ||
99 | __in BAL_INFO_BUNDLE* pBundle | ||
100 | ); | ||
101 | |||
102 | |||
103 | #ifdef __cplusplus | ||
104 | } | ||
105 | #endif | ||
diff --git a/src/api/burn/balutil/inc/balretry.h b/src/api/burn/balutil/inc/balretry.h new file mode 100644 index 00000000..35282a7e --- /dev/null +++ b/src/api/burn/balutil/inc/balretry.h | |||
@@ -0,0 +1,74 @@ | |||
1 | #pragma once | ||
2 | // Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. | ||
3 | |||
4 | |||
5 | #ifdef __cplusplus | ||
6 | extern "C" { | ||
7 | #endif | ||
8 | |||
9 | /******************************************************************* | ||
10 | BalRetryInitialize - initialize the retry count and timeout between | ||
11 | retries (in milliseconds). | ||
12 | ********************************************************************/ | ||
13 | DAPI_(void) BalRetryInitialize( | ||
14 | __in DWORD dwMaxRetries, | ||
15 | __in DWORD dwTimeout | ||
16 | ); | ||
17 | |||
18 | /******************************************************************* | ||
19 | BalRetryUninitialize - call to cleanup any memory allocated during | ||
20 | use of the retry utility. | ||
21 | ********************************************************************/ | ||
22 | DAPI_(void) BalRetryUninitialize(); | ||
23 | |||
24 | /******************************************************************* | ||
25 | BalRetryStartPackage - call when a package begins to be modified. If | ||
26 | the package is being retried, the function will | ||
27 | wait the specified timeout. | ||
28 | ********************************************************************/ | ||
29 | DAPI_(void) BalRetryStartPackage( | ||
30 | __in_z LPCWSTR wzPackageId | ||
31 | ); | ||
32 | |||
33 | /******************************************************************* | ||
34 | BalRetryErrorOccured - call when an error occurs for the retry utility | ||
35 | to consider. | ||
36 | ********************************************************************/ | ||
37 | DAPI_(void) BalRetryErrorOccurred( | ||
38 | __in_z LPCWSTR wzPackageId, | ||
39 | __in DWORD dwError | ||
40 | ); | ||
41 | |||
42 | /******************************************************************* | ||
43 | BalRetryEndPackage - returns TRUE if a retry is recommended. | ||
44 | ********************************************************************/ | ||
45 | DAPI_(HRESULT) BalRetryEndPackage( | ||
46 | __in_z LPCWSTR wzPackageId, | ||
47 | __in HRESULT hrError, | ||
48 | __inout BOOL* pfRetry | ||
49 | ); | ||
50 | |||
51 | /******************************************************************* | ||
52 | BalRetryStartContainerOrPayload - call when a container or payload | ||
53 | begins to be acquired. If the target is being retried, | ||
54 | the function will wait the specified timeout. | ||
55 | ********************************************************************/ | ||
56 | DAPI_(void) BalRetryStartContainerOrPayload( | ||
57 | __in_z_opt LPCWSTR wzContainerOrPackageId, | ||
58 | __in_z_opt LPCWSTR wzPayloadId | ||
59 | ); | ||
60 | |||
61 | /******************************************************************* | ||
62 | BalRetryEndContainerOrPayload - returns TRUE if a retry is recommended. | ||
63 | ********************************************************************/ | ||
64 | DAPI_(HRESULT) BalRetryEndContainerOrPayload( | ||
65 | __in_z_opt LPCWSTR wzContainerOrPackageId, | ||
66 | __in_z_opt LPCWSTR wzPayloadId, | ||
67 | __in HRESULT hrError, | ||
68 | __inout BOOL* pfRetry | ||
69 | ); | ||
70 | |||
71 | |||
72 | #ifdef __cplusplus | ||
73 | } | ||
74 | #endif | ||
diff --git a/src/api/burn/balutil/inc/balutil.h b/src/api/burn/balutil/inc/balutil.h new file mode 100644 index 00000000..fad8a471 --- /dev/null +++ b/src/api/burn/balutil/inc/balutil.h | |||
@@ -0,0 +1,199 @@ | |||
1 | #pragma once | ||
2 | // Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. | ||
3 | |||
4 | |||
5 | #include "dutil.h" | ||
6 | |||
7 | |||
8 | #ifdef __cplusplus | ||
9 | extern "C" { | ||
10 | #endif | ||
11 | |||
12 | #define BalExitOnFailureSource(d, x, f, ...) if (FAILED(x)) { BalLogError(x, f, __VA_ARGS__); ExitTraceSource(d, x, f, __VA_ARGS__); goto LExit; } | ||
13 | #define BalExitOnRootFailureSource(d, x, f, ...) if (FAILED(x)) { BalLogError(x, f, __VA_ARGS__); Dutil_RootFailure(__FILE__, __LINE__, x); ExitTraceSource(d, x, f, __VA_ARGS__); goto LExit; } | ||
14 | #define BalExitOnLastErrorSource(d, x, f, ...) { x = ::GetLastError(); x = HRESULT_FROM_WIN32(x); if (FAILED(x)) { BalLogError(x, f, __VA_ARGS__); ExitTraceSource(d, x, f, __VA_ARGS__); goto LExit; } } | ||
15 | #define BalExitOnNullSource(d, p, x, e, f, ...) if (NULL == p) { x = e; BalLogError(x, f, __VA_ARGS__); ExitTraceSource(d, x, f, __VA_ARGS__); goto LExit; } | ||
16 | #define BalExitOnNullWithLastErrorSource(d, p, x, f, ...) if (NULL == p) { DWORD Dutil_er = ::GetLastError(); x = HRESULT_FROM_WIN32(Dutil_er); if (!FAILED(x)) { x = E_FAIL; } BalLogError(x, f, __VA_ARGS__); ExitTraceSource(d, x, f, __VA_ARGS__); goto LExit; } | ||
17 | #define BalExitWithLastErrorSource(d, x, f, ...) { DWORD Dutil_er = ::GetLastError(); x = HRESULT_FROM_WIN32(Dutil_er); if (!FAILED(x)) { x = E_FAIL; } BalLogError(x, f, __VA_ARGS__); ExitTraceSource(d, x, f, __VA_ARGS__); goto LExit; } | ||
18 | |||
19 | #define BalExitOnFailure(x, f, ...) BalExitOnFailureSource(DUTIL_SOURCE_DEFAULT, x, f, __VA_ARGS__) | ||
20 | #define BalExitOnRootFailure(x, f, ...) BalExitOnRootFailureSource(DUTIL_SOURCE_DEFAULT, x, f, __VA_ARGS__) | ||
21 | #define BalExitOnLastError(x, f, ...) BalExitOnLastErrorSource(DUTIL_SOURCE_DEFAULT, x, f, __VA_ARGS__) | ||
22 | #define BalExitOnNull(p, x, e, f, ...) BalExitOnNullSource(DUTIL_SOURCE_DEFAULT, p, x, e, f, __VA_ARGS__) | ||
23 | #define BalExitOnNullWithLastError(p, x, f, ...) BalExitOnNullWithLastErrorSource(DUTIL_SOURCE_DEFAULT, p, x, f, __VA_ARGS__) | ||
24 | #define BalExitWithLastError(x, f, ...) BalExitWithLastErrorSource(DUTIL_SOURCE_DEFAULT, x, f, __VA_ARGS__) | ||
25 | |||
26 | #ifndef FACILITY_WIX | ||
27 | #define FACILITY_WIX 500 | ||
28 | #endif | ||
29 | |||
30 | const LPCWSTR BAL_MANIFEST_FILENAME = L"BootstrapperApplicationData.xml"; | ||
31 | |||
32 | static const HRESULT E_WIXSTDBA_CONDITION_FAILED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIX, 1); | ||
33 | |||
34 | static const HRESULT E_MBAHOST_NET452_ON_WIN7RTM = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIX, 1000); | ||
35 | static const HRESULT E_DNCHOST_SCD_RUNTIME_FAILURE = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIX, 1001); | ||
36 | |||
37 | |||
38 | /******************************************************************* | ||
39 | BalInitialize - remembers the engine interface to enable logging and | ||
40 | other functions. | ||
41 | |||
42 | ********************************************************************/ | ||
43 | DAPI_(void) BalInitialize( | ||
44 | __in IBootstrapperEngine* pEngine | ||
45 | ); | ||
46 | |||
47 | /******************************************************************* | ||
48 | BalInitializeFromCreateArgs - convenience function to call BalBootstrapperEngineCreate | ||
49 | then pass it along to BalInitialize. | ||
50 | |||
51 | ********************************************************************/ | ||
52 | DAPI_(HRESULT) BalInitializeFromCreateArgs( | ||
53 | __in const BOOTSTRAPPER_CREATE_ARGS* pArgs, | ||
54 | __out_opt IBootstrapperEngine** ppEngine | ||
55 | ); | ||
56 | |||
57 | /******************************************************************* | ||
58 | BalUninitialize - cleans up utility layer internals. | ||
59 | |||
60 | ********************************************************************/ | ||
61 | DAPI_(void) BalUninitialize(); | ||
62 | |||
63 | /******************************************************************* | ||
64 | BalManifestLoad - loads the Application manifest into an XML document. | ||
65 | |||
66 | ********************************************************************/ | ||
67 | DAPI_(HRESULT) BalManifestLoad( | ||
68 | __in HMODULE hUXModule, | ||
69 | __out IXMLDOMDocument** ppixdManifest | ||
70 | ); | ||
71 | |||
72 | /******************************************************************* | ||
73 | BalEvaluateCondition - evaluates a condition using variables in the engine. | ||
74 | |||
75 | ********************************************************************/ | ||
76 | DAPI_(HRESULT) BalEvaluateCondition( | ||
77 | __in_z LPCWSTR wzCondition, | ||
78 | __out BOOL* pf | ||
79 | ); | ||
80 | |||
81 | /******************************************************************* | ||
82 | BalFormatString - formats a string using variables in the engine. | ||
83 | |||
84 | Note: Use StrFree() to release psczOut. | ||
85 | ********************************************************************/ | ||
86 | DAPI_(HRESULT) BalFormatString( | ||
87 | __in_z LPCWSTR wzFormat, | ||
88 | __inout LPWSTR* psczOut | ||
89 | ); | ||
90 | |||
91 | /******************************************************************* | ||
92 | BalGetNumericVariable - gets a number from a variable in the engine. | ||
93 | |||
94 | Note: Returns E_NOTFOUND if variable does not exist. | ||
95 | ********************************************************************/ | ||
96 | DAPI_(HRESULT) BalGetNumericVariable( | ||
97 | __in_z LPCWSTR wzVariable, | ||
98 | __out LONGLONG* pllValue | ||
99 | ); | ||
100 | |||
101 | /******************************************************************* | ||
102 | BalSetNumericVariable - sets a numeric variable in the engine. | ||
103 | |||
104 | ********************************************************************/ | ||
105 | DAPI_(HRESULT) BalSetNumericVariable( | ||
106 | __in_z LPCWSTR wzVariable, | ||
107 | __in LONGLONG llValue | ||
108 | ); | ||
109 | |||
110 | /******************************************************************* | ||
111 | BalVariableExists - checks if a variable exists in the engine. | ||
112 | |||
113 | ********************************************************************/ | ||
114 | DAPI_(BOOL) BalVariableExists( | ||
115 | __in_z LPCWSTR wzVariable | ||
116 | ); | ||
117 | |||
118 | /******************************************************************* | ||
119 | BalGetStringVariable - gets a string from a variable in the engine. | ||
120 | |||
121 | Note: Use StrFree() to release psczValue. | ||
122 | ********************************************************************/ | ||
123 | DAPI_(HRESULT) BalGetStringVariable( | ||
124 | __in_z LPCWSTR wzVariable, | ||
125 | __inout LPWSTR* psczValue | ||
126 | ); | ||
127 | |||
128 | /******************************************************************* | ||
129 | BalSetStringVariable - sets a string variable in the engine. | ||
130 | |||
131 | ********************************************************************/ | ||
132 | DAPI_(HRESULT) BalSetStringVariable( | ||
133 | __in_z LPCWSTR wzVariable, | ||
134 | __in_z_opt LPCWSTR wzValue, | ||
135 | __in BOOL fFormatted | ||
136 | ); | ||
137 | |||
138 | /******************************************************************* | ||
139 | BalLog - logs a message with the engine. | ||
140 | |||
141 | ********************************************************************/ | ||
142 | DAPIV_(HRESULT) BalLog( | ||
143 | __in BOOTSTRAPPER_LOG_LEVEL level, | ||
144 | __in_z __format_string LPCSTR szFormat, | ||
145 | ... | ||
146 | ); | ||
147 | |||
148 | /******************************************************************* | ||
149 | BalLogArgs - logs a message with the engine. | ||
150 | |||
151 | ********************************************************************/ | ||
152 | DAPI_(HRESULT) BalLogArgs( | ||
153 | __in BOOTSTRAPPER_LOG_LEVEL level, | ||
154 | __in_z __format_string LPCSTR szFormat, | ||
155 | __in va_list args | ||
156 | ); | ||
157 | |||
158 | /******************************************************************* | ||
159 | BalLogError - logs an error message with the engine. | ||
160 | |||
161 | ********************************************************************/ | ||
162 | DAPIV_(HRESULT) BalLogError( | ||
163 | __in HRESULT hr, | ||
164 | __in_z __format_string LPCSTR szFormat, | ||
165 | ... | ||
166 | ); | ||
167 | |||
168 | /******************************************************************* | ||
169 | BalLogErrorArgs - logs an error message with the engine. | ||
170 | |||
171 | ********************************************************************/ | ||
172 | DAPI_(HRESULT) BalLogErrorArgs( | ||
173 | __in HRESULT hr, | ||
174 | __in_z __format_string LPCSTR szFormat, | ||
175 | __in va_list args | ||
176 | ); | ||
177 | |||
178 | /******************************************************************* | ||
179 | BalLogId - logs a message with the engine with a string embedded in a | ||
180 | MESSAGETABLE resource. | ||
181 | |||
182 | ********************************************************************/ | ||
183 | DAPIV_(HRESULT) BalLogId( | ||
184 | __in BOOTSTRAPPER_LOG_LEVEL level, | ||
185 | __in DWORD dwLogId, | ||
186 | __in HMODULE hModule, | ||
187 | ... | ||
188 | ); | ||
189 | |||
190 | DAPI_(HRESULT) BalLogIdArgs( | ||
191 | __in BOOTSTRAPPER_LOG_LEVEL level, | ||
192 | __in DWORD dwLogId, | ||
193 | __in HMODULE hModule, | ||
194 | __in va_list args | ||
195 | ); | ||
196 | |||
197 | #ifdef __cplusplus | ||
198 | } | ||
199 | #endif | ||