@joebigelow / wix-1
Code Commits Issues Pulls Sessions CI/CD
main
main
cpp 5,893 lines 204 KB
Raw
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
7 static 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 );
14 static 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 );
21 static 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 );
28 static HRESULT CombineArgsAndResults(
29 __in BUFF_BUFFER* pBufferArgs,
30 __in BUFF_BUFFER* pBufferResults,
31 __in BUFF_BUFFER* pBufferCombined
32 );
33
34 // function definitions
35
36 EXTERN_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
87 LExit:
88 PipeFreeRpcResult(&rpc);
89 ReleaseBuffer(bufferResults);
90 ReleaseBuffer(bufferArgs);
91
92 return hr;
93 }
94
95 EXTERN_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
157 LExit:
158 PipeFreeRpcResult(&rpc);
159 ReleaseBuffer(bufferResults);
160 ReleaseBuffer(bufferArgs);
161
162 return hr;
163 }
164
165 EXTERN_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
217 LExit:
218 PipeFreeRpcResult(&rpc);
219 ReleaseBuffer(bufferResults);
220 ReleaseBuffer(bufferArgs);
221
222 return hr;
223 }
224
225 EXTERN_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
276 LExit:
277 PipeFreeRpcResult(&rpc);
278 ReleaseBuffer(bufferResults);
279 ReleaseBuffer(bufferArgs);
280
281 return hr;
282 }
283
284 EXTERN_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
327 LExit:
328 PipeFreeRpcResult(&rpc);
329 ReleaseBuffer(bufferResults);
330 ReleaseBuffer(bufferArgs);
331
332 return hr;
333 }
334
335 EXTERN_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
431 LExit:
432 PipeFreeRpcResult(&rpc);
433 ReleaseBuffer(bufferResults);
434 ReleaseBuffer(bufferArgs);
435
436 return hr;
437 }
438
439 EXTERN_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
509 LExit:
510 PipeFreeRpcResult(&rpc);
511 ReleaseBuffer(bufferResults);
512 ReleaseBuffer(bufferArgs);
513
514 return hr;
515 }
516
517 EXTERN_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
588 LExit:
589 PipeFreeRpcResult(&rpc);
590 ReleaseBuffer(bufferResults);
591 ReleaseBuffer(bufferArgs);
592
593 return hr;
594 }
595
596 EXTERN_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
719 LExit:
720 PipeFreeRpcResult(&rpc);
721 ReleaseBuffer(bufferResults);
722 ReleaseBuffer(bufferArgs);
723
724 return hr;
725 }
726
727 EXTERN_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
773 LExit:
774 PipeFreeRpcResult(&rpc);
775 ReleaseBuffer(bufferResults);
776 ReleaseBuffer(bufferArgs);
777
778 return hr;
779 }
780
781 EXTERN_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
819 LExit:
820 PipeFreeRpcResult(&rpc);
821 ReleaseBuffer(bufferResults);
822 ReleaseBuffer(bufferArgs);
823
824 return hr;
825 }
826
827 EXTERN_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
883 LExit:
884 PipeFreeRpcResult(&rpc);
885 ReleaseBuffer(bufferResults);
886 ReleaseBuffer(bufferArgs);
887
888 return hr;
889 }
890
891 EXTERN_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
939 LExit:
940 PipeFreeRpcResult(&rpc);
941 ReleaseBuffer(bufferResults);
942 ReleaseBuffer(bufferArgs);
943
944 return hr;
945 }
946
947 EXTERN_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
1018 LExit:
1019 PipeFreeRpcResult(&rpc);
1020 ReleaseBuffer(bufferResults);
1021 ReleaseBuffer(bufferArgs);
1022
1023 return hr;
1024 }
1025
1026 EXTERN_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
1092 LExit:
1093 PipeFreeRpcResult(&rpc);
1094 ReleaseBuffer(bufferResults);
1095 ReleaseBuffer(bufferArgs);
1096
1097 return hr;
1098 }
1099
1100 EXTERN_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
1165 LExit:
1166 PipeFreeRpcResult(&rpc);
1167 ReleaseBuffer(bufferResults);
1168 ReleaseBuffer(bufferArgs);
1169
1170 return hr;
1171 }
1172
1173 EXTERN_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
1241 LExit:
1242 PipeFreeRpcResult(&rpc);
1243 ReleaseBuffer(bufferResults);
1244 ReleaseBuffer(bufferArgs);
1245
1246 return hr;
1247 }
1248
1249 EXTERN_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
1305 LExit:
1306 PipeFreeRpcResult(&rpc);
1307 ReleaseBuffer(bufferResults);
1308 ReleaseBuffer(bufferArgs);
1309
1310 return hr;
1311 }
1312
1313 EXTERN_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
1361 LExit:
1362 PipeFreeRpcResult(&rpc);
1363 ReleaseBuffer(bufferResults);
1364 ReleaseBuffer(bufferArgs);
1365
1366 return hr;
1367 }
1368
1369 EXTERN_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
1440 LExit:
1441 PipeFreeRpcResult(&rpc);
1442 ReleaseBuffer(bufferResults);
1443 ReleaseBuffer(bufferArgs);
1444
1445 return hr;
1446 }
1447
1448 EXTERN_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
1504 LExit:
1505 PipeFreeRpcResult(&rpc);
1506 ReleaseBuffer(bufferResults);
1507 ReleaseBuffer(bufferArgs);
1508
1509 return hr;
1510 }
1511
1512 EXTERN_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
1582 LExit:
1583 PipeFreeRpcResult(&rpc);
1584 ReleaseBuffer(bufferResults);
1585 ReleaseBuffer(bufferArgs);
1586
1587 return hr;
1588 }
1589
1590 EXTERN_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
1666 LExit:
1667 PipeFreeRpcResult(&rpc);
1668 ReleaseBuffer(bufferResults);
1669 ReleaseBuffer(bufferArgs);
1670
1671 return hr;
1672 }
1673
1674 EXTERN_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
1725 LExit:
1726 PipeFreeRpcResult(&rpc);
1727 ReleaseBuffer(bufferResults);
1728 ReleaseBuffer(bufferArgs);
1729
1730 return hr;
1731 }
1732
1733 EXTERN_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
1800 LExit:
1801 PipeFreeRpcResult(&rpc);
1802 ReleaseBuffer(bufferResults);
1803 ReleaseBuffer(bufferArgs);
1804
1805 return hr;
1806 }
1807
1808 EXTERN_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
1878 LExit:
1879 PipeFreeRpcResult(&rpc);
1880 ReleaseBuffer(bufferResults);
1881 ReleaseBuffer(bufferArgs);
1882
1883 return hr;
1884 }
1885
1886 EXTERN_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
1924 LExit:
1925 PipeFreeRpcResult(&rpc);
1926 ReleaseBuffer(bufferResults);
1927 ReleaseBuffer(bufferArgs);
1928
1929 return hr;
1930 }
1931
1932 EXTERN_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
1993 LExit:
1994 PipeFreeRpcResult(&rpc);
1995 ReleaseBuffer(bufferResults);
1996 ReleaseBuffer(bufferArgs);
1997
1998 return hr;
1999 }
2000
2001 EXTERN_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
2062 LExit:
2063 PipeFreeRpcResult(&rpc);
2064 ReleaseBuffer(bufferResults);
2065 ReleaseBuffer(bufferArgs);
2066
2067 return hr;
2068 }
2069
2070 EXTERN_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
2113 LExit:
2114 PipeFreeRpcResult(&rpc);
2115 ReleaseBuffer(bufferResults);
2116 ReleaseBuffer(bufferArgs);
2117
2118 return hr;
2119 }
2120
2121 EXTERN_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
2197 LExit:
2198 PipeFreeRpcResult(&rpc);
2199 ReleaseBuffer(bufferResults);
2200 ReleaseBuffer(bufferArgs);
2201
2202 return hr;
2203 }
2204
2205 EXTERN_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
2266 LExit:
2267 PipeFreeRpcResult(&rpc);
2268 ReleaseBuffer(bufferResults);
2269 ReleaseBuffer(bufferArgs);
2270
2271 return hr;
2272 }
2273
2274 EXTERN_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
2325 LExit:
2326 PipeFreeRpcResult(&rpc);
2327 ReleaseBuffer(bufferResults);
2328 ReleaseBuffer(bufferArgs);
2329
2330 return hr;
2331 }
2332
2333 EXTERN_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
2386 LExit:
2387 PipeFreeRpcResult(&rpc);
2388 ReleaseBuffer(bufferResults);
2389 ReleaseBuffer(bufferArgs);
2390
2391 return hr;
2392 }
2393
2394 EXTERN_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
2470 LExit:
2471 PipeFreeRpcResult(&rpc);
2472 ReleaseBuffer(bufferResults);
2473 ReleaseBuffer(bufferArgs);
2474
2475 return hr;
2476 }
2477
2478 EXTERN_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
2549 LExit:
2550 PipeFreeRpcResult(&rpc);
2551 ReleaseBuffer(bufferResults);
2552 ReleaseBuffer(bufferArgs);
2553
2554 return hr;
2555 }
2556
2557 EXTERN_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
2633 LExit:
2634 PipeFreeRpcResult(&rpc);
2635 ReleaseBuffer(bufferResults);
2636 ReleaseBuffer(bufferArgs);
2637
2638 return hr;
2639 }
2640
2641 EXTERN_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
2702 LExit:
2703 PipeFreeRpcResult(&rpc);
2704 ReleaseBuffer(bufferResults);
2705 ReleaseBuffer(bufferArgs);
2706
2707 return hr;
2708 }
2709
2710 EXTERN_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
2811 LExit:
2812 PipeFreeRpcResult(&rpc);
2813 ReleaseBuffer(bufferResults);
2814 ReleaseBuffer(bufferArgs);
2815
2816 return hr;
2817 }
2818
2819 EXTERN_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
2880 LExit:
2881 PipeFreeRpcResult(&rpc);
2882 ReleaseBuffer(bufferResults);
2883 ReleaseBuffer(bufferArgs);
2884
2885 return hr;
2886 }
2887
2888 EXTERN_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
2944 LExit:
2945 PipeFreeRpcResult(&rpc);
2946 ReleaseBuffer(bufferResults);
2947 ReleaseBuffer(bufferArgs);
2948
2949 return hr;
2950 }
2951
2952 EXTERN_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
2998 LExit:
2999 PipeFreeRpcResult(&rpc);
3000 ReleaseBuffer(bufferResults);
3001 ReleaseBuffer(bufferArgs);
3002
3003 return hr;
3004 }
3005
3006 EXTERN_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
3044 LExit:
3045 PipeFreeRpcResult(&rpc);
3046 ReleaseBuffer(bufferResults);
3047 ReleaseBuffer(bufferArgs);
3048
3049 return hr;
3050 }
3051
3052 EXTERN_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
3142 LExit:
3143 PipeFreeRpcResult(&rpc);
3144 ReleaseBuffer(bufferResults);
3145 ReleaseBuffer(bufferArgs);
3146
3147 return hr;
3148 }
3149
3150 EXTERN_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
3201 LExit:
3202 PipeFreeRpcResult(&rpc);
3203 ReleaseBuffer(bufferResults);
3204 ReleaseBuffer(bufferArgs);
3205
3206 return hr;
3207 }
3208
3209 EXTERN_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
3247 LExit:
3248 PipeFreeRpcResult(&rpc);
3249 ReleaseBuffer(bufferResults);
3250 ReleaseBuffer(bufferArgs);
3251
3252 return hr;
3253 }
3254
3255 EXTERN_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
3330 LExit:
3331 PipeFreeRpcResult(&rpc);
3332 ReleaseBuffer(bufferResults);
3333 ReleaseBuffer(bufferArgs);
3334
3335 return hr;
3336 }
3337
3338 EXTERN_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
3423 LExit:
3424 PipeFreeRpcResult(&rpc);
3425 ReleaseBuffer(bufferResults);
3426 ReleaseBuffer(bufferArgs);
3427
3428 return hr;
3429 }
3430
3431 EXTERN_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
3502 LExit:
3503 PipeFreeRpcResult(&rpc);
3504 ReleaseBuffer(bufferResults);
3505 ReleaseBuffer(bufferArgs);
3506
3507 return hr;
3508 }
3509
3510 EXTERN_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
3577 LExit:
3578 PipeFreeRpcResult(&rpc);
3579 ReleaseBuffer(bufferResults);
3580 ReleaseBuffer(bufferArgs);
3581
3582 return hr;
3583 }
3584
3585 EXTERN_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
3641 LExit:
3642 PipeFreeRpcResult(&rpc);
3643 ReleaseBuffer(bufferResults);
3644 ReleaseBuffer(bufferArgs);
3645
3646 return hr;
3647 }
3648
3649 EXTERN_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
3711 LExit:
3712 PipeFreeRpcResult(&rpc);
3713 ReleaseBuffer(bufferResults);
3714 ReleaseBuffer(bufferArgs);
3715
3716 return hr;
3717 }
3718
3719 EXTERN_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
3776 LExit:
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
3797 EXTERN_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
3843 LExit:
3844 PipeFreeRpcResult(&rpc);
3845 ReleaseBuffer(bufferResults);
3846 ReleaseBuffer(bufferArgs);
3847
3848 return hr;
3849 }
3850
3851 EXTERN_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
3894 LExit:
3895 PipeFreeRpcResult(&rpc);
3896 ReleaseBuffer(bufferResults);
3897 ReleaseBuffer(bufferArgs);
3898
3899 return hr;
3900 }
3901
3902 EXTERN_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
3935 LExit:
3936 PipeFreeRpcResult(&rpc);
3937 ReleaseBuffer(bufferResults);
3938 ReleaseBuffer(bufferArgs);
3939
3940 return hr;
3941 }
3942
3943 EXTERN_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
3981 LExit:
3982 PipeFreeRpcResult(&rpc);
3983 ReleaseBuffer(bufferResults);
3984 ReleaseBuffer(bufferArgs);
3985
3986 return hr;
3987 }
3988
3989 EXTERN_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
4040 LExit:
4041 PipeFreeRpcResult(&rpc);
4042 ReleaseBuffer(bufferResults);
4043 ReleaseBuffer(bufferArgs);
4044
4045 return hr;
4046 }
4047
4048 EXTERN_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
4123 LExit:
4124 PipeFreeRpcResult(&rpc);
4125 ReleaseBuffer(bufferResults);
4126 ReleaseBuffer(bufferArgs);
4127
4128 return hr;
4129 }
4130
4131 EXTERN_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
4184 LExit:
4185 PipeFreeRpcResult(&rpc);
4186 ReleaseBuffer(bufferResults);
4187 ReleaseBuffer(bufferArgs);
4188
4189 return hr;
4190 }
4191
4192 EXTERN_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
4262 LExit:
4263 PipeFreeRpcResult(&rpc);
4264 ReleaseBuffer(bufferResults);
4265 ReleaseBuffer(bufferArgs);
4266
4267 return hr;
4268 }
4269
4270 EXTERN_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
4308 LExit:
4309 PipeFreeRpcResult(&rpc);
4310 ReleaseBuffer(bufferResults);
4311 ReleaseBuffer(bufferArgs);
4312
4313 return hr;
4314 }
4315
4316 EXTERN_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
4401 LExit:
4402 PipeFreeRpcResult(&rpc);
4403 ReleaseBuffer(bufferResults);
4404 ReleaseBuffer(bufferArgs);
4405
4406 return hr;
4407 }
4408
4409 EXTERN_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
4511 LExit:
4512 PipeFreeRpcResult(&rpc);
4513 ReleaseBuffer(bufferResults);
4514 ReleaseBuffer(bufferArgs);
4515
4516 return hr;
4517 }
4518
4519 EXTERN_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
4567 LExit:
4568 PipeFreeRpcResult(&rpc);
4569 ReleaseBuffer(bufferResults);
4570 ReleaseBuffer(bufferArgs);
4571
4572 return hr;
4573 }
4574
4575 EXTERN_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
4633 LExit:
4634 PipeFreeRpcResult(&rpc);
4635 ReleaseBuffer(bufferResults);
4636 ReleaseBuffer(bufferArgs);
4637
4638 return hr;
4639 }
4640
4641 EXTERN_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
4743 LExit:
4744 PipeFreeRpcResult(&rpc);
4745 ReleaseBuffer(bufferResults);
4746 ReleaseBuffer(bufferArgs);
4747
4748 return hr;
4749 }
4750
4751 EXTERN_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
4799 LExit:
4800 PipeFreeRpcResult(&rpc);
4801 ReleaseBuffer(bufferResults);
4802 ReleaseBuffer(bufferArgs);
4803
4804 return hr;
4805 }
4806
4807 EXTERN_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
4872 LExit:
4873 PipeFreeRpcResult(&rpc);
4874 ReleaseBuffer(bufferResults);
4875 ReleaseBuffer(bufferArgs);
4876
4877 return hr;
4878 }
4879
4880 EXTERN_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
4945 LExit:
4946 PipeFreeRpcResult(&rpc);
4947 ReleaseBuffer(bufferResults);
4948 ReleaseBuffer(bufferArgs);
4949
4950 return hr;
4951 }
4952
4953 EXTERN_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
Showing first 5,000 of 5,893 lines. View raw