plan.cpp · joebigelow/wix · siGit Code & Deploy

@joebigelow / wix

Code Commits Issues Pulls Sessions CI/CD

main

cpp 3,142 lines 121 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	#define PlanDumpLevel REPORT_DEBUG
6
7	// internal struct definitions
8
9
10	// internal function definitions
11
12	static void PlannedExecutePackage(
13	__in BURN_PLAN* pPlan,
14	__in BURN_PACKAGE* pPackage
15	);
16	static void UninitializeRegistrationAction(
17	__in BURN_DEPENDENT_REGISTRATION_ACTION* pAction
18	);
19	static void UninitializeCacheAction(
20	__in BURN_CACHE_ACTION* pCacheAction
21	);
22	static void ResetPlannedContainerState(
23	__in BURN_CONTAINER* pContainer
24	);
25	static void ResetPlannedPayloadsState(
26	__in BURN_PAYLOADS* pPayloads
27	);
28	static void ResetPlannedPayloadGroupState(
29	__in BURN_PAYLOAD_GROUP* pPayloadGroup
30	);
31	static void ResetPlannedPackageState(
32	__in BURN_PACKAGE* pPackage
33	);
34	static void ResetPlannedRollbackBoundaryState(
35	__in BURN_ROLLBACK_BOUNDARY* pRollbackBoundary
36	);
37	static HRESULT PlanPackagesHelper(
38	__in BURN_PACKAGE* rgPackages,
39	__in DWORD cPackages,
40	__in BURN_USER_EXPERIENCE* pUX,
41	__in BURN_PLAN* pPlan,
42	__in BURN_LOGGING* pLog,
43	__in BURN_VARIABLES* pVariables
44	);
45	static HRESULT InitializePackage(
46	__in BURN_PLAN* pPlan,
47	__in BURN_USER_EXPERIENCE* pUX,
48	__in BURN_VARIABLES* pVariables,
49	__in BURN_PACKAGE* pPackage
50	);
51	static HRESULT ProcessPackage(
52	__in BOOL fBundlePerMachine,
53	__in BURN_USER_EXPERIENCE* pUX,
54	__in BURN_PLAN* pPlan,
55	__in BURN_PACKAGE* pPackage,
56	__in BURN_LOGGING* pLog,
57	__in BURN_VARIABLES* pVariables,
58	__inout BURN_ROLLBACK_BOUNDARY** ppRollbackBoundary
59	);
60	static HRESULT ProcessPackageRollbackBoundary(
61	__in BURN_PLAN* pPlan,
62	__in BURN_USER_EXPERIENCE* pUX,
63	__in BURN_LOGGING* pLog,
64	__in BURN_VARIABLES* pVariables,
65	__in_opt BURN_ROLLBACK_BOUNDARY* pEffectiveRollbackBoundary,
66	__inout BURN_ROLLBACK_BOUNDARY** ppRollbackBoundary
67	);
68	static HRESULT GetActionDefaultRequestState(
69	__in BOOTSTRAPPER_ACTION action,
70	__in BOOTSTRAPPER_PACKAGE_STATE currentState,
71	__out BOOTSTRAPPER_REQUEST_STATE* pRequestState
72	);
73	static HRESULT AddRegistrationAction(
74	__in BURN_PLAN* pPlan,
75	__in BURN_DEPENDENT_REGISTRATION_ACTION_TYPE type,
76	__in_z LPCWSTR wzDependentProviderKey,
77	__in_z LPCWSTR wzOwnerBundleId
78	);
79	static HRESULT AddCachePackage(
80	__in BURN_PLAN* pPlan,
81	__in BURN_PACKAGE* pPackage,
82	__in BOOL fVital
83	);
84	static HRESULT AddCachePackageHelper(
85	__in BURN_PLAN* pPlan,
86	__in BURN_PACKAGE* pPackage,
87	__in BOOL fVital
88	);
89	static HRESULT AddCacheSlipstreamMsps(
90	__in BURN_PLAN* pPlan,
91	__in BURN_PACKAGE* pPackage
92	);
93	static DWORD GetNextCheckpointId(
94	__in BURN_PLAN* pPlan
95	);
96	static HRESULT AppendCacheAction(
97	__in BURN_PLAN* pPlan,
98	__out BURN_CACHE_ACTION** ppCacheAction
99	);
100	static HRESULT AppendRollbackCacheAction(
101	__in BURN_PLAN* pPlan,
102	__out BURN_CACHE_ACTION** ppCacheAction
103	);
104	static HRESULT AppendCleanAction(
105	__in BURN_PLAN* pPlan,
106	__out BURN_CLEAN_ACTION** ppCleanAction
107	);
108	static HRESULT AppendRestoreRelatedBundleAction(
109	__in BURN_PLAN* pPlan,
110	__out BURN_EXECUTE_ACTION** ppExecuteAction
111	);
112	static HRESULT ProcessPayloadGroup(
113	__in BURN_PLAN* pPlan,
114	__in BURN_PAYLOAD_GROUP* pPayloadGroup
115	);
116	static void RemoveUnnecessaryActions(
117	__in BOOL fExecute,
118	__in BURN_EXECUTE_ACTION* rgActions,
119	__in DWORD cActions
120	);
121	static void FinalizePatchActions(
122	__in BOOL fExecute,
123	__in BURN_EXECUTE_ACTION* rgActions,
124	__in DWORD cActions
125	);
126	static void CalculateExpectedRegistrationStates(
127	__in BURN_PACKAGE* rgPackages,
128	__in DWORD cPackages
129	);
130	static HRESULT PlanDependencyActions(
131	__in BOOL fBundlePerMachine,
132	__in BURN_PLAN* pPlan,
133	__in BURN_PACKAGE* pPackage
134	);
135	static HRESULT CalculateExecuteActions(
136	__in BURN_PACKAGE* pPackage,
137	__in_opt BURN_ROLLBACK_BOUNDARY* pActiveRollbackBoundary
138	);
139	static BURN_CACHE_PACKAGE_TYPE GetCachePackageType(
140	__in BURN_PACKAGE* pPackage,
141	__in BOOL fExecute
142	);
143	static BOOL ForceCache(
144	__in BURN_PLAN* pPlan,
145	__in BURN_PACKAGE* pPackage
146	);
147
148	// function definitions
149
150	extern "C" void PlanReset(
151	__in BURN_PLAN* pPlan,
152	__in BURN_VARIABLES* pVariables,
153	__in BURN_CONTAINERS* pContainers,
154	__in BURN_PACKAGES* pPackages,
155	__in BURN_PAYLOAD_GROUP* pLayoutPayloads
156	)
157	{
158	ReleaseNullStr(pPlan->sczLayoutDirectory);
159	PackageUninitialize(&pPlan->forwardCompatibleBundle);
160
161	if (pPlan->rgRegistrationActions)
162	{
163	for (DWORD i = 0; i < pPlan->cRegistrationActions; ++i)
164	{
165	UninitializeRegistrationAction(&pPlan->rgRegistrationActions[i]);
166	}
167	MemFree(pPlan->rgRegistrationActions);
168	}
169
170	if (pPlan->rgRollbackRegistrationActions)
171	{
172	for (DWORD i = 0; i < pPlan->cRollbackRegistrationActions; ++i)
173	{
174	UninitializeRegistrationAction(&pPlan->rgRollbackRegistrationActions[i]);
175	}
176	MemFree(pPlan->rgRollbackRegistrationActions);
177	}
178
179	if (pPlan->rgCacheActions)
180	{
181	for (DWORD i = 0; i < pPlan->cCacheActions; ++i)
182	{
183	UninitializeCacheAction(&pPlan->rgCacheActions[i]);
184	}
185	MemFree(pPlan->rgCacheActions);
186	}
187
188	if (pPlan->rgExecuteActions)
189	{
190	for (DWORD i = 0; i < pPlan->cExecuteActions; ++i)
191	{
192	PlanUninitializeExecuteAction(&pPlan->rgExecuteActions[i]);
193	}
194	MemFree(pPlan->rgExecuteActions);
195	}
196
197	if (pPlan->rgRollbackActions)
198	{
199	for (DWORD i = 0; i < pPlan->cRollbackActions; ++i)
200	{
201	PlanUninitializeExecuteAction(&pPlan->rgRollbackActions[i]);
202	}
203	MemFree(pPlan->rgRollbackActions);
204	}
205
206	if (pPlan->rgRestoreRelatedBundleActions)
207	{
208	for (DWORD i = 0; i < pPlan->cRestoreRelatedBundleActions; ++i)
209	{
210	PlanUninitializeExecuteAction(&pPlan->rgRestoreRelatedBundleActions[i]);
211	}
212	MemFree(pPlan->rgRestoreRelatedBundleActions);
213	}
214
215	if (pPlan->rgCleanActions)
216	{
217	// Nothing needs to be freed inside clean actions today.
218	MemFree(pPlan->rgCleanActions);
219	}
220
221	if (pPlan->rgPlannedProviders)
222	{
223	ReleaseDependencyArray(pPlan->rgPlannedProviders, pPlan->cPlannedProviders);
224	}
225
226	if (pPlan->rgContainerProgress)
227	{
228	MemFree(pPlan->rgContainerProgress);
229	}
230
231	if (pPlan->shContainerProgress)
232	{
233	ReleaseDict(pPlan->shContainerProgress);
234	}
235
236	if (pPlan->rgPayloadProgress)
237	{
238	MemFree(pPlan->rgPayloadProgress);
239	}
240
241	if (pPlan->shPayloadProgress)
242	{
243	ReleaseDict(pPlan->shPayloadProgress);
244	}
245
246	if (pPlan->pPayloads)
247	{
248	ResetPlannedPayloadsState(pPlan->pPayloads);
249	}
250
251	memset(pPlan, 0, sizeof(BURN_PLAN));
252
253	if (pContainers->rgContainers)
254	{
255	for (DWORD i = 0; i < pContainers->cContainers; ++i)
256	{
257	ResetPlannedContainerState(&pContainers->rgContainers[i]);
258	}
259	}
260
261	// Reset the planned actions for each package.
262	if (pPackages->rgPackages)
263	{
264	for (DWORD i = 0; i < pPackages->cPackages; ++i)
265	{
266	ResetPlannedPackageState(&pPackages->rgPackages[i]);
267	}
268	}
269
270	ResetPlannedPayloadGroupState(pLayoutPayloads);
271
272	// Reset the planned state for each rollback boundary.
273	if (pPackages->rgRollbackBoundaries)
274	{
275	for (DWORD i = 0; i < pPackages->cRollbackBoundaries; ++i)
276	{
277	ResetPlannedRollbackBoundaryState(&pPackages->rgRollbackBoundaries[i]);
278	}
279	}
280
281	PlanSetVariables(BOOTSTRAPPER_ACTION_UNKNOWN, pVariables);
282	}
283
284	extern "C" void PlanUninitializeExecuteAction(
285	__in BURN_EXECUTE_ACTION* pExecuteAction
286	)
287	{
288	switch (pExecuteAction->type)
289	{
290	case BURN_EXECUTE_ACTION_TYPE_RELATED_BUNDLE:
291	ReleaseStr(pExecuteAction->relatedBundle.sczIgnoreDependencies);
292	ReleaseStr(pExecuteAction->relatedBundle.sczAncestors);
293	ReleaseStr(pExecuteAction->relatedBundle.sczEngineWorkingDirectory);
294	break;
295
296	case BURN_EXECUTE_ACTION_TYPE_BUNDLE_PACKAGE:
297	ReleaseStr(pExecuteAction->bundlePackage.sczParent);
298	ReleaseStr(pExecuteAction->bundlePackage.sczIgnoreDependencies);
299	ReleaseStr(pExecuteAction->bundlePackage.sczAncestors);
300	ReleaseStr(pExecuteAction->bundlePackage.sczEngineWorkingDirectory);
301	break;
302
303	case BURN_EXECUTE_ACTION_TYPE_EXE_PACKAGE:
304	ReleaseStr(pExecuteAction->exePackage.sczAncestors);
305	ReleaseStr(pExecuteAction->exePackage.sczEngineWorkingDirectory);
306	break;
307
308	case BURN_EXECUTE_ACTION_TYPE_MSI_PACKAGE:
309	ReleaseStr(pExecuteAction->msiPackage.sczLogPath);
310	ReleaseMem(pExecuteAction->msiPackage.rgFeatures);
311	break;
312
313	case BURN_EXECUTE_ACTION_TYPE_MSP_TARGET:
314	ReleaseStr(pExecuteAction->mspTarget.sczTargetProductCode);
315	ReleaseStr(pExecuteAction->mspTarget.sczLogPath);
316	ReleaseMem(pExecuteAction->mspTarget.rgOrderedPatches);
317	break;
318
319	case BURN_EXECUTE_ACTION_TYPE_MSU_PACKAGE:
320	ReleaseStr(pExecuteAction->msuPackage.sczLogPath);
321	break;
322
323	case BURN_EXECUTE_ACTION_TYPE_PACKAGE_DEPENDENCY:
324	ReleaseStr(pExecuteAction->packageDependency.sczBundleProviderKey);
325	break;
326
327	case BURN_EXECUTE_ACTION_TYPE_UNINSTALL_MSI_COMPATIBLE_PACKAGE:
328	ReleaseStr(pExecuteAction->uninstallMsiCompatiblePackage.sczLogPath);
329	break;
330	}
331	}
332
333	extern "C" HRESULT PlanSetVariables(
334	__in BOOTSTRAPPER_ACTION action,
335	__in BURN_VARIABLES* pVariables
336	)
337	{
338	HRESULT hr = S_OK;
339
340	hr = VariableSetNumeric(pVariables, BURN_BUNDLE_ACTION, action, TRUE);
341	ExitOnFailure(hr, "Failed to set the bundle action built-in variable.");
342
343	LExit:
344	return hr;
345	}
346
347	extern "C" HRESULT PlanDefaultPackageRequestState(
348	__in BURN_PACKAGE_TYPE packageType,
349	__in BOOTSTRAPPER_PACKAGE_STATE currentState,
350	__in BOOTSTRAPPER_ACTION action,
351	__in BOOTSTRAPPER_PACKAGE_CONDITION_RESULT installCondition,
352	__in BOOTSTRAPPER_PACKAGE_CONDITION_RESULT repairCondition,
353	__in BOOTSTRAPPER_RELATION_TYPE relationType,
354	__out BOOTSTRAPPER_REQUEST_STATE* pRequestState
355	)
356	{
357	HRESULT hr = S_OK;
358	BOOTSTRAPPER_REQUEST_STATE defaultRequestState = BOOTSTRAPPER_REQUEST_STATE_NONE;
359
360	// If doing layout, then always default to requesting the package be cached.
361	if (BOOTSTRAPPER_ACTION_LAYOUT == action)
362	{
363	*pRequestState = BOOTSTRAPPER_REQUEST_STATE_CACHE;
364	}
365	else if (BOOTSTRAPPER_ACTION_CACHE == action)
366	{
367	switch (currentState)
368	{
369	case BOOTSTRAPPER_PACKAGE_STATE_PRESENT: __fallthrough;
370	case BOOTSTRAPPER_PACKAGE_STATE_SUPERSEDED:
371	*pRequestState = BOOTSTRAPPER_REQUEST_STATE_PRESENT;
372	break;
373
374	default:
375	*pRequestState = BOOTSTRAPPER_REQUEST_STATE_CACHE;
376	break;
377	}
378	}
379	else if (BOOTSTRAPPER_RELATION_PATCH == relationType && BURN_PACKAGE_TYPE_MSP == packageType)
380	{
381	// For patch related bundles, only install a patch if currently absent during install, modify, or repair.
382	if (BOOTSTRAPPER_PACKAGE_STATE_ABSENT != currentState)
383	{
384	*pRequestState = BOOTSTRAPPER_REQUEST_STATE_NONE;
385	}
386	else if (BOOTSTRAPPER_ACTION_INSTALL == action \|\|
387	BOOTSTRAPPER_ACTION_MODIFY == action \|\|
388	BOOTSTRAPPER_ACTION_REPAIR == action)
389	{
390	*pRequestState = BOOTSTRAPPER_REQUEST_STATE_PRESENT;
391	}
392	}
393	else // pick the best option for the action state and install condition.
394	{
395	hr = GetActionDefaultRequestState(action, currentState, &defaultRequestState);
396	ExitOnFailure(hr, "Failed to get default request state for action.");
397
398	if (BOOTSTRAPPER_ACTION_UNINSTALL != action && BOOTSTRAPPER_ACTION_UNSAFE_UNINSTALL != action)
399	{
400	// If we're not doing an uninstall, use the install condition
401	// to determine whether to use the default request state or make the package absent.
402	if (BOOTSTRAPPER_PACKAGE_CONDITION_FALSE == installCondition)
403	{
404	defaultRequestState = BOOTSTRAPPER_REQUEST_STATE_ABSENT;
405	}
406	// Obsolete means the package is not on the machine and should not be installed,
407	// except patches can be obsolete and present.
408	// Superseded means the package is on the machine but not active, so only uninstall operations are allowed.
409	// All other operations do nothing.
410	else if (BOOTSTRAPPER_PACKAGE_STATE_OBSOLETE == currentState \|\| BOOTSTRAPPER_PACKAGE_STATE_SUPERSEDED == currentState)
411	{
412	defaultRequestState = BOOTSTRAPPER_REQUEST_STATE_PRESENT <= defaultRequestState ? BOOTSTRAPPER_REQUEST_STATE_NONE : defaultRequestState;
413	}
414	else if (BOOTSTRAPPER_ACTION_REPAIR == action && BOOTSTRAPPER_PACKAGE_CONDITION_FALSE == repairCondition)
415	{
416	defaultRequestState = BOOTSTRAPPER_REQUEST_STATE_PRESENT;
417	}
418	}
419
420	*pRequestState = defaultRequestState;
421	}
422
423	LExit:
424	return hr;
425	}
426
427	extern "C" HRESULT PlanLayoutBundle(
428	__in BURN_PLAN* pPlan,
429	__in_z LPCWSTR wzExecutableName,
430	__in DWORD64 qwBundleSize,
431	__in BURN_VARIABLES* pVariables,
432	__in BURN_PAYLOAD_GROUP* pLayoutPayloads
433	)
434	{
435	HRESULT hr = S_OK;
436	BURN_CACHE_ACTION* pCacheAction = NULL;
437	LPWSTR sczLayoutDirectory = NULL;
438	LPWSTR sczExecutablePath = NULL;
439
440	// Get the layout directory.
441	hr = VariableGetString(pVariables, BURN_BUNDLE_LAYOUT_DIRECTORY, &sczLayoutDirectory);
442	if (E_NOTFOUND == hr) // if not set, use the current directory as the layout directory.
443	{
444	hr = PathForCurrentProcess(&sczExecutablePath, NULL);
445	ExitOnFailure(hr, "Failed to get path for current executing process as layout directory.");
446
447	hr = PathGetDirectory(sczExecutablePath, &sczLayoutDirectory);
448	ExitOnFailure(hr, "Failed to get executing process as layout directory.");
449	}
450	ExitOnFailure(hr, "Failed to get bundle layout directory property.");
451
452	hr = PathGetFullPathName(sczLayoutDirectory, &pPlan->sczLayoutDirectory, NULL, NULL);
453	ExitOnFailure(hr, "Failed to ensure layout directory is fully qualified.");
454
455	hr = PathBackslashTerminate(&pPlan->sczLayoutDirectory);
456	ExitOnFailure(hr, "Failed to ensure layout directory is backslash terminated.");
457
458	hr = ProcessPayloadGroup(pPlan, pLayoutPayloads);
459	ExitOnFailure(hr, "Failed to process payload group for bundle.");
460
461	// Plan the layout of the bundle engine itself.
462	hr = AppendCacheAction(pPlan, &pCacheAction);
463	ExitOnFailure(hr, "Failed to append bundle start action.");
464
465	pCacheAction->type = BURN_CACHE_ACTION_TYPE_LAYOUT_BUNDLE;
466
467	hr = StrAllocString(&pCacheAction->bundleLayout.sczExecutableName, wzExecutableName, 0);
468	ExitOnFailure(hr, "Failed to to copy executable name for bundle.");
469
470	hr = CacheCalculateBundleLayoutWorkingPath(pPlan->pCache, pPlan->wzBundleId, &pCacheAction->bundleLayout.sczUnverifiedPath);
471	ExitOnFailure(hr, "Failed to calculate bundle layout working path.");
472
473	pCacheAction->bundleLayout.qwBundleSize = qwBundleSize;
474	pCacheAction->bundleLayout.pPayloadGroup = pLayoutPayloads;
475
476	// Acquire + Verify + Finalize
477	pPlan->qwCacheSizeTotal += 3 * qwBundleSize;
478
479	++pPlan->cOverallProgressTicksTotal;
480
481	LExit:
482	ReleaseStr(sczExecutablePath);
483	ReleaseStr(sczLayoutDirectory);
484
485	return hr;
486	}
487
488	extern "C" HRESULT PlanForwardCompatibleBundles(
489	__in BURN_USER_EXPERIENCE* pUX,
490	__in BURN_PLAN* pPlan,
491	__in BURN_REGISTRATION* pRegistration
492	)
493	{
494	HRESULT hr = S_OK;
495	BOOL fRecommendIgnore = TRUE;
496	BOOL fIgnoreBundle = FALSE;
497	BOOTSTRAPPER_ACTION action = pPlan->action;
498
499	if (!pRegistration->fForwardCompatibleBundleExists)
500	{
501	ExitFunction();
502	}
503
504	// Only change the recommendation if an active parent was provided.
505	if (pPlan->pInternalCommand->sczActiveParent && *pPlan->pInternalCommand->sczActiveParent)
506	{
507	// On install, recommend running the forward compatible bundle because there is an active parent. This
508	// will essentially register the parent with the forward compatible bundle.
509	if (BOOTSTRAPPER_ACTION_INSTALL == action)
510	{
511	fRecommendIgnore = FALSE;
512	}
513	else if (BOOTSTRAPPER_ACTION_UNSAFE_UNINSTALL == action \|\|
514	BOOTSTRAPPER_ACTION_UNINSTALL == action \|\|
515	BOOTSTRAPPER_ACTION_MODIFY == action \|\|
516	BOOTSTRAPPER_ACTION_REPAIR == action)
517	{
518	// When modifying the bundle, only recommend running the forward compatible bundle if the parent
519	// is already registered as a dependent of the provider key.
520	if (pRegistration->fParentRegisteredAsDependent)
521	{
522	fRecommendIgnore = FALSE;
523	}
524	}
525	}
526
527	for (DWORD iRelatedBundle = 0; iRelatedBundle < pRegistration->relatedBundles.cRelatedBundles; ++iRelatedBundle)
528	{
529	BURN_RELATED_BUNDLE* pRelatedBundle = pRegistration->relatedBundles.rgRelatedBundles + iRelatedBundle;
530	if (!pRelatedBundle->fForwardCompatible)
531	{
532	continue;
533	}
534
535	fIgnoreBundle = fRecommendIgnore;
536
537	hr = BACallbackOnPlanForwardCompatibleBundle(pUX, pRelatedBundle->package.sczId, pRelatedBundle->detectRelationType, pRelatedBundle->sczTag, pRelatedBundle->package.fPerMachine, pRelatedBundle->pVersion, &fIgnoreBundle);
538	ExitOnRootFailure(hr, "BA aborted plan forward compatible bundle.");
539
540	if (!fIgnoreBundle)
541	{
542	hr = PseudoBundleInitializePassthrough(&pPlan->forwardCompatibleBundle, pPlan->pInternalCommand, pPlan->pCommand, &pRelatedBundle->package);
543	ExitOnFailure(hr, "Failed to initialize pass through bundle.");
544
545	pPlan->fEnabledForwardCompatibleBundle = TRUE;
546	break;
547	}
548	}
549
550	LExit:
551	return hr;
552	}
553
554	extern "C" HRESULT PlanPackages(
555	__in BURN_USER_EXPERIENCE* pUX,
556	__in BURN_PACKAGES* pPackages,
557	__in BURN_PLAN* pPlan,
558	__in BURN_LOGGING* pLog,
559	__in BURN_VARIABLES* pVariables
560	)
561	{
562	HRESULT hr = S_OK;
563
564	hr = PlanPackagesHelper(pPackages->rgPackages, pPackages->cPackages, pUX, pPlan, pLog, pVariables);
565
566	return hr;
567	}
568
569	extern "C" HRESULT PlanRegistration(
570	__in BURN_PLAN* pPlan,
571	__in BURN_REGISTRATION* pRegistration,
572	__in BURN_DEPENDENCIES* pDependencies,
573	__in BOOTSTRAPPER_RESUME_TYPE /resumeType/,
574	__in BOOTSTRAPPER_RELATION_TYPE relationType,
575	__inout BOOL* pfContinuePlanning
576	)
577	{
578	HRESULT hr = S_OK;
579	STRINGDICT_HANDLE sdBundleDependents = NULL;
580	STRINGDICT_HANDLE sdIgnoreDependents = NULL;
581	BOOL fDependentBlocksUninstall = FALSE;
582
583	pPlan->fCanAffectMachineState = TRUE; // register the bundle since we're modifying machine state.
584	pPlan->fDisallowRemoval = FALSE; // by default the bundle can be planned to be removed
585
586	// Ensure the bundle is cached if not running from the cache.
587	if (!CacheBundleRunningFromCache(pPlan->pCache))
588	{
589	pPlan->dwRegistrationOperations \|= BURN_REGISTRATION_ACTION_OPERATIONS_CACHE_BUNDLE;
590	}
591
592	if (pPlan->pInternalCommand->fArpSystemComponent)
593	{
594	pPlan->dwRegistrationOperations \|= BURN_REGISTRATION_ACTION_OPERATIONS_ARP_SYSTEM_COMPONENT;
595	}
596
597	if (BOOTSTRAPPER_ACTION_UNINSTALL == pPlan->action \|\| BOOTSTRAPPER_ACTION_UNSAFE_UNINSTALL == pPlan->action)
598	{
599	// If our provider key was not owned by a different bundle,
600	// then plan to write our provider key registration to "fix it" if broken
601	// in case the bundle isn't successfully uninstalled.
602	if (!pRegistration->fDetectedForeignProviderKeyBundleId)
603	{
604	pPlan->dwRegistrationOperations \|= BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY;
605	}
606
607	// Create the dictionary of dependents that should be ignored.
608	hr = DictCreateStringList(&sdIgnoreDependents, 5, DICT_FLAG_CASEINSENSITIVE);
609	ExitOnFailure(hr, "Failed to create the string dictionary.");
610
611	// If the self-dependent dependent exists, plan its removal. If we did not do this, we
612	// would prevent self-removal.
613	if (pRegistration->fSelfRegisteredAsDependent)
614	{
615	hr = AddRegistrationAction(pPlan, BURN_DEPENDENT_REGISTRATION_ACTION_TYPE_UNREGISTER, pDependencies->wzSelfDependent, pRegistration->sczId);
616	ExitOnFailure(hr, "Failed to allocate registration action.");
617
618	hr = DependencyAddIgnoreDependencies(sdIgnoreDependents, pDependencies->wzSelfDependent);
619	ExitOnFailure(hr, "Failed to add self-dependent to ignore dependents.");
620	}
621
622	if (!pDependencies->fIgnoreAllDependents)
623	{
624	// If we are not doing an upgrade, we check to see if there are still dependents on us and if so we skip planning.
625	// However, when being upgraded, we always execute our uninstall because a newer version of us is probably
626	// already on the machine and we need to clean up the stuff specific to this bundle.
627	if (BOOTSTRAPPER_RELATION_UPGRADE != relationType)
628	{
629	// If there were other dependencies to ignore, add them.
630	for (DWORD iDependency = 0; iDependency < pDependencies->cIgnoredDependencies; ++iDependency)
631	{
632	DEPENDENCY* pDependency = pDependencies->rgIgnoredDependencies + iDependency;
633
634	hr = DictKeyExists(sdIgnoreDependents, pDependency->sczKey);
635	if (E_NOTFOUND != hr)
636	{
637	ExitOnFailure(hr, "Failed to check the dictionary of ignored dependents.");
638	}
639	else
640	{
641	hr = DictAddKey(sdIgnoreDependents, pDependency->sczKey);
642	ExitOnFailure(hr, "Failed to add dependent key to ignored dependents.");
643	}
644	}
645
646	// For addon or patch bundles, dependent related bundles should be ignored. This allows
647	// that addon or patch to be removed even though bundles it targets still are registered.
648	for (DWORD i = 0; i < pRegistration->relatedBundles.cRelatedBundles; ++i)
649	{
650	const BURN_RELATED_BUNDLE* pRelatedBundle = pRegistration->relatedBundles.rgRelatedBundles + i;
651
652	if (BOOTSTRAPPER_RELATION_DEPENDENT_ADDON == pRelatedBundle->planRelationType \|\|
653	BOOTSTRAPPER_RELATION_DEPENDENT_PATCH == pRelatedBundle->planRelationType)
654	{
655	for (DWORD j = 0; j < pRelatedBundle->package.cDependencyProviders; ++j)
656	{
657	const BURN_DEPENDENCY_PROVIDER* pProvider = pRelatedBundle->package.rgDependencyProviders + j;
658
659	hr = DependencyAddIgnoreDependencies(sdIgnoreDependents, pProvider->sczKey);
660	ExitOnFailure(hr, "Failed to add dependent bundle provider key to ignore dependents.");
661	}
662	}
663	}
664
665	// If there are any (non-ignored and not-planned-to-be-removed) dependents left, skip planning.
666	for (DWORD iDependent = 0; iDependent < pRegistration->cDependents; ++iDependent)
667	{
668	DEPENDENCY* pDependent = pRegistration->rgDependents + iDependent;
669
670	hr = DictKeyExists(sdIgnoreDependents, pDependent->sczKey);
671	if (E_NOTFOUND == hr)
672	{
673	hr = S_OK;
674
675	// TODO: callback to the BA and let it have the option to ignore this dependent?
676	if (!fDependentBlocksUninstall)
677	{
678	fDependentBlocksUninstall = TRUE;
679
680	LogId(REPORT_STANDARD, MSG_PLAN_SKIPPED_DUE_TO_DEPENDENTS);
681	}
682
683	LogId(REPORT_VERBOSE, MSG_DEPENDENCY_BUNDLE_DEPENDENT, pDependent->sczKey, LoggingStringOrUnknownIfNull(pDependent->sczName));
684	}
685	ExitOnFailure(hr, "Failed to check for remaining dependents during planning.");
686	}
687
688	if (fDependentBlocksUninstall)
689	{
690	if (BOOTSTRAPPER_ACTION_UNSAFE_UNINSTALL == pPlan->action)
691	{
692	fDependentBlocksUninstall = FALSE;
693	LogId(REPORT_STANDARD, MSG_PLAN_NOT_SKIPPED_DUE_TO_DEPENDENTS);
694	}
695	else
696	{
697	pPlan->fDisallowRemoval = TRUE; // ensure the registration stays
698	*pfContinuePlanning = FALSE; // skip the rest of planning.
699	}
700	}
701	}
702	}
703	}
704	else
705	{
706	BOOL fAddonOrPatchBundle = (pRegistration->cAddonCodes \|\| pRegistration->cPatchCodes);
707
708	// Always plan to write our provider key registration when installing/modify/repair to "fix it"
709	// if broken.
710	pPlan->dwRegistrationOperations \|= BURN_REGISTRATION_ACTION_OPERATIONS_WRITE_PROVIDER_KEY;
711
712	// Create the dictionary of bundle dependents.
713	hr = DictCreateStringList(&sdBundleDependents, 5, DICT_FLAG_CASEINSENSITIVE);
714	ExitOnFailure(hr, "Failed to create the string dictionary.");
715
716	for (DWORD iDependent = 0; iDependent < pRegistration->cDependents; ++iDependent)
717	{
718	DEPENDENCY* pDependent = pRegistration->rgDependents + iDependent;
719
720	hr = DictKeyExists(sdBundleDependents, pDependent->sczKey);
721	if (E_NOTFOUND == hr)
722	{
723	hr = DictAddKey(sdBundleDependents, pDependent->sczKey);
724	ExitOnFailure(hr, "Failed to add dependent key to bundle dependents.");
725	}
726	ExitOnFailure(hr, "Failed to check the dictionary of bundle dependents.");
727	}
728
729	// Register each dependent related bundle. The ensures that addons and patches are reference
730	// counted and stick around until the last targeted bundle is removed.
731	for (DWORD i = 0; i < pRegistration->relatedBundles.cRelatedBundles; ++i)
732	{
733	const BURN_RELATED_BUNDLE* pRelatedBundle = pRegistration->relatedBundles.rgRelatedBundles + i;
734
735	if (BOOTSTRAPPER_RELATION_DEPENDENT_ADDON == pRelatedBundle->planRelationType \|\|
736	BOOTSTRAPPER_RELATION_DEPENDENT_PATCH == pRelatedBundle->planRelationType)
737	{
738	for (DWORD j = 0; j < pRelatedBundle->package.cDependencyProviders; ++j)
739	{
740	const BURN_DEPENDENCY_PROVIDER* pProvider = pRelatedBundle->package.rgDependencyProviders + j;
741
742	hr = DictKeyExists(sdBundleDependents, pProvider->sczKey);
743	if (E_NOTFOUND == hr)
744	{
745	hr = DictAddKey(sdBundleDependents, pProvider->sczKey);
746	ExitOnFailure(hr, "Failed to add new dependent key to bundle dependents.");
747
748	hr = AddRegistrationAction(pPlan, BURN_DEPENDENT_REGISTRATION_ACTION_TYPE_REGISTER, pProvider->sczKey, pRelatedBundle->package.sczId);
749	ExitOnFailure(hr, "Failed to add registration action for dependent related bundle.");
750	}
751	ExitOnFailure(hr, "Failed to check the dictionary of bundle dependents.");
752	}
753	}
754	}
755
756	// Only do the following if we decided there was a dependent self to register. If so and and an explicit parent was
757	// provided, register dependent self. Otherwise, if this bundle is not an addon or patch bundle then self-regisiter
758	// as our own dependent.
759	if (pDependencies->wzSelfDependent && !pRegistration->fSelfRegisteredAsDependent && (pDependencies->wzActiveParent \|\| !fAddonOrPatchBundle))
760	{
761	hr = AddRegistrationAction(pPlan, BURN_DEPENDENT_REGISTRATION_ACTION_TYPE_REGISTER, pDependencies->wzSelfDependent, pRegistration->sczId);
762	ExitOnFailure(hr, "Failed to add registration action for self dependent.");
763	}
764	}
765
766	LExit:
767	ReleaseDict(sdBundleDependents);
768	ReleaseDict(sdIgnoreDependents);
769
770	return hr;
771	}
772
773	extern "C" HRESULT PlanPassThroughBundle(
774	__in BURN_USER_EXPERIENCE* pUX,
775	__in BURN_PACKAGE* pPackage,
776	__in BURN_PLAN* pPlan,
777	__in BURN_LOGGING* pLog,
778	__in BURN_VARIABLES* pVariables
779	)
780	{
781	HRESULT hr = S_OK;
782
783	// Plan passthrough package.
784	hr = PlanPackagesHelper(pPackage, 1, pUX, pPlan, pLog, pVariables);
785	ExitOnFailure(hr, "Failed to process passthrough package.");
786
787	LExit:
788	return hr;
789	}
790
791	extern "C" HRESULT PlanUpdateBundle(
792	__in BURN_USER_EXPERIENCE* pUX,
793	__in BURN_PACKAGE* pPackage,
794	__in BURN_PLAN* pPlan,
795	__in BURN_LOGGING* pLog,
796	__in BURN_VARIABLES* pVariables
797	)
798	{
799	HRESULT hr = S_OK;
800
801	Assert(!pPackage->fPerMachine);
802	Assert(BURN_PACKAGE_TYPE_EXE == pPackage->type);
803	pPackage->Exe.fFireAndForget = BOOTSTRAPPER_ACTION_UPDATE_REPLACE == pPlan->action;
804
805	// Plan update package.
806	hr = PlanPackagesHelper(pPackage, 1, pUX, pPlan, pLog, pVariables);
807	ExitOnFailure(hr, "Failed to process update package.");
808
809	LExit:
810	return hr;
811	}
812
813	static HRESULT PlanPackagesHelper(
814	__in BURN_PACKAGE* rgPackages,
815	__in DWORD cPackages,
816	__in BURN_USER_EXPERIENCE* pUX,
817	__in BURN_PLAN* pPlan,
818	__in BURN_LOGGING* pLog,
819	__in BURN_VARIABLES* pVariables
820	)
821	{
822	HRESULT hr = S_OK;
823	BOOL fBundlePerMachine = pPlan->fPerMachine; // bundle is per-machine if plan starts per-machine.
824	BURN_ROLLBACK_BOUNDARY* pRollbackBoundary = NULL;
825	BOOL fReverseOrder = BOOTSTRAPPER_ACTION_UNINSTALL == pPlan->action \|\| BOOTSTRAPPER_ACTION_UNSAFE_UNINSTALL == pPlan->action;
826
827	// Initialize the packages.
828	for (DWORD i = 0; i < cPackages; ++i)
829	{
830	DWORD iPackage = fReverseOrder ? cPackages - 1 - i : i;
831	BURN_PACKAGE* pPackage = rgPackages + iPackage;
832
833	hr = InitializePackage(pPlan, pUX, pVariables, pPackage);
834	ExitOnFailure(hr, "Failed to initialize package.");
835	}
836
837	// Initialize the patch targets after all packages, since they could rely on the requested state of packages that are after the patch's package in the chain.
838	for (DWORD i = 0; i < cPackages; ++i)
839	{
840	DWORD iPackage = fReverseOrder ? cPackages - 1 - i : i;
841	BURN_PACKAGE* pPackage = rgPackages + iPackage;
842
843	if (BURN_PACKAGE_TYPE_MSP == pPackage->type)
844	{
845	hr = MspEnginePlanInitializePackage(pPackage, pUX);
846	ExitOnFailure(hr, "Failed to initialize plan package: %ls", pPackage->sczId);
847	}
848	}
849
850	// Plan the packages.
851	for (DWORD i = 0; i < cPackages; ++i)
852	{
853	DWORD iPackage = fReverseOrder ? cPackages - 1 - i : i;
854	BURN_PACKAGE* pPackage = rgPackages + iPackage;
855
856	hr = ProcessPackage(fBundlePerMachine, pUX, pPlan, pPackage, pLog, pVariables, &pRollbackBoundary);
857	ExitOnFailure(hr, "Failed to process package.");
858	}
859
860	// If we still have an open rollback boundary, complete it.
861	if (pRollbackBoundary)
862	{
863	hr = PlanRollbackBoundaryComplete(pPlan);
864	ExitOnFailure(hr, "Failed to plan final rollback boundary complete.");
865
866	pRollbackBoundary = NULL;
867	}
868
869	// Passthrough packages are never cleaned up by the calling bundle (they delete themselves when appropriate).
870	if (!pPlan->fEnabledForwardCompatibleBundle && BOOTSTRAPPER_ACTION_LAYOUT != pPlan->action)
871	{
872	// Plan clean up of packages.
873	for (DWORD i = 0; i < cPackages; ++i)
874	{
875	DWORD iPackage = fReverseOrder ? cPackages - 1 - i : i;
876	BURN_PACKAGE* pPackage = rgPackages + iPackage;
877
878	hr = PlanCleanPackage(pPlan, pPackage);
879	ExitOnFailure(hr, "Failed to plan clean package.");
880	}
881	}
882
883	// Remove unnecessary actions.
884	hr = PlanFinalizeActions(pPlan);
885	ExitOnFailure(hr, "Failed to remove unnecessary actions from plan.");
886
887	CalculateExpectedRegistrationStates(rgPackages, cPackages);
888
889	// Let the BA know the actions that were planned.
890	for (DWORD i = 0; i < cPackages; ++i)
891	{
892	DWORD iPackage = fReverseOrder ? cPackages - 1 - i : i;
893	BURN_PACKAGE* pPackage = rgPackages + iPackage;
894
895	BACallbackOnPlannedPackage(pUX, pPackage->sczId, pPackage->execute, pPackage->rollback, NULL != pPackage->hCacheEvent, pPackage->fPlannedUncache);
896
897	if (pPackage->compatiblePackage.fPlannable)
898	{
899	BACallbackOnPlannedCompatiblePackage(pUX, pPackage->sczId, pPackage->compatiblePackage.compatibleEntry.sczId, pPackage->compatiblePackage.fRemove);
900	}
901	}
902
903	LExit:
904	return hr;
905	}
906
907	static HRESULT InitializePackage(
908	__in BURN_PLAN* pPlan,
909	__in BURN_USER_EXPERIENCE* pUX,
910	__in BURN_VARIABLES* pVariables,
911	__in BURN_PACKAGE* pPackage
912	)
913	{
914	HRESULT hr = S_OK;
915	BOOTSTRAPPER_PACKAGE_CONDITION_RESULT installCondition = BOOTSTRAPPER_PACKAGE_CONDITION_DEFAULT;
916	BOOTSTRAPPER_PACKAGE_CONDITION_RESULT repairCondition = BOOTSTRAPPER_PACKAGE_CONDITION_DEFAULT;
917	BOOL fEvaluatedCondition = FALSE;
918	BOOL fBeginCalled = FALSE;
919	BOOTSTRAPPER_RELATION_TYPE relationType = pPlan->pCommand->relationType;
920
921	if (BURN_PACKAGE_TYPE_EXE == pPackage->type && pPackage->Exe.fPseudoPackage)
922	{
923	// Exe pseudo packages are not configurable.
924	// The BA already requested this package to be executed
925	// * by the overall plan action for UpdateReplace
926	// * by enabling the forward compatible bundle for Passthrough
927	pPackage->defaultRequested = pPackage->requested = BOOTSTRAPPER_REQUEST_STATE_FORCE_PRESENT;
928	ExitFunction();
929	}
930
931	if (pPackage->fCanAffectRegistration)
932	{
933	pPackage->expectedCacheRegistrationState = pPackage->cacheRegistrationState;
934	pPackage->expectedInstallRegistrationState = pPackage->installRegistrationState;
935	}
936
937	if (pPackage->sczInstallCondition && *pPackage->sczInstallCondition)
938	{
939	hr = ConditionEvaluate(pVariables, pPackage->sczInstallCondition, &fEvaluatedCondition);
940	ExitOnFailure(hr, "Failed to evaluate install condition.");
941
942	installCondition = fEvaluatedCondition ? BOOTSTRAPPER_PACKAGE_CONDITION_TRUE : BOOTSTRAPPER_PACKAGE_CONDITION_FALSE;
943	}
944
945	if (pPackage->sczRepairCondition && *pPackage->sczRepairCondition)
946	{
947	hr = ConditionEvaluate(pVariables, pPackage->sczRepairCondition, &fEvaluatedCondition);
948	ExitOnFailure(hr, "Failed to evaluate repair condition.");
949
950	repairCondition = fEvaluatedCondition ? BOOTSTRAPPER_PACKAGE_CONDITION_TRUE : BOOTSTRAPPER_PACKAGE_CONDITION_FALSE;
951	}
952
953	// Remember the default requested state so the engine doesn't get blamed for planning the wrong thing if the BA changes it.
954	hr = PlanDefaultPackageRequestState(pPackage->type, pPackage->currentState, pPlan->action, installCondition, repairCondition, relationType, &pPackage->defaultRequested);
955	ExitOnFailure(hr, "Failed to set default package state.");
956
957	pPackage->requested = pPackage->defaultRequested;
958	fBeginCalled = TRUE;
959
960	hr = BACallbackOnPlanPackageBegin(pUX, pPackage->sczId, pPackage->currentState, pPackage->fCached, installCondition, repairCondition, &pPackage->requested, &pPackage->cacheType);
961	ExitOnRootFailure(hr, "BA aborted plan package begin.");
962
963	if (BURN_PACKAGE_TYPE_MSI == pPackage->type)
964	{
965	hr = MsiEnginePlanInitializePackage(pPackage, pPlan->action, pVariables, pUX);
966	ExitOnFailure(hr, "Failed to initialize plan package: %ls", pPackage->sczId);
967	}
968
969	LExit:
970	if (fBeginCalled)
971	{
972	BACallbackOnPlanPackageComplete(pUX, pPackage->sczId, hr, pPackage->requested);
973	}
974
975	return hr;
976	}
977
978	static HRESULT ProcessPackage(
979	__in BOOL fBundlePerMachine,
980	__in BURN_USER_EXPERIENCE* pUX,
981	__in BURN_PLAN* pPlan,
982	__in BURN_PACKAGE* pPackage,
983	__in BURN_LOGGING* pLog,
984	__in BURN_VARIABLES* pVariables,
985	__inout BURN_ROLLBACK_BOUNDARY** ppRollbackBoundary
986	)
987	{
988	HRESULT hr = S_OK;
989	BURN_ROLLBACK_BOUNDARY* pEffectiveRollbackBoundary = NULL;
990	BOOL fBackward = BOOTSTRAPPER_ACTION_UNINSTALL == pPlan->action \|\| BOOTSTRAPPER_ACTION_UNSAFE_UNINSTALL == pPlan->action;
991
992	pEffectiveRollbackBoundary = fBackward ? pPackage->pRollbackBoundaryBackward : pPackage->pRollbackBoundaryForward;
993	hr = ProcessPackageRollbackBoundary(pPlan, pUX, pLog, pVariables, pEffectiveRollbackBoundary, ppRollbackBoundary);
994	ExitOnFailure(hr, "Failed to process package rollback boundary.");
995
996	if (BOOTSTRAPPER_ACTION_LAYOUT == pPlan->action)
997	{
998	if (BOOTSTRAPPER_REQUEST_STATE_NONE != pPackage->requested)
999	{
1000	hr = PlanLayoutPackage(pPlan, pPackage, TRUE);
1001	ExitOnFailure(hr, "Failed to plan layout package.");
1002	}
1003	}
1004	else
1005	{
1006	if (BOOTSTRAPPER_REQUEST_STATE_NONE != pPackage->requested \|\| pPackage->compatiblePackage.fRequested)
1007	{
1008	// If the package is in a requested state, plan it.
1009	hr = PlanExecutePackage(fBundlePerMachine, pUX, pPlan, pPackage, pLog, pVariables);
1010	ExitOnFailure(hr, "Failed to plan execute package.");
1011	}
1012	else
1013	{
1014	if (ForceCache(pPlan, pPackage))
1015	{
1016	hr = AddCachePackage(pPlan, pPackage, TRUE);
1017	ExitOnFailure(hr, "Failed to plan cache package.");
1018
1019	if (pPackage->fPerMachine)
1020	{
1021	pPlan->fPerMachine = TRUE;
1022	}
1023	}
1024
1025	// Make sure the package is properly ref-counted even if no plan is requested.
1026	hr = PlanDependencyActions(fBundlePerMachine, pPlan, pPackage);
1027	ExitOnFailure(hr, "Failed to plan dependency actions for package: %ls", pPackage->sczId);
1028	}
1029	}
1030
1031	// Add the checkpoint after each package and dependency registration action.
1032	if (BOOTSTRAPPER_ACTION_STATE_NONE != pPackage->execute \|\| BOOTSTRAPPER_ACTION_STATE_NONE != pPackage->rollback \|\| BURN_DEPENDENCY_ACTION_NONE != pPackage->dependencyExecute)
1033	{
1034	hr = PlanExecuteCheckpoint(pPlan);
1035	ExitOnFailure(hr, "Failed to append execute checkpoint.");
1036	}
1037
1038	LExit:
1039	return hr;
1040	}
1041
1042	static HRESULT ProcessPackageRollbackBoundary(
1043	__in BURN_PLAN* pPlan,
1044	__in BURN_USER_EXPERIENCE* pUX,
1045	__in BURN_LOGGING* pLog,
1046	__in BURN_VARIABLES* pVariables,
1047	__in_opt BURN_ROLLBACK_BOUNDARY* pEffectiveRollbackBoundary,
1048	__inout BURN_ROLLBACK_BOUNDARY** ppRollbackBoundary
1049	)
1050	{
1051	HRESULT hr = S_OK;
1052
1053	// If the package marks the start of a rollback boundary, start a new one.
1054	if (pEffectiveRollbackBoundary)
1055	{
1056	// Complete previous rollback boundary.
1057	if (*ppRollbackBoundary)
1058	{
1059	hr = PlanRollbackBoundaryComplete(pPlan);
1060	ExitOnFailure(hr, "Failed to plan rollback boundary complete.");
1061	}
1062
1063	// Start new rollback boundary.
1064	hr = PlanRollbackBoundaryBegin(pPlan, pUX, pLog, pVariables, pEffectiveRollbackBoundary);
1065	ExitOnFailure(hr, "Failed to plan rollback boundary begin.");
1066
1067	*ppRollbackBoundary = pEffectiveRollbackBoundary;
1068	}
1069
1070	LExit:
1071	return hr;
1072	}
1073
1074	extern "C" HRESULT PlanLayoutContainer(
1075	__in BURN_PLAN* pPlan,
1076	__in BURN_CONTAINER* pContainer
1077	)
1078	{
1079	HRESULT hr = S_OK;
1080	BURN_CACHE_ACTION* pCacheAction = NULL;
1081
1082	Assert(!pContainer->fPlanned);
1083	pContainer->fPlanned = TRUE;
1084
1085	if (pPlan->sczLayoutDirectory)
1086	{
1087	if (!pContainer->fAttached)
1088	{
1089	hr = AppendCacheAction(pPlan, &pCacheAction);
1090	ExitOnFailure(hr, "Failed to append package start action.");
1091
1092	pCacheAction->type = BURN_CACHE_ACTION_TYPE_CONTAINER;
1093	pCacheAction->container.pContainer = pContainer;
1094
1095	// Acquire + Verify + Finalize
1096	pPlan->qwCacheSizeTotal += 3 * pContainer->qwFileSize;
1097	}
1098	}
1099	else
1100	{
1101	if (!pContainer->fActuallyAttached)
1102	{
1103	// Acquire
1104	pPlan->qwCacheSizeTotal += pContainer->qwFileSize;
1105	}
1106	}
1107
1108	if (!pContainer->sczUnverifiedPath)
1109	{
1110	if (pContainer->fActuallyAttached)
1111	{
1112	hr = PathForCurrentProcess(&pContainer->sczUnverifiedPath, NULL);
1113	ExitOnFailure(hr, "Failed to get path for executing module as attached container working path.");
1114	}
1115	else
1116	{
1117	hr = CacheCalculateContainerWorkingPath(pPlan->pCache, pContainer, &pContainer->sczUnverifiedPath);
1118	ExitOnFailure(hr, "Failed to calculate unverified path for container.");
1119	}
1120	}
1121
1122	LExit:
1123	return hr;
1124	}
1125
1126	extern "C" HRESULT PlanLayoutPackage(
1127	__in BURN_PLAN* pPlan,
1128	__in BURN_PACKAGE* pPackage,
1129	__in BOOL fVital
1130	)
1131	{
1132	HRESULT hr = S_OK;
1133	BURN_CACHE_ACTION* pCacheAction = NULL;
1134
1135	AssertSz(!pPlan->fEnabledForwardCompatibleBundle, "Passthrough packages must already be cached");
1136
1137	hr = ProcessPayloadGroup(pPlan, &pPackage->payloads);
1138	ExitOnFailure(hr, "Failed to process payload group for package: %ls.", pPackage->sczId);
1139
1140	hr = AppendCacheAction(pPlan, &pCacheAction);
1141	ExitOnFailure(hr, "Failed to append package start action.");
1142
1143	pCacheAction->type = BURN_CACHE_ACTION_TYPE_PACKAGE;
1144	pCacheAction->package.pPackage = pPackage;
1145	pPackage->fCacheVital = fVital;
1146
1147	++pPlan->cOverallProgressTicksTotal;
1148
1149	LExit:
1150	return hr;
1151	}
1152
1153	extern "C" HRESULT PlanExecutePackage(
1154	__in BOOL fPerMachine,
1155	__in BURN_USER_EXPERIENCE* pUserExperience,
1156	__in BURN_PLAN* pPlan,
1157	__in BURN_PACKAGE* pPackage,
1158	__in BURN_LOGGING* pLog,
1159	__in BURN_VARIABLES* pVariables
1160	)
1161	{
1162	HRESULT hr = S_OK;
1163	BOOTSTRAPPER_DISPLAY display = pPlan->pCommand->display;
1164	BOOL fRequestedCache = BOOTSTRAPPER_CACHE_TYPE_REMOVE < pPackage->cacheType && (BOOTSTRAPPER_REQUEST_STATE_CACHE == pPackage->requested \|\| ForceCache(pPlan, pPackage));
1165
1166	hr = CalculateExecuteActions(pPackage, pPlan->pActiveRollbackBoundary);
1167	ExitOnFailure(hr, "Failed to calculate plan actions for package: %ls", pPackage->sczId);
1168
1169	// Calculate package states based on reference count and plan certain dependency actions prior to planning the package execute action.
1170	hr = DependencyPlanPackageBegin(fPerMachine, pPackage, pPlan);
1171	ExitOnFailure(hr, "Failed to begin plan dependency actions for package: %ls", pPackage->sczId);
1172
1173	pPackage->executeCacheType = fRequestedCache ? BURN_CACHE_PACKAGE_TYPE_REQUIRED : GetCachePackageType(pPackage, TRUE);
1174	pPackage->rollbackCacheType = GetCachePackageType(pPackage, FALSE);
1175
1176	if (BURN_CACHE_PACKAGE_TYPE_NONE != pPackage->executeCacheType \|\| BURN_CACHE_PACKAGE_TYPE_NONE != pPackage->rollbackCacheType)
1177	{
1178	hr = AddCachePackage(pPlan, pPackage, BURN_CACHE_PACKAGE_TYPE_REQUIRED == pPackage->executeCacheType);
1179	ExitOnFailure(hr, "Failed to plan cache package.");
1180	}
1181
1182	// Add execute actions.
1183	switch (pPackage->type)
1184	{
1185	case BURN_PACKAGE_TYPE_BUNDLE:
1186	hr = BundlePackageEnginePlanAddPackage(pPackage, pPlan, pLog, pVariables);
1187	break;
1188
1189	case BURN_PACKAGE_TYPE_EXE:
1190	hr = ExeEnginePlanAddPackage(pPackage, pPlan, pLog, pVariables);
1191	break;
1192
1193	case BURN_PACKAGE_TYPE_MSI:
1194	hr = MsiEnginePlanAddPackage(display, pUserExperience, pPackage, pPlan, pLog, pVariables);
1195	break;
1196
1197	case BURN_PACKAGE_TYPE_MSP:
1198	hr = MspEnginePlanAddPackage(display, pUserExperience, pPackage, pPlan, pLog, pVariables);
1199	break;
1200
1201	case BURN_PACKAGE_TYPE_MSU:
1202	hr = MsuEnginePlanAddPackage(pPackage, pPlan, pLog, pVariables);
1203	break;
1204
1205	default:
1206	hr = E_UNEXPECTED;
1207	ExitOnFailure(hr, "Invalid package type.");
1208	}
1209	ExitOnFailure(hr, "Failed to add plan actions for package: %ls", pPackage->sczId);
1210
1211	// Plan certain dependency actions after planning the package execute action.
1212	hr = DependencyPlanPackageComplete(pPackage, pPlan);
1213	ExitOnFailure(hr, "Failed to complete plan dependency actions for package: %ls", pPackage->sczId);
1214
1215	// If we are going to take any action on this package, add progress for it.
1216	if (BOOTSTRAPPER_ACTION_STATE_NONE != pPackage->execute \|\| BOOTSTRAPPER_ACTION_STATE_NONE != pPackage->rollback)
1217	{
1218	PlannedExecutePackage(pPlan, pPackage);
1219	}
1220
1221	// If we are going to take any action on the compatible package, add progress for it.
1222	if (pPackage->compatiblePackage.fRemove)
1223	{
1224	PlannedExecutePackage(pPlan, pPackage);
1225	}
1226
1227	LExit:
1228	return hr;
1229	}
1230
1231	extern "C" HRESULT PlanDefaultRelatedBundlePlanType(
1232	__in BOOTSTRAPPER_RELATION_TYPE relatedBundleRelationType,
1233	__in VERUTIL_VERSION* pRegistrationVersion,
1234	__in VERUTIL_VERSION* pRelatedBundleVersion,
1235	__inout BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE* pPlanRelationType
1236	)
1237	{
1238	HRESULT hr = S_OK;
1239	int nCompareResult = 0;
1240
1241	switch (relatedBundleRelationType)
1242	{
1243	case BOOTSTRAPPER_RELATION_UPGRADE:
1244	hr = VerCompareParsedVersions(pRegistrationVersion, pRelatedBundleVersion, &nCompareResult);
1245	ExitOnFailure(hr, "Failed to compare bundle version '%ls' to related bundle version '%ls'", pRegistrationVersion->sczVersion, pRelatedBundleVersion->sczVersion);
1246
1247	if (nCompareResult < 0)
1248	{
1249	*pPlanRelationType = BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE_DOWNGRADE;
1250	}
1251	else
1252	{
1253	*pPlanRelationType = BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE_UPGRADE;
1254	}
1255	break;
1256	case BOOTSTRAPPER_RELATION_ADDON:
1257	*pPlanRelationType = BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE_ADDON;
1258	break;
1259	case BOOTSTRAPPER_RELATION_PATCH:
1260	*pPlanRelationType = BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE_PATCH;
1261	break;
1262	case BOOTSTRAPPER_RELATION_DEPENDENT_ADDON:
1263	*pPlanRelationType = BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE_DEPENDENT_ADDON;
1264	break;
1265	case BOOTSTRAPPER_RELATION_DEPENDENT_PATCH:
1266	*pPlanRelationType = BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE_DEPENDENT_PATCH;
1267	break;
1268	case BOOTSTRAPPER_RELATION_DETECT:
1269	break;
1270	default:
1271	hr = E_UNEXPECTED;
1272	ExitOnFailure(hr, "Unexpected relation type encountered during plan: %d", relatedBundleRelationType);
1273	break;
1274	}
1275
1276	LExit:
1277	return hr;
1278	}
1279
1280	extern "C" HRESULT PlanDefaultRelatedBundleRequestState(
1281	__in BOOTSTRAPPER_RELATION_TYPE commandRelationType,
1282	__in BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE relatedBundleRelationType,
1283	__in BOOTSTRAPPER_ACTION action,
1284	__inout BOOTSTRAPPER_REQUEST_STATE* pRequestState
1285	)
1286	{
1287	HRESULT hr = S_OK;
1288	BOOL fUninstalling = BOOTSTRAPPER_ACTION_UNINSTALL == action \|\| BOOTSTRAPPER_ACTION_UNSAFE_UNINSTALL == action;
1289
1290	// Never touch related bundles during Cache.
1291	if (BOOTSTRAPPER_ACTION_CACHE == action)
1292	{
1293	ExitFunction1(*pRequestState = BOOTSTRAPPER_REQUEST_STATE_NONE);
1294	}
1295
1296	switch (relatedBundleRelationType)
1297	{
1298	case BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE_UPGRADE:
1299	if (BOOTSTRAPPER_RELATION_UPGRADE != commandRelationType && !fUninstalling)
1300	{
1301	*pRequestState = BOOTSTRAPPER_REQUEST_STATE_ABSENT;
1302	}
1303	break;
1304	case BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE_PATCH: __fallthrough;
1305	case BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE_ADDON:
1306	if (fUninstalling)
1307	{
1308	*pRequestState = BOOTSTRAPPER_REQUEST_STATE_ABSENT;
1309	}
1310	else if (BOOTSTRAPPER_ACTION_INSTALL == action \|\| BOOTSTRAPPER_ACTION_MODIFY == action)
1311	{
1312	*pRequestState = BOOTSTRAPPER_REQUEST_STATE_FORCE_PRESENT;
1313	}
1314	else if (BOOTSTRAPPER_ACTION_REPAIR == action)
1315	{
1316	*pRequestState = BOOTSTRAPPER_REQUEST_STATE_REPAIR;
1317	}
1318	break;
1319	case BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE_DEPENDENT_ADDON: __fallthrough;
1320	case BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE_DEPENDENT_PATCH:
1321	// Automatically repair dependent bundles to restore missing
1322	// packages after uninstall unless we're being upgraded with the
1323	// assumption that upgrades are cumulative (as intended).
1324	if (BOOTSTRAPPER_RELATION_UPGRADE != commandRelationType && fUninstalling)
1325	{
1326	*pRequestState = BOOTSTRAPPER_REQUEST_STATE_REPAIR;
1327	}
1328	break;
1329	case BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE_DOWNGRADE: __fallthrough;
1330	case BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE_NONE:
1331	break;
1332	default:
1333	hr = E_UNEXPECTED;
1334	ExitOnFailure(hr, "Unexpected plan relation type encountered during plan: %d", relatedBundleRelationType);
1335	break;
1336	}
1337
1338	LExit:
1339	return hr;
1340	}
1341
1342	extern "C" HRESULT PlanRelatedBundlesInitialize(
1343	__in BURN_USER_EXPERIENCE* pUserExperience,
1344	__in BURN_REGISTRATION* pRegistration,
1345	__in BOOTSTRAPPER_RELATION_TYPE relationType,
1346	__in BURN_PLAN* pPlan
1347	)
1348	{
1349	HRESULT hr = S_OK;
1350	BOOL fUninstalling = BOOTSTRAPPER_ACTION_UNINSTALL == pPlan->action \|\| BOOTSTRAPPER_ACTION_UNSAFE_UNINSTALL == pPlan->action;
1351
1352	for (DWORD i = 0; i < pRegistration->relatedBundles.cRelatedBundles; ++i)
1353	{
1354	BURN_RELATED_BUNDLE* pRelatedBundle = pRegistration->relatedBundles.rgRelatedBundles + i;
1355
1356	pRelatedBundle->defaultRequestedRestore = BOOTSTRAPPER_REQUEST_STATE_NONE;
1357	pRelatedBundle->requestedRestore = BOOTSTRAPPER_REQUEST_STATE_NONE;
1358	pRelatedBundle->restore = BOOTSTRAPPER_ACTION_STATE_NONE;
1359	pRelatedBundle->package.defaultRequested = BOOTSTRAPPER_REQUEST_STATE_NONE;
1360	pRelatedBundle->package.requested = BOOTSTRAPPER_REQUEST_STATE_NONE;
1361	pRelatedBundle->defaultPlanRelationType = BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE_NONE;
1362	pRelatedBundle->planRelationType = BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE_NONE;
1363	pRelatedBundle->package.executeCacheType = BURN_CACHE_PACKAGE_TYPE_NONE;
1364	pRelatedBundle->package.rollbackCacheType = BURN_CACHE_PACKAGE_TYPE_NONE;
1365
1366	// Determine the plan relation type even if later it is ignored due to the planned action, the command relation type, or the related bundle not being plannable.
1367	// This gives more information to the BA in case it wants to override default behavior.
1368	// Doing it during plan instead of Detect allows the BA to change its mind without having to go all the way through Detect again.
1369	hr = PlanDefaultRelatedBundlePlanType(pRelatedBundle->detectRelationType, pRegistration->pVersion, pRelatedBundle->pVersion, &pRelatedBundle->defaultPlanRelationType);
1370	ExitOnFailure(hr, "Failed to get default plan type for related bundle.");
1371
1372	pRelatedBundle->planRelationType = pRelatedBundle->defaultPlanRelationType;
1373
1374	hr = BACallbackOnPlanRelatedBundleType(pUserExperience, pRelatedBundle->package.sczId, &pRelatedBundle->planRelationType);
1375	ExitOnRootFailure(hr, "BA aborted plan related bundle type.");
1376
1377	if (BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE_DOWNGRADE == pRelatedBundle->planRelationType &&
1378	pRelatedBundle->fPlannable && !fUninstalling && BOOTSTRAPPER_RELATION_UPGRADE != relationType)
1379	{
1380	if (!pPlan->fDowngrade)
1381	{
1382	pPlan->fDowngrade = TRUE;
1383
1384	LogId(REPORT_STANDARD, MSG_PLAN_SKIPPED_DUE_TO_DOWNGRADE);
1385	}
1386
1387	LogId(REPORT_VERBOSE, MSG_UPGRADE_BUNDLE_DOWNGRADE, pRelatedBundle->package.sczId, pRelatedBundle->pVersion->sczVersion);
1388	}
1389	}
1390
1391	RelatedBundlesSortPlan(&pRegistration->relatedBundles);
1392
1393	LExit:
1394	return hr;
1395	}
1396
1397	extern "C" HRESULT PlanRelatedBundlesBegin(
1398	__in BURN_USER_EXPERIENCE* pUserExperience,
1399	__in BURN_REGISTRATION* pRegistration,
1400	__in BOOTSTRAPPER_RELATION_TYPE relationType,
1401	__in BURN_PLAN* pPlan
1402	)
1403	{
1404	HRESULT hr = S_OK;
1405	LPWSTR* rgsczAncestors = NULL;
1406	UINT cAncestors = 0;
1407	STRINGDICT_HANDLE sdAncestors = NULL;
1408	BOOL fUninstalling = BOOTSTRAPPER_ACTION_UNINSTALL == pPlan->action \|\| BOOTSTRAPPER_ACTION_UNSAFE_UNINSTALL == pPlan->action;
1409
1410	if (pPlan->pInternalCommand->sczAncestors)
1411	{
1412	hr = StrSplitAllocArray(&rgsczAncestors, &cAncestors, pPlan->pInternalCommand->sczAncestors, L";");
1413	ExitOnFailure(hr, "Failed to create string array from ancestors.");
1414
1415	hr = DictCreateStringListFromArray(&sdAncestors, rgsczAncestors, cAncestors, DICT_FLAG_CASEINSENSITIVE);
1416	ExitOnFailure(hr, "Failed to create dictionary from ancestors array.");
1417	}
1418
1419	for (DWORD i = 0; i < pRegistration->relatedBundles.cRelatedBundles; ++i)
1420	{
1421	BURN_RELATED_BUNDLE* pRelatedBundle = pRegistration->relatedBundles.rgpPlanSortedRelatedBundles[i];
1422
1423	if (!pRelatedBundle->fPlannable)
1424	{
1425	continue;
1426	}
1427
1428	BOOL fDependent = BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE_DEPENDENT_ADDON == pRelatedBundle->planRelationType \|\|
1429	BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE_DEPENDENT_PATCH == pRelatedBundle->planRelationType;
1430
1431	// Do not execute the same bundle twice.
1432	if (sdAncestors)
1433	{
1434	hr = DictKeyExists(sdAncestors, pRelatedBundle->package.sczId);
1435	if (SUCCEEDED(hr))
1436	{
1437	LogId(REPORT_STANDARD, MSG_PLAN_SKIPPED_RELATED_BUNDLE_SCHEDULED, pRelatedBundle->package.sczId);
1438	continue;
1439	}
1440	else if (E_NOTFOUND != hr)
1441	{
1442	ExitOnFailure(hr, "Failed to lookup the bundle ID in the ancestors dictionary.");
1443	}
1444	}
1445	else if (fDependent && BOOTSTRAPPER_RELATION_NONE != relationType)
1446	{
1447	// Avoid repair loops for older bundles that do not handle ancestors.
1448	LogId(REPORT_STANDARD, MSG_PLAN_SKIPPED_RELATED_BUNDLE_DEPENDENT, pRelatedBundle->package.sczId, LoggingRelationTypeToString(relationType));
1449	continue;
1450	}
1451
1452	// Pass along any ancestors and ourself to prevent infinite loops.
1453	pRelatedBundle->package.Bundle.wzAncestors = pRegistration->sczBundlePackageAncestors;
1454	pRelatedBundle->package.Bundle.wzEngineWorkingDirectory = pPlan->pInternalCommand->sczEngineWorkingDirectory;
1455
1456	hr = PlanDefaultRelatedBundleRequestState(relationType, pRelatedBundle->planRelationType, pPlan->action, &pRelatedBundle->package.requested);
1457	ExitOnFailure(hr, "Failed to get default request state for related bundle.");
1458
1459	pRelatedBundle->package.defaultRequested = pRelatedBundle->package.requested;
1460
1461	hr = BACallbackOnPlanRelatedBundle(pUserExperience, pRelatedBundle->package.sczId, &pRelatedBundle->package.requested);
1462	ExitOnRootFailure(hr, "BA aborted plan related bundle.");
1463
1464	// If uninstalling and the dependent related bundle may be executed, ignore its provider key to allow for downgrades with ref-counting.
1465	if (fUninstalling && fDependent && BOOTSTRAPPER_REQUEST_STATE_NONE != pRelatedBundle->package.requested)
1466	{
1467	if (0 < pRelatedBundle->package.cDependencyProviders)
1468	{
1469	// Bundles only support a single provider key.
1470	const BURN_DEPENDENCY_PROVIDER* pProvider = pRelatedBundle->package.rgDependencyProviders;
1471
1472	hr = DepDependencyArrayAlloc(&pPlan->rgPlannedProviders, &pPlan->cPlannedProviders, pProvider->sczKey, pProvider->sczDisplayName);
1473	ExitOnFailure(hr, "Failed to add the package provider key \"%ls\" to the planned list.", pProvider->sczKey);
1474	}
1475	}
1476	}
1477
1478	LExit:
1479	ReleaseDict(sdAncestors);
1480	ReleaseStrArray(rgsczAncestors, cAncestors);
1481
1482	return hr;
1483	}
1484
1485	extern "C" HRESULT PlanRelatedBundlesComplete(
1486	__in BURN_USER_EXPERIENCE* pUserExperience,
1487	__in BURN_REGISTRATION* pRegistration,
1488	__in BURN_PLAN* pPlan,
1489	__in BURN_LOGGING* pLog,
1490	__in BURN_VARIABLES* pVariables,
1491	__in DWORD dwExecuteActionEarlyIndex
1492	)
1493	{
1494	HRESULT hr = S_OK;
1495	LPWSTR sczIgnoreDependencies = NULL;
1496	STRINGDICT_HANDLE sdProviderKeys = NULL;
1497	BOOL fExecutingAnyPackage = FALSE;
1498	BOOL fInstallingAnyPackage = FALSE;
1499	BOOL fUninstalling = BOOTSTRAPPER_ACTION_UNINSTALL == pPlan->action \|\| BOOTSTRAPPER_ACTION_UNSAFE_UNINSTALL == pPlan->action;
1500
1501	// Get the list of dependencies to ignore to pass to related bundles.
1502	hr = DependencyAllocIgnoreDependencies(pPlan, &sczIgnoreDependencies);
1503	ExitOnFailure(hr, "Failed to get the list of dependencies to ignore.");
1504
1505	hr = DictCreateStringList(&sdProviderKeys, pPlan->cExecuteActions, DICT_FLAG_CASEINSENSITIVE);
1506	ExitOnFailure(hr, "Failed to create dictionary for planned packages.");
1507
1508	for (DWORD i = 0; i < pPlan->cExecuteActions; ++i)
1509	{
1510	BOOTSTRAPPER_ACTION_STATE packageAction = BOOTSTRAPPER_ACTION_STATE_NONE;
1511	BURN_PACKAGE* pPackage = &pPlan->rgExecuteActions[i].relatedBundle.pRelatedBundle->package;
1512	BOOL fBundle = FALSE;
1513
1514	switch (pPlan->rgExecuteActions[i].type)
1515	{
1516	case BURN_EXECUTE_ACTION_TYPE_BUNDLE_PACKAGE:
1517	packageAction = pPlan->rgExecuteActions[i].bundlePackage.action;
1518	pPackage = pPlan->rgExecuteActions[i].bundlePackage.pPackage;
1519	fBundle = TRUE;
1520	break;
1521
1522	case BURN_EXECUTE_ACTION_TYPE_EXE_PACKAGE:
1523	packageAction = pPlan->rgExecuteActions[i].exePackage.action;
1524	pPackage = pPlan->rgExecuteActions[i].exePackage.pPackage;
1525	fBundle = pPackage->Exe.fBundle;
1526	break;
1527
1528	case BURN_EXECUTE_ACTION_TYPE_MSI_PACKAGE:
1529	packageAction = pPlan->rgExecuteActions[i].msiPackage.action;
1530	break;
1531
1532	case BURN_EXECUTE_ACTION_TYPE_MSP_TARGET:
1533	packageAction = pPlan->rgExecuteActions[i].mspTarget.action;
1534	break;
1535
1536	case BURN_EXECUTE_ACTION_TYPE_MSU_PACKAGE:
1537	packageAction = pPlan->rgExecuteActions[i].msuPackage.action;
1538	break;
1539	}
1540
1541	if (fBundle && BOOTSTRAPPER_ACTION_STATE_NONE != packageAction)
1542	{
1543	if (pPackage->cDependencyProviders)
1544	{
1545	// Bundles only support a single provider key.
1546	const BURN_DEPENDENCY_PROVIDER* pProvider = pPackage->rgDependencyProviders;
1547	DictAddKey(sdProviderKeys, pProvider->sczKey);
1548	}
1549	}
1550
1551	fExecutingAnyPackage \|= BOOTSTRAPPER_ACTION_STATE_NONE != packageAction;
1552	fInstallingAnyPackage \|= BOOTSTRAPPER_ACTION_STATE_INSTALL == packageAction \|\| BOOTSTRAPPER_ACTION_STATE_MINOR_UPGRADE == packageAction;
1553	}
1554
1555	for (DWORD i = 0; i < pRegistration->relatedBundles.cRelatedBundles; ++i)
1556	{
1557	DWORD *pdwInsertIndex = NULL;
1558	BURN_RELATED_BUNDLE* pRelatedBundle = pRegistration->relatedBundles.rgpPlanSortedRelatedBundles[i];
1559	BOOL fDependent = BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE_DEPENDENT_ADDON == pRelatedBundle->planRelationType \|\|
1560	BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE_DEPENDENT_PATCH == pRelatedBundle->planRelationType;
1561	BOOL fAddonOrPatch = BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE_ADDON == pRelatedBundle->planRelationType \|\|
1562	BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE_PATCH == pRelatedBundle->planRelationType;
1563
1564	if (!pRelatedBundle->fPlannable)
1565	{
1566	continue;
1567	}
1568
1569	// Do not execute if a major upgrade to the related bundle is an embedded bundle (Provider keys are the same)
1570	if (0 < pRelatedBundle->package.cDependencyProviders)
1571	{
1572	// Bundles only support a single provider key.
1573	const BURN_DEPENDENCY_PROVIDER* pProvider = pRelatedBundle->package.rgDependencyProviders;
1574	hr = DictKeyExists(sdProviderKeys, pProvider->sczKey);
1575	if (E_NOTFOUND != hr)
1576	{
1577	ExitOnFailure(hr, "Failed to check the dictionary for a related bundle provider key: \"%ls\".", pProvider->sczKey);
1578	// Key found, so there is an embedded bundle with the same provider key that will be executed. So this related bundle should not be added to the plan
1579	LogId(REPORT_STANDARD, MSG_PLAN_SKIPPED_RELATED_BUNDLE_EMBEDDED_BUNDLE_NEWER, pRelatedBundle->package.sczId, pProvider->sczKey);
1580	continue;
1581	}
1582	else
1583	{
1584	hr = S_OK;
1585	}
1586	}
1587
1588	// For an uninstall, there is no need to repair dependent bundles if no packages are executing.
1589	if (!fExecutingAnyPackage && fDependent && BOOTSTRAPPER_REQUEST_STATE_REPAIR == pRelatedBundle->package.requested && fUninstalling)
1590	{
1591	pRelatedBundle->package.requested = BOOTSTRAPPER_REQUEST_STATE_NONE;
1592	LogId(REPORT_STANDARD, MSG_PLAN_SKIPPED_DEPENDENT_BUNDLE_REPAIR, pRelatedBundle->package.sczId);
1593	}
1594
1595	if (fAddonOrPatch)
1596	{
1597	// Addon and patch bundles will be passed a list of dependencies to ignore for planning.
1598	hr = StrAllocString(&pRelatedBundle->package.Bundle.sczIgnoreDependencies, sczIgnoreDependencies, 0);
1599	ExitOnFailure(hr, "Failed to copy the list of dependencies to ignore.");
1600
1601	// Uninstall addons and patches early in the chain, before other packages are uninstalled.
1602	if (fUninstalling)
1603	{
1604	pdwInsertIndex = &dwExecuteActionEarlyIndex;
1605	}
1606	}
1607
1608	if (BOOTSTRAPPER_REQUEST_STATE_NONE != pRelatedBundle->package.requested)
1609	{
1610	hr = BundlePackageEnginePlanCalculatePackage(&pRelatedBundle->package);
1611	ExitOnFailure(hr, "Failed to calculate plan for related bundle: %ls", pRelatedBundle->package.sczId);
1612
1613	// Calculate package states based on reference count for addon and patch related bundles.
1614	if (fAddonOrPatch)
1615	{
1616	hr = DependencyPlanPackageBegin(pRegistration->fPerMachine, &pRelatedBundle->package, pPlan);
1617	ExitOnFailure(hr, "Failed to begin plan dependency actions to package: %ls", pRelatedBundle->package.sczId);
1618
1619	// If uninstalling a related bundle, make sure the bundle is uninstalled after removing registration.
1620	if (pdwInsertIndex && fUninstalling)
1621	{
1622	++(*pdwInsertIndex);
1623	}
1624	}
1625
1626	hr = BundlePackageEnginePlanAddRelatedBundle(pdwInsertIndex, pRelatedBundle, pPlan, pLog, pVariables);
1627	ExitOnFailure(hr, "Failed to add to plan related bundle: %ls", pRelatedBundle->package.sczId);
1628
1629	// Calculate package states based on reference count for addon and patch related bundles.
1630	if (fAddonOrPatch)
1631	{
1632	hr = DependencyPlanPackageComplete(&pRelatedBundle->package, pPlan);
1633	ExitOnFailure(hr, "Failed to complete plan dependency actions for related bundle package: %ls", pRelatedBundle->package.sczId);
1634	}
1635
1636	// If we are going to take any action on this package, add progress for it.
1637	if (BOOTSTRAPPER_ACTION_STATE_NONE != pRelatedBundle->package.execute \|\| BOOTSTRAPPER_ACTION_STATE_NONE != pRelatedBundle->package.rollback)
1638	{
1639	PlannedExecutePackage(pPlan, &pRelatedBundle->package);
1640	}
1641	}
1642	else if (fAddonOrPatch)
1643	{
1644	// Make sure the package is properly ref-counted even if no plan is requested.
1645	hr = DependencyPlanPackageBegin(pRegistration->fPerMachine, &pRelatedBundle->package, pPlan);
1646	ExitOnFailure(hr, "Failed to begin plan dependency actions for related bundle package: %ls", pRelatedBundle->package.sczId);
1647
1648	hr = DependencyPlanPackage(pdwInsertIndex, &pRelatedBundle->package, pPlan);
1649	ExitOnFailure(hr, "Failed to plan related bundle package provider actions.");
1650
1651	hr = DependencyPlanPackageComplete(&pRelatedBundle->package, pPlan);
1652	ExitOnFailure(hr, "Failed to complete plan dependency actions for related bundle package: %ls", pRelatedBundle->package.sczId);
1653	}
1654
1655	if (fInstallingAnyPackage && BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE_UPGRADE == pRelatedBundle->planRelationType)
1656	{
1657	BURN_EXECUTE_ACTION* pAction = NULL;
1658
1659	pRelatedBundle->defaultRequestedRestore = pRelatedBundle->requestedRestore = BOOTSTRAPPER_REQUEST_STATE_FORCE_PRESENT;
1660
1661	hr = BACallbackOnPlanRestoreRelatedBundle(pUserExperience, pRelatedBundle->package.sczId, &pRelatedBundle->requestedRestore);
1662	ExitOnRootFailure(hr, "BA aborted plan restore related bundle.");
1663
1664	switch (pRelatedBundle->requestedRestore)
1665	{
1666	case BOOTSTRAPPER_REQUEST_STATE_REPAIR:
1667	pRelatedBundle->restore = BOOTSTRAPPER_ACTION_STATE_REPAIR;
1668	break;
1669	case BOOTSTRAPPER_REQUEST_STATE_ABSENT: __fallthrough;
1670	case BOOTSTRAPPER_REQUEST_STATE_CACHE: __fallthrough;
1671	case BOOTSTRAPPER_REQUEST_STATE_FORCE_ABSENT:
1672	pRelatedBundle->restore = BOOTSTRAPPER_ACTION_STATE_UNINSTALL;
1673	break;
1674	case BOOTSTRAPPER_REQUEST_STATE_FORCE_PRESENT:
1675	pRelatedBundle->restore = BOOTSTRAPPER_ACTION_STATE_INSTALL;
1676	break;
1677	default:
1678	pRelatedBundle->restore = BOOTSTRAPPER_ACTION_STATE_NONE;
1679	break;
1680	}
1681
1682	if (BOOTSTRAPPER_ACTION_STATE_NONE != pRelatedBundle->restore)
1683	{
1684	hr = AppendRestoreRelatedBundleAction(pPlan, &pAction);
1685	ExitOnFailure(hr, "Failed to append restore related bundle action to plan.");
1686
1687	pAction->type = BURN_EXECUTE_ACTION_TYPE_RELATED_BUNDLE;
1688	pAction->relatedBundle.pRelatedBundle = pRelatedBundle;
1689	pAction->relatedBundle.action = pRelatedBundle->restore;
1690
1691	if (pRelatedBundle->package.Bundle.sczIgnoreDependencies)
1692	{
1693	hr = StrAllocString(&pAction->relatedBundle.sczIgnoreDependencies, pRelatedBundle->package.Bundle.sczIgnoreDependencies, 0);
1694	ExitOnFailure(hr, "Failed to allocate the list of dependencies to ignore.");
1695	}
1696
1697	if (pRelatedBundle->package.Bundle.wzAncestors)
1698	{
1699	hr = StrAllocString(&pAction->relatedBundle.sczAncestors, pRelatedBundle->package.Bundle.wzAncestors, 0);
1700	ExitOnFailure(hr, "Failed to allocate the list of ancestors.");
1701	}
1702
1703	if (pRelatedBundle->package.Bundle.wzEngineWorkingDirectory)
1704	{
1705	hr = StrAllocString(&pAction->relatedBundle.sczEngineWorkingDirectory, pRelatedBundle->package.Bundle.wzEngineWorkingDirectory, 0);
1706	ExitOnFailure(hr, "Failed to allocate the custom working directory.");
1707	}
1708	}
1709	}
1710	}
1711
1712	LExit:
1713	ReleaseDict(sdProviderKeys);
1714	ReleaseStr(sczIgnoreDependencies);
1715
1716	return hr;
1717	}
1718
1719	extern "C" HRESULT PlanFinalizeActions(
1720	__in BURN_PLAN* pPlan
1721	)
1722	{
1723	HRESULT hr = S_OK;
1724
1725	FinalizePatchActions(TRUE, pPlan->rgExecuteActions, pPlan->cExecuteActions);
1726
1727	FinalizePatchActions(FALSE, pPlan->rgRollbackActions, pPlan->cRollbackActions);
1728
1729	RemoveUnnecessaryActions(TRUE, pPlan->rgExecuteActions, pPlan->cExecuteActions);
1730
1731	RemoveUnnecessaryActions(FALSE, pPlan->rgRollbackActions, pPlan->cRollbackActions);
1732
1733	return hr;
1734	}
1735
1736	extern "C" HRESULT PlanCleanPackage(
1737	__in BURN_PLAN* pPlan,
1738	__in BURN_PACKAGE* pPackage
1739	)
1740	{
1741	HRESULT hr = S_OK;
1742	BOOL fPlanCleanPackage = FALSE;
1743	BURN_CLEAN_ACTION* pCleanAction = NULL;
1744	BOOL fUninstalling = BOOTSTRAPPER_ACTION_UNINSTALL == pPlan->action \|\| BOOTSTRAPPER_ACTION_UNSAFE_UNINSTALL == pPlan->action;
1745
1746	// The following is a complex set of logic that determines when a package should be cleaned from the cache.
1747	if (BOOTSTRAPPER_CACHE_TYPE_FORCE > pPackage->cacheType \|\| fUninstalling)
1748	{
1749	// The following are all different reasons why the package should be cleaned from the cache.
1750	// The else-ifs are used to make the conditions easier to see (rather than have them combined
1751	// in one huge condition).
1752	if (BOOTSTRAPPER_CACHE_TYPE_KEEP > pPackage->cacheType) // easy, package is not supposed to stay cached.
1753	{
1754	fPlanCleanPackage = TRUE;
1755	}
1756	else if ((BOOTSTRAPPER_REQUEST_STATE_FORCE_ABSENT == pPackage->requested \|\|
1757	BOOTSTRAPPER_REQUEST_STATE_ABSENT == pPackage->requested) && // requested to be removed and
1758	BOOTSTRAPPER_ACTION_STATE_UNINSTALL == pPackage->execute) // actually being removed.
1759	{
1760	fPlanCleanPackage = TRUE;
1761	}
1762	else if ((BOOTSTRAPPER_REQUEST_STATE_FORCE_ABSENT == pPackage->requested \|\|
1763	BOOTSTRAPPER_REQUEST_STATE_ABSENT == pPackage->requested) && // requested to be removed but
1764	BOOTSTRAPPER_ACTION_STATE_NONE == pPackage->execute && // execute is do nothing and
1765	!pPackage->fDependencyManagerWasHere && // dependency manager didn't change execute and
1766	BOOTSTRAPPER_PACKAGE_STATE_PRESENT > pPackage->currentState) // currently not installed.
1767	{
1768	fPlanCleanPackage = TRUE;
1769	}
1770	else if (fUninstalling && // uninstalling and
1771	BOOTSTRAPPER_REQUEST_STATE_NONE == pPackage->requested && // requested do nothing (aka: default) and
1772	BOOTSTRAPPER_ACTION_STATE_NONE == pPackage->execute && // execute is still do nothing and
1773	!pPackage->fDependencyManagerWasHere && // dependency manager didn't change execute and
1774	BOOTSTRAPPER_PACKAGE_STATE_PRESENT > pPackage->currentState) // currently not installed.
1775	{
1776	fPlanCleanPackage = TRUE;
1777	}
1778	}
1779
1780	if (fPlanCleanPackage)
1781	{
1782	hr = AppendCleanAction(pPlan, &pCleanAction);
1783	ExitOnFailure(hr, "Failed to append clean action to plan.");
1784
1785	pCleanAction->type = BURN_CLEAN_ACTION_TYPE_PACKAGE;
1786	pCleanAction->pPackage = pPackage;
1787
1788	pPackage->fPlannedUncache = TRUE;
1789
1790	if (pPackage->fCanAffectRegistration)
1791	{
1792	pPackage->expectedCacheRegistrationState = BURN_PACKAGE_REGISTRATION_STATE_ABSENT;
1793	}
1794	}
1795
1796	if (pPackage->compatiblePackage.fRemove)
1797	{
1798	hr = AppendCleanAction(pPlan, &pCleanAction);
1799	ExitOnFailure(hr, "Failed to append clean action to plan.");
1800
1801	pCleanAction->type = BURN_CLEAN_ACTION_TYPE_COMPATIBLE_PACKAGE;
1802	pCleanAction->pPackage = pPackage;
1803	}
1804
1805	LExit:
1806	return hr;
1807	}
1808
1809	extern "C" HRESULT PlanExecuteCacheSyncAndRollback(
1810	__in BURN_PLAN* pPlan,
1811	__in BURN_PACKAGE* pPackage
1812	)
1813	{
1814	HRESULT hr = S_OK;
1815	BURN_EXECUTE_ACTION* pAction = NULL;
1816
1817	if (pPlan->fPlanPackageCacheRollback)
1818	{
1819	hr = PlanAppendRollbackAction(pPlan, &pAction);
1820	ExitOnFailure(hr, "Failed to append rollback action.");
1821
1822	pAction->type = BURN_EXECUTE_ACTION_TYPE_UNCACHE_PACKAGE;
1823	pAction->uncachePackage.pPackage = pPackage;
1824	}
1825
1826	hr = PlanExecuteCheckpoint(pPlan);
1827	ExitOnFailure(hr, "Failed to append execute checkpoint for cache rollback.");
1828
1829	hr = PlanAppendExecuteAction(pPlan, &pAction);
1830	ExitOnFailure(hr, "Failed to append wait action for caching.");
1831
1832	pAction->type = BURN_EXECUTE_ACTION_TYPE_WAIT_CACHE_PACKAGE;
1833	pAction->waitCachePackage.pPackage = pPackage;
1834
1835	LExit:
1836	return hr;
1837	}
1838
1839	extern "C" HRESULT PlanExecuteCheckpoint(
1840	__in BURN_PLAN* pPlan
1841	)
1842	{
1843	HRESULT hr = S_OK;
1844	BURN_EXECUTE_ACTION* pAction = NULL;
1845	DWORD dwCheckpointId = GetNextCheckpointId(pPlan);
1846
1847	// execute checkpoint
1848	hr = PlanAppendExecuteAction(pPlan, &pAction);
1849	ExitOnFailure(hr, "Failed to append execute action.");
1850
1851	pAction->type = BURN_EXECUTE_ACTION_TYPE_CHECKPOINT;
1852	pAction->checkpoint.dwId = dwCheckpointId;
1853	pAction->checkpoint.pActiveRollbackBoundary = pPlan->pActiveRollbackBoundary;
1854
1855	// rollback checkpoint
1856	hr = PlanAppendRollbackAction(pPlan, &pAction);
1857	ExitOnFailure(hr, "Failed to append rollback action.");
1858
1859	pAction->type = BURN_EXECUTE_ACTION_TYPE_CHECKPOINT;
1860	pAction->checkpoint.dwId = dwCheckpointId;
1861	pAction->checkpoint.pActiveRollbackBoundary = pPlan->pActiveRollbackBoundary;
1862
1863	LExit:
1864	return hr;
1865	}
1866
1867	extern "C" HRESULT PlanInsertExecuteAction(
1868	__in DWORD dwIndex,
1869	__in BURN_PLAN* pPlan,
1870	__out BURN_EXECUTE_ACTION** ppExecuteAction
1871	)
1872	{
1873	HRESULT hr = S_OK;
1874
1875	hr = MemInsertIntoArray((void**)&pPlan->rgExecuteActions, dwIndex, 1, pPlan->cExecuteActions + 1, sizeof(BURN_EXECUTE_ACTION), 5);
1876	ExitOnFailure(hr, "Failed to grow plan's array of execute actions.");
1877
1878	*ppExecuteAction = pPlan->rgExecuteActions + dwIndex;
1879	++pPlan->cExecuteActions;
1880
1881	LExit:
1882	return hr;
1883	}
1884
1885	extern "C" HRESULT PlanInsertRollbackAction(
1886	__in DWORD dwIndex,
1887	__in BURN_PLAN* pPlan,
1888	__out BURN_EXECUTE_ACTION** ppRollbackAction
1889	)
1890	{
1891	HRESULT hr = S_OK;
1892
1893	hr = MemInsertIntoArray((void**)&pPlan->rgRollbackActions, dwIndex, 1, pPlan->cRollbackActions + 1, sizeof(BURN_EXECUTE_ACTION), 5);
1894	ExitOnFailure(hr, "Failed to grow plan's array of rollback actions.");
1895
1896	*ppRollbackAction = pPlan->rgRollbackActions + dwIndex;
1897	++pPlan->cRollbackActions;
1898
1899	LExit:
1900	return hr;
1901	}
1902
1903	extern "C" HRESULT PlanAppendExecuteAction(
1904	__in BURN_PLAN* pPlan,
1905	__out BURN_EXECUTE_ACTION** ppExecuteAction
1906	)
1907	{
1908	HRESULT hr = S_OK;
1909
1910	hr = MemEnsureArraySize((void**)&pPlan->rgExecuteActions, pPlan->cExecuteActions + 1, sizeof(BURN_EXECUTE_ACTION), 5);
1911	ExitOnFailure(hr, "Failed to grow plan's array of execute actions.");
1912
1913	*ppExecuteAction = pPlan->rgExecuteActions + pPlan->cExecuteActions;
1914	++pPlan->cExecuteActions;
1915
1916	LExit:
1917	return hr;
1918	}
1919
1920	extern "C" HRESULT PlanAppendRollbackAction(
1921	__in BURN_PLAN* pPlan,
1922	__out BURN_EXECUTE_ACTION** ppRollbackAction
1923	)
1924	{
1925	HRESULT hr = S_OK;
1926
1927	hr = MemEnsureArraySize((void**)&pPlan->rgRollbackActions, pPlan->cRollbackActions + 1, sizeof(BURN_EXECUTE_ACTION), 5);
1928	ExitOnFailure(hr, "Failed to grow plan's array of rollback actions.");
1929
1930	*ppRollbackAction = pPlan->rgRollbackActions + pPlan->cRollbackActions;
1931	++pPlan->cRollbackActions;
1932
1933	LExit:
1934	return hr;
1935	}
1936
1937	extern "C" HRESULT PlanRollbackBoundaryBegin(
1938	__in BURN_PLAN* pPlan,
1939	__in BURN_USER_EXPERIENCE* pUX,
1940	__in BURN_LOGGING* pLog,
1941	__in BURN_VARIABLES* pVariables,
1942	__in BURN_ROLLBACK_BOUNDARY* pRollbackBoundary
1943	)
1944	{
1945	HRESULT hr = S_OK;
1946	BURN_EXECUTE_ACTION* pExecuteAction = NULL;
1947
1948	AssertSz(!pPlan->pActiveRollbackBoundary, "PlanRollbackBoundaryBegin called without completing previous RollbackBoundary");
1949	pPlan->pActiveRollbackBoundary = pRollbackBoundary;
1950
1951	// Add begin rollback boundary to execute plan.
1952	hr = PlanAppendExecuteAction(pPlan, &pExecuteAction);
1953	ExitOnFailure(hr, "Failed to append rollback boundary begin action.");
1954
1955	pExecuteAction->type = BURN_EXECUTE_ACTION_TYPE_ROLLBACK_BOUNDARY_START;
1956	pExecuteAction->rollbackBoundary.pRollbackBoundary = pRollbackBoundary;
1957
1958	// Add begin rollback boundary to rollback plan.
1959	hr = PlanAppendRollbackAction(pPlan, &pExecuteAction);
1960	ExitOnFailure(hr, "Failed to append rollback boundary begin action.");
1961
1962	pExecuteAction->type = BURN_EXECUTE_ACTION_TYPE_ROLLBACK_BOUNDARY_START;
1963	pExecuteAction->rollbackBoundary.pRollbackBoundary = pRollbackBoundary;
1964
1965	hr = BACallbackOnPlanRollbackBoundary(pUX, pRollbackBoundary->sczId, &pRollbackBoundary->fTransaction);
1966	ExitOnRootFailure(hr, "BA aborted plan rollback boundary.");
1967
1968	// Only use MSI transaction if authored and the BA requested it.
1969	if (!pRollbackBoundary->fTransactionAuthored \|\| !pRollbackBoundary->fTransaction)
1970	{
1971	pRollbackBoundary->fTransaction = FALSE;
1972	}
1973	else
1974	{
1975	LoggingSetTransactionVariable(pRollbackBoundary, NULL, pLog, pVariables); // ignore errors.
1976
1977	// Add begin MSI transaction to execute plan.
1978	hr = PlanExecuteCheckpoint(pPlan);
1979	ExitOnFailure(hr, "Failed to append checkpoint before MSI transaction begin action.");
1980
1981	hr = PlanAppendExecuteAction(pPlan, &pExecuteAction);
1982	ExitOnFailure(hr, "Failed to append MSI transaction begin action.");
1983
1984	pExecuteAction->type = BURN_EXECUTE_ACTION_TYPE_BEGIN_MSI_TRANSACTION;
1985	pExecuteAction->msiTransaction.pRollbackBoundary = pRollbackBoundary;
1986	}
1987
1988	LExit:
1989	return hr;
1990	}
1991
1992	extern "C" HRESULT PlanRollbackBoundaryComplete(
1993	__in BURN_PLAN* pPlan
1994	)
1995	{
1996	HRESULT hr = S_OK;
1997	BURN_EXECUTE_ACTION* pExecuteAction = NULL;
1998	BURN_ROLLBACK_BOUNDARY* pRollbackBoundary = pPlan->pActiveRollbackBoundary;
1999
2000	AssertSz(pRollbackBoundary, "PlanRollbackBoundaryComplete called without an active RollbackBoundary");
2001
2002	if (pRollbackBoundary && pRollbackBoundary->fTransaction)
2003	{
2004	// Add commit MSI transaction to execute plan.
2005	hr = PlanAppendExecuteAction(pPlan, &pExecuteAction);
2006	ExitOnFailure(hr, "Failed to append MSI transaction commit action.");
2007
2008	pExecuteAction->type = BURN_EXECUTE_ACTION_TYPE_COMMIT_MSI_TRANSACTION;
2009	pExecuteAction->msiTransaction.pRollbackBoundary = pRollbackBoundary;
2010	}
2011
2012	pPlan->pActiveRollbackBoundary = NULL;
2013
2014	// Add checkpoints.
2015	hr = PlanExecuteCheckpoint(pPlan);
2016
2017	// Add complete rollback boundary to execute plan.
2018	hr = PlanAppendExecuteAction(pPlan, &pExecuteAction);
2019	ExitOnFailure(hr, "Failed to append rollback boundary complete action.");
2020
2021	pExecuteAction->type = BURN_EXECUTE_ACTION_TYPE_ROLLBACK_BOUNDARY_END;
2022
2023	// Add begin rollback boundary to rollback plan.
2024	hr = PlanAppendRollbackAction(pPlan, &pExecuteAction);
2025	ExitOnFailure(hr, "Failed to append rollback boundary complete action.");
2026
2027	pExecuteAction->type = BURN_EXECUTE_ACTION_TYPE_ROLLBACK_BOUNDARY_END;
2028
2029	LExit:
2030	return hr;
2031	}
2032
2033	/*******************************************************************
2034	PlanSetResumeCommand - Initializes resume command string
2035
2036	*******************************************************************/
2037	extern "C" HRESULT PlanSetResumeCommand(
2038	__in BURN_PLAN* pPlan,
2039	__in BURN_REGISTRATION* pRegistration,
2040	__in BURN_LOGGING* pLog
2041	)
2042	{
2043	HRESULT hr = S_OK;
2044
2045	// build the resume command-line.
2046	hr = CoreCreateResumeCommandLine(&pRegistration->sczResumeCommandLine, pPlan, pLog);
2047	ExitOnFailure(hr, "Failed to create resume command-line.");
2048
2049	LExit:
2050	return hr;
2051	}
2052
2053
2054	// internal function definitions
2055
2056
2057	static void PlannedExecutePackage(
2058	__in BURN_PLAN* pPlan,
2059	__in BURN_PACKAGE* pPackage
2060	)
2061	{
2062	LoggingIncrementPackageSequence();
2063
2064	++pPlan->cExecutePackagesTotal;
2065	++pPlan->cOverallProgressTicksTotal;
2066
2067	// If package is per-machine and is being executed, flag the plan to be per-machine as well.
2068	if (pPackage->fPerMachine)
2069	{
2070	pPlan->fPerMachine = TRUE;
2071	}
2072	}
2073
2074	static void UninitializeRegistrationAction(
2075	__in BURN_DEPENDENT_REGISTRATION_ACTION* pAction
2076	)
2077	{
2078	ReleaseStr(pAction->sczDependentProviderKey);
2079	ReleaseStr(pAction->sczBundleId);
2080	memset(pAction, 0, sizeof(BURN_DEPENDENT_REGISTRATION_ACTION));
2081	}
2082
2083	static void UninitializeCacheAction(
2084	__in BURN_CACHE_ACTION* pCacheAction
2085	)
2086	{
2087	switch (pCacheAction->type)
2088	{
2089	case BURN_CACHE_ACTION_TYPE_LAYOUT_BUNDLE:
2090	ReleaseStr(pCacheAction->bundleLayout.sczExecutableName);
2091	ReleaseStr(pCacheAction->bundleLayout.sczUnverifiedPath);
2092	break;
2093	}
2094	}
2095
2096	static void ResetPlannedContainerState(
2097	__in BURN_CONTAINER* pContainer
2098	)
2099	{
2100	pContainer->fPlanned = FALSE;
2101	pContainer->qwExtractSizeTotal = 0;
2102	pContainer->qwCommittedCacheProgress = 0;
2103	pContainer->qwCommittedExtractProgress = 0;
2104	pContainer->fExtracted = FALSE;
2105	pContainer->fFailedVerificationFromAcquisition = FALSE;
2106	ReleaseNullStr(pContainer->sczFailedLocalAcquisitionPath);
2107	}
2108
2109	static void ResetPlannedPayloadsState(
2110	__in BURN_PAYLOADS* pPayloads
2111	)
2112	{
2113	for (DWORD i = 0; i < pPayloads->cPayloads; ++i)
2114	{
2115	BURN_PAYLOAD* pPayload = pPayloads->rgPayloads + i;
2116
2117	pPayload->cRemainingInstances = 0;
2118	pPayload->state = BURN_PAYLOAD_STATE_NONE;
2119	pPayload->fFailedVerificationFromAcquisition = FALSE;
2120	ReleaseNullStr(pPayload->sczLocalFilePath);
2121	ReleaseNullStr(pPayload->sczFailedLocalAcquisitionPath);
2122	}
2123	}
2124
2125	static void ResetPlannedPayloadGroupState(
2126	__in BURN_PAYLOAD_GROUP* pPayloadGroup
2127	)
2128	{
2129	for (DWORD i = 0; i < pPayloadGroup->cItems; ++i)
2130	{
2131	BURN_PAYLOAD_GROUP_ITEM* pItem = pPayloadGroup->rgItems + i;
2132
2133	pItem->fCached = FALSE;
2134	pItem->qwCommittedCacheProgress = 0;
2135	}
2136	}
2137
2138	static void ResetPlannedPackageState(
2139	__in BURN_PACKAGE* pPackage
2140	)
2141	{
2142	// Reset package state that is a result of planning.
2143	pPackage->cacheType = pPackage->authoredCacheType;
2144	pPackage->defaultRequested = BOOTSTRAPPER_REQUEST_STATE_NONE;
2145	pPackage->requested = BOOTSTRAPPER_REQUEST_STATE_NONE;
2146	pPackage->fCacheVital = FALSE;
2147	pPackage->fPlannedUncache = FALSE;
2148	pPackage->execute = BOOTSTRAPPER_ACTION_STATE_NONE;
2149	pPackage->rollback = BOOTSTRAPPER_ACTION_STATE_NONE;
2150	pPackage->fProviderExecute = FALSE;
2151	pPackage->fProviderRollback = FALSE;
2152	pPackage->dependencyExecute = BURN_DEPENDENCY_ACTION_NONE;
2153	pPackage->dependencyRollback = BURN_DEPENDENCY_ACTION_NONE;
2154	pPackage->fDependencyManagerWasHere = FALSE;
2155	pPackage->expectedCacheRegistrationState = BURN_PACKAGE_REGISTRATION_STATE_UNKNOWN;
2156	pPackage->expectedInstallRegistrationState = BURN_PACKAGE_REGISTRATION_STATE_UNKNOWN;
2157	pPackage->executeCacheType = BURN_CACHE_PACKAGE_TYPE_NONE;
2158	pPackage->rollbackCacheType = BURN_CACHE_PACKAGE_TYPE_NONE;
2159	ReleaseHandle(pPackage->hCacheEvent);
2160
2161	ReleaseNullStr(pPackage->sczCacheFolder);
2162
2163	if (BURN_PACKAGE_TYPE_MSI == pPackage->type)
2164	{
2165	for (DWORD i = 0; i < pPackage->Msi.cFeatures; ++i)
2166	{
2167	BURN_MSIFEATURE* pFeature = &pPackage->Msi.rgFeatures[i];
2168
2169	pFeature->expectedState = BOOTSTRAPPER_FEATURE_STATE_UNKNOWN;
2170	pFeature->defaultRequested = BOOTSTRAPPER_FEATURE_STATE_UNKNOWN;
2171	pFeature->requested = BOOTSTRAPPER_FEATURE_STATE_UNKNOWN;
2172	pFeature->execute = BOOTSTRAPPER_FEATURE_ACTION_NONE;
2173	pFeature->rollback = BOOTSTRAPPER_FEATURE_ACTION_NONE;
2174	}
2175
2176	for (DWORD i = 0; i < pPackage->Msi.cSlipstreamMspPackages; ++i)
2177	{
2178	BURN_SLIPSTREAM_MSP* pSlipstreamMsp = &pPackage->Msi.rgSlipstreamMsps[i];
2179
2180	pSlipstreamMsp->execute = BOOTSTRAPPER_ACTION_STATE_NONE;
2181	pSlipstreamMsp->rollback = BOOTSTRAPPER_ACTION_STATE_NONE;
2182	}
2183	}
2184	else if (BURN_PACKAGE_TYPE_MSP == pPackage->type && pPackage->Msp.rgTargetProducts)
2185	{
2186	for (DWORD i = 0; i < pPackage->Msp.cTargetProductCodes; ++i)
2187	{
2188	BURN_MSPTARGETPRODUCT* pTargetProduct = &pPackage->Msp.rgTargetProducts[i];
2189
2190	pTargetProduct->defaultRequested = BOOTSTRAPPER_REQUEST_STATE_NONE;
2191	pTargetProduct->requested = BOOTSTRAPPER_REQUEST_STATE_NONE;
2192	pTargetProduct->execute = BOOTSTRAPPER_ACTION_STATE_NONE;
2193	pTargetProduct->rollback = BOOTSTRAPPER_ACTION_STATE_NONE;
2194	pTargetProduct->executeSkip = BURN_PATCH_SKIP_STATE_NONE;
2195	pTargetProduct->rollbackSkip = BURN_PATCH_SKIP_STATE_NONE;
2196	}
2197	}
2198
2199	for (DWORD i = 0; i < pPackage->cDependencyProviders; ++i)
2200	{
2201	BURN_DEPENDENCY_PROVIDER* pProvider = &pPackage->rgDependencyProviders[i];
2202
2203	pProvider->dependentExecute = BURN_DEPENDENCY_ACTION_NONE;
2204	pProvider->dependentRollback = BURN_DEPENDENCY_ACTION_NONE;
2205	pProvider->providerExecute = BURN_DEPENDENCY_ACTION_NONE;
2206	pProvider->providerRollback = BURN_DEPENDENCY_ACTION_NONE;
2207	}
2208
2209	ResetPlannedPayloadGroupState(&pPackage->payloads);
2210	}
2211
2212	static void ResetPlannedRollbackBoundaryState(
2213	__in BURN_ROLLBACK_BOUNDARY* pRollbackBoundary
2214	)
2215	{
2216	pRollbackBoundary->fActiveTransaction = FALSE;
2217	pRollbackBoundary->fTransaction = pRollbackBoundary->fTransactionAuthored;
2218	ReleaseNullStr(pRollbackBoundary->sczLogPath);
2219	}
2220
2221	static HRESULT GetActionDefaultRequestState(
2222	__in BOOTSTRAPPER_ACTION action,
2223	__in BOOTSTRAPPER_PACKAGE_STATE currentState,
2224	__out BOOTSTRAPPER_REQUEST_STATE* pRequestState
2225	)
2226	{
2227	HRESULT hr = S_OK;
2228
2229	switch (action)
2230	{
2231	case BOOTSTRAPPER_ACTION_INSTALL:
2232	*pRequestState = BOOTSTRAPPER_REQUEST_STATE_PRESENT;
2233	break;
2234
2235	case BOOTSTRAPPER_ACTION_REPAIR:
2236	*pRequestState = BOOTSTRAPPER_REQUEST_STATE_REPAIR;
2237	break;
2238
2239	case BOOTSTRAPPER_ACTION_UNSAFE_UNINSTALL: __fallthrough;
2240	case BOOTSTRAPPER_ACTION_UNINSTALL:
2241	*pRequestState = BOOTSTRAPPER_REQUEST_STATE_ABSENT;
2242	break;
2243
2244	case BOOTSTRAPPER_ACTION_MODIFY:
2245	switch (currentState)
2246	{
2247	case BOOTSTRAPPER_PACKAGE_STATE_ABSENT:
2248	*pRequestState = BOOTSTRAPPER_REQUEST_STATE_ABSENT;
2249	break;
2250
2251	case BOOTSTRAPPER_PACKAGE_STATE_PRESENT:
2252	*pRequestState = BOOTSTRAPPER_REQUEST_STATE_PRESENT;
2253	break;
2254
2255	default:
2256	*pRequestState = BOOTSTRAPPER_REQUEST_STATE_NONE;
2257	break;
2258	}
2259	break;
2260
2261	default:
2262	hr = E_INVALIDARG;
2263	ExitOnRootFailure(hr, "Invalid action state.");
2264	}
2265
2266	LExit:
2267	return hr;
2268	}
2269
2270	static HRESULT AddRegistrationAction(
2271	__in BURN_PLAN* pPlan,
2272	__in BURN_DEPENDENT_REGISTRATION_ACTION_TYPE type,
2273	__in_z LPCWSTR wzDependentProviderKey,
2274	__in_z LPCWSTR wzOwnerBundleId
2275	)
2276	{
2277	HRESULT hr = S_OK;
2278	BURN_DEPENDENT_REGISTRATION_ACTION_TYPE rollbackType = (BURN_DEPENDENT_REGISTRATION_ACTION_TYPE_REGISTER == type) ? BURN_DEPENDENT_REGISTRATION_ACTION_TYPE_UNREGISTER : BURN_DEPENDENT_REGISTRATION_ACTION_TYPE_REGISTER;
2279	BURN_DEPENDENT_REGISTRATION_ACTION* pAction = NULL;
2280
2281	// Create forward registration action.
2282	hr = MemEnsureArraySize((void**)&pPlan->rgRegistrationActions, pPlan->cRegistrationActions + 1, sizeof(BURN_DEPENDENT_REGISTRATION_ACTION), 5);
2283	ExitOnFailure(hr, "Failed to grow plan's array of registration actions.");
2284
2285	pAction = pPlan->rgRegistrationActions + pPlan->cRegistrationActions;
2286	++pPlan->cRegistrationActions;
2287
2288	pAction->type = type;
2289
2290	hr = StrAllocString(&pAction->sczBundleId, wzOwnerBundleId, 0);
2291	ExitOnFailure(hr, "Failed to copy owner bundle to registration action.");
2292
2293	hr = StrAllocString(&pAction->sczDependentProviderKey, wzDependentProviderKey, 0);
2294	ExitOnFailure(hr, "Failed to copy dependent provider key to registration action.");
2295
2296	// Create rollback registration action.
2297	hr = MemEnsureArraySize((void**)&pPlan->rgRollbackRegistrationActions, pPlan->cRollbackRegistrationActions + 1, sizeof(BURN_DEPENDENT_REGISTRATION_ACTION), 5);
2298	ExitOnFailure(hr, "Failed to grow plan's array of rollback registration actions.");
2299
2300	pAction = pPlan->rgRollbackRegistrationActions + pPlan->cRollbackRegistrationActions;
2301	++pPlan->cRollbackRegistrationActions;
2302
2303	pAction->type = rollbackType;
2304
2305	hr = StrAllocString(&pAction->sczBundleId, wzOwnerBundleId, 0);
2306	ExitOnFailure(hr, "Failed to copy owner bundle to registration action.");
2307
2308	hr = StrAllocString(&pAction->sczDependentProviderKey, wzDependentProviderKey, 0);
2309	ExitOnFailure(hr, "Failed to copy dependent provider key to rollback registration action.");
2310
2311	LExit:
2312	return hr;
2313	}
2314
2315	static HRESULT AddCachePackage(
2316	__in BURN_PLAN* pPlan,
2317	__in BURN_PACKAGE* pPackage,
2318	__in BOOL fVital
2319	)
2320	{
2321	HRESULT hr = S_OK;
2322
2323	// If this is an MSI package with slipstream MSPs, ensure the MSPs are cached first.
2324	// TODO: Slipstream packages are not accounted for when caching the MSI package is optional.
2325	if (BURN_PACKAGE_TYPE_MSI == pPackage->type && 0 < pPackage->Msi.cSlipstreamMspPackages && fVital)
2326	{
2327	hr = AddCacheSlipstreamMsps(pPlan, pPackage);
2328	ExitOnFailure(hr, "Failed to plan slipstream patches for package.");
2329	}
2330
2331	hr = AddCachePackageHelper(pPlan, pPackage, fVital);
2332	ExitOnFailure(hr, "Failed to plan cache package.");
2333
2334	LExit:
2335	return hr;
2336	}
2337
2338	static HRESULT AddCachePackageHelper(
2339	__in BURN_PLAN* pPlan,
2340	__in BURN_PACKAGE* pPackage,
2341	__in BOOL fVital
2342	)
2343	{
2344	AssertSz(pPackage->sczCacheId && *pPackage->sczCacheId, "AddCachePackageHelper() expects the package to have a cache id.");
2345
2346	HRESULT hr = S_OK;
2347	BURN_CACHE_ACTION* pCacheAction = NULL;
2348	DWORD dwCheckpoint = 0;
2349
2350	if (pPlan->fEnabledForwardCompatibleBundle) // Passthrough packages must already be cached.
2351	{
2352	ExitFunction();
2353	}
2354
2355	if (pPackage->hCacheEvent) // Only cache the package once.
2356	{
2357	ExitFunction();
2358	}
2359
2360	pPackage->hCacheEvent = ::CreateEventW(NULL, TRUE, FALSE, NULL);
2361	ExitOnNullWithLastError(pPackage->hCacheEvent, hr, "Failed to create syncpoint event.");
2362
2363	// Cache checkpoints happen before the package is cached because downloading packages'
2364	// payloads will not roll themselves back the way installation packages rollback on
2365	// failure automatically.
2366	dwCheckpoint = GetNextCheckpointId(pPlan);
2367
2368	hr = AppendCacheAction(pPlan, &pCacheAction);
2369	ExitOnFailure(hr, "Failed to append checkpoint before package start action.");
2370
2371	pCacheAction->type = BURN_CACHE_ACTION_TYPE_CHECKPOINT;
2372	pCacheAction->checkpoint.dwId = dwCheckpoint;
2373
2374	if (pPlan->fPlanPackageCacheRollback)
2375	{
2376	// Create a package cache rollback action before the checkpoint.
2377	hr = AppendRollbackCacheAction(pPlan, &pCacheAction);
2378	ExitOnFailure(hr, "Failed to append rollback cache action.");
2379
2380	pCacheAction->type = BURN_CACHE_ACTION_TYPE_ROLLBACK_PACKAGE;
2381	pCacheAction->rollbackPackage.pPackage = pPackage;
2382
2383	hr = AppendRollbackCacheAction(pPlan, &pCacheAction);
2384	ExitOnFailure(hr, "Failed to append rollback cache action.");
2385
2386	pCacheAction->type = BURN_CACHE_ACTION_TYPE_CHECKPOINT;
2387	pCacheAction->checkpoint.dwId = dwCheckpoint;
2388	}
2389
2390	hr = PlanLayoutPackage(pPlan, pPackage, fVital);
2391	ExitOnFailure(hr, "Failed to plan cache for package.");
2392
2393	// Create syncpoint action.
2394	hr = AppendCacheAction(pPlan, &pCacheAction);
2395	ExitOnFailure(hr, "Failed to append cache action.");
2396
2397	pCacheAction->type = BURN_CACHE_ACTION_TYPE_SIGNAL_SYNCPOINT;
2398	pCacheAction->syncpoint.pPackage = pPackage;
2399
2400	hr = PlanExecuteCacheSyncAndRollback(pPlan, pPackage);
2401	ExitOnFailure(hr, "Failed to plan package cache syncpoint");
2402
2403	if (pPackage->fCanAffectRegistration)
2404	{
2405	pPackage->expectedCacheRegistrationState = BURN_PACKAGE_REGISTRATION_STATE_PRESENT;
2406	}
2407
2408	LExit:
2409	return hr;
2410	}
2411
2412	static HRESULT AddCacheSlipstreamMsps(
2413	__in BURN_PLAN* pPlan,
2414	__in BURN_PACKAGE* pPackage
2415	)
2416	{
2417	HRESULT hr = S_OK;
2418
2419	AssertSz(BURN_PACKAGE_TYPE_MSI == pPackage->type, "Only MSI packages can have slipstream patches.");
2420
2421	for (DWORD i = 0; i < pPackage->Msi.cSlipstreamMspPackages; ++i)
2422	{
2423	BURN_PACKAGE* pMspPackage = pPackage->Msi.rgSlipstreamMsps[i].pMspPackage;
2424	AssertSz(BURN_PACKAGE_TYPE_MSP == pMspPackage->type, "Only MSP packages can be slipstream patches.");
2425
2426	hr = AddCachePackageHelper(pPlan, pMspPackage, TRUE);
2427	ExitOnFailure(hr, "Failed to plan slipstream MSP: %ls", pMspPackage->sczId);
2428	}
2429
2430	LExit:
2431	return hr;
2432	}
2433
2434	static DWORD GetNextCheckpointId(
2435	__in BURN_PLAN* pPlan
2436	)
2437	{
2438	return ++pPlan->dwNextCheckpointId;
2439	}
2440
2441	static HRESULT AppendCacheAction(
2442	__in BURN_PLAN* pPlan,
2443	__out BURN_CACHE_ACTION** ppCacheAction
2444	)
2445	{
2446	HRESULT hr = S_OK;
2447
2448	hr = MemEnsureArraySize(reinterpret_cast<LPVOID*>(&pPlan->rgCacheActions), pPlan->cCacheActions + 1, sizeof(BURN_CACHE_ACTION), 5);
2449	ExitOnFailure(hr, "Failed to grow plan's array of cache actions.");
2450
2451	*ppCacheAction = pPlan->rgCacheActions + pPlan->cCacheActions;
2452	++pPlan->cCacheActions;
2453
2454	LExit:
2455	return hr;
2456	}
2457
2458	static HRESULT AppendRollbackCacheAction(
2459	__in BURN_PLAN* pPlan,
2460	__out BURN_CACHE_ACTION** ppCacheAction
2461	)
2462	{
2463	HRESULT hr = S_OK;
2464
2465	hr = MemEnsureArraySize(reinterpret_cast<LPVOID*>(&pPlan->rgRollbackCacheActions), pPlan->cRollbackCacheActions + 1, sizeof(BURN_CACHE_ACTION), 5);
2466	ExitOnFailure(hr, "Failed to grow plan's array of rollback cache actions.");
2467
2468	*ppCacheAction = pPlan->rgRollbackCacheActions + pPlan->cRollbackCacheActions;
2469	++pPlan->cRollbackCacheActions;
2470
2471	LExit:
2472	return hr;
2473	}
2474
2475	static HRESULT AppendCleanAction(
2476	__in BURN_PLAN* pPlan,
2477	__out BURN_CLEAN_ACTION** ppCleanAction
2478	)
2479	{
2480	HRESULT hr = S_OK;
2481
2482	hr = MemEnsureArraySizeForNewItems(reinterpret_cast<LPVOID*>(&pPlan->rgCleanActions), pPlan->cCleanActions, 1, sizeof(BURN_CLEAN_ACTION), 5);
2483	ExitOnFailure(hr, "Failed to grow plan's array of clean actions.");
2484
2485
2486	*ppCleanAction = pPlan->rgCleanActions + pPlan->cCleanActions;
2487	++pPlan->cCleanActions;
2488
2489	LExit:
2490	return hr;
2491	}
2492
2493	static HRESULT AppendRestoreRelatedBundleAction(
2494	__in BURN_PLAN* pPlan,
2495	__out BURN_EXECUTE_ACTION** ppExecuteAction
2496	)
2497	{
2498	HRESULT hr = S_OK;
2499
2500	hr = MemEnsureArraySizeForNewItems(reinterpret_cast<LPVOID*>(&pPlan->rgRestoreRelatedBundleActions), pPlan->cRestoreRelatedBundleActions, 1, sizeof(BURN_EXECUTE_ACTION), 5);
2501	ExitOnFailure(hr, "Failed to grow plan's array of restore related bundle actions.");
2502
2503	*ppExecuteAction = pPlan->rgRestoreRelatedBundleActions + pPlan->cRestoreRelatedBundleActions;
2504	++pPlan->cRestoreRelatedBundleActions;
2505
2506	LExit:
2507	return hr;
2508	}
2509
2510	static HRESULT ProcessPayloadGroup(
2511	__in BURN_PLAN* pPlan,
2512	__in BURN_PAYLOAD_GROUP* pPayloadGroup
2513	)
2514	{
2515	HRESULT hr = S_OK;
2516
2517	for (DWORD i = 0; i < pPayloadGroup->cItems; ++i)
2518	{
2519	BURN_PAYLOAD_GROUP_ITEM* pItem = pPayloadGroup->rgItems + i;
2520	BURN_PAYLOAD* pPayload = pItem->pPayload;
2521
2522	pPayload->cRemainingInstances += 1;
2523
2524	if (pPayload->pContainer && !pPayload->pContainer->fPlanned)
2525	{
2526	hr = PlanLayoutContainer(pPlan, pPayload->pContainer);
2527	ExitOnFailure(hr, "Failed to plan container: %ls", pPayload->pContainer->sczId);
2528	}
2529
2530	if (!pPlan->sczLayoutDirectory \|\| !pPayload->pContainer)
2531	{
2532	// Acquire + Verify + Finalize
2533	pPlan->qwCacheSizeTotal += 3 * pPayload->qwFileSize;
2534
2535	if (!pPlan->sczLayoutDirectory)
2536	{
2537	// Staging
2538	pPlan->qwCacheSizeTotal += pPayload->qwFileSize;
2539	}
2540	}
2541
2542	if (!pPlan->sczLayoutDirectory && pPayload->pContainer && 1 == pPayload->cRemainingInstances)
2543	{
2544	// Extract
2545	pPlan->qwCacheSizeTotal += pPayload->qwFileSize;
2546	pPayload->pContainer->qwExtractSizeTotal += pPayload->qwFileSize;
2547	}
2548
2549	if (!pPayload->sczUnverifiedPath)
2550	{
2551	hr = CacheCalculatePayloadWorkingPath(pPlan->pCache, pPayload, &pPayload->sczUnverifiedPath);
2552	ExitOnFailure(hr, "Failed to calculate unverified path for payload.");
2553	}
2554	}
2555
2556	LExit:
2557	return hr;
2558	}
2559
2560	static void RemoveUnnecessaryActions(
2561	__in BOOL fExecute,
2562	__in BURN_EXECUTE_ACTION* rgActions,
2563	__in DWORD cActions
2564	)
2565	{
2566	LPCSTR szExecuteOrRollback = fExecute ? "execute" : "rollback";
2567
2568	for (DWORD i = 0; i < cActions; ++i)
2569	{
2570	BURN_EXECUTE_ACTION* pAction = rgActions + i;
2571
2572	if (BURN_EXECUTE_ACTION_TYPE_MSP_TARGET == pAction->type && pAction->mspTarget.pChainedTargetPackage)
2573	{
2574	BURN_MSPTARGETPRODUCT* pFirstTargetProduct = pAction->mspTarget.rgOrderedPatches->pTargetProduct;
2575	BURN_PATCH_SKIP_STATE skipState = fExecute ? pFirstTargetProduct->executeSkip : pFirstTargetProduct->rollbackSkip;
2576	BOOTSTRAPPER_ACTION_STATE chainedTargetPackageAction = fExecute ? pAction->mspTarget.pChainedTargetPackage->execute : pAction->mspTarget.pChainedTargetPackage->rollback;
2577
2578	switch (skipState)
2579	{
2580	case BURN_PATCH_SKIP_STATE_TARGET_UNINSTALL:
2581	pAction->fDeleted = TRUE;
2582	LogId(REPORT_STANDARD, MSG_PLAN_SKIP_PATCH_ACTION, pAction->mspTarget.pPackage->sczId, LoggingActionStateToString(pAction->mspTarget.action), pAction->mspTarget.pChainedTargetPackage->sczId, LoggingActionStateToString(chainedTargetPackageAction), szExecuteOrRollback);
2583	break;
2584	case BURN_PATCH_SKIP_STATE_SLIPSTREAM:
2585	pAction->fDeleted = TRUE;
2586	LogId(REPORT_STANDARD, MSG_PLAN_SKIP_SLIPSTREAM_ACTION, pAction->mspTarget.pPackage->sczId, LoggingActionStateToString(pAction->mspTarget.action), pAction->mspTarget.pChainedTargetPackage->sczId, LoggingActionStateToString(chainedTargetPackageAction), szExecuteOrRollback);
2587	break;
2588	}
2589	}
2590	}
2591	}
2592
2593	static void FinalizePatchActions(
2594	__in BOOL fExecute,
2595	__in BURN_EXECUTE_ACTION* rgActions,
2596	__in DWORD cActions
2597	)
2598	{
2599	for (DWORD i = 0; i < cActions; ++i)
2600	{
2601	BURN_EXECUTE_ACTION* pAction = rgActions + i;
2602
2603	if (BURN_EXECUTE_ACTION_TYPE_MSI_PACKAGE == pAction->type)
2604	{
2605	BURN_PACKAGE* pPackage = pAction->msiPackage.pPackage;
2606	AssertSz(BOOTSTRAPPER_ACTION_STATE_NONE < pAction->msiPackage.action, "Planned execute MSI action to do nothing");
2607
2608	if (BOOTSTRAPPER_ACTION_STATE_UNINSTALL == pAction->msiPackage.action)
2609	{
2610	// If we are uninstalling the MSI, we must skip all the patches.
2611	for (DWORD j = 0; j < pPackage->Msi.cChainedPatches; ++j)
2612	{
2613	BURN_CHAINED_PATCH* pChainedPatch = pPackage->Msi.rgChainedPatches + j;
2614	BURN_MSPTARGETPRODUCT* pTargetProduct = pChainedPatch->pMspPackage->Msp.rgTargetProducts + pChainedPatch->dwMspTargetProductIndex;
2615
2616	if (fExecute)
2617	{
2618	pTargetProduct->execute = BOOTSTRAPPER_ACTION_STATE_UNINSTALL;
2619	pTargetProduct->executeSkip = BURN_PATCH_SKIP_STATE_TARGET_UNINSTALL;
2620	}
2621	else
2622	{
2623	pTargetProduct->rollback = BOOTSTRAPPER_ACTION_STATE_UNINSTALL;
2624	pTargetProduct->rollbackSkip = BURN_PATCH_SKIP_STATE_TARGET_UNINSTALL;
2625	}
2626	}
2627	}
2628	else
2629	{
2630	// If the slipstream target is being installed or upgraded (not uninstalled or repaired) then we will slipstream so skip
2631	// the patch's standalone action. Also, if the slipstream target is being repaired and the patch is being
2632	// repaired, skip this operation since it will be redundant.
2633	//
2634	// The primary goal here is to ensure that a slipstream patch that is yet not installed is installed even if the MSI
2635	// is already on the machine. The slipstream must be installed standalone if the MSI is being repaired.
2636	for (DWORD j = 0; j < pPackage->Msi.cSlipstreamMspPackages; ++j)
2637	{
2638	BURN_SLIPSTREAM_MSP* pSlipstreamMsp = pPackage->Msi.rgSlipstreamMsps + j;
2639	BURN_CHAINED_PATCH* pChainedPatch = pPackage->Msi.rgChainedPatches + pSlipstreamMsp->dwMsiChainedPatchIndex;
2640	BURN_MSPTARGETPRODUCT* pTargetProduct = pSlipstreamMsp->pMspPackage->Msp.rgTargetProducts + pChainedPatch->dwMspTargetProductIndex;
2641	BOOTSTRAPPER_ACTION_STATE action = fExecute ? pTargetProduct->execute : pTargetProduct->rollback;
2642	BOOL fSlipstream = BOOTSTRAPPER_ACTION_STATE_UNINSTALL < action &&
2643	(BOOTSTRAPPER_ACTION_STATE_REPAIR != pAction->msiPackage.action \|\| BOOTSTRAPPER_ACTION_STATE_REPAIR == action);
2644
2645	if (fSlipstream)
2646	{
2647	if (fExecute)
2648	{
2649	pSlipstreamMsp->execute = action;
2650	pTargetProduct->executeSkip = BURN_PATCH_SKIP_STATE_SLIPSTREAM;
2651	}
2652	else
2653	{
2654	pSlipstreamMsp->rollback = action;
2655	pTargetProduct->rollbackSkip = BURN_PATCH_SKIP_STATE_SLIPSTREAM;
2656	}
2657	}
2658	}
2659	}
2660	}
2661	}
2662	}
2663
2664	static void CalculateExpectedRegistrationStates(
2665	__in BURN_PACKAGE* rgPackages,
2666	__in DWORD cPackages
2667	)
2668	{
2669	for (DWORD i = 0; i < cPackages; ++i)
2670	{
2671	BURN_PACKAGE* pPackage = rgPackages + i;
2672
2673	// MspPackages can have actions throughout the plan, so the plan needed to be finalized before anything could be calculated.
2674	if (BURN_PACKAGE_TYPE_MSP == pPackage->type && !pPackage->fDependencyManagerWasHere)
2675	{
2676	pPackage->execute = BOOTSTRAPPER_ACTION_STATE_NONE;
2677	pPackage->rollback = BOOTSTRAPPER_ACTION_STATE_NONE;
2678
2679	for (DWORD j = 0; j < pPackage->Msp.cTargetProductCodes; ++j)
2680	{
2681	BURN_MSPTARGETPRODUCT* pTargetProduct = pPackage->Msp.rgTargetProducts + j;
2682
2683	// The highest aggregate action state found will be used.
2684	if (pPackage->execute < pTargetProduct->execute)
2685	{
2686	pPackage->execute = pTargetProduct->execute;
2687	}
2688
2689	if (pPackage->rollback < pTargetProduct->rollback)
2690	{
2691	pPackage->rollback = pTargetProduct->rollback;
2692	}
2693	}
2694	}
2695
2696	if (pPackage->fCanAffectRegistration)
2697	{
2698	if (BOOTSTRAPPER_ACTION_STATE_UNINSTALL < pPackage->execute)
2699	{
2700	pPackage->expectedInstallRegistrationState = BURN_PACKAGE_REGISTRATION_STATE_PRESENT;
2701	}
2702	else if (BOOTSTRAPPER_ACTION_STATE_UNINSTALL == pPackage->execute)
2703	{
2704	pPackage->expectedInstallRegistrationState = BURN_PACKAGE_REGISTRATION_STATE_ABSENT;
2705	}
2706
2707	if (BURN_DEPENDENCY_ACTION_REGISTER == pPackage->dependencyExecute)
2708	{
2709	if (BURN_PACKAGE_REGISTRATION_STATE_IGNORED == pPackage->expectedCacheRegistrationState)
2710	{
2711	pPackage->expectedCacheRegistrationState = BURN_PACKAGE_REGISTRATION_STATE_PRESENT;
2712	}
2713	if (BURN_PACKAGE_REGISTRATION_STATE_IGNORED == pPackage->expectedInstallRegistrationState)
2714	{
2715	pPackage->expectedInstallRegistrationState = BURN_PACKAGE_REGISTRATION_STATE_PRESENT;
2716	}
2717	}
2718	else if (BURN_DEPENDENCY_ACTION_UNREGISTER == pPackage->dependencyExecute)
2719	{
2720	if (BURN_PACKAGE_REGISTRATION_STATE_PRESENT == pPackage->expectedCacheRegistrationState)
2721	{
2722	pPackage->expectedCacheRegistrationState = BURN_PACKAGE_REGISTRATION_STATE_IGNORED;
2723	}
2724	if (BURN_PACKAGE_REGISTRATION_STATE_PRESENT == pPackage->expectedInstallRegistrationState)
2725	{
2726	pPackage->expectedInstallRegistrationState = BURN_PACKAGE_REGISTRATION_STATE_IGNORED;
2727	}
2728	}
2729	}
2730	}
2731	}
2732
2733	static HRESULT PlanDependencyActions(
2734	__in BOOL fBundlePerMachine,
2735	__in BURN_PLAN* pPlan,
2736	__in BURN_PACKAGE* pPackage
2737	)
2738	{
2739	HRESULT hr = S_OK;
2740
2741	hr = DependencyPlanPackageBegin(fBundlePerMachine, pPackage, pPlan);
2742	ExitOnFailure(hr, "Failed to begin plan dependency actions for package: %ls", pPackage->sczId);
2743
2744	hr = DependencyPlanPackage(NULL, pPackage, pPlan);
2745	ExitOnFailure(hr, "Failed to plan package dependency actions.");
2746
2747	hr = DependencyPlanPackageComplete(pPackage, pPlan);
2748	ExitOnFailure(hr, "Failed to complete plan dependency actions for package: %ls", pPackage->sczId);
2749
2750	LExit:
2751	return hr;
2752	}
2753
2754	static HRESULT CalculateExecuteActions(
2755	__in BURN_PACKAGE* pPackage,
2756	__in_opt BURN_ROLLBACK_BOUNDARY* pActiveRollbackBoundary
2757	)
2758	{
2759	HRESULT hr = S_OK;
2760	BOOL fInsideMsiTransaction = pActiveRollbackBoundary && pActiveRollbackBoundary->fTransaction;
2761
2762	// Calculate execute actions.
2763	switch (pPackage->type)
2764	{
2765	case BURN_PACKAGE_TYPE_BUNDLE:
2766	hr = BundlePackageEnginePlanCalculatePackage(pPackage);
2767	break;
2768
2769	case BURN_PACKAGE_TYPE_EXE:
2770	hr = ExeEnginePlanCalculatePackage(pPackage);
2771	break;
2772
2773	case BURN_PACKAGE_TYPE_MSI:
2774	hr = MsiEnginePlanCalculatePackage(pPackage, fInsideMsiTransaction);
2775	break;
2776
2777	case BURN_PACKAGE_TYPE_MSP:
2778	hr = MspEnginePlanCalculatePackage(pPackage, fInsideMsiTransaction);
2779	break;
2780
2781	case BURN_PACKAGE_TYPE_MSU:
2782	hr = MsuEnginePlanCalculatePackage(pPackage);
2783	break;
2784
2785	default:
2786	hr = E_UNEXPECTED;
2787	ExitOnFailure(hr, "Invalid package type.");
2788	}
2789
2790	pPackage->compatiblePackage.fRemove = pPackage->compatiblePackage.fPlannable && pPackage->compatiblePackage.fRequested;
2791
2792	LExit:
2793	return hr;
2794	}
2795
2796	static BURN_CACHE_PACKAGE_TYPE GetCachePackageType(
2797	__in BURN_PACKAGE* pPackage,
2798	__in BOOL fExecute
2799	)
2800	{
2801	BURN_CACHE_PACKAGE_TYPE cachePackageType = BURN_CACHE_PACKAGE_TYPE_NONE;
2802
2803	switch (fExecute ? pPackage->execute : pPackage->rollback)
2804	{
2805	case BOOTSTRAPPER_ACTION_STATE_NONE:
2806	break;
2807	case BOOTSTRAPPER_ACTION_STATE_UNINSTALL:
2808	if (BURN_PACKAGE_TYPE_EXE == pPackage->type && BURN_EXE_DETECTION_TYPE_ARP != pPackage->Exe.detectionType)
2809	{
2810	// non-ArpEntry Exe packages require the package for all operations (even uninstall).
2811	cachePackageType = BURN_CACHE_PACKAGE_TYPE_REQUIRED;
2812	}
2813	else if (BURN_PACKAGE_TYPE_BUNDLE == pPackage->type)
2814	{
2815	// Bundle packages prefer the cache but can fallback to the ARP registration.
2816	cachePackageType = BURN_CACHE_PACKAGE_TYPE_OPTIONAL;
2817	}
2818	else
2819	{
2820	// The other package types can uninstall without the original package.
2821	cachePackageType = BURN_CACHE_PACKAGE_TYPE_NONE;
2822	}
2823	break;
2824	case BOOTSTRAPPER_ACTION_STATE_INSTALL: __fallthrough;
2825	case BOOTSTRAPPER_ACTION_STATE_MODIFY: __fallthrough;
2826	case BOOTSTRAPPER_ACTION_STATE_REPAIR: __fallthrough;
2827	case BOOTSTRAPPER_ACTION_STATE_MINOR_UPGRADE: __fallthrough;
2828	default:
2829	// TODO: bundles could theoretically use package cache.
2830	cachePackageType = BURN_CACHE_PACKAGE_TYPE_REQUIRED;
2831	break;
2832	}
2833
2834	return cachePackageType;
2835	}
2836
2837	static BOOL ForceCache(
2838	__in BURN_PLAN* pPlan,
2839	__in BURN_PACKAGE* pPackage
2840	)
2841	{
2842	switch (pPackage->cacheType)
2843	{
2844	case BOOTSTRAPPER_CACHE_TYPE_KEEP:
2845	// During actions that are expected to have source media available,
2846	// all packages that have cacheType set to keep should be cached if the package is going to be present.
2847	return (BOOTSTRAPPER_ACTION_CACHE == pPlan->action \|\| BOOTSTRAPPER_ACTION_INSTALL == pPlan->action) &&
2848	BOOTSTRAPPER_REQUEST_STATE_CACHE < pPackage->requested;
2849	case BOOTSTRAPPER_CACHE_TYPE_FORCE:
2850	// All packages that have cacheType set to force should be cached if the bundle is going to be present.
2851	return BOOTSTRAPPER_ACTION_UNINSTALL != pPlan->action && BOOTSTRAPPER_ACTION_UNSAFE_UNINSTALL != pPlan->action;
2852	default:
2853	return FALSE;
2854	}
2855	}
2856
2857	static void DependentRegistrationActionLog(
2858	__in DWORD iAction,
2859	__in BURN_DEPENDENT_REGISTRATION_ACTION* pAction,
2860	__in BOOL fRollback
2861	)
2862	{
2863	LPCWSTR wzBase = fRollback ? L" Rollback dependent registration" : L" Dependent registration";
2864	LPCWSTR wzType = NULL;
2865
2866	switch (pAction->type)
2867	{
2868	case BURN_DEPENDENT_REGISTRATION_ACTION_TYPE_REGISTER:
2869	wzType = L"REGISTER";
2870	break;
2871
2872	case BURN_DEPENDENT_REGISTRATION_ACTION_TYPE_UNREGISTER:
2873	wzType = L"UNREGISTER";
2874	break;
2875
2876	default:
2877	AssertSz(FALSE, "Unknown cache action type.");
2878	break;
2879	}
2880
2881	if (wzType)
2882	{
2883	LogStringLine(PlanDumpLevel, "%ls action[%u]: %ls bundle id: %ls, provider key: %ls", wzBase, iAction, wzType, pAction->sczBundleId, pAction->sczDependentProviderKey);
2884	}
2885	}
2886
2887	static void CacheActionLog(
2888	__in DWORD iAction,
2889	__in BURN_CACHE_ACTION* pAction,
2890	__in BOOL fRollback
2891	)
2892	{
2893	LPCWSTR wzBase = fRollback ? L" Rollback cache" : L" Cache";
2894	switch (pAction->type)
2895	{
2896	case BURN_CACHE_ACTION_TYPE_CHECKPOINT:
2897	LogStringLine(PlanDumpLevel, "%ls action[%u]: CHECKPOINT id: %u", wzBase, iAction, pAction->checkpoint.dwId);
2898	break;
2899
2900	case BURN_CACHE_ACTION_TYPE_LAYOUT_BUNDLE:
2901	LogStringLine(PlanDumpLevel, "%ls action[%u]: LAYOUT_BUNDLE working path: %ls, exe name: %ls", wzBase, iAction, pAction->bundleLayout.sczUnverifiedPath, pAction->bundleLayout.sczExecutableName);
2902	break;
2903
2904	case BURN_CACHE_ACTION_TYPE_CONTAINER:
2905	LogStringLine(PlanDumpLevel, "%ls action[%u]: CONTAINER container id: %ls, working path: %ls", wzBase, iAction, pAction->container.pContainer->sczId, pAction->container.pContainer->sczUnverifiedPath);
2906	break;
2907
2908	case BURN_CACHE_ACTION_TYPE_PACKAGE:
2909	LogStringLine(PlanDumpLevel, "%ls action[%u]: PACKAGE id: %ls, vital: %hs, execute cache type: %hs, rollback cache type: %hs", wzBase, iAction, pAction->package.pPackage->sczId, LoggingBoolToString(pAction->package.pPackage->fCacheVital), LoggingCachePackageTypeToString(pAction->package.pPackage->executeCacheType), LoggingCachePackageTypeToString(pAction->package.pPackage->rollbackCacheType));
2910	break;
2911
2912	case BURN_CACHE_ACTION_TYPE_ROLLBACK_PACKAGE:
2913	LogStringLine(PlanDumpLevel, "%ls action[%u]: ROLLBACK_PACKAGE id: %ls", wzBase, iAction, pAction->rollbackPackage.pPackage->sczId);
2914	break;
2915
2916	case BURN_CACHE_ACTION_TYPE_SIGNAL_SYNCPOINT:
2917	LogStringLine(PlanDumpLevel, "%ls action[%u]: SIGNAL_SYNCPOINT package id: %ls, event handle: 0x%p", wzBase, iAction, pAction->syncpoint.pPackage->sczId, pAction->syncpoint.pPackage->hCacheEvent);
2918	break;
2919
2920	default:
2921	AssertSz(FALSE, "Unknown cache action type.");
2922	break;
2923	}
2924	}
2925
2926	static void ExecuteActionLog(
2927	__in DWORD iAction,
2928	__in BURN_EXECUTE_ACTION* pAction,
2929	__in BOOL fRollback
2930	)
2931	{
2932	LPCWSTR wzBase = fRollback ? L" Rollback" : L" Execute";
2933	switch (pAction->type)
2934	{
2935	case BURN_EXECUTE_ACTION_TYPE_CHECKPOINT:
2936	LogStringLine(PlanDumpLevel, "%ls action[%u]: CHECKPOINT id: %u, msi transaction id: %ls", wzBase, iAction, pAction->checkpoint.dwId, pAction->checkpoint.pActiveRollbackBoundary && pAction->checkpoint.pActiveRollbackBoundary->fTransaction ? pAction->checkpoint.pActiveRollbackBoundary->sczId : L"(none)");
2937	break;
2938
2939	case BURN_EXECUTE_ACTION_TYPE_PACKAGE_PROVIDER:
2940	LogStringLine(PlanDumpLevel, "%ls action[%u]: PACKAGE_PROVIDER package id: %ls", wzBase, iAction, pAction->packageProvider.pPackage->sczId);
2941	for (DWORD j = 0; j < pAction->packageProvider.pPackage->cDependencyProviders; ++j)
2942	{
2943	const BURN_DEPENDENCY_PROVIDER* pProvider = pAction->packageProvider.pPackage->rgDependencyProviders + j;
2944	LogStringLine(PlanDumpLevel, " Provider[%u]: key: %ls, action: %hs", j, pProvider->sczKey, LoggingDependencyActionToString(fRollback ? pProvider->providerRollback : pProvider->providerExecute));
2945	}
2946	break;
2947
2948	case BURN_EXECUTE_ACTION_TYPE_PACKAGE_DEPENDENCY:
2949	LogStringLine(PlanDumpLevel, "%ls action[%u]: PACKAGE_DEPENDENCY package id: %ls, bundle provider key: %ls", wzBase, iAction, pAction->packageDependency.pPackage->sczId, pAction->packageDependency.sczBundleProviderKey);
2950	for (DWORD j = 0; j < pAction->packageProvider.pPackage->cDependencyProviders; ++j)
2951	{
2952	const BURN_DEPENDENCY_PROVIDER* pProvider = pAction->packageProvider.pPackage->rgDependencyProviders + j;
2953	LogStringLine(PlanDumpLevel, " Provider[%u]: key: %ls, action: %hs", j, pProvider->sczKey, LoggingDependencyActionToString(fRollback ? pProvider->dependentRollback : pProvider->dependentExecute));
2954	}
2955	break;
2956
2957	case BURN_EXECUTE_ACTION_TYPE_RELATED_BUNDLE:
2958	LogStringLine(PlanDumpLevel, "%ls action[%u]: RELATED_BUNDLE package id: %ls, action: %hs, ignore dependencies: %ls", wzBase, iAction, pAction->relatedBundle.pRelatedBundle->package.sczId, LoggingActionStateToString(pAction->relatedBundle.action), pAction->relatedBundle.sczIgnoreDependencies);
2959	break;
2960
2961	case BURN_EXECUTE_ACTION_TYPE_BUNDLE_PACKAGE:
2962	LogStringLine(PlanDumpLevel, "%ls action[%u]: BUNDLE_PACKAGE package id: %ls, action: %hs", wzBase, iAction, pAction->bundlePackage.pPackage->sczId, LoggingActionStateToString(pAction->bundlePackage.action));
2963	break;
2964
2965	case BURN_EXECUTE_ACTION_TYPE_EXE_PACKAGE:
2966	LogStringLine(PlanDumpLevel, "%ls action[%u]: EXE_PACKAGE package id: %ls, action: %hs", wzBase, iAction, pAction->exePackage.pPackage->sczId, LoggingActionStateToString(pAction->exePackage.action));
2967	break;
2968
2969	case BURN_EXECUTE_ACTION_TYPE_MSI_PACKAGE:
2970	LogStringLine(PlanDumpLevel, "%ls action[%u]: MSI_PACKAGE package id: %ls, action: %hs, action msi property: %ls, ui level: %u, disable externaluihandler: %hs, file versioning: %hs, log path: %ls, logging attrib: %u", wzBase, iAction, pAction->msiPackage.pPackage->sczId, LoggingActionStateToString(pAction->msiPackage.action), LoggingBurnMsiPropertyToString(pAction->msiPackage.actionMsiProperty), pAction->msiPackage.uiLevel, LoggingBoolToString(pAction->msiPackage.fDisableExternalUiHandler), LoggingMsiFileVersioningToString(pAction->msiPackage.fileVersioning), pAction->msiPackage.sczLogPath, pAction->msiPackage.dwLoggingAttributes);
2971	for (DWORD j = 0; j < pAction->msiPackage.pPackage->Msi.cSlipstreamMspPackages; ++j)
2972	{
2973	const BURN_SLIPSTREAM_MSP* pSlipstreamMsp = pAction->msiPackage.pPackage->Msi.rgSlipstreamMsps + j;
2974	LogStringLine(PlanDumpLevel, " Patch[%u]: msp package id: %ls, action: %hs", j, pSlipstreamMsp->pMspPackage->sczId, LoggingActionStateToString(fRollback ? pSlipstreamMsp->rollback : pSlipstreamMsp->execute));
2975	}
2976	break;
2977
2978	case BURN_EXECUTE_ACTION_TYPE_UNINSTALL_MSI_COMPATIBLE_PACKAGE:
2979	LogStringLine(PlanDumpLevel, "%ls action[%u]: UNINSTALL_MSI_COMPATIBLE_PACKAGE package id: %ls, compatible package id: %ls, cache id: %ls, log path: %ls, logging attrib: %u", wzBase, iAction, pAction->uninstallMsiCompatiblePackage.pParentPackage->sczId, pAction->uninstallMsiCompatiblePackage.pParentPackage->compatiblePackage.compatibleEntry.sczId, pAction->uninstallMsiCompatiblePackage.pParentPackage->compatiblePackage.sczCacheId, pAction->uninstallMsiCompatiblePackage.sczLogPath, pAction->uninstallMsiCompatiblePackage.dwLoggingAttributes);
2980	break;
2981
2982	case BURN_EXECUTE_ACTION_TYPE_MSP_TARGET:
2983	LogStringLine(PlanDumpLevel, "%ls action[%u]: MSP_TARGET package id: %ls, action: %hs, target product code: %ls, target per-machine: %hs, action msi property: %ls, ui level: %u, disable externaluihandler: %hs, file versioning: %hs, log path: %ls", wzBase, iAction, pAction->mspTarget.pPackage->sczId, LoggingActionStateToString(pAction->mspTarget.action), pAction->mspTarget.sczTargetProductCode, LoggingBoolToString(pAction->mspTarget.fPerMachineTarget), LoggingBurnMsiPropertyToString(pAction->mspTarget.actionMsiProperty), pAction->mspTarget.uiLevel, LoggingBoolToString(pAction->mspTarget.fDisableExternalUiHandler), LoggingMsiFileVersioningToString(pAction->mspTarget.fileVersioning), pAction->mspTarget.sczLogPath);
2984	for (DWORD j = 0; j < pAction->mspTarget.cOrderedPatches; ++j)
2985	{
2986	LogStringLine(PlanDumpLevel, " Patch[%u]: order: %u, msp package id: %ls", j, pAction->mspTarget.rgOrderedPatches[j].pTargetProduct->dwOrder, pAction->mspTarget.rgOrderedPatches[j].pPackage->sczId);
2987	}
2988	break;
2989
2990	case BURN_EXECUTE_ACTION_TYPE_MSU_PACKAGE:
2991	LogStringLine(PlanDumpLevel, "%ls action[%u]: MSU_PACKAGE package id: %ls, action: %hs, log path: %ls", wzBase, iAction, pAction->msuPackage.pPackage->sczId, LoggingActionStateToString(pAction->msuPackage.action), pAction->msuPackage.sczLogPath);
2992	break;
2993
2994	case BURN_EXECUTE_ACTION_TYPE_ROLLBACK_BOUNDARY_START:
2995	LogStringLine(PlanDumpLevel, "%ls action[%u]: ROLLBACK_BOUNDARY_START id: %ls, vital: %ls", wzBase, iAction, pAction->rollbackBoundary.pRollbackBoundary->sczId, pAction->rollbackBoundary.pRollbackBoundary->fVital ? L"yes" : L"no");
2996	break;
2997
2998	case BURN_EXECUTE_ACTION_TYPE_ROLLBACK_BOUNDARY_END:
2999	LogStringLine(PlanDumpLevel, "%ls action[%u]: ROLLBACK_BOUNDARY_END", wzBase, iAction);
3000	break;
3001
3002	case BURN_EXECUTE_ACTION_TYPE_WAIT_CACHE_PACKAGE:
3003	LogStringLine(PlanDumpLevel, "%ls action[%u]: WAIT_CACHE_PACKAGE id: %ls, event handle: 0x%p", wzBase, iAction, pAction->waitCachePackage.pPackage->sczId, pAction->waitCachePackage.pPackage->hCacheEvent);
3004	break;
3005
3006	case BURN_EXECUTE_ACTION_TYPE_UNCACHE_PACKAGE:
3007	LogStringLine(PlanDumpLevel, "%ls action[%u]: UNCACHE_PACKAGE id: %ls", wzBase, iAction, pAction->uncachePackage.pPackage->sczId);
3008	break;
3009
3010	case BURN_EXECUTE_ACTION_TYPE_BEGIN_MSI_TRANSACTION:
3011	LogStringLine(PlanDumpLevel, "%ls action[%u]: BEGIN_MSI_TRANSACTION id: %ls", wzBase, iAction, pAction->msiTransaction.pRollbackBoundary->sczId);
3012	break;
3013
3014	case BURN_EXECUTE_ACTION_TYPE_COMMIT_MSI_TRANSACTION:
3015	LogStringLine(PlanDumpLevel, "%ls action[%u]: COMMIT_MSI_TRANSACTION id: %ls", wzBase, iAction, pAction->msiTransaction.pRollbackBoundary->sczId);
3016	break;
3017
3018	default:
3019	AssertSz(FALSE, "Unknown execute action type.");
3020	break;
3021	}
3022
3023	if (pAction->fDeleted)
3024	{
3025	LogStringLine(PlanDumpLevel, " (deleted action)");
3026	}
3027	}
3028
3029	static void RestoreRelatedBundleActionLog(
3030	__in DWORD iAction,
3031	__in BURN_EXECUTE_ACTION* pAction
3032	)
3033	{
3034	switch (pAction->type)
3035	{
3036	case BURN_EXECUTE_ACTION_TYPE_RELATED_BUNDLE:
3037	LogStringLine(PlanDumpLevel, "Restore action[%u]: RELATED_BUNDLE package id: %ls, action: %hs, ignore dependencies: %ls", iAction, pAction->relatedBundle.pRelatedBundle->package.sczId, LoggingActionStateToString(pAction->relatedBundle.action), pAction->relatedBundle.sczIgnoreDependencies);
3038	break;
3039
3040	default:
3041	AssertSz(FALSE, "Unknown execute action type.");
3042	break;
3043	}
3044
3045	if (pAction->fDeleted)
3046	{
3047	LogStringLine(PlanDumpLevel, " (deleted action)");
3048	}
3049	}
3050
3051	static void CleanActionLog(
3052	__in DWORD iAction,
3053	__in BURN_CLEAN_ACTION* pAction
3054	)
3055	{
3056	switch (pAction->type)
3057	{
3058	case BURN_CLEAN_ACTION_TYPE_COMPATIBLE_PACKAGE:
3059	LogStringLine(PlanDumpLevel, " Clean action[%u]: CLEAN_COMPATIBLE_PACKAGE package id: %ls", iAction, pAction->pPackage->sczId);
3060	break;
3061
3062	case BURN_CLEAN_ACTION_TYPE_PACKAGE:
3063	LogStringLine(PlanDumpLevel, " Clean action[%u]: CLEAN_PACKAGE package id: %ls", iAction, pAction->pPackage->sczId);
3064	break;
3065
3066	default:
3067	AssertSz(FALSE, "Unknown clean action type.");
3068	break;
3069	}
3070	}
3071
3072	extern "C" void PlanDump(
3073	__in BURN_PLAN* pPlan
3074	)
3075	{
3076	LogStringLine(PlanDumpLevel, "--- Begin plan dump ---");
3077
3078	LogStringLine(PlanDumpLevel, "Plan action: %hs", LoggingBurnActionToString(pPlan->action));
3079	LogStringLine(PlanDumpLevel, " bundle id: %ls", pPlan->wzBundleId);
3080	LogStringLine(PlanDumpLevel, " bundle provider key: %ls", pPlan->wzBundleProviderKey);
3081	LogStringLine(PlanDumpLevel, " use-forward-compatible: %hs", LoggingTrueFalseToString(pPlan->fEnabledForwardCompatibleBundle));
3082	LogStringLine(PlanDumpLevel, " per-machine: %hs", LoggingTrueFalseToString(pPlan->fPerMachine));
3083	LogStringLine(PlanDumpLevel, " can affect machine state: %hs", LoggingTrueFalseToString(pPlan->fCanAffectMachineState));
3084	LogStringLine(PlanDumpLevel, " disable-rollback: %hs", LoggingTrueFalseToString(pPlan->fDisableRollback));
3085	LogStringLine(PlanDumpLevel, " disallow-removal: %hs", LoggingTrueFalseToString(pPlan->fDisallowRemoval));
3086	LogStringLine(PlanDumpLevel, " downgrade: %hs", LoggingTrueFalseToString(pPlan->fDowngrade));
3087	LogStringLine(PlanDumpLevel, " registration options: %hs", LoggingRegistrationOptionsToString(pPlan->dwRegistrationOperations));
3088	if (pPlan->sczLayoutDirectory)
3089	{
3090	LogStringLine(PlanDumpLevel, " layout directory: %ls", pPlan->sczLayoutDirectory);
3091	}
3092
3093	for (DWORD i = 0; i < pPlan->cRegistrationActions; ++i)
3094	{
3095	DependentRegistrationActionLog(i, pPlan->rgRegistrationActions + i, FALSE);
3096	}
3097
3098	for (DWORD i = 0; i < pPlan->cRollbackRegistrationActions; ++i)
3099	{
3100	DependentRegistrationActionLog(i, pPlan->rgRollbackRegistrationActions + i, TRUE);
3101	}
3102
3103	LogStringLine(PlanDumpLevel, "Plan cache size: %llu", pPlan->qwCacheSizeTotal);
3104	for (DWORD i = 0; i < pPlan->cCacheActions; ++i)
3105	{
3106	CacheActionLog(i, pPlan->rgCacheActions + i, FALSE);
3107	}
3108
3109	for (DWORD i = 0; i < pPlan->cRollbackCacheActions; ++i)
3110	{
3111	CacheActionLog(i, pPlan->rgRollbackCacheActions + i, TRUE);
3112	}
3113
3114	LogStringLine(PlanDumpLevel, "Plan execute package count: %u", pPlan->cExecutePackagesTotal);
3115	LogStringLine(PlanDumpLevel, " overall progress ticks: %u", pPlan->cOverallProgressTicksTotal);
3116	for (DWORD i = 0; i < pPlan->cExecuteActions; ++i)
3117	{
3118	ExecuteActionLog(i, pPlan->rgExecuteActions + i, FALSE);
3119	}
3120
3121	for (DWORD i = 0; i < pPlan->cRollbackActions; ++i)
3122	{
3123	ExecuteActionLog(i, pPlan->rgRollbackActions + i, TRUE);
3124	}
3125
3126	for (DWORD i = 0; i < pPlan->cRestoreRelatedBundleActions; ++i)
3127	{
3128	RestoreRelatedBundleActionLog(i, pPlan->rgRestoreRelatedBundleActions + i);
3129	}
3130
3131	for (DWORD i = 0; i < pPlan->cCleanActions; ++i)
3132	{
3133	CleanActionLog(i, pPlan->rgCleanActions + i);
3134	}
3135
3136	for (DWORD i = 0; i < pPlan->cPlannedProviders; ++i)
3137	{
3138	LogStringLine(PlanDumpLevel, " Dependency action[%u]: PLANNED_PROVIDER key: %ls, name: %ls", i, pPlan->rgPlannedProviders[i].sczKey, pPlan->rgPlannedProviders[i].sczName);
3139	}
3140
3141	LogStringLine(PlanDumpLevel, "--- End plan dump ---");
3142	}