Code:
/ DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Framework / MS / Internal / AppModel / XappLauncher.cs / 3 / XappLauncher.cs
using System;
using System.Deployment.Application;
using System.Runtime.Remoting;
using System.Security;
using System.Security.Policy;
using System.Xml;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Interop;
using System.Windows.Navigation;
using System.Windows.Threading;
using System.Runtime.InteropServices;
using System.Diagnostics;
using MS.Internal;
using MS.Internal.PresentationFramework;
using MS.Internal.Utility;
using Microsoft.Internal.DeploymentUI;
using Microsoft.Win32;
using System.Reflection;
using MS.Utility;
using System.Windows.Input;
namespace MS.Internal.AppModel
{
internal class XappLauncherApp : Application
{
internal XappLauncherApp(Uri deploymentManifest, Uri activationUri, string applicationId, IBrowserCallbackServices browser, DocObjHost.ApplicationRunnerCallback applicationRunner, string progressPageAssembly, string progressPageClass, string errorPageAssembly, string errorPageClass)
{
_deploymentManifest = deploymentManifest;
_activationUri = activationUri;
_applicationId = applicationId;
_browser = browser;
_applicationRunnerCallback = applicationRunner;
_fwlinkUri = null;
this.Startup += new StartupEventHandler(XappLauncherApp_Startup);
this.Exit += new ExitEventHandler(XappLauncherApp_Exit);
this.Navigated += new NavigatedEventHandler(XappLauncherApp_Navigated);
_progressPageAssembly = progressPageAssembly;
_progressPageClass = progressPageClass;
_errorPageAssembly = errorPageAssembly;
_errorPageClass = errorPageClass;
}
void OnCommandRefresh(object sender, RoutedEventArgs e)
{
HandleRefresh();
}
void OnCommandStop(object sender, RoutedEventArgs e)
{
UserStop(null);
}
void XappLauncherApp_Startup(object sender, StartupEventArgs e)
{
if (EventTrace.IsEnabled(EventTrace.Flags.performance, EventTrace.Level.verbose))
{
EventTrace.EventProvider.TraceEvent(EventTrace.Level.verbose,
EventTrace.GuidFromId(EventTraceGuidId.HOSTINGGUID), (byte)EventTrace.HostingEvent.XappLauncherAppStartup);
}
CreateApplicationIdentity();
if (_identity != null)
{
TryApplicationIdActivation();
}
else
{
TryUriActivation();
}
}
void XappLauncherApp_Exit(object sender, ExitEventArgs e)
{
if (EventTrace.IsEnabled(EventTrace.Flags.performance, EventTrace.Level.verbose))
{
EventTrace.EventProvider.TraceEvent(EventTrace.Level.verbose,
EventTrace.GuidFromId(EventTraceGuidId.HOSTINGGUID), (byte)EventTrace.HostingEvent.XappLauncherAppExit, _attemptDownload);
}
Invariant.Assert(!_isInAsynchronousOperation,
"Async downloading should have been canceled before XappLauncherApp exits.");
if (_attemptDownload)
{
_applicationRunnerCallback(new DocObjHost.ApplicationRunner(_applicationRunner));
}
_browser = null;
_applicationRunner = null;
_applicationRunnerCallback = null;
}
///
/// Critical: This code calls into critical code GetAppWindow
/// TreatAsSafe: There exists a demand here
///
[SecurityCritical, SecurityTreatAsSafe]
void XappLauncherApp_Navigated(object sender, NavigationEventArgs e)
{
if (EventTrace.IsEnabled(EventTrace.Flags.performance, EventTrace.Level.verbose))
{
EventTrace.EventProvider.TraceEvent(EventTrace.Level.verbose,
EventTrace.GuidFromId(EventTraceGuidId.HOSTINGGUID), (byte)EventTrace.HostingEvent.XappLauncherAppNavigated);
}
if (IsShuttingDown)
return;
if (!_commandBindingsRegistered)
{
_commandBindingsRegistered = true;
// These bindings handle the commands sent by the browser when the stop/refresh buttons are pressed. If nothing in the
// page has focus, they will be sent directly to the window.
MainWindow.CommandBindings.Add(new CommandBinding(NavigationCommands.BrowseStop, new ExecutedRoutedEventHandler(OnCommandStop)));
MainWindow.CommandBindings.Add(new CommandBinding(NavigationCommands.Refresh, new ExecutedRoutedEventHandler(OnCommandRefresh)));
}
SecurityHelper.DemandUIWindowPermission();
NavigationWindow navWin = GetAppWindow();
Invariant.Assert(navWin != null, "A RootBrowserWindow should have been created.");
while (navWin.CanGoBack)
{
navWin.RemoveBackEntry();
}
}
void StartAsynchronousOperation()
{
_isInAsynchronousOperation = true;
ChangeBrowserDownloadState(_isInAsynchronousOperation);
}
void ClearAsynchronousOperationStatus()
{
_isInAsynchronousOperation = false;
ChangeBrowserDownloadState(_isInAsynchronousOperation);
}
private object UserRefresh(object unused)
{
HandleRefresh();
return null;
}
internal override void PerformNavigationStateChangeTasks(
bool isNavigationInitiator, bool playNavigatingSound, NavigationStateChange state)
{
// Do not play sounds or start and stop the globe on when navigations
// occur because the progress page is merely an enhanced visual experience
// during the actual navigation to the application. Conceptually it should
// appear as something that happens during navigation and not a series of
// discrete navigations.
// We do need to ensure that the Stop and Refresh buttons are in the correct state
// while downloading the app.
if (isNavigationInitiator && state == NavigationStateChange.Completed)
{
UpdateBrowserCommands();
}
}
// This function gets called when the browser refresh button in clicked.
// This'll cause the browser to navigate the address bar
///
/// Critical: Accesses BrowserCallbackServices to navigate
/// TreatAsSafe: only navigates to a safe, already validated _deploymentManifest.
/// Potentially, this could be a DOS attack FOR THE APP ONLY if refresh was called constantly, but that is
/// below the bar for critical code progagation, as the user can recover and the system is not destabilized.
///
[SecurityCritical, SecurityTreatAsSafe]
internal void HandleRefresh()
{
lock (_lockObject) // we do this in case the refresh button is getting clicked rapidly, before the navigation happens
{
if (!_refreshing)
{
_refreshing = true;
BrowserCallbackServices.DelegateNavigation(_activationUri.ToString(), null, null);
}
}
}
///
/// Critical: Calls IBrowserCallbackServices.ChangeDownloadState which is critical
/// TreatAsSafe: Changing the download state is safe
///
[SecurityCritical, SecurityTreatAsSafe]
private void ChangeBrowserDownloadState(bool newState)
{
// start or stop waving the flag
_browser.ChangeDownloadState(newState);
}
private void TryApplicationIdActivation()
{
Dispatcher.Invoke(
DispatcherPriority.Input,
new DispatcherOperationCallback(DoDirectActivation),
null);
}
private void TryUriActivation()
{
EventTrace.NormalTraceEvent(EventTraceGuidId.HOSTINGGUID, (byte)EventTrace.HostingEvent.FirstTimeActivation);
_hostingManager = new InPlaceHostingManager(_deploymentManifest);
// Ordering is important here - downloading the manifest is done asynchronously
// so can be started before we spend time setting up the UI. This saves us some
// time - especially during cold-start scenarios.
// Calling it through the dispatcher makes sure the right context and exception
// handling is used. DispatcherPriority.Send has it executed synchronously.
Dispatcher.Invoke(
DispatcherPriority.Send,
new DispatcherOperationCallback(DoGetManifestAsync),
null);
DoDownloadUI();
}
///
/// Critical: calls ApplicationTrustCollection.Item which LinkDemands
/// TreatAsSafe: Caller can't hand in an arbitrary item string
///
[SecurityCritical, SecurityTreatAsSafe]
private object DoDirectActivation(object unused)
{
if (IsShuttingDown)
return null;
try
{
// Verify that this app is actually cached. This is because the call to
// CreatePartialActivationContext can succeed when we don't want it to;
// it appears to be insensitive to some parts of the ApplicationIdentity,
// or it tries to make things work when they really should fail. Looking
// at the UserApplicationTrusts does a better comparison.
if (ApplicationSecurityManager.UserApplicationTrusts[_identity.ToString()] != null)
{
_context = ActivationContext.CreatePartialActivationContext(_identity);
_applicationRunner = new DocObjHost.ApplicationRunner(ExecuteDirectApplication);
_attemptDownload = true;
this.Shutdown();
}
else
{
TryUriActivation();
}
}
catch(Exception exception)
{
// Delete the cached trust decision to force going down the full ClickOnce path next time
DeleteCachedApplicationTrust(_identity);
// Fatal error like NullReferenceException and SEHException should not be ignored.
if (exception is NullReferenceException || exception is SEHException)
{
throw;
}
else
{
TryUriActivation();
}
}
return null;
}
///
/// Critical: This code calls into critical code which has link demand (Activator.CreateInstance)
/// TreatAsSafe: There exists a demand here
///
[SecurityCritical, SecurityTreatAsSafe]
private void ExecuteDirectApplication()
{
SecurityHelper.DemandUnmanagedCode();
try
{
if (EventTrace.IsEnabled(EventTrace.Flags.performance))
{
EventTrace.EventProvider.TraceEvent(EventTrace.GuidFromId(EventTraceGuidId.HOSTINGGUID), (byte)EventTrace.HostingEvent.ClickOnceActivationStart, KnownBoxes.BooleanBoxes.TrueBox);
}
ObjectHandle oh = Activator.CreateInstance(_context);
if (PresentationAppDomainManager.SaveAppDomain)
{
AppDomain newDomain = oh.Unwrap() as AppDomain;
PresentationAppDomainManager.NewAppDomain = newDomain;
}
EventTrace.NormalTraceEvent(EventTraceGuidId.HOSTINGGUID, (byte)EventTrace.HostingEvent.ClickOnceActivationEnd);
}
catch (Exception exception)
{
// Delete the cached trust decision to force going down the full ClickOnce path next time
DeleteCachedApplicationTrust(_identity);
// Fatal error like NullReferenceException and SEHException should not be ignored.
if (exception is NullReferenceException || exception is SEHException)
{
throw;
}
else
{
TryUriActivation();
}
}
}
private object DoGetManifestAsync(object notUsed)
{
if (IsShuttingDown)
return null;
EventTrace.NormalTraceEvent(EventTraceGuidId.HOSTINGGUID, (byte)EventTrace.HostingEvent.DownloadDeplManifestStart);
StartAsynchronousOperation();
SetStatusText(SR.Get(SRID.HostingStatusDownloadAppInfo));
_hostingManager.GetManifestCompleted += new EventHandler(GetManifestCompleted);
// Possible reentrancy! When making the outgoing calls to the browser to update its
// status (above), a pending incoming call can be dispatched. This may be OLECMDID_STOP,
// which would lead to calling UserStop(), which makes IPHM unusable.
if (_isInAsynchronousOperation)
{
_hostingManager.GetManifestAsync();
}
return null;
}
private object GetCustomPage(string pageAssemblyName, string pageClassName)
{
if (EventTrace.IsEnabled(EventTrace.Flags.performance, EventTrace.Level.verbose))
{
EventTrace.EventProvider.TraceEvent(EventTrace.Level.verbose,
EventTrace.GuidFromId(EventTraceGuidId.HOSTINGGUID), (byte)EventTrace.HostingEvent.GetDownloadPageStart, pageClassName);
}
object customPage;
try
{
// Uses custom progress page
// If the assembly is not specified, use PresentationUI.
Assembly customPageAssembly = string.IsNullOrEmpty(pageAssemblyName) ? typeof(InstallationProgressPage).Assembly : Assembly.Load(pageAssemblyName);
customPage = customPageAssembly.CreateInstance(pageClassName);
}
catch
{
customPage = null;
}
if (EventTrace.IsEnabled(EventTrace.Flags.performance, EventTrace.Level.verbose))
{
EventTrace.EventProvider.TraceEvent(EventTrace.Level.verbose,
EventTrace.GuidFromId(EventTraceGuidId.HOSTINGGUID), (byte)EventTrace.HostingEvent.GetDownloadPageEnd);
}
return customPage;
}
void GetManifestCompleted(object sender, GetManifestCompletedEventArgs e)
{
Dispatcher.Invoke(
DispatcherPriority.Send,
new DispatcherOperationCallback(DoGetManifestCompleted),
e);
}
private object DoGetManifestCompleted(object e)
{
ClearAsynchronousOperationStatus();
EventTrace.NormalTraceEvent(EventTraceGuidId.HOSTINGGUID, (byte)EventTrace.HostingEvent.DownloadDeplManifestEnd);
GetManifestCompletedEventArgs args = (GetManifestCompletedEventArgs)e;
if (IsShuttingDown)
{
// do nothing if some thread has already called shutdown
return null;
}
if (args.Error != null)
{
// If the async operation failed, it is invalid to request the
// SupportUri so we simply pass in null.
HandleError(args.Error, args.LogFilePath, null, null);
return null;
}
if (args.Cancelled)
{
HandleCancel();
return null;
}
_identity = args.ApplicationIdentity;
_supportUri = args.SupportUri;
SetStatusText(SR.Get(SRID.HostingStatusVerifying));
try
{
if (EventTrace.IsEnabled(EventTrace.Flags.performance, EventTrace.Level.verbose))
{
EventTrace.EventProvider.TraceEvent(
EventTrace.Level.verbose, EventTrace.GuidFromId(EventTraceGuidId.HOSTINGGUID), (byte)EventTrace.HostingEvent.AssertAppRequirementsStart);
}
_hostingManager.AssertApplicationRequirements();
if (EventTrace.IsEnabled(EventTrace.Flags.performance, EventTrace.Level.verbose))
{
EventTrace.EventProvider.TraceEvent(
EventTrace.Level.verbose, EventTrace.GuidFromId(EventTraceGuidId.HOSTINGGUID), (byte)EventTrace.HostingEvent.AssertAppRequirementsEnd);
}
}
catch (Exception exception)
{
// Fatal error like NullReferenceException and SEHException should not be ignored.
if (exception is NullReferenceException || exception is SEHException)
{
throw;
}
else
{
string version = null;
if (exception is TrustNotGrantedException)
{
version = GetMissingCustomPermissionVersion(args.ApplicationManifest);
if (!string.IsNullOrEmpty(version))
{
exception = new DependentPlatformMissingException();
}
}
HandleError(exception, args.LogFilePath, args.SupportUri, version);
return null;
}
}
// AssertApplicationRequirements() does some message pumping internally, which allows
// the browser to start closing us in the meantime.
if (IsShuttingDown)
return null;
StartAsynchronousOperation();
SetStatusText(SR.Get(SRID.HostingStatusDownloadApp));
if (_progressPage != null)
{
_progressPage.ApplicationName = args.ProductName;
}
// Possible reentrancy! When making the outgoing calls to the browser to update its
// status (above), a pending incoming call can be dispatched. This may be OLECMDID_STOP,
// which would lead to calling UserStop(), which makes IPHM unusable.
if (!_isInAsynchronousOperation)
return null;
_hostingManager.DownloadProgressChanged += new EventHandler(DownloadProgressChanged);
_hostingManager.DownloadApplicationCompleted += new EventHandler(DownloadApplicationCompleted);
EventTrace.NormalTraceEvent(EventTraceGuidId.HOSTINGGUID, (byte)EventTrace.HostingEvent.DownloadApplicationStart);
_hostingManager.DownloadApplicationAsync();
return null;
}
///
/// Critical - calls InstallationProgressPage, which lives in a non-APTCA assembly.
/// _progressPage lives in a non-APTCA assembly.
/// TreatAsSafe - demands appropriate permissions.
///
[SecurityCritical, SecurityTreatAsSafe]
private void DoDownloadUI()
{
SecurityHelper.DemandUIWindowPermission();
// ASSUMES ALREADY IN CORRECT CONTEXT
if (_progressPageClass != null)
{
_progressPage = GetCustomPage(_progressPageAssembly, _progressPageClass) as IProgressPage;
}
// If we failed to get a custom page, or didn't even try, use our default.
if (_progressPage == null)
{
_progressPage = new InstallationProgressPage() as IProgressPage;
}
_progressPage.DeploymentPath = _deploymentManifest;
_progressPage.StopCallback = new DispatcherOperationCallback(UserStop);
_progressPage.RefreshCallback = new DispatcherOperationCallback(UserRefresh);
_progressPage.ApplicationName = string.Empty;
_progressPage.PublisherName = string.Empty;
_progressPage.UpdateProgress(0, 1);
BrowserWindow.ShowsNavigationUI = false; // not needed and not RightToLeft-enabled in this context
BrowserWindow.Navigate(_progressPage);
}
///
/// The demand below was put here because although PresentationFramework has
/// APTCA set, the assembly where _progressPage lives (PresentationUI) does not.
/// Critical: Because it is calling into non-aptca DLL
/// TAS: We demand permission
///
[SecurityCritical, SecurityTreatAsSafe]
private void HandleError(Exception exception, string logFilePath, Uri supportUri, string requiredWpfVersion)
{
SecurityHelper.DemandUIWindowPermission();
// Delete the cached trust decision to force going down the full ClickOnce path next time
DeleteCachedApplicationTrust(_identity);
// If we are being shut down by the browser, don't do anything else.
if (IsShuttingDown)
{
AbortActivation();
return;
}
// ASSUMES ALREADY IN CORRECT CONTEXT
SetStatusText(SR.Get(SRID.HostingStatusFailed));
string version = String.Empty;
MissingDependencyType getWinFXReq = MissingDependencyType.Others;
if (exception is DependentPlatformMissingException)
{
if (requiredWpfVersion != null)
{
getWinFXReq = MissingDependencyType.WinFX;
version = requiredWpfVersion;
DeploymentExceptionMapper.ConstructFwlinkUrl(version, out _fwlinkUri);
}
else
{
getWinFXReq = DeploymentExceptionMapper.GetWinFXRequirement(exception, _hostingManager, out version, out _fwlinkUri);
}
}
string errorTitle, errorMessage;
switch(getWinFXReq)
{
case MissingDependencyType.WinFX:
// Wrong version of Avalon is installed.
errorTitle = SR.Get(SRID.PlatformRequirementTitle);
errorMessage = SR.Get(SRID.IncompatibleWinFXText, version);
break;
case MissingDependencyType.CLR:
// Missing CLR dependency
errorTitle = SR.Get(SRID.PlatformRequirementTitle);
errorMessage = SR.Get(SRID.IncompatibleCLRText, version);
break;
default:
// All other deployment exceptions
DeploymentExceptionMapper.GetErrorTextFromException(exception, out errorTitle, out errorMessage);
break;
}
IErrorPage errorpage = null;
if (_errorPageClass != null)
{
errorpage = GetCustomPage(_errorPageAssembly, _errorPageClass) as IErrorPage;
}
// If we failed to get a custom page, or didn't even try, use our default.
if (errorpage == null)
{
//use default class
errorpage = new InstallationErrorPage() as IErrorPage;
}
errorpage.DeploymentPath = _deploymentManifest;
errorpage.ErrorTitle = errorTitle;
errorpage.ErrorText = errorMessage;
errorpage.SupportUri = supportUri;
errorpage.LogFilePath = logFilePath;
errorpage.RefreshCallback = new DispatcherOperationCallback(UserRefresh);
errorpage.GetWinFxCallback = (getWinFXReq != MissingDependencyType.Others)? new DispatcherOperationCallback(GetWinFX) : null;
errorpage.ErrorFlag = true;
BrowserWindow.Navigate(errorpage);
}
///
/// Critical - calls InstallationErrorPage, which lives in a non-APTCA assembly.
/// _progressPage lives in a non-APTCA assembly.
/// TreatAsSafe - demands appropriate permissions.
///
[SecurityCritical, SecurityTreatAsSafe]
private void HandleCancel()
{
SecurityHelper.DemandUIWindowPermission();
// Delete the cached trust decision to force going down the full ClickOnce path next time
DeleteCachedApplicationTrust(_identity);
// If we are being shut down by the browser, don't do anything else.
if (IsShuttingDown)
{
AbortActivation();
return;
}
CancelAsynchronousOperation();
// ASSUMES ALREADY IN CORRECT CONTEXT
SetStatusText(SR.Get(SRID.HostingStatusCancelled));
string errorTitle, errorMessage;
DeploymentExceptionMapper.GetErrorTextFromException(null, out errorTitle, out errorMessage);
IErrorPage errorpage = null;
//dont even try to use reflection if assembly name is null
//dont even try to use reflection if assembly name is null
if (_errorPageAssembly != null || _errorPageClass != null)
{
errorpage = GetCustomPage(_errorPageAssembly, _errorPageClass) as IErrorPage;
}
//if this is null then there is no custom page so fall back to default ui
if (errorpage == null)
{
//use default class
errorpage = new InstallationErrorPage() as IErrorPage;
}
errorpage.DeploymentPath = _deploymentManifest;
errorpage.ErrorTitle = errorTitle;
errorpage.ErrorText = errorMessage;
errorpage.SupportUri = null;
errorpage.LogFilePath = null;
errorpage.ErrorFlag = false;
errorpage.RefreshCallback = new DispatcherOperationCallback(UserRefresh);
errorpage.GetWinFxCallback = null;
BrowserWindow.Navigate(errorpage);
}
void DownloadProgressChanged(object sender, DownloadProgressChangedEventArgs e)
{
_bytesDownloaded = e.BytesDownloaded;
_bytesTotal = e.TotalBytesToDownload;
if (!_updatePending)
{
_updatePending = true;
Dispatcher.BeginInvoke(
DispatcherPriority.Background,
new DispatcherOperationCallback(DoDownloadProgressChanged),
null);
}
}
///
/// The demand below was put here because although PresentationFramework has
/// APTCA set, the assembly where _progressPage lives (PresentationUI) does not.
///
private object DoDownloadProgressChanged(object unused)
{
if (IsShuttingDown)
return null;
if (EventTrace.IsEnabled(EventTrace.Flags.performance, EventTrace.Level.verbose))
{
EventTrace.EventProvider.TraceEvent(EventTrace.Level.verbose,
EventTrace.GuidFromId(EventTraceGuidId.HOSTINGGUID), (byte)EventTrace.HostingEvent.DownloadProgressUpdate, _bytesDownloaded, _bytesTotal);
}
SecurityHelper.DemandUIWindowPermission();
if (_progressPage != null)
{
_progressPage.UpdateProgress(_bytesDownloaded, _bytesTotal);
}
_updatePending = false;
return null;
}
void DownloadApplicationCompleted(object sender, DownloadApplicationCompletedEventArgs e)
{
_hostingManager.DownloadProgressChanged -= new EventHandler(DownloadProgressChanged);
Dispatcher.Invoke(
DispatcherPriority.Send,
new DispatcherOperationCallback(DoDownloadApplicationCompleted),
e);
}
private object DoDownloadApplicationCompleted(object e)
{
EventTrace.NormalTraceEvent(EventTraceGuidId.HOSTINGGUID, (byte)EventTrace.HostingEvent.DownloadApplicationEnd);
DownloadApplicationCompletedEventArgs args = (DownloadApplicationCompletedEventArgs)e;
// Race condition: UserStop() can be called after InPlaceHostingManager has completed
// the downloading but before our callback is called.
bool canceled = !_isInAsynchronousOperation || args.Cancelled;
if (IsShuttingDown)
{
// some other thread has already called shutdown and released
// the BrowserCallBackService. Nothing we can do here
return null;
}
ClearAsynchronousOperationStatus();
if (args.Error != null)
{
HandleError(args.Error, args.LogFilePath, _supportUri, null);
return null;
}
if (canceled)
{
HandleCancel();
return null;
}
SetStatusText(string.Empty);
_applicationRunner = new DocObjHost.ApplicationRunner(ExecuteDownloadedApplication);
_attemptDownload = true;
Shutdown();
return null;
}
private void ExecuteDownloadedApplication()
{
if (EventTrace.IsEnabled(EventTrace.Flags.performance))
{
EventTrace.EventProvider.TraceEvent(EventTrace.GuidFromId(EventTraceGuidId.HOSTINGGUID), (byte)EventTrace.HostingEvent.ClickOnceActivationStart, KnownBoxes.BooleanBoxes.FalseBox);
}
ObjectHandle oh = _hostingManager.Execute();
if (PresentationAppDomainManager.SaveAppDomain)
{
AppDomain newDomain = oh.Unwrap() as AppDomain;
PresentationAppDomainManager.NewAppDomain = newDomain;
}
EventTrace.NormalTraceEvent(EventTraceGuidId.HOSTINGGUID, (byte)EventTrace.HostingEvent.ClickOnceActivationEnd);
}
private object UserStop(object unused)
{
if (MainWindow != null && MainWindow.Content is IProgressPage)
{
if (_isInAsynchronousOperation)
{
CancelAsynchronousOperation();
}
else
{
HandleCancel();
}
}
return null;
}
internal void AbortActivation()
{
EventTrace.NormalTraceEvent(EventTraceGuidId.HOSTINGGUID, (byte)EventTrace.HostingEvent.AbortingActivation);
CancelAsynchronousOperation();
_attemptDownload = false;
Shutdown(ERROR_ACTIVATION_ABORTED);
}
private void CancelAsynchronousOperation()
{
lock (_lockObject)
{
if (_isInAsynchronousOperation)
{
Invariant.Assert(_hostingManager != null, "_hostingManager should not be null if _isInAsynchronousOperation is true");
_hostingManager.CancelAsync();
ClearAsynchronousOperationStatus();
}
}
}
///
/// Critical: This code calls into RootBrowserWindow which is critical
/// TreatAsSafe: There is a demand
///
private RootBrowserWindow BrowserWindow
{
[SecurityCritical,SecurityTreatAsSafe]
get
{
SecurityHelper.DemandUIWindowPermission();
RootBrowserWindow rbw = (RootBrowserWindow)GetAppWindow();
Invariant.Assert(rbw != null, "Should have instantiated RBW if it wasn't already there");
return rbw;
}
}
private void CreateApplicationIdentity()
{
_identity = null;
if (_applicationId != null)
{
try
{
_identity = new ApplicationIdentity(_applicationId);
}
catch(Exception exception)
{
// Fatal error like NullReferenceException and SEHException should not be ignored.
if (exception is NullReferenceException || exception is SEHException)
{
throw;
}
// For a non-critical exception, it can be ignored here.
// Because the code tries to make an ApplicationIdentity from a string in registry,
// If it fails, it isn�t fatal, the code just needs to do activation from the deployment Uri.
}
}
}
///
/// This is necessary as a workaround for various ClickOnce issues and the interaction
/// between cached trust decisions and our direct activation shortcut. If there is a
/// cached trust decision for a given ApplicationIdentity, we will try the direct
/// activation shortcut. If something goes wrong, we want to delete that cached trust
/// decision, so that next time we will be forced to go down the offical ClickOnce
/// deployment pathway.
///
///
/// Critical: calls ApplicationTrustCollection.Remove which LinkDemands
///
[SecurityCritical]
private void DeleteCachedApplicationTrust(ApplicationIdentity identity)
{
if (identity != null)
{
ApplicationTrust trust = new ApplicationTrust(identity);
// This does not throw if the trust isn't there.
ApplicationSecurityManager.UserApplicationTrusts.Remove(trust);
}
}
///
/// This function is private to xapplauncher. It invokes the default browser with Uri
/// to WinFXSetup.exe. Its called from the "Install WinFX" button on the error page
/// shown when an app requests a different version of WinFX than the one installed.
///
///
/// Critical - Gets access to critical resource (uri and browsercallback services), calls critical
/// code (launch browser).
/// TreatAsSafe - There exists a demand here.
///
[SecurityCritical, SecurityTreatAsSafe]
private object GetWinFX(object unused)
{
SecurityHelper.DemandUnmanagedCode();
AppSecurityManager.ShellExecuteDefaultBrowser(_fwlinkUri);
return null;
}
///
/// Critical - calls SetStatusText which is SUC'ed.
/// TreatAsSafe - setting the status bar text of the browser considered safe.
/// IE/MSRC does not consider hostile setting of text ( even for hyperlink spoofing)
/// to be an exploit.
///
[SecurityCritical, SecurityTreatAsSafe]
private void SetStatusText(string newStatusText)
{
_browser.SetStatusText(newStatusText);
}
///
/// If trust was not granted, it may have been because the assembly of a custom permission
/// could not be loaded. In this case, we are interested in custom permissions that are
/// from WindowsBase.
///
/// The XmlReader for the application manifest
/// If the specified version of WindowsBase could not be loaded, the version, else null.
private string GetMissingCustomPermissionVersion(XmlReader reader)
{
string requiredVersion = null;
while (reader.ReadToFollowing("IPermission", "urn:schemas-microsoft-com:asm.v2"))
{
string attr = reader.GetAttribute("class");
// Strip the first item in the comma-delimited list, which is the permission class
AssemblyName assyName = new AssemblyName(attr.Substring(attr.IndexOf(",",StringComparison.OrdinalIgnoreCase) + 1));
if (assyName.Name.Equals("WindowsBase", StringComparison.OrdinalIgnoreCase))
{
try
{
Assembly assy = Assembly.Load(assyName);
}
catch (Exception e)
{
// This will give a FileLoadException under the debugger, but a FileNotFoundException otherwise
if (e is System.IO.FileNotFoundException || e is System.IO.FileLoadException)
{
requiredVersion = assyName.Version.ToString();
break;
}
else
{
throw;
}
}
}
}
reader.Close();
return requiredVersion;
}
InPlaceHostingManager _hostingManager;
IBrowserCallbackServices _browser;
ApplicationIdentity _identity;
Uri _deploymentManifest;
Uri _activationUri;
Uri _fwlinkUri;
Uri _supportUri;
string _applicationId;
ActivationContext _context;
DocObjHost.ApplicationRunnerCallback _applicationRunnerCallback;
DocObjHost.ApplicationRunner _applicationRunner;
IProgressPage _progressPage;
bool _attemptDownload;
bool _isInAsynchronousOperation;
const int ERROR_ACTIVATION_ABORTED = 30; // defined in host\inc\Definitions.hxx
object _lockObject = new object();
long _bytesDownloaded;
long _bytesTotal;
bool _updatePending;
string _progressPageAssembly = null;
string _progressPageClass = null;
string _errorPageAssembly = null;
string _errorPageClass = null;
bool _commandBindingsRegistered;
bool _refreshing;
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- CollectionType.cs
- LabelEditEvent.cs
- HttpRequestCacheValidator.cs
- Char.cs
- CharAnimationUsingKeyFrames.cs
- SqlFormatter.cs
- ImportDesigner.xaml.cs
- BoolExpressionVisitors.cs
- EditorOptionAttribute.cs
- Scanner.cs
- MetadataPropertyAttribute.cs
- HttpCapabilitiesBase.cs
- JsonFormatWriterGenerator.cs
- SqlMethodAttribute.cs
- ListViewInsertionMark.cs
- PolyQuadraticBezierSegment.cs
- SiteMapNode.cs
- RegisteredArrayDeclaration.cs
- BamlRecordHelper.cs
- ProjectionPlanCompiler.cs
- TextComposition.cs
- ClientSettingsSection.cs
- MultiPropertyDescriptorGridEntry.cs
- FilterEventArgs.cs
- CngUIPolicy.cs
- SQLDouble.cs
- OutputCacheProfileCollection.cs
- IndividualDeviceConfig.cs
- TaskResultSetter.cs
- DefaultTextStoreTextComposition.cs
- InteropEnvironment.cs
- ReadOnlyDataSource.cs
- StringSource.cs
- ViewLoader.cs
- BaseTemplateParser.cs
- CFStream.cs
- SecurityTokenProvider.cs
- RenderingBiasValidation.cs
- GcHandle.cs
- ToolStripRenderer.cs
- _ConnectionGroup.cs
- WebDisplayNameAttribute.cs
- WinCategoryAttribute.cs
- ScriptReferenceBase.cs
- DbMetaDataFactory.cs
- StylusEventArgs.cs
- XhtmlBasicControlAdapter.cs
- XmlElementCollection.cs
- webeventbuffer.cs
- XmlUrlEditor.cs
- DataBindingHandlerAttribute.cs
- AddingNewEventArgs.cs
- HtmlUtf8RawTextWriter.cs
- ComplexType.cs
- HttpCapabilitiesBase.cs
- SignedXml.cs
- LocalizabilityAttribute.cs
- CompositeDesignerAccessibleObject.cs
- typedescriptorpermissionattribute.cs
- TypeGeneratedEventArgs.cs
- SqlGenericUtil.cs
- DataListItemEventArgs.cs
- OutputCacheProfileCollection.cs
- File.cs
- WebPartsPersonalizationAuthorization.cs
- storepermission.cs
- FormDocumentDesigner.cs
- XamlTreeBuilder.cs
- JoinTreeNode.cs
- DataGridDesigner.cs
- XslTransform.cs
- TableTextElementCollectionInternal.cs
- invalidudtexception.cs
- ListViewDataItem.cs
- ObjectFullSpanRewriter.cs
- IgnoreSection.cs
- EntityClassGenerator.cs
- ToolStripItemRenderEventArgs.cs
- TextDataBindingHandler.cs
- ViewgenGatekeeper.cs
- XmlFormatExtensionAttribute.cs
- TypeGenericEnumerableViewSchema.cs
- AtlasWeb.Designer.cs
- DependencyPropertyDescriptor.cs
- EventTask.cs
- PassportIdentity.cs
- PartialTrustHelpers.cs
- BoolExpressionVisitors.cs
- ListViewInsertedEventArgs.cs
- SystemIPGlobalStatistics.cs
- DoubleCollectionConverter.cs
- DiscreteKeyFrames.cs
- EmptyStringExpandableObjectConverter.cs
- BitmapEffect.cs
- VSWCFServiceContractGenerator.cs
- InvalidCastException.cs
- AuditLogLocation.cs
- TreeNodeBindingCollection.cs
- ComplexObject.cs
- DownloadProgressEventArgs.cs