aboutsummaryrefslogtreecommitdiff
path: root/src/burn/engine/bacallback.cpp
diff options
context:
space:
mode:
authorRob Mensching <rob@firegiant.com>2024-01-11 18:26:20 -0800
committerRob Mensching <rob@firegiant.com>2024-03-06 18:03:38 -0800
commit0d3d54992104288e9ee0c834d0b96e8502fd2d42 (patch)
tree9efa49c4983cd2ba1becab64bd1f2faccac88acf /src/burn/engine/bacallback.cpp
parent2824298d9dd817a47527c920363556b54ead5d5d (diff)
downloadwix-0d3d54992104288e9ee0c834d0b96e8502fd2d42.tar.gz
wix-0d3d54992104288e9ee0c834d0b96e8502fd2d42.tar.bz2
wix-0d3d54992104288e9ee0c834d0b96e8502fd2d42.zip
Move the BootstrapperApplication out of proc
Diffstat (limited to 'src/burn/engine/bacallback.cpp')
-rw-r--r--src/burn/engine/bacallback.cpp5893
1 files changed, 5893 insertions, 0 deletions
diff --git a/src/burn/engine/bacallback.cpp b/src/burn/engine/bacallback.cpp
new file mode 100644
index 00000000..f4e6894d
--- /dev/null
+++ b/src/burn/engine/bacallback.cpp
@@ -0,0 +1,5893 @@
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 "precomp.h"
4
5// internal function declarations
6
7static HRESULT FilterExecuteResult(
8 __in BURN_USER_EXPERIENCE* pUserExperience,
9 __in HRESULT hrStatus,
10 __in BOOL fRollback,
11 __in BOOL fCancel,
12 __in LPCWSTR sczEventName
13 );
14static HRESULT SendBAMessage(
15 __in BURN_USER_EXPERIENCE* pUserExperience,
16 __in BOOTSTRAPPER_APPLICATION_MESSAGE message,
17 __in BUFF_BUFFER* pBufferArgs,
18 __in BUFF_BUFFER* pBufferResults,
19 __in PIPE_RPC_RESULT* pResult
20 );
21static HRESULT SendBAMessageFromInactiveEngine(
22 __in BURN_USER_EXPERIENCE* pUserExperience,
23 __in BOOTSTRAPPER_APPLICATION_MESSAGE message,
24 __in BUFF_BUFFER* pBufferArgs,
25 __in BUFF_BUFFER* pBufferResults,
26 __in PIPE_RPC_RESULT* pResult
27 );
28static HRESULT CombineArgsAndResults(
29 __in BUFF_BUFFER* pBufferArgs,
30 __in BUFF_BUFFER* pBufferResults,
31 __in BUFF_BUFFER* pBufferCombined
32 );
33
34// function definitions
35
36EXTERN_C HRESULT BACallbackOnApplyBegin(
37 __in BURN_USER_EXPERIENCE* pUserExperience,
38 __in DWORD dwPhaseCount
39 )
40{
41 HRESULT hr = S_OK;
42 BA_ONAPPLYBEGIN_ARGS args = { };
43 BA_ONAPPLYBEGIN_RESULTS results = { };
44 BUFF_BUFFER bufferArgs = { };
45 BUFF_BUFFER bufferResults = { };
46 PIPE_RPC_RESULT rpc = { };
47 SIZE_T iBuffer = 0;
48
49 // Init structs.
50 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
51 args.dwPhaseCount = dwPhaseCount;
52
53 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
54
55 // Send args.
56 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
57 ExitOnFailure(hr, "Failed to write API version of OnApplyBegin args.");
58
59 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwPhaseCount);
60 ExitOnFailure(hr, "Failed to write phase count of OnApplyBegin args command.");
61
62 // Send results.
63 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
64 ExitOnFailure(hr, "Failed to write API version of OnApplyBegin results.");
65
66 // Callback.
67 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONAPPLYBEGIN, &bufferArgs, &bufferResults, &rpc);
68 ExitOnFailure(hr, "BA OnApplyBegin failed.");
69
70 if (S_FALSE == hr)
71 {
72 ExitFunction();
73 }
74
75 // Read results.
76 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
77 ExitOnFailure(hr, "Failed to read size of OnApplyBegin result.");
78
79 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
80 ExitOnFailure(hr, "Failed to read cancel of OnApplyBegin result.");
81
82 if (results.fCancel)
83 {
84 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
85 }
86
87LExit:
88 PipeFreeRpcResult(&rpc);
89 ReleaseBuffer(bufferResults);
90 ReleaseBuffer(bufferArgs);
91
92 return hr;
93}
94
95EXTERN_C HRESULT BACallbackOnApplyComplete(
96 __in BURN_USER_EXPERIENCE* pUserExperience,
97 __in HRESULT hrStatus,
98 __in BOOTSTRAPPER_APPLY_RESTART restart,
99 __inout BOOTSTRAPPER_APPLYCOMPLETE_ACTION* pAction
100 )
101{
102 HRESULT hr = S_OK;
103 BA_ONAPPLYCOMPLETE_ARGS args = { };
104 BA_ONAPPLYCOMPLETE_RESULTS results = { };
105 BUFF_BUFFER bufferArgs = { };
106 BUFF_BUFFER bufferResults = { };
107 PIPE_RPC_RESULT rpc = { };
108 SIZE_T iBuffer = 0;
109
110 // Init structs.
111 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
112 args.hrStatus = hrStatus;
113 args.restart = restart;
114 args.recommendation = *pAction;
115
116 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
117 results.action = *pAction;
118
119 // Send args.
120 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
121 ExitOnFailure(hr, "Failed to write API version of OnApplyComplete args.");
122
123 hr = BuffWriteNumberToBuffer(&bufferArgs, args.hrStatus);
124 ExitOnFailure(hr, "Failed to write status of OnApplyComplete args.");
125
126 hr = BuffWriteNumberToBuffer(&bufferArgs, args.restart);
127 ExitOnFailure(hr, "Failed to write restart of OnApplyComplete args.");
128
129 hr = BuffWriteNumberToBuffer(&bufferArgs, args.recommendation);
130 ExitOnFailure(hr, "Failed to write recommended action of OnApplyComplete args.");
131
132 // Send results.
133 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
134 ExitOnFailure(hr, "Failed to write API version of OnApplyComplete results.");
135
136 hr = BuffWriteNumberToBuffer(&bufferResults, results.action);
137 ExitOnFailure(hr, "Failed to write default action of OnApplyComplete results.");
138
139 // Callback.
140 hr = SendBAMessageFromInactiveEngine(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONAPPLYCOMPLETE, &bufferArgs, &bufferResults, &rpc);
141 ExitOnFailure(hr, "BA OnApplyComplete failed.");
142
143 if (S_FALSE == hr)
144 {
145 ExitFunction();
146 }
147
148 // Read results.
149 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
150 ExitOnFailure(hr, "Failed to read size of OnApplyComplete result.");
151
152 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.action));
153 ExitOnFailure(hr, "Failed to read action of OnApplyComplete result.");
154
155 *pAction = results.action;
156
157LExit:
158 PipeFreeRpcResult(&rpc);
159 ReleaseBuffer(bufferResults);
160 ReleaseBuffer(bufferArgs);
161
162 return hr;
163}
164
165EXTERN_C HRESULT BACallbackOnApplyDowngrade(
166 __in BURN_USER_EXPERIENCE* pUserExperience,
167 __inout HRESULT* phrStatus
168 )
169{
170 HRESULT hr = S_OK;
171 BA_ONAPPLYDOWNGRADE_ARGS args = { };
172 BA_ONAPPLYDOWNGRADE_RESULTS results = { };
173 BUFF_BUFFER bufferArgs = { };
174 BUFF_BUFFER bufferResults = { };
175 PIPE_RPC_RESULT rpc = { };
176 SIZE_T iBuffer = 0;
177
178 // Init structs.
179 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
180 args.hrRecommended = *phrStatus;
181
182 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
183 results.hrStatus = *phrStatus;
184
185 // Send args.
186 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
187 ExitOnFailure(hr, "Failed to write API version of OnApplyDowngrade args.");
188
189 hr = BuffWriteNumberToBuffer(&bufferArgs, args.hrRecommended);
190 ExitOnFailure(hr, "Failed to write recommended status of OnApplyDowngrade args.");
191
192 // Send results.
193 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
194 ExitOnFailure(hr, "Failed to write API version of OnApplyDowngrade results.");
195
196 hr = BuffWriteNumberToBuffer(&bufferResults, results.hrStatus);
197 ExitOnFailure(hr, "Failed to write default action of OnApplyDowngrade results.");
198
199 // Callback.
200 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONAPPLYDOWNGRADE, &bufferArgs, &bufferResults, &rpc);
201 ExitOnFailure(hr, "BA OnApplyDowngrade failed.");
202
203 if (S_FALSE == hr)
204 {
205 ExitFunction();
206 }
207
208 // Read results.
209 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
210 ExitOnFailure(hr, "Failed to read size of OnApplyDowngrade result.");
211
212 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.hrStatus));
213 ExitOnFailure(hr, "Failed to read action of OnApplyDowngrade result.");
214
215 *phrStatus = results.hrStatus;
216
217LExit:
218 PipeFreeRpcResult(&rpc);
219 ReleaseBuffer(bufferResults);
220 ReleaseBuffer(bufferArgs);
221
222 return hr;
223}
224
225EXTERN_C HRESULT BACallbackOnBeginMsiTransactionBegin(
226 __in BURN_USER_EXPERIENCE* pUserExperience,
227 __in LPCWSTR wzTransactionId
228 )
229{
230 HRESULT hr = S_OK;
231 BA_ONBEGINMSITRANSACTIONBEGIN_ARGS args = { };
232 BA_ONBEGINMSITRANSACTIONBEGIN_RESULTS results = { };
233 BUFF_BUFFER bufferArgs = { };
234 BUFF_BUFFER bufferResults = { };
235 PIPE_RPC_RESULT rpc = { };
236 SIZE_T iBuffer = 0;
237
238 // Init structs.
239 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
240 args.wzTransactionId = wzTransactionId;
241
242 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
243
244 // Send args.
245 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
246 ExitOnFailure(hr, "Failed to write API version of OnBeginMsiTransactionBegin args.");
247
248 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzTransactionId);
249 ExitOnFailure(hr, "Failed to write recommended status of OnBeginMsiTransactionBegin args.");
250
251 // Send results.
252 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
253 ExitOnFailure(hr, "Failed to write API version of OnBeginMsiTransactionBegin results.");
254
255 // Callback.
256 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONBEGINMSITRANSACTIONBEGIN, &bufferArgs, &bufferResults, &rpc);
257 ExitOnFailure(hr, "BA OnBeginMsiTransactionBegin failed.");
258
259 if (S_FALSE == hr)
260 {
261 ExitFunction();
262 }
263
264 // Read results.
265 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
266 ExitOnFailure(hr, "Failed to read size of OnBeginMsiTransactionBegin result.");
267
268 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
269 ExitOnFailure(hr, "Failed to read action of OnBeginMsiTransactionBegin result.");
270
271 if (results.fCancel)
272 {
273 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
274 }
275
276LExit:
277 PipeFreeRpcResult(&rpc);
278 ReleaseBuffer(bufferResults);
279 ReleaseBuffer(bufferArgs);
280
281 return hr;
282}
283
284EXTERN_C HRESULT BACallbackOnBeginMsiTransactionComplete(
285 __in BURN_USER_EXPERIENCE* pUserExperience,
286 __in LPCWSTR wzTransactionId,
287 __in HRESULT hrStatus
288 )
289{
290 HRESULT hr = S_OK;
291 BA_ONBEGINMSITRANSACTIONCOMPLETE_ARGS args = { };
292 BA_ONBEGINMSITRANSACTIONCOMPLETE_RESULTS results = { };
293 BUFF_BUFFER bufferArgs = { };
294 BUFF_BUFFER bufferResults = { };
295 PIPE_RPC_RESULT rpc = { };
296
297 // Init structs.
298 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
299 args.wzTransactionId = wzTransactionId;
300 args.hrStatus = hrStatus;
301
302 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
303
304 // Send args.
305 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
306 ExitOnFailure(hr, "Failed to write API version of OnBeginMsiTransactionComplete args.");
307
308 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzTransactionId);
309 ExitOnFailure(hr, "Failed to write recommended status of OnBeginMsiTransactionComplete args.");
310
311 hr = BuffWriteNumberToBuffer(&bufferArgs, args.hrStatus);
312 ExitOnFailure(hr, "Failed to write status of OnBeginMsiTransactionComplete args.");
313
314 // Send results.
315 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
316 ExitOnFailure(hr, "Failed to write API version of OnBeginMsiTransactionComplete results.");
317
318 // Callback.
319 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONBEGINMSITRANSACTIONCOMPLETE, &bufferArgs, &bufferResults, &rpc);
320 ExitOnFailure(hr, "BA OnBeginMsiTransactionComplete failed.");
321
322 if (S_FALSE == hr)
323 {
324 ExitFunction();
325 }
326
327LExit:
328 PipeFreeRpcResult(&rpc);
329 ReleaseBuffer(bufferResults);
330 ReleaseBuffer(bufferArgs);
331
332 return hr;
333}
334
335EXTERN_C HRESULT BACallbackOnCacheAcquireBegin(
336 __in BURN_USER_EXPERIENCE* pUserExperience,
337 __in_z_opt LPCWSTR wzPackageOrContainerId,
338 __in_z_opt LPCWSTR wzPayloadId,
339 __in_z LPWSTR* pwzSource,
340 __in_z LPWSTR* pwzDownloadUrl,
341 __in_z_opt LPCWSTR wzPayloadContainerId,
342 __out BOOTSTRAPPER_CACHE_OPERATION* pCacheOperation
343 )
344{
345 HRESULT hr = S_OK;
346 BA_ONCACHEACQUIREBEGIN_ARGS args = { };
347 BA_ONCACHEACQUIREBEGIN_RESULTS results = { };
348 BUFF_BUFFER bufferArgs = { };
349 BUFF_BUFFER bufferResults = { };
350 PIPE_RPC_RESULT rpc = { };
351 SIZE_T iBuffer = 0;
352
353 *pCacheOperation = BOOTSTRAPPER_CACHE_OPERATION_NONE;
354
355 // Init structs.
356 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
357 args.wzPackageOrContainerId = wzPackageOrContainerId;
358 args.wzPayloadId = wzPayloadId;
359 args.wzSource = *pwzSource;
360 args.wzDownloadUrl = *pwzDownloadUrl;
361 args.wzPayloadContainerId = wzPayloadContainerId;
362 args.recommendation = *pCacheOperation;
363
364 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
365 results.action = *pCacheOperation;
366
367 // Send args.
368 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
369 ExitOnFailure(hr, "Failed to write API version of OnCacheAcquireBegin args.");
370
371 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageOrContainerId);
372 ExitOnFailure(hr, "Failed to write package or container of OnCacheAcquireBegin args.");
373
374 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPayloadId);
375 ExitOnFailure(hr, "Failed to write payload id of OnCacheAcquireBegin args.");
376
377 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzSource);
378 ExitOnFailure(hr, "Failed to write source of OnCacheAcquireBegin args.");
379
380 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzDownloadUrl);
381 ExitOnFailure(hr, "Failed to write download url of OnCacheAcquireBegin args.");
382
383 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPayloadContainerId);
384 ExitOnFailure(hr, "Failed to write payload container id of OnCacheAcquireBegin args.");
385
386 hr = BuffWriteNumberToBuffer(&bufferArgs, args.recommendation);
387 ExitOnFailure(hr, "Failed to write recommendation of OnCacheAcquireBegin args.");
388
389 // Send results.
390 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
391 ExitOnFailure(hr, "Failed to write API version of OnCacheAcquireBegin results.");
392
393 hr = BuffWriteNumberToBuffer(&bufferResults, results.action);
394 ExitOnFailure(hr, "Failed to write action of OnCacheAcquireBegin results.");
395
396 // Callback.
397 hr = SendBAMessageFromInactiveEngine(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEACQUIREBEGIN, &bufferArgs, &bufferResults, &rpc);
398 ExitOnFailure(hr, "BA OnCacheAcquireBegin failed.");
399
400 if (S_FALSE == hr)
401 {
402 ExitFunction();
403 }
404
405 // Read results.
406 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
407 ExitOnFailure(hr, "Failed to read size of OnCacheAcquireBegin result.");
408
409 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
410 ExitOnFailure(hr, "Failed to read cancel of OnCacheAcquireBegin result.");
411
412 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.action));
413 ExitOnFailure(hr, "Failed to read action of OnCacheAcquireBegin result.");
414
415 if (results.fCancel)
416 {
417 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
418 }
419 else
420 {
421 // Verify the BA requested an action that is possible.
422 if (BOOTSTRAPPER_CACHE_OPERATION_DOWNLOAD == results.action && *pwzDownloadUrl && **pwzDownloadUrl ||
423 BOOTSTRAPPER_CACHE_OPERATION_EXTRACT == results.action && wzPayloadContainerId ||
424 BOOTSTRAPPER_CACHE_OPERATION_COPY == results.action ||
425 BOOTSTRAPPER_CACHE_OPERATION_NONE == results.action)
426 {
427 *pCacheOperation = results.action;
428 }
429 }
430
431LExit:
432 PipeFreeRpcResult(&rpc);
433 ReleaseBuffer(bufferResults);
434 ReleaseBuffer(bufferArgs);
435
436 return hr;
437}
438
439EXTERN_C HRESULT BACallbackOnCacheAcquireComplete(
440 __in BURN_USER_EXPERIENCE* pUserExperience,
441 __in_z_opt LPCWSTR wzPackageOrContainerId,
442 __in_z_opt LPCWSTR wzPayloadId,
443 __in HRESULT hrStatus,
444 __inout BOOL* pfRetry
445 )
446{
447 HRESULT hr = S_OK;
448 BA_ONCACHEACQUIRECOMPLETE_ARGS args = { };
449 BA_ONCACHEACQUIRECOMPLETE_RESULTS results = { };
450 BUFF_BUFFER bufferArgs = { };
451 BUFF_BUFFER bufferResults = { };
452 PIPE_RPC_RESULT rpc = { };
453 SIZE_T iBuffer = 0;
454
455 // Init structs.
456 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
457 args.wzPackageOrContainerId = wzPackageOrContainerId;
458 args.wzPayloadId = wzPayloadId;
459 args.hrStatus = hrStatus;
460 args.recommendation = *pfRetry ? BOOTSTRAPPER_CACHEACQUIRECOMPLETE_ACTION_RETRY : BOOTSTRAPPER_CACHEACQUIRECOMPLETE_ACTION_NONE;
461
462 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
463 results.action = args.recommendation;
464
465 // Send args.
466 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
467 ExitOnFailure(hr, "Failed to write API version of OnCacheAcquireComplete args.");
468
469 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageOrContainerId);
470 ExitOnFailure(hr, "Failed to write package or container of OnCacheAcquireComplete args.");
471
472 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPayloadId);
473 ExitOnFailure(hr, "Failed to write payload id of OnCacheAcquireComplete args.");
474
475 hr = BuffWriteNumberToBuffer(&bufferArgs, args.hrStatus);
476 ExitOnFailure(hr, "Failed to write status of OnCacheAcquireComplete args.");
477
478 hr = BuffWriteNumberToBuffer(&bufferArgs, args.recommendation);
479 ExitOnFailure(hr, "Failed to write recommendation of OnCacheAcquireComplete args.");
480
481 // Send results.
482 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
483 ExitOnFailure(hr, "Failed to write API version of OnCacheAcquireComplete results.");
484
485 hr = BuffWriteNumberToBuffer(&bufferResults, results.action);
486 ExitOnFailure(hr, "Failed to write action of OnCacheAcquireComplete results.");
487
488 // Callback.
489 hr = SendBAMessageFromInactiveEngine(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEACQUIRECOMPLETE, &bufferArgs, &bufferResults, &rpc);
490 ExitOnFailure(hr, "BA OnCacheAcquireComplete failed.");
491
492 if (S_FALSE == hr)
493 {
494 ExitFunction();
495 }
496
497 // Read results.
498 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
499 ExitOnFailure(hr, "Failed to read size of OnCacheAcquireComplete result.");
500
501 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.action));
502 ExitOnFailure(hr, "Failed to read action of OnCacheAcquireComplete result.");
503
504 if (FAILED(hrStatus))
505 {
506 *pfRetry = BOOTSTRAPPER_CACHEACQUIRECOMPLETE_ACTION_RETRY == results.action;
507 }
508
509LExit:
510 PipeFreeRpcResult(&rpc);
511 ReleaseBuffer(bufferResults);
512 ReleaseBuffer(bufferArgs);
513
514 return hr;
515}
516
517EXTERN_C BAAPI BACallbackOnCacheAcquireProgress(
518 __in BURN_USER_EXPERIENCE* pUserExperience,
519 __in_z_opt LPCWSTR wzPackageOrContainerId,
520 __in_z_opt LPCWSTR wzPayloadId,
521 __in DWORD64 dw64Progress,
522 __in DWORD64 dw64Total,
523 __in DWORD dwOverallPercentage
524 )
525{
526 HRESULT hr = S_OK;
527 BA_ONCACHEACQUIREPROGRESS_ARGS args = { };
528 BA_ONCACHEACQUIREPROGRESS_RESULTS results = { };
529 BUFF_BUFFER bufferArgs = { };
530 BUFF_BUFFER bufferResults = { };
531 PIPE_RPC_RESULT rpc = { };
532 SIZE_T iBuffer = 0;
533
534 // Init structs.
535 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
536 args.wzPackageOrContainerId = wzPackageOrContainerId;
537 args.wzPayloadId = wzPayloadId;
538 args.dw64Progress = dw64Progress;
539 args.dw64Total = dw64Total;
540 args.dwOverallPercentage = dwOverallPercentage;
541
542 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
543
544 // Send args.
545 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
546 ExitOnFailure(hr, "Failed to write API version of OnCacheAcquireProgress args.");
547
548 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageOrContainerId);
549 ExitOnFailure(hr, "Failed to write package or container of OnCacheAcquireProgress args.");
550
551 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPayloadId);
552 ExitOnFailure(hr, "Failed to write payload id of OnCacheAcquireProgress args.");
553
554 hr = BuffWriteNumber64ToBuffer(&bufferArgs, args.dw64Progress);
555 ExitOnFailure(hr, "Failed to write progress of OnCacheAcquireProgress args.");
556
557 hr = BuffWriteNumber64ToBuffer(&bufferArgs, args.dw64Total);
558 ExitOnFailure(hr, "Failed to write total progress of OnCacheAcquireProgress args.");
559
560 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwOverallPercentage);
561 ExitOnFailure(hr, "Failed to write overall percentage of OnCacheAcquireProgress args.");
562
563 // Send results.
564 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
565 ExitOnFailure(hr, "Failed to write API version of OnCacheAcquireProgress results.");
566
567 // Callback.
568 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEACQUIREPROGRESS, &bufferArgs, &bufferResults, &rpc);
569 ExitOnFailure(hr, "BA OnCacheAcquireProgress failed.");
570
571 if (S_FALSE == hr)
572 {
573 ExitFunction();
574 }
575
576 // Read results.
577 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
578 ExitOnFailure(hr, "Failed to read size of OnCacheAcquireProgress result.");
579
580 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
581 ExitOnFailure(hr, "Failed to read cancel of OnCacheAcquireProgress result.");
582
583 if (results.fCancel)
584 {
585 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
586 }
587
588LExit:
589 PipeFreeRpcResult(&rpc);
590 ReleaseBuffer(bufferResults);
591 ReleaseBuffer(bufferArgs);
592
593 return hr;
594}
595
596EXTERN_C HRESULT BACallbackOnCacheAcquireResolving(
597 __in BURN_USER_EXPERIENCE* pUserExperience,
598 __in_z_opt LPCWSTR wzPackageOrContainerId,
599 __in_z_opt LPCWSTR wzPayloadId,
600 __in_ecount_z(cSearchPaths) LPWSTR* rgSearchPaths,
601 __in DWORD cSearchPaths,
602 __in BOOL fFoundLocal,
603 __in DWORD* pdwChosenSearchPath,
604 __in_z_opt LPWSTR* pwzDownloadUrl,
605 __in_z_opt LPCWSTR wzPayloadContainerId,
606 __inout BOOTSTRAPPER_CACHE_RESOLVE_OPERATION* pCacheOperation
607 )
608{
609 HRESULT hr = S_OK;
610 BA_ONCACHEACQUIRERESOLVING_ARGS args = { };
611 BA_ONCACHEACQUIRERESOLVING_RESULTS results = { };
612 BUFF_BUFFER bufferArgs = { };
613 BUFF_BUFFER bufferResults = { };
614 PIPE_RPC_RESULT rpc = { };
615 SIZE_T iBuffer = 0;
616
617 // Init structs.
618 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
619 args.wzPackageOrContainerId = wzPackageOrContainerId;
620 args.wzPayloadId = wzPayloadId;
621 args.rgSearchPaths = const_cast<LPCWSTR*>(rgSearchPaths);
622 args.cSearchPaths = cSearchPaths;
623 args.fFoundLocal = fFoundLocal;
624 args.dwRecommendedSearchPath = *pdwChosenSearchPath;
625 args.wzDownloadUrl = *pwzDownloadUrl;
626 args.recommendation = *pCacheOperation;
627
628 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
629 results.dwChosenSearchPath = *pdwChosenSearchPath;
630 results.action = *pCacheOperation;
631
632 // Send args.
633 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
634 ExitOnFailure(hr, "Failed to write API version of OnCacheAcquireResolving args.");
635
636 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageOrContainerId);
637 ExitOnFailure(hr, "Failed to write package or container of OnCacheAcquireResolving args.");
638
639 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPayloadId);
640 ExitOnFailure(hr, "Failed to write payload id of OnCacheAcquireResolving args.");
641
642 hr = BuffWriteNumberToBuffer(&bufferArgs, args.cSearchPaths);
643 ExitOnFailure(hr, "Failed to write count of search paths of OnCacheAcquireResolving args.");
644
645 for (DWORD i = 0; i < args.cSearchPaths; ++i)
646 {
647 hr = BuffWriteStringToBuffer(&bufferArgs, args.rgSearchPaths[i]);
648 ExitOnFailure(hr, "Failed to write search path[%u] of OnCacheAcquireResolving args.", i);
649 }
650
651 hr = BuffWriteNumberToBuffer(&bufferArgs, args.fFoundLocal);
652 ExitOnFailure(hr, "Failed to write found local of OnCacheAcquireResolving args.");
653
654 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwRecommendedSearchPath);
655 ExitOnFailure(hr, "Failed to write recommended search path of OnCacheAcquireResolving args.");
656
657 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzDownloadUrl);
658 ExitOnFailure(hr, "Failed to write download url of OnCacheAcquireResolving args.");
659
660 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPayloadContainerId);
661 ExitOnFailure(hr, "Failed to write payload container id of OnCacheAcquireResolving args.");
662
663 hr = BuffWriteNumberToBuffer(&bufferArgs, args.recommendation);
664 ExitOnFailure(hr, "Failed to write recommendation of OnCacheAcquireResolving args.");
665
666 // Send results.
667 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
668 ExitOnFailure(hr, "Failed to write API version of OnCacheAcquireResolving results.");
669
670 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwChosenSearchPath);
671 ExitOnFailure(hr, "Failed to write chose search path of OnCacheAcquireResolving results.");
672
673 hr = BuffWriteNumberToBuffer(&bufferResults, results.action);
674 ExitOnFailure(hr, "Failed to write action of OnCacheAcquireResolving results.");
675
676 // Callback.
677 hr = SendBAMessageFromInactiveEngine(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEACQUIRERESOLVING, &bufferArgs, &bufferResults, &rpc);
678 ExitOnFailure(hr, "BA OnCacheAcquireResolving failed.");
679
680 if (S_FALSE == hr)
681 {
682 ExitFunction();
683 }
684
685 // Read results.
686 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
687 ExitOnFailure(hr, "Failed to read size of OnCacheAcquireResolving result.");
688
689 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwChosenSearchPath);
690 ExitOnFailure(hr, "Failed to read chosen search path of OnCacheAcquireResolving result.");
691
692 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.action));
693 ExitOnFailure(hr, "Failed to read action of OnCacheAcquireResolving result.");
694
695 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
696 ExitOnFailure(hr, "Failed to read cancel of OnCacheAcquireResolving result.");
697
698 if (results.fCancel)
699 {
700 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
701 }
702 else
703 {
704 // Verify the BA requested an action that is possible.
705 if (BOOTSTRAPPER_CACHE_RESOLVE_DOWNLOAD == results.action && *pwzDownloadUrl && **pwzDownloadUrl ||
706 BOOTSTRAPPER_CACHE_RESOLVE_CONTAINER == results.action && wzPayloadContainerId ||
707 BOOTSTRAPPER_CACHE_RESOLVE_RETRY == results.action ||
708 BOOTSTRAPPER_CACHE_RESOLVE_NONE == results.action)
709 {
710 *pCacheOperation = results.action;
711 }
712 else if (BOOTSTRAPPER_CACHE_RESOLVE_LOCAL == results.action && results.dwChosenSearchPath < cSearchPaths)
713 {
714 *pdwChosenSearchPath = results.dwChosenSearchPath;
715 *pCacheOperation = results.action;
716 }
717 }
718
719LExit:
720 PipeFreeRpcResult(&rpc);
721 ReleaseBuffer(bufferResults);
722 ReleaseBuffer(bufferArgs);
723
724 return hr;
725}
726
727EXTERN_C HRESULT BACallbackOnCacheBegin(
728 __in BURN_USER_EXPERIENCE* pUserExperience
729 )
730{
731 HRESULT hr = S_OK;
732 BA_ONCACHEBEGIN_ARGS args = { };
733 BA_ONCACHEBEGIN_RESULTS results = { };
734 BUFF_BUFFER bufferArgs = { };
735 BUFF_BUFFER bufferResults = { };
736 PIPE_RPC_RESULT rpc = { };
737 SIZE_T iBuffer = 0;
738
739 // Init structs.
740 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
741
742 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
743
744 // Send args.
745 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
746 ExitOnFailure(hr, "Failed to write API version of OnCacheBegin args.");
747
748 // Send results.
749 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
750 ExitOnFailure(hr, "Failed to write API version of OnCacheBegin results.");
751
752 // Callback.
753 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEBEGIN, &bufferArgs, &bufferResults, &rpc);
754 ExitOnFailure(hr, "BA OnCacheBegin failed.");
755
756 if (S_FALSE == hr)
757 {
758 ExitFunction();
759 }
760
761 // Read results.
762 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
763 ExitOnFailure(hr, "Failed to read size of OnCacheBegin result.");
764
765 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
766 ExitOnFailure(hr, "Failed to read cancel of OnCacheBegin result.");
767
768 if (results.fCancel)
769 {
770 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
771 }
772
773LExit:
774 PipeFreeRpcResult(&rpc);
775 ReleaseBuffer(bufferResults);
776 ReleaseBuffer(bufferArgs);
777
778 return hr;
779}
780
781EXTERN_C HRESULT BACallbackOnCacheComplete(
782 __in BURN_USER_EXPERIENCE* pUserExperience,
783 __in HRESULT hrStatus
784 )
785{
786 HRESULT hr = S_OK;
787 BA_ONCACHECOMPLETE_ARGS args = { };
788 BA_ONCACHECOMPLETE_RESULTS results = { };
789 BUFF_BUFFER bufferArgs = { };
790 BUFF_BUFFER bufferResults = { };
791 PIPE_RPC_RESULT rpc = { };
792
793 // Init structs.
794 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
795 args.hrStatus = hrStatus;
796
797 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
798
799 // Send args.
800 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
801 ExitOnFailure(hr, "Failed to write API version of OnCacheComplete args.");
802
803 hr = BuffWriteNumberToBuffer(&bufferArgs, args.hrStatus);
804 ExitOnFailure(hr, "Failed to write status of OnCacheComplete args.");
805
806 // Send results.
807 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
808 ExitOnFailure(hr, "Failed to write API version of OnCacheComplete results.");
809
810 // Callback.
811 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHECOMPLETE, &bufferArgs, &bufferResults, &rpc);
812 ExitOnFailure(hr, "BA OnCacheComplete failed.");
813
814 if (S_FALSE == hr)
815 {
816 ExitFunction();
817 }
818
819LExit:
820 PipeFreeRpcResult(&rpc);
821 ReleaseBuffer(bufferResults);
822 ReleaseBuffer(bufferArgs);
823
824 return hr;
825}
826
827EXTERN_C BAAPI BACallbackOnCacheContainerOrPayloadVerifyBegin(
828 __in BURN_USER_EXPERIENCE* pUserExperience,
829 __in_z_opt LPCWSTR wzPackageOrContainerId,
830 __in_z_opt LPCWSTR wzPayloadId
831 )
832{
833 HRESULT hr = S_OK;
834 BA_ONCACHECONTAINERORPAYLOADVERIFYBEGIN_ARGS args = { };
835 BA_ONCACHECONTAINERORPAYLOADVERIFYBEGIN_RESULTS results = { };
836 BUFF_BUFFER bufferArgs = { };
837 BUFF_BUFFER bufferResults = { };
838 PIPE_RPC_RESULT rpc = { };
839 SIZE_T iBuffer = 0;
840
841 // Init structs.
842 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
843 args.wzPackageOrContainerId = wzPackageOrContainerId;
844 args.wzPayloadId = wzPayloadId;
845
846 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
847
848 // Send args.
849 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
850 ExitOnFailure(hr, "Failed to write API version of OnCacheContainerOrPayloadVerifyBegin args.");
851
852 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageOrContainerId);
853 ExitOnFailure(hr, "Failed to write package or container id of OnCacheContainerOrPayloadVerifyBegin args.");
854
855 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPayloadId);
856 ExitOnFailure(hr, "Failed to write payload id of OnCacheContainerOrPayloadVerifyBegin args.");
857
858 // Send results.
859 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
860 ExitOnFailure(hr, "Failed to write API version of OnCacheContainerOrPayloadVerifyBegin results.");
861
862 // Callback.
863 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHECONTAINERORPAYLOADVERIFYBEGIN, &bufferArgs, &bufferResults, &rpc);
864 ExitOnFailure(hr, "BA OnCacheContainerOrPayloadVerifyBegin failed.");
865
866 if (S_FALSE == hr)
867 {
868 ExitFunction();
869 }
870
871 // Read results.
872 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
873 ExitOnFailure(hr, "Failed to read size of OnCacheContainerOrPayloadVerifyBegin result.");
874
875 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
876 ExitOnFailure(hr, "Failed to read cancel of OnCacheContainerOrPayloadVerifyBegin result.");
877
878 if (results.fCancel)
879 {
880 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
881 }
882
883LExit:
884 PipeFreeRpcResult(&rpc);
885 ReleaseBuffer(bufferResults);
886 ReleaseBuffer(bufferArgs);
887
888 return hr;
889}
890
891EXTERN_C HRESULT BACallbackOnCacheContainerOrPayloadVerifyComplete(
892 __in BURN_USER_EXPERIENCE* pUserExperience,
893 __in_z_opt LPCWSTR wzPackageOrContainerId,
894 __in_z_opt LPCWSTR wzPayloadId,
895 __in HRESULT hrStatus
896 )
897{
898 HRESULT hr = S_OK;
899 BA_ONCACHECONTAINERORPAYLOADVERIFYCOMPLETE_ARGS args = { };
900 BA_ONCACHECONTAINERORPAYLOADVERIFYCOMPLETE_RESULTS results = { };
901 BUFF_BUFFER bufferArgs = { };
902 BUFF_BUFFER bufferResults = { };
903 PIPE_RPC_RESULT rpc = { };
904
905 // Init structs.
906 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
907 args.wzPackageOrContainerId = wzPackageOrContainerId;
908 args.wzPayloadId = wzPayloadId;
909 args.hrStatus = hrStatus;
910
911 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
912
913 // Send args.
914 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
915 ExitOnFailure(hr, "Failed to write API version of OnCacheContainerOrPayloadVerifyComplete args.");
916
917 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageOrContainerId);
918 ExitOnFailure(hr, "Failed to write package or container id of OnCacheContainerOrPayloadVerifyComplete args.");
919
920 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPayloadId);
921 ExitOnFailure(hr, "Failed to write payload id of OnCacheContainerOrPayloadVerifyComplete args.");
922
923 hr = BuffWriteNumberToBuffer(&bufferArgs, args.hrStatus);
924 ExitOnFailure(hr, "Failed to write status of OnCacheContainerOrPayloadVerifyComplete args.");
925
926 // Send results.
927 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
928 ExitOnFailure(hr, "Failed to write API version of OnCacheContainerOrPayloadVerifyComplete results.");
929
930 // Callback.
931 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHECONTAINERORPAYLOADVERIFYCOMPLETE, &bufferArgs, &bufferResults, &rpc);
932 ExitOnFailure(hr, "BA OnCacheContainerOrPayloadVerifyComplete failed.");
933
934 if (S_FALSE == hr)
935 {
936 ExitFunction();
937 }
938
939LExit:
940 PipeFreeRpcResult(&rpc);
941 ReleaseBuffer(bufferResults);
942 ReleaseBuffer(bufferArgs);
943
944 return hr;
945}
946
947EXTERN_C HRESULT BACallbackOnCacheContainerOrPayloadVerifyProgress(
948 __in BURN_USER_EXPERIENCE* pUserExperience,
949 __in_z_opt LPCWSTR wzPackageOrContainerId,
950 __in_z_opt LPCWSTR wzPayloadId,
951 __in DWORD64 dw64Progress,
952 __in DWORD64 dw64Total,
953 __in DWORD dwOverallPercentage
954 )
955{
956 HRESULT hr = S_OK;
957 BA_ONCACHECONTAINERORPAYLOADVERIFYPROGRESS_ARGS args = { };
958 BA_ONCACHECONTAINERORPAYLOADVERIFYPROGRESS_RESULTS results = { };
959 BUFF_BUFFER bufferArgs = { };
960 BUFF_BUFFER bufferResults = { };
961 PIPE_RPC_RESULT rpc = { };
962 SIZE_T iBuffer = 0;
963
964 // Init structs.
965 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
966 args.wzPackageOrContainerId = wzPackageOrContainerId;
967 args.wzPayloadId = wzPayloadId;
968 args.dw64Progress = dw64Progress;
969 args.dw64Total = dw64Total;
970 args.dwOverallPercentage = dwOverallPercentage;
971
972 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
973
974 // Send args.
975 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
976 ExitOnFailure(hr, "Failed to write API version of OnCacheContainerOrPayloadVerifyProgress args.");
977
978 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageOrContainerId);
979 ExitOnFailure(hr, "Failed to write package or container id of OnCacheContainerOrPayloadVerifyProgress args.");
980
981 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPayloadId);
982 ExitOnFailure(hr, "Failed to write payload id of OnCacheContainerOrPayloadVerifyProgress args.");
983
984 hr = BuffWriteNumber64ToBuffer(&bufferArgs, args.dw64Progress);
985 ExitOnFailure(hr, "Failed to write progress of OnCacheContainerOrPayloadVerifyProgress args.");
986
987 hr = BuffWriteNumber64ToBuffer(&bufferArgs, args.dw64Total);
988 ExitOnFailure(hr, "Failed to write total progress of OnCacheContainerOrPayloadVerifyProgress args.");
989
990 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwOverallPercentage);
991 ExitOnFailure(hr, "Failed to write overall percentage of OnCacheContainerOrPayloadVerifyProgress args.");
992
993 // Send results.
994 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
995 ExitOnFailure(hr, "Failed to write API version of OnCacheContainerOrPayloadVerifyProgress results.");
996
997 // Callback.
998 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHECONTAINERORPAYLOADVERIFYPROGRESS, &bufferArgs, &bufferResults, &rpc);
999 ExitOnFailure(hr, "BA OnCacheContainerOrPayloadVerifyProgress failed.");
1000
1001 if (S_FALSE == hr)
1002 {
1003 ExitFunction();
1004 }
1005
1006 // Read results.
1007 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
1008 ExitOnFailure(hr, "Failed to read size of OnCacheContainerOrPayloadVerifyProgress result.");
1009
1010 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
1011 ExitOnFailure(hr, "Failed to read cancel of OnCacheContainerOrPayloadVerifyProgress result.");
1012
1013 if (results.fCancel)
1014 {
1015 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
1016 }
1017
1018LExit:
1019 PipeFreeRpcResult(&rpc);
1020 ReleaseBuffer(bufferResults);
1021 ReleaseBuffer(bufferArgs);
1022
1023 return hr;
1024}
1025
1026EXTERN_C HRESULT BACallbackOnCachePackageBegin(
1027 __in BURN_USER_EXPERIENCE* pUserExperience,
1028 __in_z LPCWSTR wzPackageId,
1029 __in DWORD cCachePayloads,
1030 __in DWORD64 dw64PackageCacheSize,
1031 __in BOOL fVital
1032 )
1033{
1034 HRESULT hr = S_OK;
1035 BA_ONCACHEPACKAGEBEGIN_ARGS args = { };
1036 BA_ONCACHEPACKAGEBEGIN_RESULTS results = { };
1037 BUFF_BUFFER bufferArgs = { };
1038 BUFF_BUFFER bufferResults = { };
1039 PIPE_RPC_RESULT rpc = { };
1040 SIZE_T iBuffer = 0;
1041
1042 // Init structs.
1043 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1044 args.wzPackageId = wzPackageId;
1045 args.cCachePayloads = cCachePayloads;
1046 args.dw64PackageCacheSize = dw64PackageCacheSize;
1047 args.fVital = fVital;
1048
1049 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1050
1051 // Send args.
1052 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
1053 ExitOnFailure(hr, "Failed to write API version of OnCachePackageBegin args.");
1054
1055 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageId);
1056 ExitOnFailure(hr, "Failed to write package id of OnCachePackageBegin args.");
1057
1058 hr = BuffWriteNumberToBuffer(&bufferArgs, args.cCachePayloads);
1059 ExitOnFailure(hr, "Failed to write count of cached payloads of OnCachePackageBegin args.");
1060
1061 hr = BuffWriteNumber64ToBuffer(&bufferArgs, args.dw64PackageCacheSize);
1062 ExitOnFailure(hr, "Failed to write package cache size of OnCachePackageBegin args.");
1063
1064 hr = BuffWriteNumberToBuffer(&bufferArgs, args.fVital);
1065 ExitOnFailure(hr, "Failed to write vital of OnCachePackageBegin args.");
1066
1067 // Send results.
1068 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
1069 ExitOnFailure(hr, "Failed to write API version of OnCachePackageBegin results.");
1070
1071 // Callback.
1072 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEPACKAGEBEGIN, &bufferArgs, &bufferResults, &rpc);
1073 ExitOnFailure(hr, "BA OnCachePackageBegin failed.");
1074
1075 if (S_FALSE == hr)
1076 {
1077 ExitFunction();
1078 }
1079
1080 // Read results.
1081 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
1082 ExitOnFailure(hr, "Failed to read size of OnCachePackageBegin result.");
1083
1084 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
1085 ExitOnFailure(hr, "Failed to read cancel of OnCachePackageBegin result.");
1086
1087 if (results.fCancel)
1088 {
1089 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
1090 }
1091
1092LExit:
1093 PipeFreeRpcResult(&rpc);
1094 ReleaseBuffer(bufferResults);
1095 ReleaseBuffer(bufferArgs);
1096
1097 return hr;
1098}
1099
1100EXTERN_C HRESULT BACallbackOnCachePackageComplete(
1101 __in BURN_USER_EXPERIENCE* pUserExperience,
1102 __in_z LPCWSTR wzPackageId,
1103 __in HRESULT hrStatus,
1104 __inout BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION* pAction
1105 )
1106{
1107 HRESULT hr = S_OK;
1108 BA_ONCACHEPACKAGECOMPLETE_ARGS args = { };
1109 BA_ONCACHEPACKAGECOMPLETE_RESULTS results = { };
1110 BUFF_BUFFER bufferArgs = { };
1111 BUFF_BUFFER bufferResults = { };
1112 PIPE_RPC_RESULT rpc = { };
1113 SIZE_T iBuffer = 0;
1114
1115 // Init structs.
1116 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1117 args.wzPackageId = wzPackageId;
1118 args.hrStatus = hrStatus;
1119 args.recommendation = *pAction;
1120
1121 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1122 results.action = *pAction;
1123
1124 // Send args.
1125 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
1126 ExitOnFailure(hr, "Failed to write API version of OnCachePackageComplete args.");
1127
1128 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageId);
1129 ExitOnFailure(hr, "Failed to write package id of OnCachePackageComplete args.");
1130
1131 hr = BuffWriteNumberToBuffer(&bufferArgs, args.hrStatus);
1132 ExitOnFailure(hr, "Failed to write status of OnCachePackageComplete args.");
1133
1134 hr = BuffWriteNumberToBuffer(&bufferArgs, args.recommendation);
1135 ExitOnFailure(hr, "Failed to write recommendation of OnCachePackageComplete args.");
1136
1137 // Send results.
1138 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
1139 ExitOnFailure(hr, "Failed to write API version of OnCachePackageComplete results.");
1140
1141 hr = BuffWriteNumberToBuffer(&bufferResults, results.action);
1142 ExitOnFailure(hr, "Failed to write action of OnCachePackageComplete results.");
1143
1144 // Callback.
1145 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEPACKAGECOMPLETE, &bufferArgs, &bufferResults, &rpc);
1146 ExitOnFailure(hr, "BA OnCachePackageComplete failed.");
1147
1148 if (S_FALSE == hr)
1149 {
1150 ExitFunction();
1151 }
1152
1153 // Read results.
1154 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
1155 ExitOnFailure(hr, "Failed to read size of OnCachePackageComplete result.");
1156
1157 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.action));
1158 ExitOnFailure(hr, "Failed to read cancel of OnCachePackageComplete result.");
1159
1160 if (FAILED(hrStatus))
1161 {
1162 *pAction = results.action;
1163 }
1164
1165LExit:
1166 PipeFreeRpcResult(&rpc);
1167 ReleaseBuffer(bufferResults);
1168 ReleaseBuffer(bufferArgs);
1169
1170 return hr;
1171}
1172
1173EXTERN_C HRESULT BACallbackOnCachePackageNonVitalValidationFailure(
1174 __in BURN_USER_EXPERIENCE* pUserExperience,
1175 __in_z LPCWSTR wzPackageId,
1176 __in HRESULT hrStatus,
1177 __inout BOOTSTRAPPER_CACHEPACKAGENONVITALVALIDATIONFAILURE_ACTION* pAction
1178 )
1179{
1180 HRESULT hr = S_OK;
1181 BA_ONCACHEPACKAGENONVITALVALIDATIONFAILURE_ARGS args = { };
1182 BA_ONCACHEPACKAGENONVITALVALIDATIONFAILURE_RESULTS results = { };
1183 BUFF_BUFFER bufferArgs = { };
1184 BUFF_BUFFER bufferResults = { };
1185 PIPE_RPC_RESULT rpc = { };
1186 SIZE_T iBuffer = 0;
1187
1188 // Init structs.
1189 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1190 args.wzPackageId = wzPackageId;
1191 args.hrStatus = hrStatus;
1192 args.recommendation = *pAction;
1193
1194 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1195 results.action = *pAction;
1196
1197 // Send args.
1198 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
1199 ExitOnFailure(hr, "Failed to write API version of OnCachePackageNonVitalValidationFailure args.");
1200
1201 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageId);
1202 ExitOnFailure(hr, "Failed to write package id of OnCachePackageNonVitalValidationFailure args.");
1203
1204 hr = BuffWriteNumberToBuffer(&bufferArgs, args.hrStatus);
1205 ExitOnFailure(hr, "Failed to write status of OnCachePackageNonVitalValidationFailure args.");
1206
1207 hr = BuffWriteNumberToBuffer(&bufferArgs, args.recommendation);
1208 ExitOnFailure(hr, "Failed to write recommendation of OnCachePackageNonVitalValidationFailure args.");
1209
1210 // Send results.
1211 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
1212 ExitOnFailure(hr, "Failed to write API version of OnCachePackageNonVitalValidationFailure results.");
1213
1214 hr = BuffWriteNumberToBuffer(&bufferResults, results.action);
1215 ExitOnFailure(hr, "Failed to write API version of OnCachePackageNonVitalValidationFailure results.");
1216
1217 // Callback.
1218 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEPACKAGENONVITALVALIDATIONFAILURE, &bufferArgs, &bufferResults, &rpc);
1219 ExitOnFailure(hr, "BA OnCachePackageNonVitalValidationFailure failed.");
1220
1221 if (S_FALSE == hr)
1222 {
1223 ExitFunction();
1224 }
1225
1226 // Read results.
1227 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
1228 ExitOnFailure(hr, "Failed to read size of OnCachePackageNonVitalValidationFailure result.");
1229
1230 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.action));
1231 ExitOnFailure(hr, "Failed to read cancel of OnCachePackageNonVitalValidationFailure result.");
1232
1233 switch (results.action)
1234 {
1235 case BOOTSTRAPPER_CACHEPACKAGENONVITALVALIDATIONFAILURE_ACTION_NONE: __fallthrough;
1236 case BOOTSTRAPPER_CACHEPACKAGENONVITALVALIDATIONFAILURE_ACTION_ACQUIRE:
1237 *pAction = results.action;
1238 break;
1239 }
1240
1241LExit:
1242 PipeFreeRpcResult(&rpc);
1243 ReleaseBuffer(bufferResults);
1244 ReleaseBuffer(bufferArgs);
1245
1246 return hr;
1247}
1248
1249EXTERN_C HRESULT BACallbackOnCachePayloadExtractBegin(
1250 __in BURN_USER_EXPERIENCE* pUserExperience,
1251 __in_z_opt LPCWSTR wzContainerId,
1252 __in_z_opt LPCWSTR wzPayloadId
1253 )
1254{
1255 HRESULT hr = S_OK;
1256 BA_ONCACHEPAYLOADEXTRACTBEGIN_ARGS args = { };
1257 BA_ONCACHEPAYLOADEXTRACTBEGIN_RESULTS results = { };
1258 BUFF_BUFFER bufferArgs = { };
1259 BUFF_BUFFER bufferResults = { };
1260 PIPE_RPC_RESULT rpc = { };
1261 SIZE_T iBuffer = 0;
1262
1263 // Init structs.
1264 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1265 args.wzContainerId = wzContainerId;
1266 args.wzPayloadId = wzPayloadId;
1267
1268 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1269
1270 // Send args.
1271 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
1272 ExitOnFailure(hr, "Failed to write API version of OnCachePayloadExtractBegin args.");
1273
1274 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzContainerId);
1275 ExitOnFailure(hr, "Failed to write container id of OnCachePayloadExtractBegin args.");
1276
1277 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPayloadId);
1278 ExitOnFailure(hr, "Failed to write payload id of OnCachePayloadExtractBegin args.");
1279
1280 // Send results.
1281 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
1282 ExitOnFailure(hr, "Failed to write API version of OnCachePayloadExtractBegin results.");
1283
1284 // Callback.
1285 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEPAYLOADEXTRACTBEGIN, &bufferArgs, &bufferResults, &rpc);
1286 ExitOnFailure(hr, "BA OnCachePayloadExtractBegin failed.");
1287
1288 if (S_FALSE == hr)
1289 {
1290 ExitFunction();
1291 }
1292
1293 // Read results.
1294 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
1295 ExitOnFailure(hr, "Failed to read size of OnCachePayloadExtractBegin result.");
1296
1297 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
1298 ExitOnFailure(hr, "Failed to read cancel of OnCachePayloadExtractBegin result.");
1299
1300 if (results.fCancel)
1301 {
1302 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
1303 }
1304
1305LExit:
1306 PipeFreeRpcResult(&rpc);
1307 ReleaseBuffer(bufferResults);
1308 ReleaseBuffer(bufferArgs);
1309
1310 return hr;
1311}
1312
1313EXTERN_C HRESULT BACallbackOnCachePayloadExtractComplete(
1314 __in BURN_USER_EXPERIENCE* pUserExperience,
1315 __in_z_opt LPCWSTR wzContainerId,
1316 __in_z_opt LPCWSTR wzPayloadId,
1317 __in HRESULT hrStatus
1318 )
1319{
1320 HRESULT hr = S_OK;
1321 BA_ONCACHEPAYLOADEXTRACTCOMPLETE_ARGS args = { };
1322 BA_ONCACHEPAYLOADEXTRACTCOMPLETE_RESULTS results = { };
1323 BUFF_BUFFER bufferArgs = { };
1324 BUFF_BUFFER bufferResults = { };
1325 PIPE_RPC_RESULT rpc = { };
1326
1327 // Init structs.
1328 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1329 args.wzContainerId = wzContainerId;
1330 args.wzPayloadId = wzPayloadId;
1331 args.hrStatus = hrStatus;
1332
1333 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1334
1335 // Send args.
1336 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
1337 ExitOnFailure(hr, "Failed to write API version of OnCachePayloadExtractComplete args.");
1338
1339 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzContainerId);
1340 ExitOnFailure(hr, "Failed to write container id of OnCachePayloadExtractComplete args.");
1341
1342 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPayloadId);
1343 ExitOnFailure(hr, "Failed to write payload id of OnCachePayloadExtractComplete args.");
1344
1345 hr = BuffWriteNumberToBuffer(&bufferArgs, args.hrStatus);
1346 ExitOnFailure(hr, "Failed to write status of OnCachePayloadExtractComplete args.");
1347
1348 // Send results.
1349 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
1350 ExitOnFailure(hr, "Failed to write API version of OnCachePayloadExtractComplete results.");
1351
1352 // Callback.
1353 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEPAYLOADEXTRACTCOMPLETE, &bufferArgs, &bufferResults, &rpc);
1354 ExitOnFailure(hr, "BA OnCachePayloadExtractComplete failed.");
1355
1356 if (S_FALSE == hr)
1357 {
1358 ExitFunction();
1359 }
1360
1361LExit:
1362 PipeFreeRpcResult(&rpc);
1363 ReleaseBuffer(bufferResults);
1364 ReleaseBuffer(bufferArgs);
1365
1366 return hr;
1367}
1368
1369EXTERN_C HRESULT BACallbackOnCachePayloadExtractProgress(
1370 __in BURN_USER_EXPERIENCE* pUserExperience,
1371 __in_z_opt LPCWSTR wzContainerId,
1372 __in_z_opt LPCWSTR wzPayloadId,
1373 __in DWORD64 dw64Progress,
1374 __in DWORD64 dw64Total,
1375 __in DWORD dwOverallPercentage
1376 )
1377{
1378 HRESULT hr = S_OK;
1379 BA_ONCACHEPAYLOADEXTRACTPROGRESS_ARGS args = { };
1380 BA_ONCACHEPAYLOADEXTRACTPROGRESS_RESULTS results = { };
1381 BUFF_BUFFER bufferArgs = { };
1382 BUFF_BUFFER bufferResults = { };
1383 PIPE_RPC_RESULT rpc = { };
1384 SIZE_T iBuffer = 0;
1385
1386 // Init structs.
1387 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1388 args.wzContainerId = wzContainerId;
1389 args.wzPayloadId = wzPayloadId;
1390 args.dw64Progress = dw64Progress;
1391 args.dw64Total = dw64Total;
1392 args.dwOverallPercentage = dwOverallPercentage;
1393
1394 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1395
1396 // Send args.
1397 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
1398 ExitOnFailure(hr, "Failed to write API version of OnCachePayloadExtractProgress args.");
1399
1400 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzContainerId);
1401 ExitOnFailure(hr, "Failed to write container id of OnCachePayloadExtractProgress args.");
1402
1403 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPayloadId);
1404 ExitOnFailure(hr, "Failed to write payload id of OnCachePayloadExtractProgress args.");
1405
1406 hr = BuffWriteNumber64ToBuffer(&bufferArgs, args.dw64Progress);
1407 ExitOnFailure(hr, "Failed to write progress of OnCachePayloadExtractProgress args.");
1408
1409 hr = BuffWriteNumber64ToBuffer(&bufferArgs, args.dw64Total);
1410 ExitOnFailure(hr, "Failed to write total progress of OnCachePayloadExtractProgress args.");
1411
1412 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwOverallPercentage);
1413 ExitOnFailure(hr, "Failed to write overall percentage of OnCachePayloadExtractProgress args.");
1414
1415 // Send results.
1416 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
1417 ExitOnFailure(hr, "Failed to write API version of OnCachePayloadExtractProgress results.");
1418
1419 // Callback.
1420 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEPAYLOADEXTRACTPROGRESS, &bufferArgs, &bufferResults, &rpc);
1421 ExitOnFailure(hr, "BA OnCachePayloadExtractProgress failed.");
1422
1423 if (S_FALSE == hr)
1424 {
1425 ExitFunction();
1426 }
1427
1428 // Read results.
1429 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
1430 ExitOnFailure(hr, "Failed to read size of OnCachePayloadExtractProgress result.");
1431
1432 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
1433 ExitOnFailure(hr, "Failed to read cancel of OnCachePayloadExtractProgress result.");
1434
1435 if (results.fCancel)
1436 {
1437 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
1438 }
1439
1440LExit:
1441 PipeFreeRpcResult(&rpc);
1442 ReleaseBuffer(bufferResults);
1443 ReleaseBuffer(bufferArgs);
1444
1445 return hr;
1446}
1447
1448EXTERN_C HRESULT BACallbackOnCacheVerifyBegin(
1449 __in BURN_USER_EXPERIENCE* pUserExperience,
1450 __in_z_opt LPCWSTR wzPackageOrContainerId,
1451 __in_z_opt LPCWSTR wzPayloadId
1452 )
1453{
1454 HRESULT hr = S_OK;
1455 BA_ONCACHEVERIFYBEGIN_ARGS args = { };
1456 BA_ONCACHEVERIFYBEGIN_RESULTS results = { };
1457 BUFF_BUFFER bufferArgs = { };
1458 BUFF_BUFFER bufferResults = { };
1459 PIPE_RPC_RESULT rpc = { };
1460 SIZE_T iBuffer = 0;
1461
1462 // Init structs.
1463 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1464 args.wzPackageOrContainerId = wzPackageOrContainerId;
1465 args.wzPayloadId = wzPayloadId;
1466
1467 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1468
1469 // Send args.
1470 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
1471 ExitOnFailure(hr, "Failed to write API version of OnCacheVerifyBegin args.");
1472
1473 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageOrContainerId);
1474 ExitOnFailure(hr, "Failed to write package or container id of OnCacheVerifyBegin args.");
1475
1476 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPayloadId);
1477 ExitOnFailure(hr, "Failed to write payload id of OnCacheVerifyBegin args.");
1478
1479 // Send results.
1480 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
1481 ExitOnFailure(hr, "Failed to write API version of OnCacheVerifyBegin results.");
1482
1483 // Callback.
1484 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEVERIFYBEGIN, &bufferArgs, &bufferResults, &rpc);
1485 ExitOnFailure(hr, "BA OnCacheVerifyBegin failed.");
1486
1487 if (S_FALSE == hr)
1488 {
1489 ExitFunction();
1490 }
1491
1492 // Read results.
1493 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
1494 ExitOnFailure(hr, "Failed to read size of OnCacheVerifyBegin result.");
1495
1496 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
1497 ExitOnFailure(hr, "Failed to read cancel of OnCacheVerifyBegin result.");
1498
1499 if (results.fCancel)
1500 {
1501 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
1502 }
1503
1504LExit:
1505 PipeFreeRpcResult(&rpc);
1506 ReleaseBuffer(bufferResults);
1507 ReleaseBuffer(bufferArgs);
1508
1509 return hr;
1510}
1511
1512EXTERN_C HRESULT BACallbackOnCacheVerifyComplete(
1513 __in BURN_USER_EXPERIENCE* pUserExperience,
1514 __in_z_opt LPCWSTR wzPackageOrContainerId,
1515 __in_z_opt LPCWSTR wzPayloadId,
1516 __in HRESULT hrStatus,
1517 __inout BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION* pAction
1518 )
1519{
1520 HRESULT hr = S_OK;
1521 BA_ONCACHEVERIFYCOMPLETE_ARGS args = { };
1522 BA_ONCACHEVERIFYCOMPLETE_RESULTS results = { };
1523 BUFF_BUFFER bufferArgs = { };
1524 BUFF_BUFFER bufferResults = { };
1525 PIPE_RPC_RESULT rpc = { };
1526 SIZE_T iBuffer = 0;
1527
1528 // Init structs.
1529 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1530 args.wzPackageOrContainerId = wzPackageOrContainerId;
1531 args.wzPayloadId = wzPayloadId;
1532 args.hrStatus = hrStatus;
1533 args.recommendation = *pAction;
1534
1535 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1536 results.action = *pAction;
1537
1538 // Send args.
1539 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
1540 ExitOnFailure(hr, "Failed to write API version of OnCacheVerifyComplete args.");
1541
1542 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageOrContainerId);
1543 ExitOnFailure(hr, "Failed to write package or container id of OnCacheVerifyComplete args.");
1544
1545 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPayloadId);
1546 ExitOnFailure(hr, "Failed to write payload id of OnCacheVerifyComplete args.");
1547
1548 hr = BuffWriteNumberToBuffer(&bufferArgs, args.hrStatus);
1549 ExitOnFailure(hr, "Failed to write status of OnCacheVerifyComplete args.");
1550
1551 hr = BuffWriteNumberToBuffer(&bufferArgs, args.recommendation);
1552 ExitOnFailure(hr, "Failed to write recommendation of OnCacheVerifyComplete args.");
1553
1554 // Send results.
1555 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
1556 ExitOnFailure(hr, "Failed to write API version of OnCacheVerifyComplete results.");
1557
1558 hr = BuffWriteNumberToBuffer(&bufferResults, results.action);
1559 ExitOnFailure(hr, "Failed to write action of OnCacheVerifyComplete results.");
1560
1561 // Callback.
1562 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEVERIFYCOMPLETE, &bufferArgs, &bufferResults, &rpc);
1563 ExitOnFailure(hr, "BA OnCacheVerifyComplete failed.");
1564
1565 if (S_FALSE == hr)
1566 {
1567 ExitFunction();
1568 }
1569
1570 // Read results.
1571 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
1572 ExitOnFailure(hr, "Failed to read size of OnCacheVerifyComplete result.");
1573
1574 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.action));
1575 ExitOnFailure(hr, "Failed to read action of OnCacheVerifyComplete result.");
1576
1577 if (FAILED(hrStatus))
1578 {
1579 *pAction = results.action;
1580 }
1581
1582LExit:
1583 PipeFreeRpcResult(&rpc);
1584 ReleaseBuffer(bufferResults);
1585 ReleaseBuffer(bufferArgs);
1586
1587 return hr;
1588}
1589
1590EXTERN_C HRESULT BACallbackOnCacheVerifyProgress(
1591 __in BURN_USER_EXPERIENCE* pUserExperience,
1592 __in_z_opt LPCWSTR wzPackageOrContainerId,
1593 __in_z_opt LPCWSTR wzPayloadId,
1594 __in DWORD64 dw64Progress,
1595 __in DWORD64 dw64Total,
1596 __in DWORD dwOverallPercentage,
1597 __in BOOTSTRAPPER_CACHE_VERIFY_STEP verifyStep
1598 )
1599{
1600 HRESULT hr = S_OK;
1601 BA_ONCACHEVERIFYPROGRESS_ARGS args = { };
1602 BA_ONCACHEVERIFYPROGRESS_RESULTS results = { };
1603 BUFF_BUFFER bufferArgs = { };
1604 BUFF_BUFFER bufferResults = { };
1605 PIPE_RPC_RESULT rpc = { };
1606 SIZE_T iBuffer = 0;
1607
1608 // Init structs.
1609 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1610 args.wzPackageOrContainerId = wzPackageOrContainerId;
1611 args.wzPayloadId = wzPayloadId;
1612 args.dw64Progress = dw64Progress;
1613 args.dw64Total = dw64Total;
1614 args.dwOverallPercentage = dwOverallPercentage;
1615 args.verifyStep = verifyStep;
1616
1617 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1618
1619 // Send args.
1620 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
1621 ExitOnFailure(hr, "Failed to write API version of OnCacheVerifyProgress args.");
1622
1623 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageOrContainerId);
1624 ExitOnFailure(hr, "Failed to write package or container id of OnCacheVerifyProgress args.");
1625
1626 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPayloadId);
1627 ExitOnFailure(hr, "Failed to write payload id of OnCacheVerifyProgress args.");
1628
1629 hr = BuffWriteNumber64ToBuffer(&bufferArgs, args.dw64Progress);
1630 ExitOnFailure(hr, "Failed to write progress of OnCacheVerifyProgress args.");
1631
1632 hr = BuffWriteNumber64ToBuffer(&bufferArgs, args.dw64Total);
1633 ExitOnFailure(hr, "Failed to write total progress of OnCacheVerifyProgress args.");
1634
1635 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwOverallPercentage);
1636 ExitOnFailure(hr, "Failed to write overall percentage of OnCacheVerifyProgress args.");
1637
1638 hr = BuffWriteNumberToBuffer(&bufferArgs, args.verifyStep);
1639 ExitOnFailure(hr, "Failed to write verify step of OnCacheVerifyProgress args.");
1640
1641 // Send results.
1642 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
1643 ExitOnFailure(hr, "Failed to write API version of OnCacheVerifyProgress results.");
1644
1645 // Callback.
1646 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEVERIFYPROGRESS, &bufferArgs, &bufferResults, &rpc);
1647 ExitOnFailure(hr, "BA OnCacheVerifyProgress failed.");
1648
1649 if (S_FALSE == hr)
1650 {
1651 ExitFunction();
1652 }
1653
1654 // Read results.
1655 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
1656 ExitOnFailure(hr, "Failed to read size of OnCacheVerifyProgress result.");
1657
1658 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
1659 ExitOnFailure(hr, "Failed to read cancel of OnCacheVerifyProgress result.");
1660
1661 if (results.fCancel)
1662 {
1663 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
1664 }
1665
1666LExit:
1667 PipeFreeRpcResult(&rpc);
1668 ReleaseBuffer(bufferResults);
1669 ReleaseBuffer(bufferArgs);
1670
1671 return hr;
1672}
1673
1674EXTERN_C HRESULT BACallbackOnCommitMsiTransactionBegin(
1675 __in BURN_USER_EXPERIENCE* pUserExperience,
1676 __in LPCWSTR wzTransactionId
1677 )
1678{
1679 HRESULT hr = S_OK;
1680 BA_ONCOMMITMSITRANSACTIONBEGIN_ARGS args = { };
1681 BA_ONCOMMITMSITRANSACTIONBEGIN_RESULTS results = { };
1682 BUFF_BUFFER bufferArgs = { };
1683 BUFF_BUFFER bufferResults = { };
1684 PIPE_RPC_RESULT rpc = { };
1685 SIZE_T iBuffer = 0;
1686
1687 // Init structs.
1688 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1689 args.wzTransactionId = wzTransactionId;
1690
1691 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1692
1693 // Send args.
1694 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
1695 ExitOnFailure(hr, "Failed to write API version of OnCommitMsiTransactionBegin args.");
1696
1697 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzTransactionId);
1698 ExitOnFailure(hr, "Failed to write transaction id of OnCommitMsiTransactionBegin args.");
1699
1700 // Send results.
1701 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
1702 ExitOnFailure(hr, "Failed to write API version of OnCommitMsiTransactionBegin results.");
1703
1704 // Callback.
1705 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONCOMMITMSITRANSACTIONBEGIN, &bufferArgs, &bufferResults, &rpc);
1706 ExitOnFailure(hr, "BA OnCommitMsiTransactionBegin failed.");
1707
1708 if (S_FALSE == hr)
1709 {
1710 ExitFunction();
1711 }
1712
1713 // Read results.
1714 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
1715 ExitOnFailure(hr, "Failed to read size of OnCommitMsiTransactionBegin result.");
1716
1717 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
1718 ExitOnFailure(hr, "Failed to read cancel of OnCommitMsiTransactionBegin result.");
1719
1720 if (results.fCancel)
1721 {
1722 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
1723 }
1724
1725LExit:
1726 PipeFreeRpcResult(&rpc);
1727 ReleaseBuffer(bufferResults);
1728 ReleaseBuffer(bufferArgs);
1729
1730 return hr;
1731}
1732
1733EXTERN_C HRESULT BACallbackOnCommitMsiTransactionComplete(
1734 __in BURN_USER_EXPERIENCE* pUserExperience,
1735 __in LPCWSTR wzTransactionId,
1736 __in HRESULT hrStatus,
1737 __in BOOTSTRAPPER_APPLY_RESTART restart,
1738 __inout BOOTSTRAPPER_EXECUTEMSITRANSACTIONCOMPLETE_ACTION* pAction
1739)
1740{
1741 HRESULT hr = S_OK;
1742 BA_ONCOMMITMSITRANSACTIONCOMPLETE_ARGS args = { };
1743 BA_ONCOMMITMSITRANSACTIONCOMPLETE_RESULTS results = { };
1744 BUFF_BUFFER bufferArgs = { };
1745 BUFF_BUFFER bufferResults = { };
1746 PIPE_RPC_RESULT rpc = { };
1747 SIZE_T iBuffer = 0;
1748
1749 // Init structs.
1750 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1751 args.wzTransactionId = wzTransactionId;
1752 args.hrStatus = hrStatus;
1753 args.restart = restart;
1754 args.recommendation = *pAction;
1755
1756 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1757 results.action = *pAction;
1758
1759 // Send args.
1760 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
1761 ExitOnFailure(hr, "Failed to write API version of OnCommitMsiTransactionComplete args.");
1762
1763 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzTransactionId);
1764 ExitOnFailure(hr, "Failed to write transaction id of OnCommitMsiTransactionComplete args.");
1765
1766 hr = BuffWriteNumberToBuffer(&bufferArgs, args.hrStatus);
1767 ExitOnFailure(hr, "Failed to write status of OnCommitMsiTransactionComplete args.");
1768
1769 hr = BuffWriteNumberToBuffer(&bufferArgs, args.restart);
1770 ExitOnFailure(hr, "Failed to write restart of OnCommitMsiTransactionComplete args.");
1771
1772 hr = BuffWriteNumberToBuffer(&bufferArgs, args.recommendation);
1773 ExitOnFailure(hr, "Failed to write recommendation of OnCommitMsiTransactionComplete args.");
1774
1775 // Send results.
1776 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
1777 ExitOnFailure(hr, "Failed to write API version of OnCommitMsiTransactionComplete results.");
1778
1779 hr = BuffWriteNumberToBuffer(&bufferResults, results.action);
1780 ExitOnFailure(hr, "Failed to write API version of OnCommitMsiTransactionComplete results.");
1781
1782 // Callback.
1783 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONCOMMITMSITRANSACTIONCOMPLETE, &bufferArgs, &bufferResults, &rpc);
1784 ExitOnFailure(hr, "BA OnCommitMsiTransactionComplete failed.");
1785
1786 if (S_FALSE == hr)
1787 {
1788 ExitFunction();
1789 }
1790
1791 // Read results.
1792 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
1793 ExitOnFailure(hr, "Failed to read size of OnCommitMsiTransactionComplete result.");
1794
1795 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.action));
1796 ExitOnFailure(hr, "Failed to read action of OnCommitMsiTransactionComplete result.");
1797
1798 *pAction = results.action;
1799
1800LExit:
1801 PipeFreeRpcResult(&rpc);
1802 ReleaseBuffer(bufferResults);
1803 ReleaseBuffer(bufferArgs);
1804
1805 return hr;
1806}
1807
1808EXTERN_C HRESULT BACallbackOnCreate(
1809 __in BURN_USER_EXPERIENCE* pUserExperience,
1810 __in BOOTSTRAPPER_COMMAND* pCommand
1811)
1812{
1813 HRESULT hr = S_OK;
1814 BA_ONCREATE_ARGS args = { };
1815 BA_ONCREATE_RESULTS results = { };
1816 BUFF_BUFFER bufferArgs = { };
1817 BUFF_BUFFER bufferResults = { };
1818 PIPE_RPC_RESULT rpc = { };
1819
1820 // Init structs.
1821 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1822
1823 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1824
1825 // Send args.
1826 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
1827 ExitOnFailure(hr, "Failed to write API version of OnCreate args.");
1828
1829 hr = BuffWriteNumberToBuffer(&bufferArgs, pCommand->cbSize);
1830 ExitOnFailure(hr, "Failed to write size of OnCreate args command.");
1831
1832 hr = BuffWriteNumberToBuffer(&bufferArgs, pCommand->action);
1833 ExitOnFailure(hr, "Failed to write action of OnCreate args command.");
1834
1835 hr = BuffWriteNumberToBuffer(&bufferArgs, pCommand->display);
1836 ExitOnFailure(hr, "Failed to write display of OnCreate args command.");
1837
1838 hr = BuffWriteStringToBuffer(&bufferArgs, pCommand->wzCommandLine);
1839 ExitOnFailure(hr, "Failed to write command-line of OnCreate args command.");
1840
1841 hr = BuffWriteNumberToBuffer(&bufferArgs, pCommand->nCmdShow);
1842 ExitOnFailure(hr, "Failed to write show command of OnCreate args command.");
1843
1844 hr = BuffWriteNumberToBuffer(&bufferArgs, pCommand->resumeType);
1845 ExitOnFailure(hr, "Failed to write resume type of OnCreate args command.");
1846
1847 hr = BuffWriteNumber64ToBuffer(&bufferArgs, reinterpret_cast<DWORD64>(pCommand->hwndSplashScreen));
1848 ExitOnFailure(hr, "Failed to write splash screen handle of OnCreate args command.");
1849
1850 hr = BuffWriteNumberToBuffer(&bufferArgs, pCommand->relationType);
1851 ExitOnFailure(hr, "Failed to write relation type of OnCreate args command.");
1852
1853 hr = BuffWriteNumberToBuffer(&bufferArgs, pCommand->fPassthrough);
1854 ExitOnFailure(hr, "Failed to write passthrough of OnCreate args command.");
1855
1856 hr = BuffWriteStringToBuffer(&bufferArgs, pCommand->wzLayoutDirectory);
1857 ExitOnFailure(hr, "Failed to write layout directory of OnCreate args command.");
1858
1859 hr = BuffWriteStringToBuffer(&bufferArgs, pCommand->wzBootstrapperWorkingFolder);
1860 ExitOnFailure(hr, "Failed to write working folder of OnCreate args command.");
1861
1862 hr = BuffWriteStringToBuffer(&bufferArgs, pCommand->wzBootstrapperApplicationDataPath);
1863 ExitOnFailure(hr, "Failed to write application data path of OnCreate args command.");
1864
1865 // Send results.
1866 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
1867 ExitOnFailure(hr, "Failed to write API version of OnCreate results.");
1868
1869 // Callback.
1870 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONCREATE, &bufferArgs, &bufferResults, &rpc);
1871 ExitOnFailure(hr, "BA OnCreate failed.");
1872
1873 if (S_FALSE == hr)
1874 {
1875 ExitFunction();
1876 }
1877
1878LExit:
1879 PipeFreeRpcResult(&rpc);
1880 ReleaseBuffer(bufferResults);
1881 ReleaseBuffer(bufferArgs);
1882
1883 return hr;
1884}
1885
1886EXTERN_C HRESULT BACallbackOnDestroy(
1887 __in BURN_USER_EXPERIENCE* pUserExperience,
1888 __in BOOL fReload
1889)
1890{
1891 HRESULT hr = S_OK;
1892 BA_ONDESTROY_ARGS args = { };
1893 BA_ONDESTROY_RESULTS results = { };
1894 BUFF_BUFFER bufferArgs = { };
1895 BUFF_BUFFER bufferResults = { };
1896 PIPE_RPC_RESULT rpc = { };
1897
1898 // Init structs.
1899 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1900 args.fReload = fReload;
1901
1902 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1903
1904 // Send args.
1905 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
1906 ExitOnFailure(hr, "Failed to write API version of OnDestroy args.");
1907
1908 hr = BuffWriteNumberToBuffer(&bufferArgs, args.fReload);
1909 ExitOnFailure(hr, "Failed to write reload of OnDestroy args.");
1910
1911 // Send results.
1912 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
1913 ExitOnFailure(hr, "Failed to write API version of OnDestroy results.");
1914
1915 // Callback.
1916 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONDESTROY, &bufferArgs, &bufferResults, &rpc);
1917 ExitOnFailure(hr, "BA OnDestroy failed.");
1918
1919 if (S_FALSE == hr)
1920 {
1921 ExitFunction();
1922 }
1923
1924LExit:
1925 PipeFreeRpcResult(&rpc);
1926 ReleaseBuffer(bufferResults);
1927 ReleaseBuffer(bufferArgs);
1928
1929 return hr;
1930}
1931
1932EXTERN_C HRESULT BACallbackOnDetectBegin(
1933 __in BURN_USER_EXPERIENCE* pUserExperience,
1934 __in BOOL fCached,
1935 __in BOOTSTRAPPER_REGISTRATION_TYPE registrationType,
1936 __in DWORD cPackages
1937 )
1938{
1939 HRESULT hr = S_OK;
1940 BA_ONDETECTBEGIN_ARGS args = { };
1941 BA_ONDETECTBEGIN_RESULTS results = { };
1942 BUFF_BUFFER bufferArgs = { };
1943 BUFF_BUFFER bufferResults = { };
1944 PIPE_RPC_RESULT rpc = { };
1945 SIZE_T iBuffer = 0;
1946
1947 // Init structs.
1948 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1949 args.registrationType = registrationType;
1950 args.cPackages = cPackages;
1951 args.fCached = fCached;
1952
1953 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
1954
1955 // Send args.
1956 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
1957 ExitOnFailure(hr, "Failed to write API version of OnDetectBegin args.");
1958
1959 hr = BuffWriteNumberToBuffer(&bufferArgs, args.registrationType);
1960 ExitOnFailure(hr, "Failed to write restart of OnDetectBegin args.");
1961
1962 hr = BuffWriteNumberToBuffer(&bufferArgs, args.cPackages);
1963 ExitOnFailure(hr, "Failed to write package count of OnDetectBegin args.");
1964
1965 hr = BuffWriteNumberToBuffer(&bufferArgs, args.fCached);
1966 ExitOnFailure(hr, "Failed to write cached of OnDetectBegin args.");
1967
1968 // Send results.
1969 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
1970 ExitOnFailure(hr, "Failed to write API version of OnDetectBegin results.");
1971
1972 // Callback.
1973 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTBEGIN, &bufferArgs, &bufferResults, &rpc);
1974 ExitOnFailure(hr, "BA OnDetectBegin failed.");
1975
1976 if (S_FALSE == hr)
1977 {
1978 ExitFunction();
1979 }
1980
1981 // Read results.
1982 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
1983 ExitOnFailure(hr, "Failed to read size of OnDetectBegin result.");
1984
1985 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
1986 ExitOnFailure(hr, "Failed to read cancel of OnDetectBegin result.");
1987
1988 if (results.fCancel)
1989 {
1990 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
1991 }
1992
1993LExit:
1994 PipeFreeRpcResult(&rpc);
1995 ReleaseBuffer(bufferResults);
1996 ReleaseBuffer(bufferArgs);
1997
1998 return hr;
1999}
2000
2001EXTERN_C HRESULT BACallbackOnDetectCompatibleMsiPackage(
2002 __in BURN_USER_EXPERIENCE* pUserExperience,
2003 __in_z LPCWSTR wzPackageId,
2004 __in_z LPCWSTR wzCompatiblePackageId,
2005 __in VERUTIL_VERSION* pCompatiblePackageVersion
2006 )
2007{
2008 HRESULT hr = S_OK;
2009 BA_ONDETECTCOMPATIBLEMSIPACKAGE_ARGS args = { };
2010 BA_ONDETECTCOMPATIBLEMSIPACKAGE_RESULTS results = { };
2011 BUFF_BUFFER bufferArgs = { };
2012 BUFF_BUFFER bufferResults = { };
2013 PIPE_RPC_RESULT rpc = { };
2014 SIZE_T iBuffer = 0;
2015
2016 // Init structs.
2017 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2018 args.wzPackageId = wzPackageId;
2019 args.wzCompatiblePackageId = wzCompatiblePackageId;
2020 args.wzCompatiblePackageVersion = pCompatiblePackageVersion->sczVersion;
2021
2022 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2023
2024 // Send args.
2025 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
2026 ExitOnFailure(hr, "Failed to write API version of OnDetectCompatibleMsiPackage args.");
2027
2028 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageId);
2029 ExitOnFailure(hr, "Failed to write package id of OnDetectCompatibleMsiPackage args.");
2030
2031 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzCompatiblePackageId);
2032 ExitOnFailure(hr, "Failed to write compatible package id of OnDetectCompatibleMsiPackage args.");
2033
2034 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzCompatiblePackageVersion);
2035 ExitOnFailure(hr, "Failed to write compatible package version of OnDetectCompatibleMsiPackage args.");
2036
2037 // Send results.
2038 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
2039 ExitOnFailure(hr, "Failed to write API version of OnDetectCompatibleMsiPackage results.");
2040
2041 // Callback.
2042 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTCOMPATIBLEMSIPACKAGE, &bufferArgs, &bufferResults, &rpc);
2043 ExitOnFailure(hr, "BA OnDetectCompatibleMsiPackage failed.");
2044
2045 if (S_FALSE == hr)
2046 {
2047 ExitFunction();
2048 }
2049
2050 // Read results.
2051 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
2052 ExitOnFailure(hr, "Failed to read size of OnDetectCompatibleMsiPackage result.");
2053
2054 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
2055 ExitOnFailure(hr, "Failed to read cancel of OnDetectCompatibleMsiPackage result.");
2056
2057 if (results.fCancel)
2058 {
2059 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
2060 }
2061
2062LExit:
2063 PipeFreeRpcResult(&rpc);
2064 ReleaseBuffer(bufferResults);
2065 ReleaseBuffer(bufferArgs);
2066
2067 return hr;
2068}
2069
2070EXTERN_C HRESULT BACallbackOnDetectComplete(
2071 __in BURN_USER_EXPERIENCE* pUserExperience,
2072 __in HRESULT hrStatus,
2073 __in BOOL fEligibleForCleanup
2074 )
2075{
2076 HRESULT hr = S_OK;
2077 BA_ONDETECTCOMPLETE_ARGS args = { };
2078 BA_ONDETECTCOMPLETE_RESULTS results = { };
2079 BUFF_BUFFER bufferArgs = { };
2080 BUFF_BUFFER bufferResults = { };
2081 PIPE_RPC_RESULT rpc = { };
2082
2083 // Init structs.
2084 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2085 args.hrStatus = hrStatus;
2086 args.fEligibleForCleanup = fEligibleForCleanup;
2087
2088 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2089
2090 // Send args.
2091 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
2092 ExitOnFailure(hr, "Failed to write API version of OnDetectComplete args.");
2093
2094 hr = BuffWriteNumberToBuffer(&bufferArgs, args.hrStatus);
2095 ExitOnFailure(hr, "Failed to write status of OnDetectComplete args.");
2096
2097 hr = BuffWriteNumberToBuffer(&bufferArgs, args.fEligibleForCleanup);
2098 ExitOnFailure(hr, "Failed to write eligible for cleanup of OnDetectComplete args.");
2099
2100 // Send results.
2101 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
2102 ExitOnFailure(hr, "Failed to write API version of OnDetectComplete results.");
2103
2104 // Callback.
2105 hr = SendBAMessageFromInactiveEngine(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTCOMPLETE, &bufferArgs, &bufferResults, &rpc);
2106 ExitOnFailure(hr, "BA OnDetectComplete failed.");
2107
2108 if (S_FALSE == hr)
2109 {
2110 ExitFunction();
2111 }
2112
2113LExit:
2114 PipeFreeRpcResult(&rpc);
2115 ReleaseBuffer(bufferResults);
2116 ReleaseBuffer(bufferArgs);
2117
2118 return hr;
2119}
2120
2121EXTERN_C HRESULT BACallbackOnDetectForwardCompatibleBundle(
2122 __in BURN_USER_EXPERIENCE* pUserExperience,
2123 __in_z LPCWSTR wzBundleId,
2124 __in BOOTSTRAPPER_RELATION_TYPE relationType,
2125 __in_z LPCWSTR wzBundleTag,
2126 __in BOOL fPerMachine,
2127 __in VERUTIL_VERSION* pVersion,
2128 __in BOOL fMissingFromCache
2129 )
2130{
2131 HRESULT hr = S_OK;
2132 BA_ONDETECTFORWARDCOMPATIBLEBUNDLE_ARGS args = { };
2133 BA_ONDETECTFORWARDCOMPATIBLEBUNDLE_RESULTS results = { };
2134 BUFF_BUFFER bufferArgs = { };
2135 BUFF_BUFFER bufferResults = { };
2136 PIPE_RPC_RESULT rpc = { };
2137 SIZE_T iBuffer = 0;
2138
2139 // Init structs.
2140 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2141 args.wzBundleId = wzBundleId;
2142 args.relationType = relationType;
2143 args.wzBundleTag = wzBundleTag;
2144 args.fPerMachine = fPerMachine;
2145 args.wzVersion = pVersion->sczVersion;
2146 args.fMissingFromCache = fMissingFromCache;
2147
2148 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2149
2150 // Send args.
2151 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
2152 ExitOnFailure(hr, "Failed to write API version of OnDetectForwardCompatibleBundle args.");
2153
2154 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzBundleId);
2155 ExitOnFailure(hr, "Failed to write bundle id of OnDetectForwardCompatibleBundle args.");
2156
2157 hr = BuffWriteNumberToBuffer(&bufferArgs, args.relationType);
2158 ExitOnFailure(hr, "Failed to write relation type of OnDetectForwardCompatibleBundle args.");
2159
2160 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzBundleTag);
2161 ExitOnFailure(hr, "Failed to write bundle tag of OnDetectForwardCompatibleBundle args.");
2162
2163 hr = BuffWriteNumberToBuffer(&bufferArgs, args.fPerMachine);
2164 ExitOnFailure(hr, "Failed to write per-machine of OnDetectForwardCompatibleBundle args.");
2165
2166 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzVersion);
2167 ExitOnFailure(hr, "Failed to write version of OnDetectForwardCompatibleBundle args.");
2168
2169 hr = BuffWriteNumberToBuffer(&bufferArgs, args.fMissingFromCache);
2170 ExitOnFailure(hr, "Failed to write missing from cache of OnDetectForwardCompatibleBundle args.");
2171
2172 // Send results.
2173 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
2174 ExitOnFailure(hr, "Failed to write API version of OnDetectForwardCompatibleBundle results.");
2175
2176 // Callback.
2177 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTFORWARDCOMPATIBLEBUNDLE, &bufferArgs, &bufferResults, &rpc);
2178 ExitOnFailure(hr, "BA OnDetectForwardCompatibleBundle failed.");
2179
2180 if (S_FALSE == hr)
2181 {
2182 ExitFunction();
2183 }
2184
2185 // Read results.
2186 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
2187 ExitOnFailure(hr, "Failed to read size of OnDetectForwardCompatibleBundle result.");
2188
2189 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
2190 ExitOnFailure(hr, "Failed to read cancel of OnDetectForwardCompatibleBundle result.");
2191
2192 if (results.fCancel)
2193 {
2194 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
2195 }
2196
2197LExit:
2198 PipeFreeRpcResult(&rpc);
2199 ReleaseBuffer(bufferResults);
2200 ReleaseBuffer(bufferArgs);
2201
2202 return hr;
2203}
2204
2205EXTERN_C HRESULT BACallbackOnDetectMsiFeature(
2206 __in BURN_USER_EXPERIENCE* pUserExperience,
2207 __in_z LPCWSTR wzPackageId,
2208 __in_z LPCWSTR wzFeatureId,
2209 __in BOOTSTRAPPER_FEATURE_STATE state
2210 )
2211{
2212 HRESULT hr = S_OK;
2213 BA_ONDETECTMSIFEATURE_ARGS args = { };
2214 BA_ONDETECTMSIFEATURE_RESULTS results = { };
2215 BUFF_BUFFER bufferArgs = { };
2216 BUFF_BUFFER bufferResults = { };
2217 PIPE_RPC_RESULT rpc = { };
2218 SIZE_T iBuffer = 0;
2219
2220 // Init structs.
2221 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2222 args.wzPackageId = wzPackageId;
2223 args.wzFeatureId = wzFeatureId;
2224 args.state = state;
2225
2226 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2227
2228 // Send args.
2229 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
2230 ExitOnFailure(hr, "Failed to write API version of OnDetectMsiFeature args.");
2231
2232 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageId);
2233 ExitOnFailure(hr, "Failed to write package id of OnDetectMsiFeature args.");
2234
2235 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzFeatureId);
2236 ExitOnFailure(hr, "Failed to write feature id of OnDetectMsiFeature args.");
2237
2238 hr = BuffWriteNumberToBuffer(&bufferArgs, args.state);
2239 ExitOnFailure(hr, "Failed to write state of OnDetectMsiFeature args.");
2240
2241 // Send results.
2242 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
2243 ExitOnFailure(hr, "Failed to write API version of OnDetectMsiFeature results.");
2244
2245 // Callback.
2246 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTMSIFEATURE, &bufferArgs, &bufferResults, &rpc);
2247 ExitOnFailure(hr, "BA OnDetectMsiFeature failed.");
2248
2249 if (S_FALSE == hr)
2250 {
2251 ExitFunction();
2252 }
2253
2254 // Read results.
2255 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
2256 ExitOnFailure(hr, "Failed to read size of OnDetectMsiFeature result.");
2257
2258 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
2259 ExitOnFailure(hr, "Failed to read cancel of OnDetectMsiFeature result.");
2260
2261 if (results.fCancel)
2262 {
2263 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
2264 }
2265
2266LExit:
2267 PipeFreeRpcResult(&rpc);
2268 ReleaseBuffer(bufferResults);
2269 ReleaseBuffer(bufferArgs);
2270
2271 return hr;
2272}
2273
2274EXTERN_C HRESULT BACallbackOnDetectPackageBegin(
2275 __in BURN_USER_EXPERIENCE* pUserExperience,
2276 __in_z LPCWSTR wzPackageId
2277 )
2278{
2279 HRESULT hr = S_OK;
2280 BA_ONDETECTPACKAGEBEGIN_ARGS args = { };
2281 BA_ONDETECTPACKAGEBEGIN_RESULTS results = { };
2282 BUFF_BUFFER bufferArgs = { };
2283 BUFF_BUFFER bufferResults = { };
2284 PIPE_RPC_RESULT rpc = { };
2285 SIZE_T iBuffer = 0;
2286
2287 // Init structs.
2288 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2289 args.wzPackageId = wzPackageId;
2290
2291 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2292
2293 // Send args.
2294 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
2295 ExitOnFailure(hr, "Failed to write API version of OnDetectPackageBegin args.");
2296
2297 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageId);
2298 ExitOnFailure(hr, "Failed to write package id of OnDetectPackageBegin args.");
2299
2300 // Send results.
2301 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
2302 ExitOnFailure(hr, "Failed to write API version of OnDetectPackageBegin results.");
2303
2304 // Callback.
2305 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTPACKAGEBEGIN, &bufferArgs, &bufferResults, &rpc);
2306 ExitOnFailure(hr, "BA OnDetectPackageBegin failed.");
2307
2308 if (S_FALSE == hr)
2309 {
2310 ExitFunction();
2311 }
2312
2313 // Read results.
2314 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
2315 ExitOnFailure(hr, "Failed to read size of OnDetectPackageBegin result.");
2316
2317 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
2318 ExitOnFailure(hr, "Failed to read cancel of OnDetectPackageBegin result.");
2319
2320 if (results.fCancel)
2321 {
2322 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
2323 }
2324
2325LExit:
2326 PipeFreeRpcResult(&rpc);
2327 ReleaseBuffer(bufferResults);
2328 ReleaseBuffer(bufferArgs);
2329
2330 return hr;
2331}
2332
2333EXTERN_C HRESULT BACallbackOnDetectPackageComplete(
2334 __in BURN_USER_EXPERIENCE* pUserExperience,
2335 __in_z LPCWSTR wzPackageId,
2336 __in HRESULT hrStatus,
2337 __in BOOTSTRAPPER_PACKAGE_STATE state,
2338 __in BOOL fCached
2339 )
2340{
2341 HRESULT hr = S_OK;
2342 BA_ONDETECTPACKAGECOMPLETE_ARGS args = { };
2343 BA_ONDETECTPACKAGECOMPLETE_RESULTS results = { };
2344 BUFF_BUFFER bufferArgs = { };
2345 BUFF_BUFFER bufferResults = { };
2346 PIPE_RPC_RESULT rpc = { };
2347
2348 // Init structs.
2349 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2350 args.wzPackageId = wzPackageId;
2351 args.hrStatus = hrStatus;
2352 args.state = state;
2353 args.fCached = fCached;
2354
2355 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2356
2357 // Send args.
2358 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
2359 ExitOnFailure(hr, "Failed to write API version of OnDetectPackageComplete args.");
2360
2361 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageId);
2362 ExitOnFailure(hr, "Failed to write package id of OnDetectPackageComplete args.");
2363
2364 hr = BuffWriteNumberToBuffer(&bufferArgs, args.hrStatus);
2365 ExitOnFailure(hr, "Failed to write status of OnDetectPackageComplete args.");
2366
2367 hr = BuffWriteNumberToBuffer(&bufferArgs, args.state);
2368 ExitOnFailure(hr, "Failed to write state of OnDetectPackageComplete args.");
2369
2370 hr = BuffWriteNumberToBuffer(&bufferArgs, args.fCached);
2371 ExitOnFailure(hr, "Failed to write cached of OnDetectPackageComplete args.");
2372
2373 // Send results.
2374 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
2375 ExitOnFailure(hr, "Failed to write API version of OnDetectPackageComplete results.");
2376
2377 // Callback.
2378 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTPACKAGECOMPLETE, &bufferArgs, &bufferResults, &rpc);
2379 ExitOnFailure(hr, "BA OnDetectPackageComplete failed.");
2380
2381 if (S_FALSE == hr)
2382 {
2383 ExitFunction();
2384 }
2385
2386LExit:
2387 PipeFreeRpcResult(&rpc);
2388 ReleaseBuffer(bufferResults);
2389 ReleaseBuffer(bufferArgs);
2390
2391 return hr;
2392}
2393
2394EXTERN_C HRESULT BACallbackOnDetectRelatedBundle(
2395 __in BURN_USER_EXPERIENCE* pUserExperience,
2396 __in_z LPCWSTR wzBundleId,
2397 __in BOOTSTRAPPER_RELATION_TYPE relationType,
2398 __in_z LPCWSTR wzBundleTag,
2399 __in BOOL fPerMachine,
2400 __in VERUTIL_VERSION* pVersion,
2401 __in BOOL fMissingFromCache
2402 )
2403{
2404 HRESULT hr = S_OK;
2405 BA_ONDETECTRELATEDBUNDLE_ARGS args = { };
2406 BA_ONDETECTRELATEDBUNDLE_RESULTS results = { };
2407 BUFF_BUFFER bufferArgs = { };
2408 BUFF_BUFFER bufferResults = { };
2409 PIPE_RPC_RESULT rpc = { };
2410 SIZE_T iBuffer = 0;
2411
2412 // Init structs.
2413 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2414 args.wzBundleId = wzBundleId;
2415 args.relationType = relationType;
2416 args.wzBundleTag = wzBundleTag;
2417 args.fPerMachine = fPerMachine;
2418 args.wzVersion = pVersion->sczVersion;
2419 args.fMissingFromCache = fMissingFromCache;
2420
2421 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2422
2423 // Send args.
2424 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
2425 ExitOnFailure(hr, "Failed to write API version of OnDetectRelatedBundle args.");
2426
2427 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzBundleId);
2428 ExitOnFailure(hr, "Failed to write bundle id of OnDetectRelatedBundle args.");
2429
2430 hr = BuffWriteNumberToBuffer(&bufferArgs, args.relationType);
2431 ExitOnFailure(hr, "Failed to write relation type of OnDetectRelatedBundle args.");
2432
2433 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzBundleTag);
2434 ExitOnFailure(hr, "Failed to write bundle tag of OnDetectRelatedBundle args.");
2435
2436 hr = BuffWriteNumberToBuffer(&bufferArgs, args.fPerMachine);
2437 ExitOnFailure(hr, "Failed to write per-machine of OnDetectRelatedBundle args.");
2438
2439 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzVersion);
2440 ExitOnFailure(hr, "Failed to write version of OnDetectRelatedBundle args.");
2441
2442 hr = BuffWriteNumberToBuffer(&bufferArgs, args.fMissingFromCache);
2443 ExitOnFailure(hr, "Failed to write cached of OnDetectRelatedBundle args.");
2444
2445 // Send results.
2446 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
2447 ExitOnFailure(hr, "Failed to write API version of OnDetectRelatedBundle results.");
2448
2449 // Callback.
2450 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTRELATEDBUNDLE, &bufferArgs, &bufferResults, &rpc);
2451 ExitOnFailure(hr, "BA OnDetectRelatedBundle failed.");
2452
2453 if (S_FALSE == hr)
2454 {
2455 ExitFunction();
2456 }
2457
2458 // Read results.
2459 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
2460 ExitOnFailure(hr, "Failed to read size of OnDetectRelatedBundle result.");
2461
2462 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
2463 ExitOnFailure(hr, "Failed to read cancel of OnDetectRelatedBundle result.");
2464
2465 if (results.fCancel)
2466 {
2467 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
2468 }
2469
2470LExit:
2471 PipeFreeRpcResult(&rpc);
2472 ReleaseBuffer(bufferResults);
2473 ReleaseBuffer(bufferArgs);
2474
2475 return hr;
2476}
2477
2478EXTERN_C HRESULT BACallbackOnDetectRelatedBundlePackage(
2479 __in BURN_USER_EXPERIENCE* pUserExperience,
2480 __in_z LPCWSTR wzPackageId,
2481 __in_z LPCWSTR wzBundleId,
2482 __in BOOTSTRAPPER_RELATION_TYPE relationType,
2483 __in BOOL fPerMachine,
2484 __in VERUTIL_VERSION* pVersion
2485 )
2486{
2487 HRESULT hr = S_OK;
2488 BA_ONDETECTRELATEDBUNDLEPACKAGE_ARGS args = { };
2489 BA_ONDETECTRELATEDBUNDLEPACKAGE_RESULTS results = { };
2490 BUFF_BUFFER bufferArgs = { };
2491 BUFF_BUFFER bufferResults = { };
2492 PIPE_RPC_RESULT rpc = { };
2493 SIZE_T iBuffer = 0;
2494
2495 // Init structs.
2496 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2497 args.wzPackageId = wzPackageId;
2498 args.wzBundleId = wzBundleId;
2499 args.relationType = relationType;
2500 args.fPerMachine = fPerMachine;
2501 args.wzVersion = pVersion->sczVersion;
2502
2503 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2504
2505 // Send args.
2506 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
2507 ExitOnFailure(hr, "Failed to write API version of OnDetectRelatedBundlePackage args.");
2508
2509 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageId);
2510 ExitOnFailure(hr, "Failed to write package id of OnDetectRelatedBundlePackage args.");
2511
2512 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzBundleId);
2513 ExitOnFailure(hr, "Failed to write bundle id of OnDetectRelatedBundlePackage args.");
2514
2515 hr = BuffWriteNumberToBuffer(&bufferArgs, args.relationType);
2516 ExitOnFailure(hr, "Failed to write relation type of OnDetectRelatedBundlePackage args.");
2517
2518 hr = BuffWriteNumberToBuffer(&bufferArgs, args.fPerMachine);
2519 ExitOnFailure(hr, "Failed to write per-machine of OnDetectRelatedBundlePackage args.");
2520
2521 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzVersion);
2522 ExitOnFailure(hr, "Failed to write version of OnDetectRelatedBundlePackage args.");
2523
2524 // Send results.
2525 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
2526 ExitOnFailure(hr, "Failed to write API version of OnDetectRelatedBundlePackage results.");
2527
2528 // Callback.
2529 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTRELATEDBUNDLEPACKAGE, &bufferArgs, &bufferResults, &rpc);
2530 ExitOnFailure(hr, "BA OnDetectRelatedBundlePackage failed.");
2531
2532 if (S_FALSE == hr)
2533 {
2534 ExitFunction();
2535 }
2536
2537 // Read results.
2538 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
2539 ExitOnFailure(hr, "Failed to read size of OnDetectRelatedBundlePackage result.");
2540
2541 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
2542 ExitOnFailure(hr, "Failed to read cancel of OnDetectRelatedBundlePackage result.");
2543
2544 if (results.fCancel)
2545 {
2546 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
2547 }
2548
2549LExit:
2550 PipeFreeRpcResult(&rpc);
2551 ReleaseBuffer(bufferResults);
2552 ReleaseBuffer(bufferArgs);
2553
2554 return hr;
2555}
2556
2557EXTERN_C HRESULT BACallbackOnDetectRelatedMsiPackage(
2558 __in BURN_USER_EXPERIENCE* pUserExperience,
2559 __in_z LPCWSTR wzPackageId,
2560 __in_z LPCWSTR wzUpgradeCode,
2561 __in_z LPCWSTR wzProductCode,
2562 __in BOOL fPerMachine,
2563 __in VERUTIL_VERSION* pVersion,
2564 __in BOOTSTRAPPER_RELATED_OPERATION operation
2565 )
2566{
2567 HRESULT hr = S_OK;
2568 BA_ONDETECTRELATEDMSIPACKAGE_ARGS args = { };
2569 BA_ONDETECTRELATEDMSIPACKAGE_RESULTS results = { };
2570 BUFF_BUFFER bufferArgs = { };
2571 BUFF_BUFFER bufferResults = { };
2572 PIPE_RPC_RESULT rpc = { };
2573 SIZE_T iBuffer = 0;
2574
2575 // Init structs.
2576 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2577 args.wzPackageId = wzPackageId;
2578 args.wzUpgradeCode = wzUpgradeCode;
2579 args.wzProductCode = wzProductCode;
2580 args.fPerMachine = fPerMachine;
2581 args.wzVersion = pVersion->sczVersion;
2582 args.operation = operation;
2583
2584 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2585
2586 // Send args.
2587 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
2588 ExitOnFailure(hr, "Failed to write API version of OnDetectRelatedMsiPackage args.");
2589
2590 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageId);
2591 ExitOnFailure(hr, "Failed to write package id of OnDetectRelatedMsiPackage args.");
2592
2593 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzUpgradeCode);
2594 ExitOnFailure(hr, "Failed to write upgrade code of OnDetectRelatedMsiPackage args.");
2595
2596 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzProductCode);
2597 ExitOnFailure(hr, "Failed to write product code of OnDetectRelatedMsiPackage args.");
2598
2599 hr = BuffWriteNumberToBuffer(&bufferArgs, args.fPerMachine);
2600 ExitOnFailure(hr, "Failed to write per-machine of OnDetectRelatedMsiPackage args.");
2601
2602 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzVersion);
2603 ExitOnFailure(hr, "Failed to write version of OnDetectRelatedMsiPackage args.");
2604
2605 hr = BuffWriteNumberToBuffer(&bufferArgs, args.operation);
2606 ExitOnFailure(hr, "Failed to write operation OnDetectRelatedMsiPackage args.");
2607
2608 // Send results.
2609 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
2610 ExitOnFailure(hr, "Failed to write API version of OnDetectRelatedMsiPackage results.");
2611
2612 // Callback.
2613 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTRELATEDMSIPACKAGE, &bufferArgs, &bufferResults, &rpc);
2614 ExitOnFailure(hr, "BA OnDetectRelatedMsiPackage failed.");
2615
2616 if (S_FALSE == hr)
2617 {
2618 ExitFunction();
2619 }
2620
2621 // Read results.
2622 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
2623 ExitOnFailure(hr, "Failed to read size of OnDetectRelatedMsiPackage result.");
2624
2625 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
2626 ExitOnFailure(hr, "Failed to read cancel of OnDetectRelatedMsiPackage result.");
2627
2628 if (results.fCancel)
2629 {
2630 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
2631 }
2632
2633LExit:
2634 PipeFreeRpcResult(&rpc);
2635 ReleaseBuffer(bufferResults);
2636 ReleaseBuffer(bufferArgs);
2637
2638 return hr;
2639}
2640
2641EXTERN_C HRESULT BACallbackOnDetectPatchTarget(
2642 __in BURN_USER_EXPERIENCE* pUserExperience,
2643 __in_z LPCWSTR wzPackageId,
2644 __in_z LPCWSTR wzProductCode,
2645 __in BOOTSTRAPPER_PACKAGE_STATE patchState
2646 )
2647{
2648 HRESULT hr = S_OK;
2649 BA_ONDETECTPATCHTARGET_ARGS args = { };
2650 BA_ONDETECTPATCHTARGET_RESULTS results = { };
2651 BUFF_BUFFER bufferArgs = { };
2652 BUFF_BUFFER bufferResults = { };
2653 PIPE_RPC_RESULT rpc = { };
2654 SIZE_T iBuffer = 0;
2655
2656 // Init structs.
2657 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2658 args.wzPackageId = wzPackageId;
2659 args.wzProductCode = wzProductCode;
2660 args.patchState = patchState;
2661
2662 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2663
2664 // Send args.
2665 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
2666 ExitOnFailure(hr, "Failed to write API version of OnDetectPatchTarget args.");
2667
2668 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageId);
2669 ExitOnFailure(hr, "Failed to write package id of OnDetectPatchTarget args.");
2670
2671 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzProductCode);
2672 ExitOnFailure(hr, "Failed to write product code of OnDetectPatchTarget args.");
2673
2674 hr = BuffWriteNumberToBuffer(&bufferArgs, args.patchState);
2675 ExitOnFailure(hr, "Failed to write patch state OnDetectPatchTarget args.");
2676
2677 // Send results.
2678 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
2679 ExitOnFailure(hr, "Failed to write API version of OnDetectPatchTarget results.");
2680
2681 // Callback.
2682 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTPATCHTARGET, &bufferArgs, &bufferResults, &rpc);
2683 ExitOnFailure(hr, "BA OnDetectPatchTarget failed.");
2684
2685 if (S_FALSE == hr)
2686 {
2687 ExitFunction();
2688 }
2689
2690 // Read results.
2691 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
2692 ExitOnFailure(hr, "Failed to read size of OnDetectPatchTarget result.");
2693
2694 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
2695 ExitOnFailure(hr, "Failed to read cancel of OnDetectPatchTarget result.");
2696
2697 if (results.fCancel)
2698 {
2699 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
2700 }
2701
2702LExit:
2703 PipeFreeRpcResult(&rpc);
2704 ReleaseBuffer(bufferResults);
2705 ReleaseBuffer(bufferArgs);
2706
2707 return hr;
2708}
2709
2710EXTERN_C HRESULT BACallbackOnDetectUpdate(
2711 __in BURN_USER_EXPERIENCE* pUserExperience,
2712 __in_z_opt LPCWSTR wzUpdateLocation,
2713 __in DWORD64 dw64Size,
2714 __in_z_opt LPCWSTR wzHash,
2715 __in BOOTSTRAPPER_UPDATE_HASH_TYPE hashAlgorithm,
2716 __in VERUTIL_VERSION* pVersion,
2717 __in_z_opt LPCWSTR wzTitle,
2718 __in_z_opt LPCWSTR wzSummary,
2719 __in_z_opt LPCWSTR wzContentType,
2720 __in_z_opt LPCWSTR wzContent,
2721 __inout BOOL* pfStopProcessingUpdates
2722 )
2723{
2724 HRESULT hr = S_OK;
2725 BA_ONDETECTUPDATE_ARGS args = { };
2726 BA_ONDETECTUPDATE_RESULTS results = { };
2727 BUFF_BUFFER bufferArgs = { };
2728 BUFF_BUFFER bufferResults = { };
2729 PIPE_RPC_RESULT rpc = { };
2730 SIZE_T iBuffer = 0;
2731
2732 // Init structs.
2733 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2734 args.wzUpdateLocation = wzUpdateLocation;
2735 args.dw64Size = dw64Size;
2736 args.wzHash = wzHash;
2737 args.hashAlgorithm = hashAlgorithm;
2738 args.wzVersion = pVersion->sczVersion;
2739 args.wzTitle = wzTitle;
2740 args.wzSummary = wzSummary;
2741 args.wzContentType = wzContentType;
2742 args.wzContent = wzContent;
2743
2744 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2745 results.fStopProcessingUpdates = *pfStopProcessingUpdates;
2746
2747 // Send args.
2748 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
2749 ExitOnFailure(hr, "Failed to write API version of OnDetectUpdate args.");
2750
2751 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzUpdateLocation);
2752 ExitOnFailure(hr, "Failed to write update location of OnDetectUpdate args.");
2753
2754 hr = BuffWriteNumber64ToBuffer(&bufferArgs, args.dw64Size);
2755 ExitOnFailure(hr, "Failed to write update size OnDetectUpdate args.");
2756
2757 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzHash);
2758 ExitOnFailure(hr, "Failed to write hash of OnDetectUpdate args.");
2759
2760 hr = BuffWriteNumberToBuffer(&bufferArgs, args.hashAlgorithm);
2761 ExitOnFailure(hr, "Failed to write hash algorithm OnDetectUpdate args.");
2762
2763 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzVersion);
2764 ExitOnFailure(hr, "Failed to write version of OnDetectUpdate args.");
2765
2766 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzTitle);
2767 ExitOnFailure(hr, "Failed to write title of OnDetectUpdate args.");
2768
2769 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzSummary);
2770 ExitOnFailure(hr, "Failed to write summary of OnDetectUpdate args.");
2771
2772 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzContentType);
2773 ExitOnFailure(hr, "Failed to write content type of OnDetectUpdate args.");
2774
2775 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzContent);
2776 ExitOnFailure(hr, "Failed to write content of OnDetectUpdate args.");
2777
2778 // Send results.
2779 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
2780 ExitOnFailure(hr, "Failed to write API version of OnDetectUpdate results.");
2781
2782 hr = BuffWriteNumberToBuffer(&bufferResults, results.fStopProcessingUpdates);
2783 ExitOnFailure(hr, "Failed to write stop processing updates of OnDetectUpdate results.");
2784
2785 // Callback.
2786 hr = SendBAMessageFromInactiveEngine(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTUPDATE, &bufferArgs, &bufferResults, &rpc);
2787 ExitOnFailure(hr, "BA OnDetectUpdate failed.");
2788
2789 if (S_FALSE == hr)
2790 {
2791 ExitFunction();
2792 }
2793
2794 // Read results.
2795 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
2796 ExitOnFailure(hr, "Failed to read size of OnDetectUpdate result.");
2797
2798 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
2799 ExitOnFailure(hr, "Failed to read cancel of OnDetectUpdate result.");
2800
2801 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fStopProcessingUpdates));
2802 ExitOnFailure(hr, "Failed to read stop processing updates of OnDetectUpdate result.");
2803
2804 if (results.fCancel)
2805 {
2806 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
2807 }
2808
2809 *pfStopProcessingUpdates = results.fStopProcessingUpdates;
2810
2811LExit:
2812 PipeFreeRpcResult(&rpc);
2813 ReleaseBuffer(bufferResults);
2814 ReleaseBuffer(bufferArgs);
2815
2816 return hr;
2817}
2818
2819EXTERN_C HRESULT BACallbackOnDetectUpdateBegin(
2820 __in BURN_USER_EXPERIENCE* pUserExperience,
2821 __in_z LPCWSTR wzUpdateLocation,
2822 __inout BOOL* pfSkip
2823 )
2824{
2825 HRESULT hr = S_OK;
2826 BA_ONDETECTUPDATEBEGIN_ARGS args = { };
2827 BA_ONDETECTUPDATEBEGIN_RESULTS results = { };
2828 BUFF_BUFFER bufferArgs = { };
2829 BUFF_BUFFER bufferResults = { };
2830 PIPE_RPC_RESULT rpc = { };
2831 SIZE_T iBuffer = 0;
2832
2833 // Init structs.
2834 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2835 args.wzUpdateLocation = wzUpdateLocation;
2836
2837 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2838 results.fSkip = *pfSkip;
2839
2840 // Send args.
2841 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
2842 ExitOnFailure(hr, "Failed to write API version of OnDetectUpdateBegin args.");
2843
2844 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzUpdateLocation);
2845 ExitOnFailure(hr, "Failed to write update location of OnDetectUpdateBegin args.");
2846
2847 // Send results.
2848 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
2849 ExitOnFailure(hr, "Failed to write API version of OnDetectUpdateBegin results.");
2850
2851 hr = BuffWriteNumberToBuffer(&bufferResults, results.fSkip);
2852 ExitOnFailure(hr, "Failed to write skip of OnDetectUpdateBegin results.");
2853
2854 // Callback.
2855 hr = SendBAMessageFromInactiveEngine(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTUPDATEBEGIN, &bufferArgs, &bufferResults, &rpc);
2856 ExitOnFailure(hr, "BA OnDetectUpdateBegin failed.");
2857
2858 if (S_FALSE == hr)
2859 {
2860 ExitFunction();
2861 }
2862
2863 // Read results.
2864 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
2865 ExitOnFailure(hr, "Failed to read size of OnDetectUpdateBegin result.");
2866
2867 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
2868 ExitOnFailure(hr, "Failed to read cancel of OnDetectUpdateBegin result.");
2869
2870 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fSkip));
2871 ExitOnFailure(hr, "Failed to read cancel of OnDetectUpdateBegin result.");
2872
2873 if (results.fCancel)
2874 {
2875 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
2876 }
2877
2878 *pfSkip = results.fSkip;
2879
2880LExit:
2881 PipeFreeRpcResult(&rpc);
2882 ReleaseBuffer(bufferResults);
2883 ReleaseBuffer(bufferArgs);
2884
2885 return hr;
2886}
2887
2888EXTERN_C HRESULT BACallbackOnDetectUpdateComplete(
2889 __in BURN_USER_EXPERIENCE* pUserExperience,
2890 __in HRESULT hrStatus,
2891 __inout BOOL* pfIgnoreError
2892 )
2893{
2894 HRESULT hr = S_OK;
2895 BA_ONDETECTUPDATECOMPLETE_ARGS args = { };
2896 BA_ONDETECTUPDATECOMPLETE_RESULTS results = { };
2897 BUFF_BUFFER bufferArgs = { };
2898 BUFF_BUFFER bufferResults = { };
2899 PIPE_RPC_RESULT rpc = { };
2900 SIZE_T iBuffer = 0;
2901
2902 // Init structs.
2903 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2904 args.hrStatus = hrStatus;
2905
2906 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2907 results.fIgnoreError = *pfIgnoreError;
2908
2909 // Send args.
2910 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
2911 ExitOnFailure(hr, "Failed to write API version of OnDetectUpdateComplete args.");
2912
2913 hr = BuffWriteNumberToBuffer(&bufferArgs, args.hrStatus);
2914 ExitOnFailure(hr, "Failed to write status of OnDetectUpdateComplete args.");
2915
2916 // Send results.
2917 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
2918 ExitOnFailure(hr, "Failed to write API version of OnDetectUpdateComplete results.");
2919
2920 hr = BuffWriteNumberToBuffer(&bufferResults, results.fIgnoreError);
2921 ExitOnFailure(hr, "Failed to write ignore error of OnDetectUpdateComplete results.");
2922
2923 // Callback.
2924 hr = SendBAMessageFromInactiveEngine(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTUPDATECOMPLETE, &bufferArgs, &bufferResults, &rpc);
2925 ExitOnFailure(hr, "BA OnDetectUpdateComplete failed.");
2926
2927 if (S_FALSE == hr)
2928 {
2929 ExitFunction();
2930 }
2931
2932 // Read results.
2933 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
2934 ExitOnFailure(hr, "Failed to read size of OnDetectUpdateComplete result.");
2935
2936 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fIgnoreError));
2937 ExitOnFailure(hr, "Failed to read ignore error of OnDetectUpdateComplete result.");
2938
2939 if (FAILED(hrStatus))
2940 {
2941 *pfIgnoreError = results.fIgnoreError;
2942 }
2943
2944LExit:
2945 PipeFreeRpcResult(&rpc);
2946 ReleaseBuffer(bufferResults);
2947 ReleaseBuffer(bufferArgs);
2948
2949 return hr;
2950}
2951
2952EXTERN_C HRESULT BACallbackOnElevateBegin(
2953 __in BURN_USER_EXPERIENCE* pUserExperience
2954 )
2955{
2956 HRESULT hr = S_OK;
2957 BA_ONELEVATEBEGIN_ARGS args = { };
2958 BA_ONELEVATEBEGIN_RESULTS results = { };
2959 BUFF_BUFFER bufferArgs = { };
2960 BUFF_BUFFER bufferResults = { };
2961 PIPE_RPC_RESULT rpc = { };
2962 SIZE_T iBuffer = 0;
2963
2964 // Init structs.
2965 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2966
2967 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
2968
2969 // Send args.
2970 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
2971 ExitOnFailure(hr, "Failed to write API version of OnElevateBegin args.");
2972
2973 // Send results.
2974 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
2975 ExitOnFailure(hr, "Failed to write API version of OnElevateBegin results.");
2976
2977 // Callback.
2978 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONELEVATEBEGIN, &bufferArgs, &bufferResults, &rpc);
2979 ExitOnFailure(hr, "BA OnElevateBegin failed.");
2980
2981 if (S_FALSE == hr)
2982 {
2983 ExitFunction();
2984 }
2985
2986 // Read results.
2987 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
2988 ExitOnFailure(hr, "Failed to read size of OnElevateBegin result.");
2989
2990 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
2991 ExitOnFailure(hr, "Failed to read cancel of OnElevateBegin result.");
2992
2993 if (results.fCancel)
2994 {
2995 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
2996 }
2997
2998LExit:
2999 PipeFreeRpcResult(&rpc);
3000 ReleaseBuffer(bufferResults);
3001 ReleaseBuffer(bufferArgs);
3002
3003 return hr;
3004}
3005
3006EXTERN_C HRESULT BACallbackOnElevateComplete(
3007 __in BURN_USER_EXPERIENCE* pUserExperience,
3008 __in HRESULT hrStatus
3009 )
3010{
3011 HRESULT hr = S_OK;
3012 BA_ONELEVATECOMPLETE_ARGS args = { };
3013 BA_ONELEVATECOMPLETE_RESULTS results = { };
3014 BUFF_BUFFER bufferArgs = { };
3015 BUFF_BUFFER bufferResults = { };
3016 PIPE_RPC_RESULT rpc = { };
3017
3018 // Init structs.
3019 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3020 args.hrStatus = hrStatus;
3021
3022 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3023
3024 // Send args.
3025 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
3026 ExitOnFailure(hr, "Failed to write API version of OnElevateComplete args.");
3027
3028 hr = BuffWriteNumberToBuffer(&bufferArgs, args.hrStatus);
3029 ExitOnFailure(hr, "Failed to write status of OnElevateComplete args.");
3030
3031 // Send results.
3032 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
3033 ExitOnFailure(hr, "Failed to write API version of OnElevateComplete results.");
3034
3035 // Callback.
3036 hr = SendBAMessageFromInactiveEngine(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONELEVATECOMPLETE, &bufferArgs, &bufferResults, &rpc);
3037 ExitOnFailure(hr, "BA OnElevateComplete failed.");
3038
3039 if (S_FALSE == hr)
3040 {
3041 ExitFunction();
3042 }
3043
3044LExit:
3045 PipeFreeRpcResult(&rpc);
3046 ReleaseBuffer(bufferResults);
3047 ReleaseBuffer(bufferArgs);
3048
3049 return hr;
3050}
3051
3052EXTERN_C HRESULT BACallbackOnError(
3053 __in BURN_USER_EXPERIENCE* pUserExperience,
3054 __in BOOTSTRAPPER_ERROR_TYPE errorType,
3055 __in_z_opt LPCWSTR wzPackageId,
3056 __in DWORD dwCode,
3057 __in_z_opt LPCWSTR wzError,
3058 __in DWORD dwUIHint,
3059 __in DWORD cData,
3060 __in_ecount_z_opt(cData) LPCWSTR* rgwzData,
3061 __inout int* pnResult
3062 )
3063{
3064 HRESULT hr = S_OK;
3065 BA_ONERROR_ARGS args = { };
3066 BA_ONERROR_RESULTS results = { };
3067 BUFF_BUFFER bufferArgs = { };
3068 BUFF_BUFFER bufferResults = { };
3069 PIPE_RPC_RESULT rpc = { };
3070 SIZE_T iBuffer = 0;
3071
3072 // Init structs.
3073 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3074 args.errorType = errorType;
3075 args.wzPackageId = wzPackageId;
3076 args.dwCode = dwCode;
3077 args.wzError = wzError;
3078 args.dwUIHint = dwUIHint;
3079 args.cData = cData;
3080 args.rgwzData = rgwzData;
3081 args.nRecommendation = *pnResult;
3082
3083 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3084 results.nResult = *pnResult;
3085
3086 // Send args.
3087 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
3088 ExitOnFailure(hr, "Failed to write API version of OnError args.");
3089
3090 hr = BuffWriteNumberToBuffer(&bufferArgs, args.errorType);
3091 ExitOnFailure(hr, "Failed to write error type OnError args.");
3092
3093 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageId);
3094 ExitOnFailure(hr, "Failed to write package id of OnError args.");
3095
3096 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwCode);
3097 ExitOnFailure(hr, "Failed to write code OnError args.");
3098
3099 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzError);
3100 ExitOnFailure(hr, "Failed to write error of OnError args.");
3101
3102 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwUIHint);
3103 ExitOnFailure(hr, "Failed to write UI hint OnError args.");
3104
3105 hr = BuffWriteNumberToBuffer(&bufferArgs, args.cData);
3106 ExitOnFailure(hr, "Failed to write count of data of OnError args.");
3107
3108 for (DWORD i = 0; i < args.cData; ++i)
3109 {
3110 hr = BuffWriteStringToBuffer(&bufferArgs, args.rgwzData[i]);
3111 ExitOnFailure(hr, "Failed to write data[%u] of OnError args.", i);
3112 }
3113
3114 hr = BuffWriteNumberToBuffer(&bufferArgs, args.nRecommendation);
3115 ExitOnFailure(hr, "Failed to write recommendation of OnError args.");
3116
3117 // Send results.
3118 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
3119 ExitOnFailure(hr, "Failed to write API version of OnError results.");
3120
3121 hr = BuffWriteNumberToBuffer(&bufferResults, results.nResult);
3122 ExitOnFailure(hr, "Failed to write result of OnError results.");
3123
3124 // Callback.
3125 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONERROR, &bufferArgs, &bufferResults, &rpc);
3126 ExitOnFailure(hr, "BA OnError failed.");
3127
3128 if (S_FALSE == hr)
3129 {
3130 ExitFunction();
3131 }
3132
3133 // Read results.
3134 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
3135 ExitOnFailure(hr, "Failed to read size of OnError result.");
3136
3137 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.nResult));
3138 ExitOnFailure(hr, "Failed to read result of OnError result.");
3139
3140 *pnResult = results.nResult;
3141
3142LExit:
3143 PipeFreeRpcResult(&rpc);
3144 ReleaseBuffer(bufferResults);
3145 ReleaseBuffer(bufferArgs);
3146
3147 return hr;
3148}
3149
3150EXTERN_C HRESULT BACallbackOnExecuteBegin(
3151 __in BURN_USER_EXPERIENCE* pUserExperience,
3152 __in DWORD cExecutingPackages
3153 )
3154{
3155 HRESULT hr = S_OK;
3156 BA_ONEXECUTEBEGIN_ARGS args = { };
3157 BA_ONEXECUTEBEGIN_RESULTS results = { };
3158 BUFF_BUFFER bufferArgs = { };
3159 BUFF_BUFFER bufferResults = { };
3160 PIPE_RPC_RESULT rpc = { };
3161 SIZE_T iBuffer = 0;
3162
3163 // Init structs.
3164 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3165 args.cExecutingPackages = cExecutingPackages;
3166
3167 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3168
3169 // Send args.
3170 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
3171 ExitOnFailure(hr, "Failed to write API version of OnExecuteBegin args.");
3172
3173 hr = BuffWriteNumberToBuffer(&bufferArgs, args.cExecutingPackages);
3174 ExitOnFailure(hr, "Failed to write executing packages OnExecuteBegin args.");
3175
3176 // Send results.
3177 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
3178 ExitOnFailure(hr, "Failed to write API version of OnExecuteBegin results.");
3179
3180 // Callback.
3181 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEBEGIN, &bufferArgs, &bufferResults, &rpc);
3182 ExitOnFailure(hr, "BA OnExecuteBegin failed.");
3183
3184 if (S_FALSE == hr)
3185 {
3186 ExitFunction();
3187 }
3188
3189 // Read results.
3190 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
3191 ExitOnFailure(hr, "Failed to read size of OnExecuteBegin result.");
3192
3193 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
3194 ExitOnFailure(hr, "Failed to read cancel of OnExecuteBegin result.");
3195
3196 if (results.fCancel)
3197 {
3198 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
3199 }
3200
3201LExit:
3202 PipeFreeRpcResult(&rpc);
3203 ReleaseBuffer(bufferResults);
3204 ReleaseBuffer(bufferArgs);
3205
3206 return hr;
3207}
3208
3209EXTERN_C HRESULT BACallbackOnExecuteComplete(
3210 __in BURN_USER_EXPERIENCE* pUserExperience,
3211 __in HRESULT hrStatus
3212 )
3213{
3214 HRESULT hr = S_OK;
3215 BA_ONEXECUTECOMPLETE_ARGS args = { };
3216 BA_ONEXECUTECOMPLETE_RESULTS results = { };
3217 BUFF_BUFFER bufferArgs = { };
3218 BUFF_BUFFER bufferResults = { };
3219 PIPE_RPC_RESULT rpc = { };
3220
3221 // Init structs.
3222 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3223 args.hrStatus = hrStatus;
3224
3225 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3226
3227 // Send args.
3228 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
3229 ExitOnFailure(hr, "Failed to write API version of OnExecuteComplete args.");
3230
3231 hr = BuffWriteNumberToBuffer(&bufferArgs, args.hrStatus);
3232 ExitOnFailure(hr, "Failed to write status OnExecuteComplete args.");
3233
3234 // Send results.
3235 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
3236 ExitOnFailure(hr, "Failed to write API version of OnExecuteComplete results.");
3237
3238 // Callback.
3239 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTECOMPLETE, &bufferArgs, &bufferResults, &rpc);
3240 ExitOnFailure(hr, "BA OnExecuteComplete failed.");
3241
3242 if (S_FALSE == hr)
3243 {
3244 ExitFunction();
3245 }
3246
3247LExit:
3248 PipeFreeRpcResult(&rpc);
3249 ReleaseBuffer(bufferResults);
3250 ReleaseBuffer(bufferArgs);
3251
3252 return hr;
3253}
3254
3255EXTERN_C HRESULT BACallbackOnExecuteFilesInUse(
3256 __in BURN_USER_EXPERIENCE* pUserExperience,
3257 __in_z LPCWSTR wzPackageId,
3258 __in DWORD cFiles,
3259 __in_ecount_z_opt(cFiles) LPCWSTR* rgwzFiles,
3260 __in BOOTSTRAPPER_FILES_IN_USE_TYPE source,
3261 __inout int* pnResult
3262 )
3263{
3264 HRESULT hr = S_OK;
3265 BA_ONEXECUTEFILESINUSE_ARGS args = { };
3266 BA_ONEXECUTEFILESINUSE_RESULTS results = { };
3267 BUFF_BUFFER bufferArgs = { };
3268 BUFF_BUFFER bufferResults = { };
3269 PIPE_RPC_RESULT rpc = { };
3270 SIZE_T iBuffer = 0;
3271
3272 // Init structs.
3273 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3274 args.wzPackageId = wzPackageId;
3275 args.cFiles = cFiles;
3276 args.rgwzFiles = rgwzFiles;
3277 args.nRecommendation = *pnResult;
3278 args.source = source;
3279
3280 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3281 results.nResult = *pnResult;
3282
3283 // Send args.
3284 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
3285 ExitOnFailure(hr, "Failed to write API version of OnExecuteFilesInUse args.");
3286
3287 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageId);
3288 ExitOnFailure(hr, "Failed to write package id of OnExecuteFilesInUse args.");
3289
3290 hr = BuffWriteNumberToBuffer(&bufferArgs, args.cFiles);
3291 ExitOnFailure(hr, "Failed to write count of files of OnExecuteFilesInUse args.");
3292
3293 for (DWORD i = 0; i < args.cFiles; ++i)
3294 {
3295 hr = BuffWriteStringToBuffer(&bufferArgs, args.rgwzFiles[i]);
3296 ExitOnFailure(hr, "Failed to write file[%u] of OnExecuteFilesInUse args.", i);
3297 }
3298
3299 hr = BuffWriteNumberToBuffer(&bufferArgs, args.nRecommendation);
3300 ExitOnFailure(hr, "Failed to write recommendation of OnExecuteFilesInUse args.");
3301
3302 hr = BuffWriteNumberToBuffer(&bufferArgs, args.source);
3303 ExitOnFailure(hr, "Failed to write source of OnExecuteFilesInUse args.");
3304
3305 // Send results.
3306 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
3307 ExitOnFailure(hr, "Failed to write API version of OnExecuteFilesInUse results.");
3308
3309 hr = BuffWriteNumberToBuffer(&bufferResults, results.nResult);
3310 ExitOnFailure(hr, "Failed to write result of OnExecuteFilesInUse results.");
3311
3312 // Callback.
3313 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEFILESINUSE, &bufferArgs, &bufferResults, &rpc);
3314 ExitOnFailure(hr, "BA OnExecuteFilesInUse failed.");
3315
3316 if (S_FALSE == hr)
3317 {
3318 ExitFunction();
3319 }
3320
3321 // Read results.
3322 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
3323 ExitOnFailure(hr, "Failed to read size of OnExecuteFilesInUse result.");
3324
3325 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.nResult));
3326 ExitOnFailure(hr, "Failed to read result of OnExecuteFilesInUse result.");
3327
3328 *pnResult = results.nResult;
3329
3330LExit:
3331 PipeFreeRpcResult(&rpc);
3332 ReleaseBuffer(bufferResults);
3333 ReleaseBuffer(bufferArgs);
3334
3335 return hr;
3336}
3337
3338EXTERN_C HRESULT BACallbackOnExecuteMsiMessage(
3339 __in BURN_USER_EXPERIENCE* pUserExperience,
3340 __in_z LPCWSTR wzPackageId,
3341 __in INSTALLMESSAGE messageType,
3342 __in DWORD dwUIHint,
3343 __in_z LPCWSTR wzMessage,
3344 __in DWORD cData,
3345 __in_ecount_z_opt(cData) LPCWSTR* rgwzData,
3346 __inout int* pnResult
3347 )
3348{
3349 HRESULT hr = S_OK;
3350 BA_ONEXECUTEMSIMESSAGE_ARGS args = { };
3351 BA_ONEXECUTEMSIMESSAGE_RESULTS results = { };
3352 BUFF_BUFFER bufferArgs = { };
3353 BUFF_BUFFER bufferResults = { };
3354 PIPE_RPC_RESULT rpc = { };
3355 SIZE_T iBuffer = 0;
3356
3357 // Init structs.
3358 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3359 args.wzPackageId = wzPackageId;
3360 args.messageType = messageType;
3361 args.dwUIHint = dwUIHint;
3362 args.wzMessage = wzMessage;
3363 args.cData = cData;
3364 args.rgwzData = rgwzData;
3365 args.nRecommendation = *pnResult;
3366
3367 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3368 results.nResult = *pnResult;
3369
3370 // Send args.
3371 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
3372 ExitOnFailure(hr, "Failed to write API version of OnExecuteMsiMessage args.");
3373
3374 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageId);
3375 ExitOnFailure(hr, "Failed to write package id of OnExecuteMsiMessage args.");
3376
3377 hr = BuffWriteNumberToBuffer(&bufferArgs, args.messageType);
3378 ExitOnFailure(hr, "Failed to write message type OnExecuteMsiMessage args.");
3379
3380 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwUIHint);
3381 ExitOnFailure(hr, "Failed to write UI hint OnExecuteMsiMessage args.");
3382
3383 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzMessage);
3384 ExitOnFailure(hr, "Failed to write message of OnExecuteMsiMessage args.");
3385
3386 hr = BuffWriteNumberToBuffer(&bufferArgs, args.cData);
3387 ExitOnFailure(hr, "Failed to write count of data of OnExecuteMsiMessage args.");
3388
3389 for (DWORD i = 0; i < args.cData; ++i)
3390 {
3391 hr = BuffWriteStringToBuffer(&bufferArgs, args.rgwzData[i]);
3392 ExitOnFailure(hr, "Failed to write data[%u] of OnExecuteMsiMessage args.", i);
3393 }
3394
3395 hr = BuffWriteNumberToBuffer(&bufferArgs, args.nRecommendation);
3396 ExitOnFailure(hr, "Failed to write recommendation of OnExecuteMsiMessage args.");
3397
3398 // Send results.
3399 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
3400 ExitOnFailure(hr, "Failed to write API version of OnExecuteMsiMessage results.");
3401
3402 hr = BuffWriteNumberToBuffer(&bufferResults, results.nResult);
3403 ExitOnFailure(hr, "Failed to write result of OnExecuteMsiMessage results.");
3404
3405 // Callback.
3406 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEMSIMESSAGE, &bufferArgs, &bufferResults, &rpc);
3407 ExitOnFailure(hr, "BA OnExecuteMsiMessage failed.");
3408
3409 if (S_FALSE == hr)
3410 {
3411 ExitFunction();
3412 }
3413
3414 // Read results.
3415 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
3416 ExitOnFailure(hr, "Failed to read size of OnExecuteMsiMessage result.");
3417
3418 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.nResult));
3419 ExitOnFailure(hr, "Failed to read cancel of OnExecuteMsiMessage result.");
3420
3421 *pnResult = results.nResult;
3422
3423LExit:
3424 PipeFreeRpcResult(&rpc);
3425 ReleaseBuffer(bufferResults);
3426 ReleaseBuffer(bufferArgs);
3427
3428 return hr;
3429}
3430
3431EXTERN_C HRESULT BACallbackOnExecutePackageBegin(
3432 __in BURN_USER_EXPERIENCE* pUserExperience,
3433 __in_z LPCWSTR wzPackageId,
3434 __in BOOL fExecute,
3435 __in BOOTSTRAPPER_ACTION_STATE action,
3436 __in INSTALLUILEVEL uiLevel,
3437 __in BOOL fDisableExternalUiHandler
3438 )
3439{
3440 HRESULT hr = S_OK;
3441 BA_ONEXECUTEPACKAGEBEGIN_ARGS args = { };
3442 BA_ONEXECUTEPACKAGEBEGIN_RESULTS results = { };
3443 BUFF_BUFFER bufferArgs = { };
3444 BUFF_BUFFER bufferResults = { };
3445 PIPE_RPC_RESULT rpc = { };
3446 SIZE_T iBuffer = 0;
3447
3448 // Init structs.
3449 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3450 args.wzPackageId = wzPackageId;
3451 args.fExecute = fExecute;
3452 args.action = action;
3453 args.uiLevel = uiLevel;
3454 args.fDisableExternalUiHandler = fDisableExternalUiHandler;
3455
3456 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3457
3458 // Send args.
3459 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
3460 ExitOnFailure(hr, "Failed to write API version of OnExecutePackageBegin args.");
3461
3462 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageId);
3463 ExitOnFailure(hr, "Failed to write package id of OnExecutePackageBegin args.");
3464
3465 hr = BuffWriteNumberToBuffer(&bufferArgs, args.fExecute);
3466 ExitOnFailure(hr, "Failed to write execute OnExecutePackageBegin args.");
3467
3468 hr = BuffWriteNumberToBuffer(&bufferArgs, args.action);
3469 ExitOnFailure(hr, "Failed to write action OnExecutePackageBegin args.");
3470
3471 hr = BuffWriteNumberToBuffer(&bufferArgs, args.uiLevel);
3472 ExitOnFailure(hr, "Failed to write UI level of OnExecutePackageBegin args.");
3473
3474 hr = BuffWriteNumberToBuffer(&bufferArgs, args.fDisableExternalUiHandler);
3475 ExitOnFailure(hr, "Failed to write disable external UI handler of OnExecutePackageBegin args.");
3476
3477 // Send results.
3478 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
3479 ExitOnFailure(hr, "Failed to write API version of OnExecutePackageBegin results.");
3480
3481 // Callback.
3482 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEPACKAGEBEGIN, &bufferArgs, &bufferResults, &rpc);
3483 ExitOnFailure(hr, "BA OnExecutePackageBegin failed.");
3484
3485 if (S_FALSE == hr)
3486 {
3487 ExitFunction();
3488 }
3489
3490 // Read results.
3491 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
3492 ExitOnFailure(hr, "Failed to read size of OnExecutePackageBegin result.");
3493
3494 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
3495 ExitOnFailure(hr, "Failed to read cancel of OnExecutePackageBegin result.");
3496
3497 if (results.fCancel)
3498 {
3499 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
3500 }
3501
3502LExit:
3503 PipeFreeRpcResult(&rpc);
3504 ReleaseBuffer(bufferResults);
3505 ReleaseBuffer(bufferArgs);
3506
3507 return hr;
3508}
3509
3510EXTERN_C HRESULT BACallbackOnExecutePackageComplete(
3511 __in BURN_USER_EXPERIENCE* pUserExperience,
3512 __in_z LPCWSTR wzPackageId,
3513 __in HRESULT hrStatus,
3514 __in BOOTSTRAPPER_APPLY_RESTART restart,
3515 __inout BOOTSTRAPPER_EXECUTEPACKAGECOMPLETE_ACTION* pAction
3516 )
3517{
3518 HRESULT hr = S_OK;
3519 BA_ONEXECUTEPACKAGECOMPLETE_ARGS args = { };
3520 BA_ONEXECUTEPACKAGECOMPLETE_RESULTS results = { };
3521 BUFF_BUFFER bufferArgs = { };
3522 BUFF_BUFFER bufferResults = { };
3523 PIPE_RPC_RESULT rpc = { };
3524 SIZE_T iBuffer = 0;
3525
3526 // Init structs.
3527 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3528 args.wzPackageId = wzPackageId;
3529 args.hrStatus = hrStatus;
3530 args.restart = restart;
3531 args.recommendation = *pAction;
3532
3533 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3534 results.action = *pAction;
3535
3536 // Send args.
3537 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
3538 ExitOnFailure(hr, "Failed to write API version of OnExecutePackageComplete args.");
3539
3540 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageId);
3541 ExitOnFailure(hr, "Failed to write package id of OnExecutePackageComplete args.");
3542
3543 hr = BuffWriteNumberToBuffer(&bufferArgs, args.hrStatus);
3544 ExitOnFailure(hr, "Failed to write status of OnExecutePackageComplete args.");
3545
3546 hr = BuffWriteNumberToBuffer(&bufferArgs, args.restart);
3547 ExitOnFailure(hr, "Failed to write restart of OnExecutePackageComplete args.");
3548
3549 hr = BuffWriteNumberToBuffer(&bufferArgs, args.recommendation);
3550 ExitOnFailure(hr, "Failed to write recommendation of OnExecutePackageComplete args.");
3551
3552 // Send results.
3553 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
3554 ExitOnFailure(hr, "Failed to write API version of OnExecutePackageComplete results.");
3555
3556 hr = BuffWriteNumberToBuffer(&bufferResults, results.action);
3557 ExitOnFailure(hr, "Failed to write action of OnExecutePackageComplete results.");
3558
3559 // Callback.
3560 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEPACKAGECOMPLETE, &bufferArgs, &bufferResults, &rpc);
3561 ExitOnFailure(hr, "BA OnExecutePackageComplete failed.");
3562
3563 if (S_FALSE == hr)
3564 {
3565 ExitFunction();
3566 }
3567
3568 // Read results.
3569 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
3570 ExitOnFailure(hr, "Failed to read size of OnExecutePackageComplete result.");
3571
3572 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.action));
3573 ExitOnFailure(hr, "Failed to read action of OnExecutePackageComplete result.");
3574
3575 *pAction = results.action;
3576
3577LExit:
3578 PipeFreeRpcResult(&rpc);
3579 ReleaseBuffer(bufferResults);
3580 ReleaseBuffer(bufferArgs);
3581
3582 return hr;
3583}
3584
3585EXTERN_C HRESULT BACallbackOnExecutePatchTarget(
3586 __in BURN_USER_EXPERIENCE* pUserExperience,
3587 __in_z LPCWSTR wzPackageId,
3588 __in_z LPCWSTR wzTargetProductCode
3589 )
3590{
3591 HRESULT hr = S_OK;
3592 BA_ONEXECUTEPATCHTARGET_ARGS args = { };
3593 BA_ONEXECUTEPATCHTARGET_RESULTS results = { };
3594 BUFF_BUFFER bufferArgs = { };
3595 BUFF_BUFFER bufferResults = { };
3596 PIPE_RPC_RESULT rpc = { };
3597 SIZE_T iBuffer = 0;
3598
3599 // Init structs.
3600 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3601 args.wzPackageId = wzPackageId;
3602 args.wzTargetProductCode = wzTargetProductCode;
3603
3604 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3605
3606 // Send args.
3607 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
3608 ExitOnFailure(hr, "Failed to write API version of OnExecutePatchTarget args.");
3609
3610 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageId);
3611 ExitOnFailure(hr, "Failed to write package id of OnExecutePatchTarget args.");
3612
3613 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzTargetProductCode);
3614 ExitOnFailure(hr, "Failed to write target product code of OnExecutePatchTarget args.");
3615
3616 // Send results.
3617 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
3618 ExitOnFailure(hr, "Failed to write API version of OnExecutePatchTarget results.");
3619
3620 // Callback.
3621 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEPATCHTARGET, &bufferArgs, &bufferResults, &rpc);
3622 ExitOnFailure(hr, "BA OnExecutePatchTarget failed.");
3623
3624 if (S_FALSE == hr)
3625 {
3626 ExitFunction();
3627 }
3628
3629 // Read results.
3630 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
3631 ExitOnFailure(hr, "Failed to read size of OnExecutePatchTarget result.");
3632
3633 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
3634 ExitOnFailure(hr, "Failed to read cancel of OnExecutePatchTarget result.");
3635
3636 if (results.fCancel)
3637 {
3638 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
3639 }
3640
3641LExit:
3642 PipeFreeRpcResult(&rpc);
3643 ReleaseBuffer(bufferResults);
3644 ReleaseBuffer(bufferArgs);
3645
3646 return hr;
3647}
3648
3649EXTERN_C HRESULT BACallbackOnExecuteProcessCancel(
3650 __in BURN_USER_EXPERIENCE* pUserExperience,
3651 __in_z LPCWSTR wzPackageId,
3652 __in DWORD dwProcessId,
3653 __inout BOOTSTRAPPER_EXECUTEPROCESSCANCEL_ACTION* pAction
3654 )
3655{
3656 HRESULT hr = S_OK;
3657 BA_ONEXECUTEPROCESSCANCEL_ARGS args = { };
3658 BA_ONEXECUTEPROCESSCANCEL_RESULTS results = { };
3659 BUFF_BUFFER bufferArgs = { };
3660 BUFF_BUFFER bufferResults = { };
3661 PIPE_RPC_RESULT rpc = { };
3662 SIZE_T iBuffer = 0;
3663
3664 // Init structs.
3665 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3666 args.wzPackageId = wzPackageId;
3667 args.dwProcessId = dwProcessId;
3668 args.recommendation = *pAction;
3669
3670 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3671 results.action = *pAction;
3672
3673 // Send args.
3674 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
3675 ExitOnFailure(hr, "Failed to write API version of OnExecuteProcessCancel args.");
3676
3677 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageId);
3678 ExitOnFailure(hr, "Failed to write package id of OnExecuteProcessCancel args.");
3679
3680 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwProcessId);
3681 ExitOnFailure(hr, "Failed to write process id of OnExecuteProcessCancel args.");
3682
3683 hr = BuffWriteNumberToBuffer(&bufferArgs, args.recommendation);
3684 ExitOnFailure(hr, "Failed to write recommendation of OnExecuteProcessCancel args.");
3685
3686 // Send results.
3687 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
3688 ExitOnFailure(hr, "Failed to write API version of OnExecuteProcessCancel results.");
3689
3690 hr = BuffWriteNumberToBuffer(&bufferResults, results.action);
3691 ExitOnFailure(hr, "Failed to write action of OnExecuteProcessCancel results.");
3692
3693 // Callback.
3694 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEPROCESSCANCEL, &bufferArgs, &bufferResults, &rpc);
3695 ExitOnFailure(hr, "BA OnExecuteProcessCancel failed.");
3696
3697 if (S_FALSE == hr)
3698 {
3699 ExitFunction();
3700 }
3701
3702 // Read results.
3703 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
3704 ExitOnFailure(hr, "Failed to read size of OnExecuteProcessCancel result.");
3705
3706 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.action));
3707 ExitOnFailure(hr, "Failed to read action of OnExecuteProcessCancel result.");
3708
3709 *pAction = results.action;
3710
3711LExit:
3712 PipeFreeRpcResult(&rpc);
3713 ReleaseBuffer(bufferResults);
3714 ReleaseBuffer(bufferArgs);
3715
3716 return hr;
3717}
3718
3719EXTERN_C HRESULT BACallbackOnExecuteProgress(
3720 __in BURN_USER_EXPERIENCE* pUserExperience,
3721 __in_z LPCWSTR wzPackageId,
3722 __in DWORD dwProgressPercentage,
3723 __in DWORD dwOverallPercentage,
3724 __out int* pnResult
3725 )
3726{
3727 HRESULT hr = S_OK;
3728 BA_ONEXECUTEPROGRESS_ARGS args = { };
3729 BA_ONEXECUTEPROGRESS_RESULTS results = { };
3730 BUFF_BUFFER bufferArgs = { };
3731 BUFF_BUFFER bufferResults = { };
3732 PIPE_RPC_RESULT rpc = { };
3733 SIZE_T iBuffer = 0;
3734
3735 // Init structs.
3736 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3737 args.wzPackageId = wzPackageId;
3738 args.dwProgressPercentage = dwProgressPercentage;
3739 args.dwOverallPercentage = dwOverallPercentage;
3740
3741 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3742
3743 // Send args.
3744 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
3745 ExitOnFailure(hr, "Failed to write API version of OnExecuteProgress args.");
3746
3747 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageId);
3748 ExitOnFailure(hr, "Failed to write package id of OnExecuteProgress args.");
3749
3750 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwProgressPercentage);
3751 ExitOnFailure(hr, "Failed to write progress of OnExecuteProgress args.");
3752
3753 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwOverallPercentage);
3754 ExitOnFailure(hr, "Failed to write overall progress of OnExecuteProgress args.");
3755
3756 // Send results.
3757 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
3758 ExitOnFailure(hr, "Failed to write API version of OnExecuteProgress results.");
3759
3760 // Callback.
3761 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEPROGRESS, &bufferArgs, &bufferResults, &rpc);
3762 ExitOnFailure(hr, "BA OnExecuteProgress failed.");
3763
3764 if (S_FALSE == hr)
3765 {
3766 ExitFunction();
3767 }
3768
3769 // Read results.
3770 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
3771 ExitOnFailure(hr, "Failed to read size of OnExecuteProgress result.");
3772
3773 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
3774 ExitOnFailure(hr, "Failed to read cancel of OnExecuteProgress result.");
3775
3776LExit:
3777 if (FAILED(hr))
3778 {
3779 *pnResult = IDERROR;
3780 }
3781 else if (results.fCancel)
3782 {
3783 *pnResult = IDCANCEL;
3784 }
3785 else
3786 {
3787 *pnResult = IDNOACTION;
3788 }
3789
3790 PipeFreeRpcResult(&rpc);
3791 ReleaseBuffer(bufferResults);
3792 ReleaseBuffer(bufferArgs);
3793
3794 return hr;
3795}
3796
3797EXTERN_C HRESULT BACallbackOnLaunchApprovedExeBegin(
3798 __in BURN_USER_EXPERIENCE* pUserExperience
3799 )
3800{
3801 HRESULT hr = S_OK;
3802 BA_ONLAUNCHAPPROVEDEXEBEGIN_ARGS args = { };
3803 BA_ONLAUNCHAPPROVEDEXEBEGIN_RESULTS results = { };
3804 BUFF_BUFFER bufferArgs = { };
3805 BUFF_BUFFER bufferResults = { };
3806 PIPE_RPC_RESULT rpc = { };
3807 SIZE_T iBuffer = 0;
3808
3809 // Init structs.
3810 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3811
3812 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3813
3814 // Send args.
3815 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
3816 ExitOnFailure(hr, "Failed to write API version of OnLaunchApprovedExeBegin args.");
3817
3818 // Send results.
3819 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
3820 ExitOnFailure(hr, "Failed to write API version of OnLaunchApprovedExeBegin results.");
3821
3822 // Callback.
3823 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONLAUNCHAPPROVEDEXEBEGIN, &bufferArgs, &bufferResults, &rpc);
3824 ExitOnFailure(hr, "BA OnLaunchApprovedExeBegin failed.");
3825
3826 if (S_FALSE == hr)
3827 {
3828 ExitFunction();
3829 }
3830
3831 // Read results.
3832 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
3833 ExitOnFailure(hr, "Failed to read size of OnLaunchApprovedExeBegin result.");
3834
3835 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
3836 ExitOnFailure(hr, "Failed to read cancel of OnLaunchApprovedExeBegin result.");
3837
3838 if (results.fCancel)
3839 {
3840 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
3841 }
3842
3843LExit:
3844 PipeFreeRpcResult(&rpc);
3845 ReleaseBuffer(bufferResults);
3846 ReleaseBuffer(bufferArgs);
3847
3848 return hr;
3849}
3850
3851EXTERN_C HRESULT BACallbackOnLaunchApprovedExeComplete(
3852 __in BURN_USER_EXPERIENCE* pUserExperience,
3853 __in HRESULT hrStatus,
3854 __in DWORD dwProcessId
3855 )
3856{
3857 HRESULT hr = S_OK;
3858 BA_ONLAUNCHAPPROVEDEXECOMPLETE_ARGS args = { };
3859 BA_ONLAUNCHAPPROVEDEXECOMPLETE_RESULTS results = { };
3860 BUFF_BUFFER bufferArgs = { };
3861 BUFF_BUFFER bufferResults = { };
3862 PIPE_RPC_RESULT rpc = { };
3863
3864 // Init structs.
3865 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3866 args.hrStatus = hrStatus;
3867 args.dwProcessId = dwProcessId;
3868
3869 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3870
3871 // Send args.
3872 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
3873 ExitOnFailure(hr, "Failed to write API version of OnLaunchApprovedExeComplete args.");
3874
3875 hr = BuffWriteNumberToBuffer(&bufferArgs, args.hrStatus);
3876 ExitOnFailure(hr, "Failed to write status of OnLaunchApprovedExeComplete args.");
3877
3878 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwProcessId);
3879 ExitOnFailure(hr, "Failed to write process id of OnLaunchApprovedExeComplete args.");
3880
3881 // Send results.
3882 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
3883 ExitOnFailure(hr, "Failed to write API version of OnLaunchApprovedExeComplete results.");
3884
3885 // Callback.
3886 hr = SendBAMessageFromInactiveEngine(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONLAUNCHAPPROVEDEXECOMPLETE, &bufferArgs, &bufferResults, &rpc);
3887 ExitOnFailure(hr, "BA OnLaunchApprovedExeComplete failed.");
3888
3889 if (S_FALSE == hr)
3890 {
3891 ExitFunction();
3892 }
3893
3894LExit:
3895 PipeFreeRpcResult(&rpc);
3896 ReleaseBuffer(bufferResults);
3897 ReleaseBuffer(bufferArgs);
3898
3899 return hr;
3900}
3901
3902EXTERN_C HRESULT BACallbackOnPauseAUBegin(
3903 __in BURN_USER_EXPERIENCE* pUserExperience
3904 )
3905{
3906 HRESULT hr = S_OK;
3907 BA_ONPAUSEAUTOMATICUPDATESBEGIN_ARGS args = { };
3908 BA_ONPAUSEAUTOMATICUPDATESBEGIN_RESULTS results = { };
3909 BUFF_BUFFER bufferArgs = { };
3910 BUFF_BUFFER bufferResults = { };
3911 PIPE_RPC_RESULT rpc = { };
3912
3913 // Init structs.
3914 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3915
3916 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3917
3918 // Send args.
3919 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
3920 ExitOnFailure(hr, "Failed to write API version of OnPauseAUBegin args.");
3921
3922 // Send results.
3923 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
3924 ExitOnFailure(hr, "Failed to write API version of OnPauseAUBegin results.");
3925
3926 // Callback.
3927 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONPAUSEAUTOMATICUPDATESBEGIN, &bufferArgs, &bufferResults, &rpc);
3928 ExitOnFailure(hr, "BA OnPauseAUBegin failed.");
3929
3930 if (S_FALSE == hr)
3931 {
3932 ExitFunction();
3933 }
3934
3935LExit:
3936 PipeFreeRpcResult(&rpc);
3937 ReleaseBuffer(bufferResults);
3938 ReleaseBuffer(bufferArgs);
3939
3940 return hr;
3941}
3942
3943EXTERN_C HRESULT BACallbackOnPauseAUComplete(
3944 __in BURN_USER_EXPERIENCE* pUserExperience,
3945 __in HRESULT hrStatus
3946 )
3947{
3948 HRESULT hr = S_OK;
3949 BA_ONPAUSEAUTOMATICUPDATESCOMPLETE_ARGS args = { };
3950 BA_ONPAUSEAUTOMATICUPDATESCOMPLETE_RESULTS results = { };
3951 BUFF_BUFFER bufferArgs = { };
3952 BUFF_BUFFER bufferResults = { };
3953 PIPE_RPC_RESULT rpc = { };
3954
3955 // Init structs.
3956 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3957 args.hrStatus = hrStatus;
3958
3959 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
3960
3961 // Send args.
3962 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
3963 ExitOnFailure(hr, "Failed to write API version of OnPauseAUComplete args.");
3964
3965 hr = BuffWriteNumberToBuffer(&bufferArgs, args.hrStatus);
3966 ExitOnFailure(hr, "Failed to write status of OnPauseAUComplete args.");
3967
3968 // Send results.
3969 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
3970 ExitOnFailure(hr, "Failed to write API version of OnPauseAUComplete results.");
3971
3972 // Callback.
3973 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONPAUSEAUTOMATICUPDATESCOMPLETE, &bufferArgs, &bufferResults, &rpc);
3974 ExitOnFailure(hr, "BA OnPauseAUComplete failed.");
3975
3976 if (S_FALSE == hr)
3977 {
3978 ExitFunction();
3979 }
3980
3981LExit:
3982 PipeFreeRpcResult(&rpc);
3983 ReleaseBuffer(bufferResults);
3984 ReleaseBuffer(bufferArgs);
3985
3986 return hr;
3987}
3988
3989EXTERN_C HRESULT BACallbackOnPlanBegin(
3990 __in BURN_USER_EXPERIENCE* pUserExperience,
3991 __in DWORD cPackages
3992 )
3993{
3994 HRESULT hr = S_OK;
3995 BA_ONPLANBEGIN_ARGS args = { };
3996 BA_ONPLANBEGIN_RESULTS results = { };
3997 BUFF_BUFFER bufferArgs = { };
3998 BUFF_BUFFER bufferResults = { };
3999 PIPE_RPC_RESULT rpc = { };
4000 SIZE_T iBuffer = 0;
4001
4002 // Init structs.
4003 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4004 args.cPackages = cPackages;
4005
4006 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4007
4008 // Send args.
4009 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
4010 ExitOnFailure(hr, "Failed to write API version of OnPlanBegin args.");
4011
4012 hr = BuffWriteNumberToBuffer(&bufferArgs, args.cPackages);
4013 ExitOnFailure(hr, "Failed to write count of packages of OnPlanBegin args.");
4014
4015 // Send results.
4016 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
4017 ExitOnFailure(hr, "Failed to write API version of OnPlanBegin results.");
4018
4019 // Callback.
4020 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANBEGIN, &bufferArgs, &bufferResults, &rpc);
4021 ExitOnFailure(hr, "BA OnPlanBegin failed.");
4022
4023 if (S_FALSE == hr)
4024 {
4025 ExitFunction();
4026 }
4027
4028 // Read results.
4029 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
4030 ExitOnFailure(hr, "Failed to read size of OnPlanBegin result.");
4031
4032 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
4033 ExitOnFailure(hr, "Failed to read cancel of OnPlanBegin result.");
4034
4035 if (results.fCancel)
4036 {
4037 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
4038 }
4039
4040LExit:
4041 PipeFreeRpcResult(&rpc);
4042 ReleaseBuffer(bufferResults);
4043 ReleaseBuffer(bufferArgs);
4044
4045 return hr;
4046}
4047
4048EXTERN_C HRESULT BACallbackOnPlanCompatibleMsiPackageBegin(
4049 __in BURN_USER_EXPERIENCE* pUserExperience,
4050 __in_z LPCWSTR wzPackageId,
4051 __in_z LPCWSTR wzCompatiblePackageId,
4052 __in VERUTIL_VERSION* pCompatiblePackageVersion,
4053 __inout BOOL* pfRequested
4054 )
4055{
4056 HRESULT hr = S_OK;
4057 BA_ONPLANCOMPATIBLEMSIPACKAGEBEGIN_ARGS args = { };
4058 BA_ONPLANCOMPATIBLEMSIPACKAGEBEGIN_RESULTS results = { };
4059 BUFF_BUFFER bufferArgs = { };
4060 BUFF_BUFFER bufferResults = { };
4061 PIPE_RPC_RESULT rpc = { };
4062 SIZE_T iBuffer = 0;
4063
4064 // Init structs.
4065 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4066 args.wzPackageId = wzPackageId;
4067 args.wzCompatiblePackageId = wzCompatiblePackageId;
4068 args.wzCompatiblePackageVersion = pCompatiblePackageVersion->sczVersion;
4069 args.fRecommendedRemove = *pfRequested;
4070
4071 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4072 results.fRequestRemove = *pfRequested;
4073
4074 // Send args.
4075 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
4076 ExitOnFailure(hr, "Failed to write API version of OnPlanCompatibleMsiPackageBegin args.");
4077
4078 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageId);
4079 ExitOnFailure(hr, "Failed to write package id of OnPlanCompatibleMsiPackageBegin args.");
4080
4081 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzCompatiblePackageId);
4082 ExitOnFailure(hr, "Failed to write compatible package id of OnPlanCompatibleMsiPackageBegin args.");
4083
4084 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzCompatiblePackageVersion);
4085 ExitOnFailure(hr, "Failed to write compatible package version of OnPlanCompatibleMsiPackageBegin args.");
4086
4087 hr = BuffWriteNumberToBuffer(&bufferArgs, args.fRecommendedRemove);
4088 ExitOnFailure(hr, "Failed to write recommend remove of OnPlanCompatibleMsiPackageBegin args.");
4089
4090 // Send results.
4091 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
4092 ExitOnFailure(hr, "Failed to write API version of OnPlanCompatibleMsiPackageBegin results.");
4093
4094 hr = BuffWriteNumberToBuffer(&bufferResults, results.fRequestRemove);
4095 ExitOnFailure(hr, "Failed to write request remove of OnPlanCompatibleMsiPackageBegin results.");
4096
4097 // Callback.
4098 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANCOMPATIBLEMSIPACKAGEBEGIN, &bufferArgs, &bufferResults, &rpc);
4099 ExitOnFailure(hr, "BA OnPlanCompatibleMsiPackageBegin failed.");
4100
4101 if (S_FALSE == hr)
4102 {
4103 ExitFunction();
4104 }
4105
4106 // Read results.
4107 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
4108 ExitOnFailure(hr, "Failed to read size of OnPlanCompatibleMsiPackageBegin result.");
4109
4110 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
4111 ExitOnFailure(hr, "Failed to read cancel of OnPlanCompatibleMsiPackageBegin result.");
4112
4113 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fRequestRemove));
4114 ExitOnFailure(hr, "Failed to read requested remove of OnPlanCompatibleMsiPackageBegin result.");
4115
4116 if (results.fCancel)
4117 {
4118 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
4119 }
4120
4121 *pfRequested = results.fRequestRemove;
4122
4123LExit:
4124 PipeFreeRpcResult(&rpc);
4125 ReleaseBuffer(bufferResults);
4126 ReleaseBuffer(bufferArgs);
4127
4128 return hr;
4129}
4130
4131EXTERN_C HRESULT BACallbackOnPlanCompatibleMsiPackageComplete(
4132 __in BURN_USER_EXPERIENCE* pUserExperience,
4133 __in_z LPCWSTR wzPackageId,
4134 __in_z LPCWSTR wzCompatiblePackageId,
4135 __in HRESULT hrStatus,
4136 __in BOOL fRequested
4137 )
4138{
4139 HRESULT hr = S_OK;
4140 BA_ONPLANCOMPATIBLEMSIPACKAGECOMPLETE_ARGS args = { };
4141 BA_ONPLANCOMPATIBLEMSIPACKAGECOMPLETE_RESULTS results = { };
4142 BUFF_BUFFER bufferArgs = { };
4143 BUFF_BUFFER bufferResults = { };
4144 PIPE_RPC_RESULT rpc = { };
4145
4146 // Init structs.
4147 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4148 args.wzPackageId = wzPackageId;
4149 args.wzCompatiblePackageId = wzCompatiblePackageId;
4150 args.hrStatus = hrStatus;
4151 args.fRequestedRemove = fRequested;
4152
4153 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4154
4155 // Send args.
4156 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
4157 ExitOnFailure(hr, "Failed to write API version of OnPlanCompatibleMsiPackageComplete args.");
4158
4159 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageId);
4160 ExitOnFailure(hr, "Failed to write package id of OnPlanCompatibleMsiPackageComplete args.");
4161
4162 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzCompatiblePackageId);
4163 ExitOnFailure(hr, "Failed to write compatible package id of OnPlanCompatibleMsiPackageComplete args.");
4164
4165 hr = BuffWriteNumberToBuffer(&bufferArgs, args.hrStatus);
4166 ExitOnFailure(hr, "Failed to write status of OnPlanCompatibleMsiPackageComplete args.");
4167
4168 hr = BuffWriteNumberToBuffer(&bufferArgs, args.fRequestedRemove);
4169 ExitOnFailure(hr, "Failed to write requested remove of OnPlanCompatibleMsiPackageComplete args.");
4170
4171 // Send results.
4172 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
4173 ExitOnFailure(hr, "Failed to write API version of OnPlanCompatibleMsiPackageComplete results.");
4174
4175 // Callback.
4176 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANCOMPATIBLEMSIPACKAGECOMPLETE, &bufferArgs, &bufferResults, &rpc);
4177 ExitOnFailure(hr, "BA OnPlanCompatibleMsiPackageComplete failed.");
4178
4179 if (S_FALSE == hr)
4180 {
4181 ExitFunction();
4182 }
4183
4184LExit:
4185 PipeFreeRpcResult(&rpc);
4186 ReleaseBuffer(bufferResults);
4187 ReleaseBuffer(bufferArgs);
4188
4189 return hr;
4190}
4191
4192EXTERN_C HRESULT BACallbackOnPlanMsiFeature(
4193 __in BURN_USER_EXPERIENCE* pUserExperience,
4194 __in_z LPCWSTR wzPackageId,
4195 __in_z LPCWSTR wzFeatureId,
4196 __inout BOOTSTRAPPER_FEATURE_STATE* pRequestedState
4197 )
4198{
4199 HRESULT hr = S_OK;
4200 BA_ONPLANMSIFEATURE_ARGS args = { };
4201 BA_ONPLANMSIFEATURE_RESULTS results = { };
4202 BUFF_BUFFER bufferArgs = { };
4203 BUFF_BUFFER bufferResults = { };
4204 PIPE_RPC_RESULT rpc = { };
4205 SIZE_T iBuffer = 0;
4206
4207 // Init structs.
4208 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4209 args.wzPackageId = wzPackageId;
4210 args.wzFeatureId = wzFeatureId;
4211 args.recommendedState = *pRequestedState;
4212
4213 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4214 results.requestedState = *pRequestedState;
4215
4216 // Send args.
4217 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
4218 ExitOnFailure(hr, "Failed to write API version of OnPlanMsiFeature args.");
4219
4220 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageId);
4221 ExitOnFailure(hr, "Failed to write package id of OnPlanMsiFeature args.");
4222
4223 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzFeatureId);
4224 ExitOnFailure(hr, "Failed to write feature id of OnPlanMsiFeature args.");
4225
4226 hr = BuffWriteNumberToBuffer(&bufferArgs, args.recommendedState);
4227 ExitOnFailure(hr, "Failed to write recommended state of OnPlanMsiFeature args.");
4228
4229 // Send results.
4230 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
4231 ExitOnFailure(hr, "Failed to write API version of OnPlanMsiFeature results.");
4232
4233 hr = BuffWriteNumberToBuffer(&bufferResults, results.requestedState);
4234 ExitOnFailure(hr, "Failed to write requested state of OnPlanMsiFeature results.");
4235
4236 // Callback.
4237 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANMSIFEATURE, &bufferArgs, &bufferResults, &rpc);
4238 ExitOnFailure(hr, "BA OnPlanMsiFeature failed.");
4239
4240 if (S_FALSE == hr)
4241 {
4242 ExitFunction();
4243 }
4244
4245 // Read results.
4246 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
4247 ExitOnFailure(hr, "Failed to read size of OnPlanMsiFeature result.");
4248
4249 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.requestedState));
4250 ExitOnFailure(hr, "Failed to read requested state of OnPlanMsiFeature result.");
4251
4252 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
4253 ExitOnFailure(hr, "Failed to read cancel of OnPlanMsiFeature result.");
4254
4255 if (results.fCancel)
4256 {
4257 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
4258 }
4259
4260 *pRequestedState = results.requestedState;
4261
4262LExit:
4263 PipeFreeRpcResult(&rpc);
4264 ReleaseBuffer(bufferResults);
4265 ReleaseBuffer(bufferArgs);
4266
4267 return hr;
4268}
4269
4270EXTERN_C HRESULT BACallbackOnPlanComplete(
4271 __in BURN_USER_EXPERIENCE* pUserExperience,
4272 __in HRESULT hrStatus
4273 )
4274{
4275 HRESULT hr = S_OK;
4276 BA_ONPLANCOMPLETE_ARGS args = { };
4277 BA_ONPLANCOMPLETE_RESULTS results = { };
4278 BUFF_BUFFER bufferArgs = { };
4279 BUFF_BUFFER bufferResults = { };
4280 PIPE_RPC_RESULT rpc = { };
4281
4282 // Init structs.
4283 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4284 args.hrStatus = hrStatus;
4285
4286 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4287
4288 // Send args.
4289 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
4290 ExitOnFailure(hr, "Failed to write API version of OnPlanComplete args.");
4291
4292 hr = BuffWriteNumberToBuffer(&bufferArgs, args.hrStatus);
4293 ExitOnFailure(hr, "Failed to write status of OnPlanComplete args.");
4294
4295 // Send results.
4296 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
4297 ExitOnFailure(hr, "Failed to write API version of OnPlanComplete results.");
4298
4299 // Callback.
4300 hr = SendBAMessageFromInactiveEngine(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANCOMPLETE, &bufferArgs, &bufferResults, &rpc);
4301 ExitOnFailure(hr, "BA OnPlanComplete failed.");
4302
4303 if (S_FALSE == hr)
4304 {
4305 ExitFunction();
4306 }
4307
4308LExit:
4309 PipeFreeRpcResult(&rpc);
4310 ReleaseBuffer(bufferResults);
4311 ReleaseBuffer(bufferArgs);
4312
4313 return hr;
4314}
4315
4316EXTERN_C HRESULT BACallbackOnPlanForwardCompatibleBundle(
4317 __in BURN_USER_EXPERIENCE* pUserExperience,
4318 __in_z LPCWSTR wzBundleId,
4319 __in BOOTSTRAPPER_RELATION_TYPE relationType,
4320 __in_z LPCWSTR wzBundleTag,
4321 __in BOOL fPerMachine,
4322 __in VERUTIL_VERSION* pVersion,
4323 __inout BOOL* pfIgnoreBundle
4324 )
4325{
4326 HRESULT hr = S_OK;
4327 BA_ONPLANFORWARDCOMPATIBLEBUNDLE_ARGS args = { };
4328 BA_ONPLANFORWARDCOMPATIBLEBUNDLE_RESULTS results = { };
4329 BUFF_BUFFER bufferArgs = { };
4330 BUFF_BUFFER bufferResults = { };
4331 PIPE_RPC_RESULT rpc = { };
4332 SIZE_T iBuffer = 0;
4333
4334 // Init structs.
4335 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4336 args.wzBundleId = wzBundleId;
4337 args.relationType = relationType;
4338 args.wzBundleTag = wzBundleTag;
4339 args.fPerMachine = fPerMachine;
4340 args.wzVersion = pVersion->sczVersion;
4341 args.fRecommendedIgnoreBundle = *pfIgnoreBundle;
4342
4343 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4344 results.fIgnoreBundle = *pfIgnoreBundle;
4345
4346 // Send args.
4347 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
4348 ExitOnFailure(hr, "Failed to write API version of OnPlanForwardCompatibleBundle args.");
4349
4350 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzBundleId);
4351 ExitOnFailure(hr, "Failed to write bundle id of OnPlanForwardCompatibleBundle args.");
4352
4353 hr = BuffWriteNumberToBuffer(&bufferArgs, args.relationType);
4354 ExitOnFailure(hr, "Failed to write relation type of OnPlanForwardCompatibleBundle args.");
4355
4356 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzBundleTag);
4357 ExitOnFailure(hr, "Failed to write bundle tag of OnPlanForwardCompatibleBundle args.");
4358
4359 hr = BuffWriteNumberToBuffer(&bufferArgs, args.fPerMachine);
4360 ExitOnFailure(hr, "Failed to write per-machine of OnPlanForwardCompatibleBundle args.");
4361
4362 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzVersion);
4363 ExitOnFailure(hr, "Failed to write version of OnPlanForwardCompatibleBundle args.");
4364
4365 hr = BuffWriteNumberToBuffer(&bufferArgs, args.fRecommendedIgnoreBundle);
4366 ExitOnFailure(hr, "Failed to write recommended ignore bundle of OnPlanForwardCompatibleBundle args.");
4367
4368 // Send results.
4369 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
4370 ExitOnFailure(hr, "Failed to write API version of OnPlanForwardCompatibleBundle results.");
4371
4372 hr = BuffWriteNumberToBuffer(&bufferResults, results.fIgnoreBundle);
4373 ExitOnFailure(hr, "Failed to write ignore bundle of OnPlanForwardCompatibleBundle results.");
4374
4375 // Callback.
4376 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANFORWARDCOMPATIBLEBUNDLE, &bufferArgs, &bufferResults, &rpc);
4377 ExitOnFailure(hr, "BA OnPlanForwardCompatibleBundle failed.");
4378
4379 if (S_FALSE == hr)
4380 {
4381 ExitFunction();
4382 }
4383
4384 // Read results.
4385 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
4386 ExitOnFailure(hr, "Failed to read size of OnPlanForwardCompatibleBundle result.");
4387
4388 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
4389 ExitOnFailure(hr, "Failed to read cancel of OnPlanForwardCompatibleBundle result.");
4390
4391 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fIgnoreBundle));
4392 ExitOnFailure(hr, "Failed to read ignore bundle of OnPlanForwardCompatibleBundle result.");
4393
4394 if (results.fCancel)
4395 {
4396 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
4397 }
4398
4399 *pfIgnoreBundle = results.fIgnoreBundle;
4400
4401LExit:
4402 PipeFreeRpcResult(&rpc);
4403 ReleaseBuffer(bufferResults);
4404 ReleaseBuffer(bufferArgs);
4405
4406 return hr;
4407}
4408
4409EXTERN_C HRESULT BACallbackOnPlanMsiPackage(
4410 __in BURN_USER_EXPERIENCE* pUserExperience,
4411 __in_z LPCWSTR wzPackageId,
4412 __in BOOL fExecute,
4413 __in BOOTSTRAPPER_ACTION_STATE action,
4414 __inout BURN_MSI_PROPERTY* pActionMsiProperty,
4415 __inout INSTALLUILEVEL* pUiLevel,
4416 __inout BOOL* pfDisableExternalUiHandler,
4417 __inout BOOTSTRAPPER_MSI_FILE_VERSIONING* pFileVersioning
4418 )
4419{
4420 HRESULT hr = S_OK;
4421 BA_ONPLANMSIPACKAGE_ARGS args = { };
4422 BA_ONPLANMSIPACKAGE_RESULTS results = { };
4423 BUFF_BUFFER bufferArgs = { };
4424 BUFF_BUFFER bufferResults = { };
4425 PIPE_RPC_RESULT rpc = { };
4426 SIZE_T iBuffer = 0;
4427
4428 // Init structs.
4429 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4430 args.wzPackageId = wzPackageId;
4431 args.fExecute = fExecute;
4432 args.action = action;
4433 args.recommendedFileVersioning = *pFileVersioning;
4434
4435 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4436 results.actionMsiProperty = *pActionMsiProperty;
4437 results.uiLevel = *pUiLevel;
4438 results.fDisableExternalUiHandler = *pfDisableExternalUiHandler;
4439 results.fileVersioning = args.recommendedFileVersioning;
4440
4441 // Send args.
4442 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
4443 ExitOnFailure(hr, "Failed to write API version of OnPlanMsiPackage args.");
4444
4445 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageId);
4446 ExitOnFailure(hr, "Failed to write package id of OnPlanMsiPackage args.");
4447
4448 hr = BuffWriteNumberToBuffer(&bufferArgs, args.fExecute);
4449 ExitOnFailure(hr, "Failed to write execute of OnPlanMsiPackage args.");
4450
4451 hr = BuffWriteNumberToBuffer(&bufferArgs, args.action);
4452 ExitOnFailure(hr, "Failed to write action of OnPlanMsiPackage args.");
4453
4454 hr = BuffWriteNumberToBuffer(&bufferArgs, args.recommendedFileVersioning);
4455 ExitOnFailure(hr, "Failed to write recommended file versioning of OnPlanMsiPackage args.");
4456
4457 // Send results.
4458 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
4459 ExitOnFailure(hr, "Failed to write API version of OnPlanMsiPackage results.");
4460
4461 hr = BuffWriteNumberToBuffer(&bufferResults, results.actionMsiProperty);
4462 ExitOnFailure(hr, "Failed to write action msi property of OnPlanMsiPackage results.");
4463
4464 hr = BuffWriteNumberToBuffer(&bufferResults, results.uiLevel);
4465 ExitOnFailure(hr, "Failed to write UI level of OnPlanMsiPackage results.");
4466
4467 hr = BuffWriteNumberToBuffer(&bufferResults, results.fDisableExternalUiHandler);
4468 ExitOnFailure(hr, "Failed to write disable external UI handler of OnPlanMsiPackage results.");
4469
4470 hr = BuffWriteNumberToBuffer(&bufferResults, results.fileVersioning);
4471 ExitOnFailure(hr, "Failed to write file versioning of OnPlanMsiPackage results.");
4472
4473 // Callback.
4474 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANMSIPACKAGE, &bufferArgs, &bufferResults, &rpc);
4475 ExitOnFailure(hr, "BA OnPlanMsiPackage failed.");
4476
4477 if (S_FALSE == hr)
4478 {
4479 ExitFunction();
4480 }
4481
4482 // Read results.
4483 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
4484 ExitOnFailure(hr, "Failed to read size of OnPlanMsiPackage result.");
4485
4486 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
4487 ExitOnFailure(hr, "Failed to read cancel of OnPlanMsiPackage result.");
4488
4489 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.actionMsiProperty));
4490 ExitOnFailure(hr, "Failed to read action MSI property of OnPlanMsiPackage result.");
4491
4492 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.uiLevel));
4493 ExitOnFailure(hr, "Failed to read UI level of OnPlanMsiPackage result.");
4494
4495 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fDisableExternalUiHandler));
4496 ExitOnFailure(hr, "Failed to read disable external UI handler of OnPlanMsiPackage result.");
4497
4498 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fileVersioning));
4499 ExitOnFailure(hr, "Failed to read file versioning of OnPlanMsiPackage result.");
4500
4501 if (results.fCancel)
4502 {
4503 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
4504 }
4505
4506 *pActionMsiProperty = results.actionMsiProperty;
4507 *pUiLevel = results.uiLevel;
4508 *pfDisableExternalUiHandler = results.fDisableExternalUiHandler;
4509 *pFileVersioning = results.fileVersioning;
4510
4511LExit:
4512 PipeFreeRpcResult(&rpc);
4513 ReleaseBuffer(bufferResults);
4514 ReleaseBuffer(bufferArgs);
4515
4516 return hr;
4517}
4518
4519EXTERN_C HRESULT BACallbackOnPlannedCompatiblePackage(
4520 __in BURN_USER_EXPERIENCE* pUserExperience,
4521 __in_z LPCWSTR wzPackageId,
4522 __in_z LPCWSTR wzCompatiblePackageId,
4523 __in BOOL fRemove
4524 )
4525{
4526 HRESULT hr = S_OK;
4527 BA_ONPLANNEDCOMPATIBLEPACKAGE_ARGS args = { };
4528 BA_ONPLANNEDCOMPATIBLEPACKAGE_RESULTS results = { };
4529 BUFF_BUFFER bufferArgs = { };
4530 BUFF_BUFFER bufferResults = { };
4531 PIPE_RPC_RESULT rpc = { };
4532
4533 // Init structs.
4534 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4535 args.wzPackageId = wzPackageId;
4536 args.wzCompatiblePackageId = wzCompatiblePackageId;
4537 args.fRemove = fRemove;
4538
4539 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4540
4541 // Send args.
4542 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
4543 ExitOnFailure(hr, "Failed to write API version of OnPlannedCompatiblePackage args.");
4544
4545 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageId);
4546 ExitOnFailure(hr, "Failed to write package id of OnPlannedCompatiblePackage args.");
4547
4548 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzCompatiblePackageId);
4549 ExitOnFailure(hr, "Failed to write compatible package id of OnPlannedCompatiblePackage args.");
4550
4551 hr = BuffWriteNumberToBuffer(&bufferArgs, args.fRemove);
4552 ExitOnFailure(hr, "Failed to write remove of OnPlannedCompatiblePackage args.");
4553
4554 // Send results.
4555 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
4556 ExitOnFailure(hr, "Failed to write API version of OnPlannedCompatiblePackage results.");
4557
4558 // Callback.
4559 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANNEDCOMPATIBLEPACKAGE, &bufferArgs, &bufferResults, &rpc);
4560 ExitOnFailure(hr, "BA OnPlannedCompatiblePackage failed.");
4561
4562 if (S_FALSE == hr)
4563 {
4564 ExitFunction();
4565 }
4566
4567LExit:
4568 PipeFreeRpcResult(&rpc);
4569 ReleaseBuffer(bufferResults);
4570 ReleaseBuffer(bufferArgs);
4571
4572 return hr;
4573}
4574
4575EXTERN_C HRESULT BACallbackOnPlannedPackage(
4576 __in BURN_USER_EXPERIENCE* pUserExperience,
4577 __in_z LPCWSTR wzPackageId,
4578 __in BOOTSTRAPPER_ACTION_STATE execute,
4579 __in BOOTSTRAPPER_ACTION_STATE rollback,
4580 __in BOOL fPlannedCache,
4581 __in BOOL fPlannedUncache
4582 )
4583{
4584 HRESULT hr = S_OK;
4585 BA_ONPLANNEDPACKAGE_ARGS args = { };
4586 BA_ONPLANNEDPACKAGE_RESULTS results = { };
4587 BUFF_BUFFER bufferArgs = { };
4588 BUFF_BUFFER bufferResults = { };
4589 PIPE_RPC_RESULT rpc = { };
4590
4591 // Init structs.
4592 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4593 args.wzPackageId = wzPackageId;
4594 args.execute = execute;
4595 args.rollback = rollback;
4596 args.fPlannedCache = fPlannedCache;
4597 args.fPlannedUncache = fPlannedUncache;
4598
4599 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4600
4601 // Send args.
4602 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
4603 ExitOnFailure(hr, "Failed to write API version of OnPlannedPackage args.");
4604
4605 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageId);
4606 ExitOnFailure(hr, "Failed to write package id of OnPlannedPackage args.");
4607
4608 hr = BuffWriteNumberToBuffer(&bufferArgs, args.execute);
4609 ExitOnFailure(hr, "Failed to write execute of OnPlannedPackage args.");
4610
4611 hr = BuffWriteNumberToBuffer(&bufferArgs, args.rollback);
4612 ExitOnFailure(hr, "Failed to write rollback of OnPlannedPackage args.");
4613
4614 hr = BuffWriteNumberToBuffer(&bufferArgs, args.fPlannedCache);
4615 ExitOnFailure(hr, "Failed to write planned cache of OnPlannedPackage args.");
4616
4617 hr = BuffWriteNumberToBuffer(&bufferArgs, args.fPlannedUncache);
4618 ExitOnFailure(hr, "Failed to write planned uncache of OnPlannedPackage args.");
4619
4620 // Send results.
4621 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
4622 ExitOnFailure(hr, "Failed to write API version of OnPlannedPackage results.");
4623
4624 // Callback.
4625 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANNEDPACKAGE, &bufferArgs, &bufferResults, &rpc);
4626 ExitOnFailure(hr, "BA OnPlannedPackage failed.");
4627
4628 if (S_FALSE == hr)
4629 {
4630 ExitFunction();
4631 }
4632
4633LExit:
4634 PipeFreeRpcResult(&rpc);
4635 ReleaseBuffer(bufferResults);
4636 ReleaseBuffer(bufferArgs);
4637
4638 return hr;
4639}
4640
4641EXTERN_C HRESULT BACallbackOnPlanPackageBegin(
4642 __in BURN_USER_EXPERIENCE* pUserExperience,
4643 __in_z LPCWSTR wzPackageId,
4644 __in BOOTSTRAPPER_PACKAGE_STATE state,
4645 __in BOOL fCached,
4646 __in BOOTSTRAPPER_PACKAGE_CONDITION_RESULT installCondition,
4647 __in BOOTSTRAPPER_PACKAGE_CONDITION_RESULT repairCondition,
4648 __inout BOOTSTRAPPER_REQUEST_STATE* pRequestedState,
4649 __inout BOOTSTRAPPER_CACHE_TYPE* pRequestedCacheType
4650 )
4651{
4652 HRESULT hr = S_OK;
4653 BA_ONPLANPACKAGEBEGIN_ARGS args = { };
4654 BA_ONPLANPACKAGEBEGIN_RESULTS results = { };
4655 BUFF_BUFFER bufferArgs = { };
4656 BUFF_BUFFER bufferResults = { };
4657 PIPE_RPC_RESULT rpc = { };
4658 SIZE_T iBuffer = 0;
4659
4660 // Init structs.
4661 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4662 args.wzPackageId = wzPackageId;
4663 args.state = state;
4664 args.fCached = fCached;
4665 args.installCondition = installCondition;
4666 args.repairCondition = repairCondition;
4667 args.recommendedState = *pRequestedState;
4668 args.recommendedCacheType = *pRequestedCacheType;
4669
4670 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4671 results.requestedState = *pRequestedState;
4672 results.requestedCacheType = *pRequestedCacheType;
4673
4674 // Send args.
4675 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
4676 ExitOnFailure(hr, "Failed to write API version of OnPlanPackageBegin args.");
4677
4678 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageId);
4679 ExitOnFailure(hr, "Failed to write package id of OnPlanPackageBegin args.");
4680
4681 hr = BuffWriteNumberToBuffer(&bufferArgs, args.state);
4682 ExitOnFailure(hr, "Failed to write state of OnPlanPackageBegin args.");
4683
4684 hr = BuffWriteNumberToBuffer(&bufferArgs, args.fCached);
4685 ExitOnFailure(hr, "Failed to write cached of OnPlanPackageBegin args.");
4686
4687 hr = BuffWriteNumberToBuffer(&bufferArgs, args.installCondition);
4688 ExitOnFailure(hr, "Failed to write install condition of OnPlanPackageBegin args.");
4689
4690 hr = BuffWriteNumberToBuffer(&bufferArgs, args.repairCondition);
4691 ExitOnFailure(hr, "Failed to write repair condition of OnPlanPackageBegin args.");
4692
4693 hr = BuffWriteNumberToBuffer(&bufferArgs, args.recommendedState);
4694 ExitOnFailure(hr, "Failed to write recommended state of OnPlanPackageBegin args.");
4695
4696 hr = BuffWriteNumberToBuffer(&bufferArgs, args.recommendedCacheType);
4697 ExitOnFailure(hr, "Failed to write recommended cache type of OnPlanPackageBegin args.");
4698
4699 // Send results.
4700 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
4701 ExitOnFailure(hr, "Failed to write API version of OnPlanPackageBegin results.");
4702
4703 hr = BuffWriteNumberToBuffer(&bufferResults, results.requestedState);
4704 ExitOnFailure(hr, "Failed to write requested state of OnPlanPackageBegin results.");
4705
4706 hr = BuffWriteNumberToBuffer(&bufferResults, results.requestedCacheType);
4707 ExitOnFailure(hr, "Failed to write requested cache type of OnPlanPackageBegin results.");
4708
4709 // Callback.
4710 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANPACKAGEBEGIN, &bufferArgs, &bufferResults, &rpc);
4711 ExitOnFailure(hr, "BA OnPlanPackageBegin failed.");
4712
4713 if (S_FALSE == hr)
4714 {
4715 ExitFunction();
4716 }
4717
4718 // Read results.
4719 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
4720 ExitOnFailure(hr, "Failed to read size of OnPlanPackageBegin result.");
4721
4722 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
4723 ExitOnFailure(hr, "Failed to read cancel of OnPlanPackageBegin result.");
4724
4725 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.requestedState));
4726 ExitOnFailure(hr, "Failed to read requested state of OnPlanPackageBegin result.");
4727
4728 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.requestedCacheType));
4729 ExitOnFailure(hr, "Failed to read requested cache type of OnPlanPackageBegin result.");
4730
4731 if (results.fCancel)
4732 {
4733 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
4734 }
4735
4736 *pRequestedState = results.requestedState;
4737
4738 if (BOOTSTRAPPER_CACHE_TYPE_REMOVE <= results.requestedCacheType && BOOTSTRAPPER_CACHE_TYPE_FORCE >= results.requestedCacheType)
4739 {
4740 *pRequestedCacheType = results.requestedCacheType;
4741 }
4742
4743LExit:
4744 PipeFreeRpcResult(&rpc);
4745 ReleaseBuffer(bufferResults);
4746 ReleaseBuffer(bufferArgs);
4747
4748 return hr;
4749}
4750
4751EXTERN_C HRESULT BACallbackOnPlanPackageComplete(
4752 __in BURN_USER_EXPERIENCE* pUserExperience,
4753 __in_z LPCWSTR wzPackageId,
4754 __in HRESULT hrStatus,
4755 __in BOOTSTRAPPER_REQUEST_STATE requested
4756 )
4757{
4758 HRESULT hr = S_OK;
4759 BA_ONPLANPACKAGECOMPLETE_ARGS args = { };
4760 BA_ONPLANPACKAGECOMPLETE_RESULTS results = { };
4761 BUFF_BUFFER bufferArgs = { };
4762 BUFF_BUFFER bufferResults = { };
4763 PIPE_RPC_RESULT rpc = { };
4764
4765 // Init structs.
4766 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4767 args.wzPackageId = wzPackageId;
4768 args.hrStatus = hrStatus;
4769 args.requested = requested;
4770
4771 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4772
4773 // Send args.
4774 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
4775 ExitOnFailure(hr, "Failed to write API version of OnPlanPackageComplete args.");
4776
4777 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageId);
4778 ExitOnFailure(hr, "Failed to write package id of OnPlanPackageComplete args.");
4779
4780 hr = BuffWriteNumberToBuffer(&bufferArgs, args.hrStatus);
4781 ExitOnFailure(hr, "Failed to write status of OnPlanPackageComplete args.");
4782
4783 hr = BuffWriteNumberToBuffer(&bufferArgs, args.requested);
4784 ExitOnFailure(hr, "Failed to write requested of OnPlanPackageComplete args.");
4785
4786 // Send results.
4787 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
4788 ExitOnFailure(hr, "Failed to write API version of OnPlanPackageComplete results.");
4789
4790 // Callback.
4791 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANPACKAGECOMPLETE, &bufferArgs, &bufferResults, &rpc);
4792 ExitOnFailure(hr, "BA OnPlanPackageComplete failed.");
4793
4794 if (S_FALSE == hr)
4795 {
4796 ExitFunction();
4797 }
4798
4799LExit:
4800 PipeFreeRpcResult(&rpc);
4801 ReleaseBuffer(bufferResults);
4802 ReleaseBuffer(bufferArgs);
4803
4804 return hr;
4805}
4806
4807EXTERN_C HRESULT BACallbackOnPlanRelatedBundle(
4808 __in BURN_USER_EXPERIENCE* pUserExperience,
4809 __in_z LPCWSTR wzBundleId,
4810 __inout BOOTSTRAPPER_REQUEST_STATE* pRequestedState
4811 )
4812{
4813 HRESULT hr = S_OK;
4814 BA_ONPLANRELATEDBUNDLE_ARGS args = { };
4815 BA_ONPLANRELATEDBUNDLE_RESULTS results = { };
4816 BUFF_BUFFER bufferArgs = { };
4817 BUFF_BUFFER bufferResults = { };
4818 PIPE_RPC_RESULT rpc = { };
4819 SIZE_T iBuffer = 0;
4820
4821 // Init structs.
4822 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4823 args.wzBundleId = wzBundleId;
4824 args.recommendedState = *pRequestedState;
4825
4826 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4827 results.requestedState = *pRequestedState;
4828
4829 // Send args.
4830 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
4831 ExitOnFailure(hr, "Failed to write API version of OnPlanRelatedBundle args.");
4832
4833 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzBundleId);
4834 ExitOnFailure(hr, "Failed to write bundle id of OnPlanRelatedBundle args.");
4835
4836 hr = BuffWriteNumberToBuffer(&bufferArgs, args.recommendedState);
4837 ExitOnFailure(hr, "Failed to write recommended state of OnPlanRelatedBundle args.");
4838
4839 // Send results.
4840 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
4841 ExitOnFailure(hr, "Failed to write API version of OnPlanRelatedBundle results.");
4842
4843 hr = BuffWriteNumberToBuffer(&bufferResults, results.requestedState);
4844 ExitOnFailure(hr, "Failed to write requested state of OnPlanRelatedBundle results.");
4845
4846 // Callback.
4847 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANRELATEDBUNDLE, &bufferArgs, &bufferResults, &rpc);
4848 ExitOnFailure(hr, "BA OnPlanRelatedBundle failed.");
4849
4850 if (S_FALSE == hr)
4851 {
4852 ExitFunction();
4853 }
4854
4855 // Read results.
4856 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
4857 ExitOnFailure(hr, "Failed to read size of OnPlanRelatedBundle result.");
4858
4859 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
4860 ExitOnFailure(hr, "Failed to read cancel of OnPlanRelatedBundle result.");
4861
4862 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.requestedState));
4863 ExitOnFailure(hr, "Failed to read requested state of OnPlanRelatedBundle result.");
4864
4865 if (results.fCancel)
4866 {
4867 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
4868 }
4869
4870 *pRequestedState = results.requestedState;
4871
4872LExit:
4873 PipeFreeRpcResult(&rpc);
4874 ReleaseBuffer(bufferResults);
4875 ReleaseBuffer(bufferArgs);
4876
4877 return hr;
4878}
4879
4880EXTERN_C HRESULT BACallbackOnPlanRelatedBundleType(
4881 __in BURN_USER_EXPERIENCE* pUserExperience,
4882 __in_z LPCWSTR wzBundleId,
4883 __inout BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE* pRequestedType
4884 )
4885{
4886 HRESULT hr = S_OK;
4887 BA_ONPLANRELATEDBUNDLETYPE_ARGS args = { };
4888 BA_ONPLANRELATEDBUNDLETYPE_RESULTS results = { };
4889 BUFF_BUFFER bufferArgs = { };
4890 BUFF_BUFFER bufferResults = { };
4891 PIPE_RPC_RESULT rpc = { };
4892 SIZE_T iBuffer = 0;
4893
4894 // Init structs.
4895 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4896 args.wzBundleId = wzBundleId;
4897 args.recommendedType = *pRequestedType;
4898
4899 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4900 results.requestedType = *pRequestedType;
4901
4902 // Send args.
4903 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
4904 ExitOnFailure(hr, "Failed to write API version of OnPlanRelatedBundleType args.");
4905
4906 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzBundleId);
4907 ExitOnFailure(hr, "Failed to write bundle id of OnPlanRelatedBundleType args.");
4908
4909 hr = BuffWriteNumberToBuffer(&bufferArgs, args.recommendedType);
4910 ExitOnFailure(hr, "Failed to write recommended type of OnPlanRelatedBundleType args.");
4911
4912 // Send results.
4913 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
4914 ExitOnFailure(hr, "Failed to write API version of OnPlanRelatedBundleType results.");
4915
4916 hr = BuffWriteNumberToBuffer(&bufferResults, results.requestedType);
4917 ExitOnFailure(hr, "Failed to write requested type of OnPlanRelatedBundleType results.");
4918
4919 // Callback.
4920 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANRELATEDBUNDLETYPE, &bufferArgs, &bufferResults, &rpc);
4921 ExitOnFailure(hr, "BA OnPlanRelatedBundleType failed.");
4922
4923 if (S_FALSE == hr)
4924 {
4925 ExitFunction();
4926 }
4927
4928 // Read results.
4929 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
4930 ExitOnFailure(hr, "Failed to read size of OnPlanRelatedBundleType result.");
4931
4932 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
4933 ExitOnFailure(hr, "Failed to read cancel of OnPlanRelatedBundleType result.");
4934
4935 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.requestedType));
4936 ExitOnFailure(hr, "Failed to read requested type of OnPlanRelatedBundleType result.");
4937
4938 if (results.fCancel)
4939 {
4940 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
4941 }
4942
4943 *pRequestedType = results.requestedType;
4944
4945LExit:
4946 PipeFreeRpcResult(&rpc);
4947 ReleaseBuffer(bufferResults);
4948 ReleaseBuffer(bufferArgs);
4949
4950 return hr;
4951}
4952
4953EXTERN_C HRESULT BACallbackOnPlanRestoreRelatedBundle(
4954 __in BURN_USER_EXPERIENCE* pUserExperience,
4955 __in_z LPCWSTR wzBundleId,
4956 __inout BOOTSTRAPPER_REQUEST_STATE* pRequestedState
4957 )
4958{
4959 HRESULT hr = S_OK;
4960 BA_ONPLANRESTORERELATEDBUNDLE_ARGS args = { };
4961 BA_ONPLANRESTORERELATEDBUNDLE_RESULTS results = { };
4962 BUFF_BUFFER bufferArgs = { };
4963 BUFF_BUFFER bufferResults = { };
4964 PIPE_RPC_RESULT rpc = { };
4965 SIZE_T iBuffer = 0;
4966
4967 // Init structs.
4968 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4969 args.wzBundleId = wzBundleId;
4970 args.recommendedState = *pRequestedState;
4971
4972 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
4973 results.requestedState = *pRequestedState;
4974
4975 // Send args.
4976 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
4977 ExitOnFailure(hr, "Failed to write API version of OnPlanRestoreRelatedBundle args.");
4978
4979 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzBundleId);
4980 ExitOnFailure(hr, "Failed to write bundle id of OnPlanRestoreRelatedBundle args.");
4981
4982 hr = BuffWriteNumberToBuffer(&bufferArgs, args.recommendedState);
4983 ExitOnFailure(hr, "Failed to write recommended state of OnPlanRestoreRelatedBundle args.");
4984
4985 // Send results.
4986 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
4987 ExitOnFailure(hr, "Failed to write API version of OnPlanRestoreRelatedBundle results.");
4988
4989 hr = BuffWriteNumberToBuffer(&bufferResults, results.requestedState);
4990 ExitOnFailure(hr, "Failed to write requested state of OnPlanRestoreRelatedBundle results.");
4991
4992 // Callback.
4993 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANRESTORERELATEDBUNDLE, &bufferArgs, &bufferResults, &rpc);
4994 ExitOnFailure(hr, "BA OnPlanRestoreRelatedBundle failed.");
4995
4996 if (S_FALSE == hr)
4997 {
4998 ExitFunction();
4999 }
5000
5001 // Read results.
5002 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
5003 ExitOnFailure(hr, "Failed to read size of OnPlanRestoreRelatedBundle result.");
5004
5005 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
5006 ExitOnFailure(hr, "Failed to read cancel of OnPlanRestoreRelatedBundle result.");
5007
5008 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.requestedState));
5009 ExitOnFailure(hr, "Failed to read requested state of OnPlanRestoreRelatedBundle result.");
5010
5011 if (results.fCancel)
5012 {
5013 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
5014 }
5015
5016 *pRequestedState = results.requestedState;
5017
5018LExit:
5019 PipeFreeRpcResult(&rpc);
5020 ReleaseBuffer(bufferResults);
5021 ReleaseBuffer(bufferArgs);
5022
5023 return hr;
5024}
5025
5026EXTERN_C HRESULT BACallbackOnPlanRollbackBoundary(
5027 __in BURN_USER_EXPERIENCE* pUserExperience,
5028 __in_z LPCWSTR wzRollbackBoundaryId,
5029 __inout BOOL* pfTransaction
5030 )
5031{
5032 HRESULT hr = S_OK;
5033 BA_ONPLANROLLBACKBOUNDARY_ARGS args = { };
5034 BA_ONPLANROLLBACKBOUNDARY_RESULTS results = { };
5035 BUFF_BUFFER bufferArgs = { };
5036 BUFF_BUFFER bufferResults = { };
5037 PIPE_RPC_RESULT rpc = { };
5038 SIZE_T iBuffer = 0;
5039
5040 // Init structs.
5041 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
5042 args.wzRollbackBoundaryId = wzRollbackBoundaryId;
5043 args.fRecommendedTransaction = *pfTransaction;
5044
5045 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
5046 results.fTransaction = *pfTransaction;
5047
5048 // Send args.
5049 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
5050 ExitOnFailure(hr, "Failed to write API version of OnPlanRollbackBoundary args.");
5051
5052 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzRollbackBoundaryId);
5053 ExitOnFailure(hr, "Failed to write rollback boundary id of OnPlanRollbackBoundary args.");
5054
5055 hr = BuffWriteNumberToBuffer(&bufferArgs, args.fRecommendedTransaction);
5056 ExitOnFailure(hr, "Failed to write recommended transaction of OnPlanRollbackBoundary args.");
5057
5058 // Send results.
5059 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
5060 ExitOnFailure(hr, "Failed to write API version of OnPlanRollbackBoundary results.");
5061
5062 hr = BuffWriteNumberToBuffer(&bufferResults, results.fTransaction);
5063 ExitOnFailure(hr, "Failed to write transaction of OnPlanRollbackBoundary results.");
5064
5065 // Callback.
5066 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANROLLBACKBOUNDARY, &bufferArgs, &bufferResults, &rpc);
5067 ExitOnFailure(hr, "BA OnPlanRollbackBoundary failed.");
5068
5069 if (S_FALSE == hr)
5070 {
5071 ExitFunction();
5072 }
5073
5074 // Read results.
5075 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
5076 ExitOnFailure(hr, "Failed to read size of OnPlanRollbackBoundary result.");
5077
5078 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fTransaction));
5079 ExitOnFailure(hr, "Failed to read transaction of OnPlanRollbackBoundary result.");
5080
5081 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
5082 ExitOnFailure(hr, "Failed to read cancel of OnPlanRollbackBoundary result.");
5083
5084 if (results.fCancel)
5085 {
5086 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
5087 }
5088
5089 *pfTransaction = results.fTransaction;
5090
5091LExit:
5092 PipeFreeRpcResult(&rpc);
5093 ReleaseBuffer(bufferResults);
5094 ReleaseBuffer(bufferArgs);
5095
5096 return hr;
5097}
5098
5099EXTERN_C HRESULT BACallbackOnPlanPatchTarget(
5100 __in BURN_USER_EXPERIENCE* pUserExperience,
5101 __in_z LPCWSTR wzPackageId,
5102 __in_z LPCWSTR wzProductCode,
5103 __inout BOOTSTRAPPER_REQUEST_STATE* pRequestedState
5104 )
5105{
5106 HRESULT hr = S_OK;
5107 BA_ONPLANPATCHTARGET_ARGS args = { };
5108 BA_ONPLANPATCHTARGET_RESULTS results = { };
5109 BUFF_BUFFER bufferArgs = { };
5110 BUFF_BUFFER bufferResults = { };
5111 PIPE_RPC_RESULT rpc = { };
5112 SIZE_T iBuffer = 0;
5113
5114 // Init structs.
5115 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
5116 args.wzPackageId = wzPackageId;
5117 args.wzProductCode = wzProductCode;
5118 args.recommendedState = *pRequestedState;
5119
5120 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
5121 results.requestedState = *pRequestedState;
5122
5123 // Send args.
5124 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
5125 ExitOnFailure(hr, "Failed to write API version of OnPlanPatchTarget args.");
5126
5127 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzPackageId);
5128 ExitOnFailure(hr, "Failed to write package id of OnPlanPatchTarget args.");
5129
5130 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzProductCode);
5131 ExitOnFailure(hr, "Failed to write product code of OnPlanPatchTarget args.");
5132
5133 hr = BuffWriteNumberToBuffer(&bufferArgs, args.recommendedState);
5134 ExitOnFailure(hr, "Failed to write recommended state of OnPlanPatchTarget args.");
5135
5136 // Send results.
5137 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
5138 ExitOnFailure(hr, "Failed to write API version of OnPlanPatchTarget results.");
5139
5140 hr = BuffWriteNumberToBuffer(&bufferResults, results.requestedState);
5141 ExitOnFailure(hr, "Failed to write requested state of OnPlanPatchTarget results.");
5142
5143 // Callback.
5144 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANPATCHTARGET, &bufferArgs, &bufferResults, &rpc);
5145 ExitOnFailure(hr, "BA OnPlanPatchTarget failed.");
5146
5147 if (S_FALSE == hr)
5148 {
5149 ExitFunction();
5150 }
5151
5152 // Read results.
5153 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
5154 ExitOnFailure(hr, "Failed to read size of OnPlanPatchTarget result.");
5155
5156 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
5157 ExitOnFailure(hr, "Failed to read cancel of OnPlanPatchTarget result.");
5158
5159 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.requestedState));
5160 ExitOnFailure(hr, "Failed to read requrested state of OnPlanPatchTarget result.");
5161
5162 if (results.fCancel)
5163 {
5164 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
5165 }
5166
5167 *pRequestedState = results.requestedState;
5168
5169LExit:
5170 PipeFreeRpcResult(&rpc);
5171 ReleaseBuffer(bufferResults);
5172 ReleaseBuffer(bufferArgs);
5173
5174 return hr;
5175}
5176
5177EXTERN_C HRESULT BACallbackOnProgress(
5178 __in BURN_USER_EXPERIENCE* pUserExperience,
5179 __in BOOL fRollback,
5180 __in DWORD dwProgressPercentage,
5181 __in DWORD dwOverallPercentage
5182 )
5183{
5184 HRESULT hr = S_OK;
5185 BA_ONPROGRESS_ARGS args = { };
5186 BA_ONPROGRESS_RESULTS results = { };
5187 BUFF_BUFFER bufferArgs = { };
5188 BUFF_BUFFER bufferResults = { };
5189 PIPE_RPC_RESULT rpc = { };
5190 SIZE_T iBuffer = 0;
5191
5192 // Init structs.
5193 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
5194 args.dwProgressPercentage = dwProgressPercentage;
5195 args.dwOverallPercentage = dwOverallPercentage;
5196
5197 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
5198
5199 // Send args.
5200 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
5201 ExitOnFailure(hr, "Failed to write API version of OnProgress args.");
5202
5203 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwProgressPercentage);
5204 ExitOnFailure(hr, "Failed to write progress of OnProgress args.");
5205
5206 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwOverallPercentage);
5207 ExitOnFailure(hr, "Failed to write overall progress of OnProgress args.");
5208
5209 // Send results.
5210 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
5211 ExitOnFailure(hr, "Failed to write API version of OnProgress results.");
5212
5213 // Callback.
5214 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONPROGRESS, &bufferArgs, &bufferResults, &rpc);
5215 ExitOnFailure(hr, "BA OnProgress failed.");
5216
5217 if (S_FALSE == hr)
5218 {
5219 ExitFunction();
5220 }
5221
5222 // Read results.
5223 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
5224 ExitOnFailure(hr, "Failed to read size of OnProgress result.");
5225
5226 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
5227 ExitOnFailure(hr, "Failed to read cancel of OnProgress result.");
5228
5229LExit:
5230 hr = FilterExecuteResult(pUserExperience, hr, fRollback, results.fCancel, L"OnProgress");
5231
5232 PipeFreeRpcResult(&rpc);
5233 ReleaseBuffer(bufferResults);
5234 ReleaseBuffer(bufferArgs);
5235
5236 return hr;
5237}
5238
5239EXTERN_C HRESULT BACallbackOnRegisterBegin(
5240 __in BURN_USER_EXPERIENCE* pUserExperience,
5241 __inout BOOTSTRAPPER_REGISTRATION_TYPE* pRegistrationType
5242 )
5243{
5244 HRESULT hr = S_OK;
5245 BA_ONREGISTERBEGIN_ARGS args = { };
5246 BA_ONREGISTERBEGIN_RESULTS results = { };
5247 BUFF_BUFFER bufferArgs = { };
5248 BUFF_BUFFER bufferResults = { };
5249 PIPE_RPC_RESULT rpc = { };
5250 SIZE_T iBuffer = 0;
5251
5252 // Init structs.
5253 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
5254 args.recommendedRegistrationType = *pRegistrationType;
5255
5256 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
5257 results.registrationType = *pRegistrationType;
5258
5259 // Send args.
5260 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
5261 ExitOnFailure(hr, "Failed to write API version of OnRegisterBegin args.");
5262
5263 hr = BuffWriteNumberToBuffer(&bufferArgs, args.recommendedRegistrationType);
5264 ExitOnFailure(hr, "Failed to write recommended registration type of OnRegisterBegin args.");
5265
5266 // Send results.
5267 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
5268 ExitOnFailure(hr, "Failed to write API version of OnRegisterBegin results.");
5269
5270 hr = BuffWriteNumberToBuffer(&bufferResults, results.registrationType);
5271 ExitOnFailure(hr, "Failed to write registration type of OnRegisterBegin results.");
5272
5273 // Callback.
5274 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONREGISTERBEGIN, &bufferArgs, &bufferResults, &rpc);
5275 ExitOnFailure(hr, "BA OnRegisterBegin failed.");
5276
5277 if (S_FALSE == hr)
5278 {
5279 ExitFunction();
5280 }
5281
5282 // Read results.
5283 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
5284 ExitOnFailure(hr, "Failed to read size of OnRegisterBegin result.");
5285
5286 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.fCancel));
5287 ExitOnFailure(hr, "Failed to read cancel of OnRegisterBegin result.");
5288
5289 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.registrationType));
5290 ExitOnFailure(hr, "Failed to read registration type of OnRegisterBegin result.");
5291
5292 if (results.fCancel)
5293 {
5294 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
5295 }
5296 else if (BOOTSTRAPPER_REGISTRATION_TYPE_NONE < results.registrationType && BOOTSTRAPPER_REGISTRATION_TYPE_FULL >= results.registrationType)
5297 {
5298 *pRegistrationType = results.registrationType;
5299 }
5300
5301LExit:
5302 PipeFreeRpcResult(&rpc);
5303 ReleaseBuffer(bufferResults);
5304 ReleaseBuffer(bufferArgs);
5305
5306 return hr;
5307}
5308
5309EXTERN_C HRESULT BACallbackOnRegisterComplete(
5310 __in BURN_USER_EXPERIENCE* pUserExperience,
5311 __in HRESULT hrStatus
5312 )
5313{
5314 HRESULT hr = S_OK;
5315 BA_ONREGISTERCOMPLETE_ARGS args = { };
5316 BA_ONREGISTERCOMPLETE_RESULTS results = { };
5317 BUFF_BUFFER bufferArgs = { };
5318 BUFF_BUFFER bufferResults = { };
5319 PIPE_RPC_RESULT rpc = { };
5320
5321 // Init structs.
5322 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
5323 args.hrStatus = hrStatus;
5324
5325 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
5326
5327 // Send args.
5328 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
5329 ExitOnFailure(hr, "Failed to write API version of OnRegisterComplete args.");
5330
5331 hr = BuffWriteNumberToBuffer(&bufferArgs, args.hrStatus);
5332 ExitOnFailure(hr, "Failed to write status type of OnRegisterComplete args.");
5333
5334 // Send results.
5335 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
5336 ExitOnFailure(hr, "Failed to write API version of OnRegisterComplete results.");
5337
5338 // Callback.
5339 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONREGISTERCOMPLETE, &bufferArgs, &bufferResults, &rpc);
5340 ExitOnFailure(hr, "BA OnRegisterComplete failed.");
5341
5342 if (S_FALSE == hr)
5343 {
5344 ExitFunction();
5345 }
5346
5347LExit:
5348 PipeFreeRpcResult(&rpc);
5349 ReleaseBuffer(bufferResults);
5350 ReleaseBuffer(bufferArgs);
5351
5352 return hr;
5353}
5354
5355EXTERN_C HRESULT BACallbackOnRollbackMsiTransactionBegin(
5356 __in BURN_USER_EXPERIENCE* pUserExperience,
5357 __in LPCWSTR wzTransactionId
5358 )
5359{
5360 HRESULT hr = S_OK;
5361 BA_ONROLLBACKMSITRANSACTIONBEGIN_ARGS args = { };
5362 BA_ONROLLBACKMSITRANSACTIONBEGIN_RESULTS results = { };
5363 BUFF_BUFFER bufferArgs = { };
5364 BUFF_BUFFER bufferResults = { };
5365 PIPE_RPC_RESULT rpc = { };
5366
5367 // Init structs.
5368 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
5369 args.wzTransactionId = wzTransactionId;
5370
5371 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
5372
5373 // Send args.
5374 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
5375 ExitOnFailure(hr, "Failed to write API version of OnRollbackMsiTransactionBegin args.");
5376
5377 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzTransactionId);
5378 ExitOnFailure(hr, "Failed to write transaction id of OnRollbackMsiTransactionBegin args.");
5379
5380 // Send results.
5381 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
5382 ExitOnFailure(hr, "Failed to write API version of OnRollbackMsiTransactionBegin results.");
5383
5384 // Callback.
5385 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONROLLBACKMSITRANSACTIONBEGIN, &bufferArgs, &bufferResults, &rpc);
5386 ExitOnFailure(hr, "BA OnRollbackMsiTransactionBegin failed.");
5387
5388 if (S_FALSE == hr)
5389 {
5390 ExitFunction();
5391 }
5392
5393LExit:
5394 PipeFreeRpcResult(&rpc);
5395 ReleaseBuffer(bufferResults);
5396 ReleaseBuffer(bufferArgs);
5397
5398 return hr;
5399}
5400
5401EXTERN_C HRESULT BACallbackOnRollbackMsiTransactionComplete(
5402 __in BURN_USER_EXPERIENCE* pUserExperience,
5403 __in LPCWSTR wzTransactionId,
5404 __in HRESULT hrStatus,
5405 __in BOOTSTRAPPER_APPLY_RESTART restart,
5406 __inout BOOTSTRAPPER_EXECUTEMSITRANSACTIONCOMPLETE_ACTION *pAction
5407 )
5408{
5409 HRESULT hr = S_OK;
5410 BA_ONROLLBACKMSITRANSACTIONCOMPLETE_ARGS args = { };
5411 BA_ONROLLBACKMSITRANSACTIONCOMPLETE_RESULTS results = { };
5412 BUFF_BUFFER bufferArgs = { };
5413 BUFF_BUFFER bufferResults = { };
5414 PIPE_RPC_RESULT rpc = { };
5415 SIZE_T iBuffer = 0;
5416
5417 // Init structs.
5418 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
5419 args.wzTransactionId = wzTransactionId;
5420 args.hrStatus = hrStatus;
5421 args.restart = restart;
5422 args.recommendation = *pAction;
5423
5424 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
5425 results.action = *pAction;
5426
5427 // Send args.
5428 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
5429 ExitOnFailure(hr, "Failed to write API version of OnRollbackMsiTransactionComplete args.");
5430
5431 hr = BuffWriteStringToBuffer(&bufferArgs, args.wzTransactionId);
5432 ExitOnFailure(hr, "Failed to write transaction id of OnRollbackMsiTransactionComplete args.");
5433
5434 hr = BuffWriteNumberToBuffer(&bufferArgs, args.hrStatus);
5435 ExitOnFailure(hr, "Failed to write status type of OnRollbackMsiTransactionComplete args.");
5436
5437 hr = BuffWriteNumberToBuffer(&bufferArgs, args.restart);
5438 ExitOnFailure(hr, "Failed to write restart of OnRollbackMsiTransactionComplete args.");
5439
5440 hr = BuffWriteNumberToBuffer(&bufferArgs, args.recommendation);
5441 ExitOnFailure(hr, "Failed to write recommedation of OnRollbackMsiTransactionComplete args.");
5442
5443 // Send results.
5444 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
5445 ExitOnFailure(hr, "Failed to write API version of OnRollbackMsiTransactionComplete results.");
5446
5447 hr = BuffWriteNumberToBuffer(&bufferResults, results.action);
5448 ExitOnFailure(hr, "Failed to write action of OnRollbackMsiTransactionComplete results.");
5449
5450 // Callback.
5451 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONROLLBACKMSITRANSACTIONCOMPLETE, &bufferArgs, &bufferResults, &rpc);
5452 ExitOnFailure(hr, "BA OnRollbackMsiTransactionComplete failed.");
5453
5454 if (S_FALSE == hr)
5455 {
5456 ExitFunction();
5457 }
5458
5459 // Read results.
5460 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
5461 ExitOnFailure(hr, "Failed to read size of OnRollbackMsiTransactionComplete result.");
5462
5463 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.action));
5464 ExitOnFailure(hr, "Failed to read cancel of OnRollbackMsiTransactionComplete result.");
5465
5466 *pAction = results.action;
5467
5468LExit:
5469 PipeFreeRpcResult(&rpc);
5470 ReleaseBuffer(bufferResults);
5471 ReleaseBuffer(bufferArgs);
5472
5473 return hr;
5474}
5475
5476EXTERN_C HRESULT BACallbackOnShutdown(
5477 __in BURN_USER_EXPERIENCE* pUserExperience,
5478 __inout BOOTSTRAPPER_SHUTDOWN_ACTION* pAction
5479 )
5480{
5481 HRESULT hr = S_OK;
5482 BA_ONSHUTDOWN_ARGS args = { sizeof(args) };
5483 BA_ONSHUTDOWN_RESULTS results = { sizeof(results) };
5484 BUFF_BUFFER bufferArgs = { };
5485 BUFF_BUFFER bufferResults = { };
5486 PIPE_RPC_RESULT rpc = { };
5487 SIZE_T iBuffer = 0;
5488
5489 // Init structs.
5490 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
5491
5492 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
5493 results.action = *pAction;
5494
5495 // Send args.
5496 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
5497 ExitOnFailure(hr, "Failed to write API version of OnShutdown args.");
5498
5499 // Send results.
5500 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
5501 ExitOnFailure(hr, "Failed to write API version of OnShutdown results.");
5502
5503 hr = BuffWriteNumberToBuffer(&bufferResults, results.action);
5504 ExitOnFailure(hr, "Failed to write action of OnShutdown results.");
5505
5506 // Callback.
5507 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONSHUTDOWN, &bufferArgs, &bufferResults, &rpc);
5508 ExitOnFailure(hr, "BA OnShutdown failed.");
5509
5510 if (S_FALSE == hr)
5511 {
5512 ExitFunction();
5513 }
5514
5515 // Read results.
5516 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
5517 ExitOnFailure(hr, "Failed to read size of OnShutdown result.");
5518
5519 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.action));
5520 ExitOnFailure(hr, "Failed to read result action of OnShutdown result.");
5521
5522 *pAction = results.action;
5523
5524LExit:
5525 PipeFreeRpcResult(&rpc);
5526 ReleaseBuffer(bufferResults);
5527 ReleaseBuffer(bufferArgs);
5528
5529 return hr;
5530}
5531
5532EXTERN_C HRESULT BACallbackOnStartup(
5533 __in BURN_USER_EXPERIENCE* pUserExperience
5534)
5535{
5536 HRESULT hr = S_OK;
5537 BA_ONSTARTUP_ARGS args = { };
5538 BA_ONSTARTUP_RESULTS results = { };
5539 BUFF_BUFFER bufferArgs = { };
5540 BUFF_BUFFER bufferResults = { };
5541 PIPE_RPC_RESULT rpc = { };
5542
5543 // Init structs.
5544 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
5545
5546 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
5547
5548 // Send args.
5549 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
5550 ExitOnFailure(hr, "Failed to write API version of OnStartup args.");
5551
5552 // Send results.
5553 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
5554 ExitOnFailure(hr, "Failed to write API version of OnStartup results.");
5555
5556 // Callback.
5557 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONSTARTUP, &bufferArgs, &bufferResults, &rpc);
5558 ExitOnFailure(hr, "BA OnStartup failed.");
5559
5560 if (S_FALSE == hr)
5561 {
5562 ExitFunction();
5563 }
5564
5565LExit:
5566 PipeFreeRpcResult(&rpc);
5567 ReleaseBuffer(bufferResults);
5568 ReleaseBuffer(bufferArgs);
5569
5570 return hr;
5571}
5572
5573EXTERN_C HRESULT BACallbackOnSystemRestorePointBegin(
5574 __in BURN_USER_EXPERIENCE* pUserExperience
5575 )
5576{
5577 HRESULT hr = S_OK;
5578 BA_ONSYSTEMRESTOREPOINTBEGIN_ARGS args = { };
5579 BA_ONSYSTEMRESTOREPOINTBEGIN_RESULTS results = { };
5580 BUFF_BUFFER bufferArgs = { };
5581 BUFF_BUFFER bufferResults = { };
5582 PIPE_RPC_RESULT rpc = { };
5583
5584 // Init structs.
5585 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
5586
5587 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
5588
5589 // Send args.
5590 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
5591 ExitOnFailure(hr, "Failed to write API version of OnSystemRestorePointBegin args.");
5592
5593 // Send results.
5594 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
5595 ExitOnFailure(hr, "Failed to write API version of OnSystemRestorePointBegin results.");
5596
5597 // Callback.
5598 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONSYSTEMRESTOREPOINTBEGIN, &bufferArgs, &bufferResults, &rpc);
5599 ExitOnFailure(hr, "BA OnSystemRestorePointBegin failed.");
5600
5601 if (S_FALSE == hr)
5602 {
5603 ExitFunction();
5604 }
5605
5606LExit:
5607 PipeFreeRpcResult(&rpc);
5608 ReleaseBuffer(bufferResults);
5609 ReleaseBuffer(bufferArgs);
5610
5611 return hr;
5612}
5613
5614EXTERN_C HRESULT BACallbackOnSystemRestorePointComplete(
5615 __in BURN_USER_EXPERIENCE* pUserExperience,
5616 __in HRESULT hrStatus
5617 )
5618{
5619 HRESULT hr = S_OK;
5620 BA_ONSYSTEMRESTOREPOINTCOMPLETE_ARGS args = { };
5621 BA_ONSYSTEMRESTOREPOINTCOMPLETE_RESULTS results = { };
5622 BUFF_BUFFER bufferArgs = { };
5623 BUFF_BUFFER bufferResults = { };
5624 PIPE_RPC_RESULT rpc = { };
5625
5626 // Init structs.
5627 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
5628 args.hrStatus = hrStatus;
5629
5630 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
5631
5632 // Send args.
5633 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
5634 ExitOnFailure(hr, "Failed to write API version of OnSystemRestorePointComplete args.");
5635
5636 hr = BuffWriteNumberToBuffer(&bufferArgs, args.hrStatus);
5637 ExitOnFailure(hr, "Failed to write status of OnSystemRestorePointComplete args.");
5638
5639 // Send results.
5640 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
5641 ExitOnFailure(hr, "Failed to write API version of OnSystemRestorePointComplete results.");
5642
5643 // Callback.
5644 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONSYSTEMRESTOREPOINTCOMPLETE, &bufferArgs, &bufferResults, &rpc);
5645 ExitOnFailure(hr, "BA OnSystemRestorePointComplete failed.");
5646
5647 if (S_FALSE == hr)
5648 {
5649 ExitFunction();
5650 }
5651
5652LExit:
5653 PipeFreeRpcResult(&rpc);
5654 ReleaseBuffer(bufferResults);
5655 ReleaseBuffer(bufferArgs);
5656
5657 return hr;
5658}
5659
5660EXTERN_C HRESULT BACallbackOnUnregisterBegin(
5661 __in BURN_USER_EXPERIENCE* pUserExperience,
5662 __inout BOOTSTRAPPER_REGISTRATION_TYPE* pRegistrationType
5663 )
5664{
5665 HRESULT hr = S_OK;
5666 BA_ONUNREGISTERBEGIN_ARGS args = { };
5667 BA_ONUNREGISTERBEGIN_RESULTS results = { };
5668 BUFF_BUFFER bufferArgs = { };
5669 BUFF_BUFFER bufferResults = { };
5670 PIPE_RPC_RESULT rpc = { };
5671 SIZE_T iBuffer = 0;
5672
5673 // Init structs.
5674 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
5675 args.recommendedRegistrationType = *pRegistrationType;
5676
5677 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
5678 results.registrationType = *pRegistrationType;
5679
5680 // Send args.
5681 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
5682 ExitOnFailure(hr, "Failed to write API version of OnUnregisterBegin args.");
5683
5684 hr = BuffWriteNumberToBuffer(&bufferArgs, args.recommendedRegistrationType);
5685 ExitOnFailure(hr, "Failed to write recommended registration type of OnUnregisterBegin args.");
5686
5687 // Send results.
5688 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
5689 ExitOnFailure(hr, "Failed to write API version of OnUnregisterBegin results.");
5690
5691 hr = BuffWriteNumberToBuffer(&bufferResults, results.registrationType);
5692 ExitOnFailure(hr, "Failed to write registration type of OnUnregisterBegin results.");
5693
5694 // Callback.
5695 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONUNREGISTERBEGIN, &bufferArgs, &bufferResults, &rpc);
5696 ExitOnFailure(hr, "BA OnUnregisterBegin failed.");
5697
5698 if (S_FALSE == hr)
5699 {
5700 ExitFunction();
5701 }
5702
5703 // Read results.
5704 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, &results.dwApiVersion);
5705 ExitOnFailure(hr, "Failed to read size of OnUnregisterBegin result.");
5706
5707 hr = BuffReadNumber(rpc.pbData, rpc.cbData, &iBuffer, reinterpret_cast<DWORD*>(&results.registrationType));
5708 ExitOnFailure(hr, "Failed to read registration type of OnUnregisterBegin result.");
5709
5710 if (BOOTSTRAPPER_REGISTRATION_TYPE_NONE < results.registrationType && BOOTSTRAPPER_REGISTRATION_TYPE_FULL >= results.registrationType)
5711 {
5712 *pRegistrationType = results.registrationType;
5713 }
5714
5715LExit:
5716 PipeFreeRpcResult(&rpc);
5717 ReleaseBuffer(bufferResults);
5718 ReleaseBuffer(bufferArgs);
5719
5720 return hr;
5721}
5722
5723EXTERN_C HRESULT BACallbackOnUnregisterComplete(
5724 __in BURN_USER_EXPERIENCE* pUserExperience,
5725 __in HRESULT hrStatus
5726 )
5727{
5728 HRESULT hr = S_OK;
5729 BA_ONUNREGISTERCOMPLETE_ARGS args = { };
5730 BA_ONUNREGISTERCOMPLETE_RESULTS results = { };
5731 BUFF_BUFFER bufferArgs = { };
5732 BUFF_BUFFER bufferResults = { };
5733 PIPE_RPC_RESULT rpc = { };
5734
5735 // Init structs.
5736 args.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
5737 args.hrStatus = hrStatus;
5738
5739 results.dwApiVersion = WIX_5_BOOTSTRAPPER_APPLICATION_API_VERSION;
5740
5741 // Send args.
5742 hr = BuffWriteNumberToBuffer(&bufferArgs, args.dwApiVersion);
5743 ExitOnFailure(hr, "Failed to write API version of OnUnregisterComplete args.");
5744
5745 hr = BuffWriteNumberToBuffer(&bufferArgs, args.hrStatus);
5746 ExitOnFailure(hr, "Failed to write status of OnUnregisterComplete args.");
5747
5748 // Send results.
5749 hr = BuffWriteNumberToBuffer(&bufferResults, results.dwApiVersion);
5750 ExitOnFailure(hr, "Failed to write API version of OnUnregisterComplete results.");
5751
5752 // Callback.
5753 hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONUNREGISTERCOMPLETE, &bufferArgs, &bufferResults, &rpc);
5754 ExitOnFailure(hr, "BA OnUnregisterComplete failed.");
5755
5756 if (S_FALSE == hr)
5757 {
5758 ExitFunction();
5759 }
5760
5761LExit:
5762 PipeFreeRpcResult(&rpc);
5763 ReleaseBuffer(bufferResults);
5764 ReleaseBuffer(bufferArgs);
5765
5766 return hr;
5767}
5768
5769// internal functions
5770
5771// This filters the BA's responses to events during apply.
5772// If an apply thread failed, then return its error so this thread will bail out.
5773// During rollback, the BA can't cancel.
5774static HRESULT FilterExecuteResult(
5775 __in BURN_USER_EXPERIENCE* pUserExperience,
5776 __in HRESULT hrStatus,
5777 __in BOOL fRollback,
5778 __in BOOL fCancel,
5779 __in LPCWSTR sczEventName
5780 )
5781{
5782 HRESULT hr = hrStatus;
5783 HRESULT hrApplyError = pUserExperience->hrApplyError; // make sure to use the same value for the whole method, since it can be changed in other threads.
5784
5785 // If we failed return that error unless this is rollback which should roll on.
5786 if (FAILED(hrApplyError) && !fRollback)
5787 {
5788 hr = hrApplyError;
5789 }
5790 else if (fRollback)
5791 {
5792 if (fCancel)
5793 {
5794 LogId(REPORT_STANDARD, MSG_APPLY_CANCEL_IGNORED_DURING_ROLLBACK, sczEventName);
5795 }
5796 // TODO: since cancel isn't allowed, should the BA's HRESULT be ignored as well?
5797 // In the previous code, they could still alter rollback by returning IDERROR.
5798 }
5799 else
5800 {
5801 ExitOnFailure(hr, "BA %ls failed.", sczEventName);
5802
5803 if (fCancel)
5804 {
5805 hr = HRESULT_FROM_WIN32(ERROR_INSTALL_USEREXIT);
5806 }
5807 }
5808
5809LExit:
5810 return hr;
5811}
5812
5813static HRESULT SendBAMessage(
5814 __in BURN_USER_EXPERIENCE* pUserExperience,
5815 __in BOOTSTRAPPER_APPLICATION_MESSAGE message,
5816 __in BUFF_BUFFER* pBufferArgs,
5817 __in BUFF_BUFFER* pBufferResults,
5818 __in PIPE_RPC_RESULT* pResult
5819 )
5820{
5821 HRESULT hr = S_OK;
5822 BUFF_BUFFER buffer = { };
5823
5824 if (PipeRpcInitialized(&pUserExperience->hBARpcPipe))
5825 {
5826 // Send the combined counted args and results buffer to the BA.
5827 hr = CombineArgsAndResults(pBufferArgs, pBufferResults, &buffer);
5828 if (SUCCEEDED(hr))
5829 {
5830 hr = PipeRpcRequest(&pUserExperience->hBARpcPipe, message, buffer.pbData, buffer.cbData, pResult);
5831 }
5832 }
5833 else
5834 {
5835 hr = S_FALSE;
5836 }
5837
5838 ReleaseBuffer(buffer);
5839 return hr;
5840}
5841
5842static HRESULT SendBAMessageFromInactiveEngine(
5843 __in BURN_USER_EXPERIENCE* pUserExperience,
5844 __in BOOTSTRAPPER_APPLICATION_MESSAGE message,
5845 __in BUFF_BUFFER* pBufferArgs,
5846 __in BUFF_BUFFER* pBufferResults,
5847 __in PIPE_RPC_RESULT* pResult
5848)
5849{
5850 HRESULT hr = S_OK;
5851 BUFF_BUFFER buffer = { };
5852
5853 if (PipeRpcInitialized(&pUserExperience->hBARpcPipe))
5854 {
5855 BootstrapperApplicationDeactivateEngine(pUserExperience);
5856
5857 // Send the combined counted args and results buffer to the BA.
5858 hr = CombineArgsAndResults(pBufferArgs, pBufferResults, &buffer);
5859 if (SUCCEEDED(hr))
5860 {
5861 hr = PipeRpcRequest(&pUserExperience->hBARpcPipe, message, buffer.pbData, buffer.cbData, pResult);
5862 }
5863
5864 BootstrapperApplicationActivateEngine(pUserExperience);
5865 }
5866 else
5867 {
5868 hr = S_FALSE;
5869 }
5870
5871 ReleaseBuffer(buffer);
5872 return hr;
5873}
5874
5875static HRESULT CombineArgsAndResults(
5876 __in BUFF_BUFFER* pBufferArgs,
5877 __in BUFF_BUFFER* pBufferResults,
5878 __in BUFF_BUFFER* pBufferCombined
5879 )
5880{
5881 HRESULT hr = S_OK;
5882
5883 // Write args to buffer.
5884 hr = BuffWriteStreamToBuffer(pBufferCombined, pBufferArgs->pbData, pBufferArgs->cbData);
5885 ExitOnFailure(hr, "Failed to write args buffer.");
5886
5887 // Write results to buffer.
5888 hr = BuffWriteStreamToBuffer(pBufferCombined, pBufferResults->pbData, pBufferResults->cbData);
5889 ExitOnFailure(hr, "Failed to write results buffer.");
5890
5891LExit:
5892 return hr;
5893}
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2026-02-01 04:21:07 +0000