mcs/class/referencesource/mscorlib/system/appdomain.cs

   1 // ==++==
   2 //
   3 //   Copyright (c) Microsoft Corporation.  All rights reserved.
   4 //
   5 // ==--==
   6 /*=============================================================================
   7 **
   8 ** Class: AppDomain
   9 **
  10 ** <OWNER>[....]</OWNER>
  11 **
  12 **
  13 ** Purpose: Domains represent an application within the runtime. Objects can
  14 **          not be shared between domains and each domain can be configured
  15 **          independently.
  16 **
  17 **
  18 =============================================================================*/
  19
  20 namespace System {
  21     using System;
  22 #if FEATURE_CLICKONCE
  23     using System.Deployment.Internal.Isolation;
  24     using System.Deployment.Internal.Isolation.Manifest;
  25     using System.Runtime.Hosting;
  26 #endif
  27     using System.Reflection;
  28     using System.Runtime;
  29     using System.Runtime.CompilerServices;
  30 #if FEATURE_REMOTING
  31     using System.Runtime.Remoting.Channels;
  32     using System.Runtime.Remoting.Contexts;
  33 #endif
  34     using System.Security;
  35     using System.Security.Permissions;
  36     using System.Security.Principal;
  37     using System.Security.Policy;
  38     using System.Security.Util;
  39     using System.Collections;
  40     using System.Collections.Generic;
  41     using System.Threading;
  42     using System.Runtime.InteropServices;
  43     using System.Runtime.Remoting;
  44 #if FEATURE_REMOTING
  45     using Context = System.Runtime.Remoting.Contexts.Context;
  46 #endif
  47     using System.Reflection.Emit;
  48     using CultureInfo = System.Globalization.CultureInfo;
  49 #if !FEATURE_CORECLR
  50     using System.Globalization;
  51 #endif
  52     using System.IO;
  53     using AssemblyHashAlgorithm = System.Configuration.Assemblies.AssemblyHashAlgorithm;
  54     using System.Text;
  55     using Microsoft.Win32;
  56     using System.Runtime.ConstrainedExecution;
  57     using System.Runtime.Versioning;
  58     using System.Diagnostics.Contracts;
  59 #if FEATURE_EXCEPTION_NOTIFICATIONS
  60     using System.Runtime.ExceptionServices;
  61 #endif // FEATURE_EXCEPTION_NOTIFICATIONS
  62
  63     [ComVisible(true)]
  64     public class ResolveEventArgs : EventArgs
  65     {
  66         private String _Name;
  67         private Assembly _RequestingAssembly;
  68
  69         public String Name {
  70             get {
  71                 return _Name;
  72             }
  73         }
  74
  75         public Assembly RequestingAssembly
  76         {
  77             get
  78             {
  79                 return _RequestingAssembly;
  80             }
  81         }
  82
  83         public ResolveEventArgs(String name)
  84         {
  85             _Name = name;
  86         }
  87
  88         public ResolveEventArgs(String name, Assembly requestingAssembly)
  89         {
  90             _Name = name;
  91             _RequestingAssembly = requestingAssembly;
  92         }
  93     }
  94
  95     [ComVisible(true)]
  96     public class AssemblyLoadEventArgs : EventArgs
  97     {
  98         private Assembly _LoadedAssembly;
  99
 100         public Assembly LoadedAssembly {
 101             get {
 102                 return _LoadedAssembly;
 103             }
 104         }
 105
 106         public AssemblyLoadEventArgs(Assembly loadedAssembly)
 107         {
 108             _LoadedAssembly = loadedAssembly;
 109         }
 110     }
 111
 112
 113     #if FEATURE_CORECLR
 114     [System.Security.SecurityCritical] // auto-generated
 115     #endif
 116     [Serializable]
 117     [ComVisible(true)]
 118     public delegate Assembly ResolveEventHandler(Object sender, ResolveEventArgs args);
 119
 120     [Serializable]
 121     [ComVisible(true)]
 122     public delegate void AssemblyLoadEventHandler(Object sender, AssemblyLoadEventArgs args);
 123
 124     [Serializable]
 125     [ComVisible(true)]
 126     public delegate void AppDomainInitializer(string[] args);
 127
 128     internal class AppDomainInitializerInfo
 129     {
 130         internal class ItemInfo
 131         {
 132             public string TargetTypeAssembly;
 133             public string TargetTypeName;
 134             public string MethodName;
 135         }
 136
 137         internal ItemInfo[] Info;
 138
 139         internal AppDomainInitializerInfo(AppDomainInitializer init)
 140         {
 141             Info=null;
 142             if (init==null)
 143                 return;
 144             List<ItemInfo> itemInfo = new List<ItemInfo>();
 145             List<AppDomainInitializer> nestedDelegates = new List<AppDomainInitializer>();
 146             nestedDelegates.Add(init);
 147             int idx=0;
 148
 149             while (nestedDelegates.Count>idx)
 150             {
 151                 AppDomainInitializer curr = nestedDelegates[idx++];
 152                 Delegate[] list= curr.GetInvocationList();
 153                 for (int i=0;i<list.Length;i++)
 154                 {
 155                     if (!list[i].Method.IsStatic)
 156                     {
 157                         if(list[i].Target==null)
 158                             continue;
 159
 160                         AppDomainInitializer nested = list[i].Target as AppDomainInitializer;
 161                         if (nested!=null)
 162                             nestedDelegates.Add(nested);
 163                         else
 164                             throw new ArgumentException(Environment.GetResourceString("Arg_MustBeStatic"),
 165                                list[i].Method.ReflectedType.FullName+"::"+list[i].Method.Name);
 166                     }
 167                     else
 168                     {
 169                         ItemInfo info=new ItemInfo();
 170                         info.TargetTypeAssembly=list[i].Method.ReflectedType.Module.Assembly.FullName;
 171                         info.TargetTypeName=list[i].Method.ReflectedType.FullName;
 172                         info.MethodName=list[i].Method.Name;
 173                         itemInfo.Add(info);
 174                     }
 175
 176                 }
 177             }
 178
 179             Info = itemInfo.ToArray();
 180         }
 181
 182         [System.Security.SecuritySafeCritical]  // auto-generated
 183         internal AppDomainInitializer Unwrap()
 184         {
 185             if (Info==null)
 186                 return null;
 187             AppDomainInitializer retVal=null;
 188             new ReflectionPermission(ReflectionPermissionFlag.MemberAccess).Assert();
 189             for (int i=0;i<Info.Length;i++)
 190             {
 191                 Assembly assembly=Assembly.Load(Info[i].TargetTypeAssembly);
 192                 AppDomainInitializer newVal=(AppDomainInitializer)Delegate.CreateDelegate(typeof(AppDomainInitializer),
 193                         assembly.GetType(Info[i].TargetTypeName),
 194                         Info[i].MethodName);
 195                 if(retVal==null)
 196                     retVal=newVal;
 197                 else
 198                     retVal+=newVal;
 199             }
 200             return retVal;
 201         }
 202     }
 203
 204
 205     [ClassInterface(ClassInterfaceType.None)]
 206     [ComDefaultInterface(typeof(System._AppDomain))]
 207     [ComVisible(true)]
 208     public sealed class AppDomain :
 209 #if FEATURE_REMOTING
 210         MarshalByRefObject,
 211 #endif
 212         _AppDomain, IEvidenceFactory
 213     {
 214         // Domain security information
 215         // These fields initialized from the other side only. (NOTE: order
 216         // of these fields cannot be changed without changing the layout in
 217         // the EE)
 218
 219         [System.Security.SecurityCritical] // auto-generated
 220         private AppDomainManager _domainManager;
 221         private Dictionary<String, Object[]> _LocalStore;
 222         private AppDomainSetup   _FusionStore;
 223         private Evidence         _SecurityIdentity;
 224 #pragma warning disable 169
 225         private Object[]         _Policies; // Called from the VM.
 226 #pragma warning restore 169
 227         [method: System.Security.SecurityCritical]
 228         public event AssemblyLoadEventHandler AssemblyLoad;
 229
 230         [System.Security.SecurityCritical]
 231         private ResolveEventHandler _TypeResolve;
 232
 233         public event ResolveEventHandler TypeResolve
 234         {
 235             [System.Security.SecurityCritical]
 236             add
 237             {
 238                 lock (this)
 239                 {
 240                     _TypeResolve += value;
 241                 }
 242             }
 243
 244             [System.Security.SecurityCritical]
 245             remove
 246             {
 247                 lock (this)
 248                 {
 249                     _TypeResolve -= value;
 250                 }
 251             }
 252         }
 253
 254         [System.Security.SecurityCritical]
 255         private ResolveEventHandler _ResourceResolve;
 256
 257         public event ResolveEventHandler ResourceResolve
 258         {
 259             [System.Security.SecurityCritical]
 260             add
 261             {
 262                 lock (this)
 263                 {
 264                     _ResourceResolve += value;
 265                 }
 266             }
 267
 268             [System.Security.SecurityCritical]
 269             remove
 270             {
 271                 lock (this)
 272                 {
 273                     _ResourceResolve -= value;
 274                 }
 275             }
 276         }
 277
 278         [System.Security.SecurityCritical]
 279         private ResolveEventHandler _AssemblyResolve;
 280
 281         public event ResolveEventHandler AssemblyResolve
 282         {
 283             [System.Security.SecurityCritical]
 284             add
 285             {
 286                 lock (this)
 287                 {
 288                     _AssemblyResolve += value;
 289                 }
 290             }
 291
 292             [System.Security.SecurityCritical]
 293             remove
 294             {
 295                 lock (this)
 296                 {
 297                     _AssemblyResolve -= value;
 298                 }
 299             }
 300         }
 301
 302 #if FEATURE_REFLECTION_ONLY_LOAD
 303         [method: System.Security.SecurityCritical]
 304         public event ResolveEventHandler ReflectionOnlyAssemblyResolve;
 305 #endif // FEATURE_REFLECTION_ONLY
 306
 307 #if FEATURE_REMOTING
 308         private Context          _DefaultContext;
 309 #endif
 310
 311 #if !FEATURE_PAL
 312 #if FEATURE_CLICKONCE
 313         private ActivationContext _activationContext;
 314         private ApplicationIdentity _applicationIdentity;
 315 #endif
 316 #endif // !FEATURE_PAL
 317         private ApplicationTrust _applicationTrust;
 318
 319 #if FEATURE_IMPERSONATION
 320         private IPrincipal       _DefaultPrincipal;
 321 #endif // FEATURE_IMPERSONATION
 322 #if FEATURE_REMOTING
 323         private DomainSpecificRemotingData _RemotingData;
 324 #endif
 325         private EventHandler     _processExit;
 326
 327         #if FEATURE_CORECLR
 328         [System.Security.SecurityCritical]
 329         #endif
 330         private EventHandler     _domainUnload;
 331
 332         #if FEATURE_CORECLR
 333         [System.Security.SecurityCritical] // auto-generated
 334         #endif
 335         private UnhandledExceptionEventHandler _unhandledException;
 336
 337 #if FEATURE_APTCA
 338         private String[]         _aptcaVisibleAssemblies;
 339 #endif
 340
 341         // The compat flags are set at domain creation time to indicate that the given breaking
 342         // changes (named in the strings) should not be used in this domain. We only use the
 343         // keys, the vhe values are ignored.
 344         private Dictionary<String, object>  _compatFlags;
 345
 346 #if FEATURE_EXCEPTION_NOTIFICATIONS
 347         // Delegate that will hold references to FirstChance exception notifications
 348         private EventHandler<FirstChanceExceptionEventArgs> _firstChanceException;
 349 #endif // FEATURE_EXCEPTION_NOTIFICATIONS
 350
 351         private IntPtr           _pDomain;                      // this is an unmanaged pointer (AppDomain * m_pDomain)` used from the VM.
 352
 353 #if FEATURE_CAS_POLICY
 354         private PrincipalPolicy  _PrincipalPolicy;              // this is an enum
 355 #endif
 356         private bool             _HasSetPolicy;
 357         private bool             _IsFastFullTrustDomain;        // quick check to see if the AppDomain is fully trusted and homogenous
 358         private bool             _compatFlagsInitialized;
 359
 360         internal const String TargetFrameworkNameAppCompatSetting = "TargetFrameworkName";
 361
 362 #if FEATURE_APPX
 363         private static APPX_FLAGS s_flags;
 364
 365         //
 366         // Keep in async with vm\appdomainnative.cpp
 367         //
 368         [Flags]
 369         private enum APPX_FLAGS
 370         {
 371             APPX_FLAGS_INITIALIZED =        0x01,
 372
 373             APPX_FLAGS_APPX_MODEL =         0x02,
 374             APPX_FLAGS_APPX_DESIGN_MODE =   0x04,
 375             APPX_FLAGS_APPX_NGEN =          0x08,
 376             APPX_FLAGS_APPX_MASK =          APPX_FLAGS_APPX_MODEL |
 377                                             APPX_FLAGS_APPX_DESIGN_MODE |
 378                                             APPX_FLAGS_APPX_NGEN,
 379
 380             APPX_FLAGS_API_CHECK =          0x10,
 381         }
 382
 383         private static APPX_FLAGS Flags
 384         {
 385             [SecuritySafeCritical]
 386             get
 387             {
 388                 if (s_flags == 0)
 389                     s_flags = nGetAppXFlags();
 390
 391                 Contract.Assert(s_flags != 0);
 392                 return s_flags;
 393             }
 394         }
 395
 396         internal static bool ProfileAPICheck
 397         {
 398             [SecuritySafeCritical]
 399             get
 400             {
 401                 return (Flags & APPX_FLAGS.APPX_FLAGS_API_CHECK) != 0;
 402             }
 403         }
 404
 405         internal static bool IsAppXNGen
 406         {
 407             [SecuritySafeCritical]
 408             get
 409             {
 410                 return (Flags & APPX_FLAGS.APPX_FLAGS_APPX_NGEN) != 0;
 411             }
 412         }
 413 #endif // FEATURE_APPX
 414
 415         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
 416         [SecurityCritical]
 417         [ResourceExposure(ResourceScope.None)]
 418         [SuppressUnmanagedCodeSecurity]
 419         [return: MarshalAs(UnmanagedType.Bool)]
 420         private static extern bool DisableFusionUpdatesFromADManager(AppDomainHandle domain);
 421
 422 #if FEATURE_APPX
 423         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
 424         [SecurityCritical]
 425         [ResourceExposure(ResourceScope.None)]
 426         [SuppressUnmanagedCodeSecurity]
 427         [return: MarshalAs(UnmanagedType.I4)]
 428         private static extern APPX_FLAGS nGetAppXFlags();
 429 #endif
 430
 431         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
 432         [SecurityCritical]
 433         [ResourceExposure(ResourceScope.None)]
 434         [SuppressUnmanagedCodeSecurity]
 435         private static extern void GetAppDomainManagerType(AppDomainHandle domain,
 436                                                            StringHandleOnStack retAssembly,
 437                                                            StringHandleOnStack retType);
 438
 439         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
 440         [SecurityCritical]
 441         [ResourceExposure(ResourceScope.None)]
 442         [SuppressUnmanagedCodeSecurity]
 443         private static extern void SetAppDomainManagerType(AppDomainHandle domain,
 444                                                            string assembly,
 445                                                            string type);
 446
 447         [System.Security.SecurityCritical]  // auto-generated
 448         [ResourceExposure(ResourceScope.None)]
 449         [MethodImplAttribute(MethodImplOptions.InternalCall)]
 450         private static extern void nSetHostSecurityManagerFlags (HostSecurityManagerOptions flags);
 451
 452         [SecurityCritical]
 453         [SuppressUnmanagedCodeSecurity]
 454         [ResourceExposure(ResourceScope.None)]
 455         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
 456         private static extern void SetSecurityHomogeneousFlag(AppDomainHandle domain,
 457                                                               [MarshalAs(UnmanagedType.Bool)] bool runtimeSuppliedHomogenousGrantSet);
 458
 459 #if FEATURE_CAS_POLICY
 460         [SecurityCritical]
 461         [SuppressUnmanagedCodeSecurity]
 462         [ResourceExposure(ResourceScope.None)]
 463         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
 464         private static extern void SetLegacyCasPolicyEnabled(AppDomainHandle domain);
 465
 466         [SecurityCritical]
 467         private void SetLegacyCasPolicyEnabled()
 468         {
 469             SetLegacyCasPolicyEnabled(GetNativeHandle());
 470         }
 471 #endif // FEATURE_CAS_POLICY
 472
 473         /// <summary>
 474         ///     Get a handle used to make a call into the VM pointing to this domain
 475         /// </summary>
 476         internal AppDomainHandle GetNativeHandle()
 477         {
 478             // This should never happen under normal circumstances. However, there ar ways to create an
 479             // uninitialized object through remoting, etc.
 480             if (_pDomain.IsNull())
 481             {
 482                 throw new InvalidOperationException(Environment.GetResourceString("Argument_InvalidHandle"));
 483             }
 484
 485 #if FEATURE_REMOTING
 486             BCLDebug.Assert(!RemotingServices.IsTransparentProxy(this), "QCalls should be made with the real AppDomain object rather than a transparent proxy");
 487 #endif // FEATURE_REMOTING
 488             return new AppDomainHandle(_pDomain);
 489         }
 490
 491         /// <summary>
 492         ///     If this AppDomain is configured to have an AppDomain manager then create the instance of it.
 493         ///     This method is also called from the VM to create the domain manager in the default domain.
 494         /// </summary>
 495         [SecuritySafeCritical]
 496         private void CreateAppDomainManager()
 497         {
 498             Contract.Assert(_domainManager == null, "_domainManager == null");
 499
 500             AppDomainSetup adSetup = FusionStore;
 501 #if FEATURE_VERSIONING
 502             String trustedPlatformAssemblies = (String)(GetData("TRUSTED_PLATFORM_ASSEMBLIES"));
 503             if (trustedPlatformAssemblies != null)
 504             {
 505                 String platformResourceRoots = (String)(GetData("PLATFORM_RESOURCE_ROOTS"));
 506                 if (platformResourceRoots == null)
 507                 {
 508                     platformResourceRoots = String.Empty;
 509                 }
 510
 511                 String appPaths = (String)(GetData("APP_PATHS"));
 512                 if (appPaths == null)
 513                 {
 514                     appPaths = String.Empty;
 515                 }
 516
 517                 String appNiPaths = (String)(GetData("APP_NI_PATHS"));
 518                 if (appNiPaths == null)
 519                 {
 520                     appNiPaths = String.Empty;
 521                 }
 522
 523                 String appLocalWinMD = (String)(GetData("APP_LOCAL_WINMETADATA"));
 524                 if (appLocalWinMD == null)
 525                 {
 526                     appLocalWinMD = String.Empty;
 527                 }
 528                 SetupBindingPaths(trustedPlatformAssemblies, platformResourceRoots, appPaths, appNiPaths, appLocalWinMD);
 529             }
 530 #endif // FEATURE_VERSIONING
 531
 532             string domainManagerAssembly;
 533             string domainManagerType;
 534             GetAppDomainManagerType(out domainManagerAssembly, out domainManagerType);
 535
 536             if (domainManagerAssembly != null && domainManagerType != null)
 537             {
 538                 try
 539                 {
 540                     new PermissionSet(PermissionState.Unrestricted).Assert();
 541                     _domainManager = CreateInstanceAndUnwrap(domainManagerAssembly, domainManagerType) as AppDomainManager;
 542                     CodeAccessPermission.RevertAssert();
 543                 }
 544                 catch (FileNotFoundException e)
 545                 {
 546                     throw new TypeLoadException(Environment.GetResourceString("Argument_NoDomainManager"), e);
 547                 }
 548                 catch (SecurityException e)
 549                 {
 550                     throw new TypeLoadException(Environment.GetResourceString("Argument_NoDomainManager"), e);
 551                 }
 552                 catch (TypeLoadException e)
 553                 {
 554                     throw new TypeLoadException(Environment.GetResourceString("Argument_NoDomainManager"), e);
 555                 }
 556
 557                 if (_domainManager == null)
 558                 {
 559                     throw new TypeLoadException(Environment.GetResourceString("Argument_NoDomainManager"));
 560                 }
 561
 562                 // If this domain was not created by a managed call to CreateDomain, then the AppDomainSetup
 563                 // will not have the correct values for the AppDomainManager set.
 564                 FusionStore.AppDomainManagerAssembly = domainManagerAssembly;
 565                 FusionStore.AppDomainManagerType = domainManagerType;
 566
 567                 bool notifyFusion = _domainManager.GetType() != typeof(System.AppDomainManager) && !DisableFusionUpdatesFromADManager();
 568
 569
 570
 571                 AppDomainSetup FusionStoreOld = null;
 572                 if (notifyFusion)
 573                     FusionStoreOld = new AppDomainSetup(FusionStore, true);
 574
 575                 // Initialize the AppDomainMAnager and register the instance with the native host if requested
 576                 _domainManager.InitializeNewDomain(FusionStore);
 577
 578                 if (notifyFusion)
 579                     SetupFusionStore(_FusionStore, FusionStoreOld); // Notify Fusion about the changes the user implementation of InitializeNewDomain may have made to the FusionStore object.
 580
 581 #if FEATURE_APPDOMAINMANAGER_INITOPTIONS
 582                 AppDomainManagerInitializationOptions flags = _domainManager.InitializationFlags;
 583                 if ((flags & AppDomainManagerInitializationOptions.RegisterWithHost) == AppDomainManagerInitializationOptions.RegisterWithHost)
 584                 {
 585                     _domainManager.RegisterWithHost();
 586                 }
 587 #endif // FEATURE_APPDOMAINMANAGER_INITOPTIONS
 588             }
 589
 590             InitializeCompatibilityFlags();
 591         }
 592
 593         /// <summary>
 594         ///     Initialize the compatibility flags to non-NULL values.
 595         ///     This method is also called from the VM when the default domain dosen't have a domain manager.
 596         /// </summary>
 597         private void InitializeCompatibilityFlags()
 598         {
 599             AppDomainSetup adSetup = FusionStore;
 600
 601             // set up shim flags regardless of whether we create a DomainManager in this method.
 602             if (adSetup.GetCompatibilityFlags() != null)
 603             {
 604                 _compatFlags = new Dictionary<String, object>(adSetup.GetCompatibilityFlags(), StringComparer.OrdinalIgnoreCase);
 605             }
 606
 607             // for perf, we don't intialize the _compatFlags dictionary when we don't need to.  However, we do need to make a
 608             // note that we've run this method, because IsCompatibilityFlagsSet needs to return different values for the
 609             // case where the compat flags have been setup.
 610             Contract.Assert(!_compatFlagsInitialized);
 611             _compatFlagsInitialized = true;
 612
 613             CompatibilitySwitches.InitializeSwitches();
 614         }
 615
 616         // Retrieves a possibly-cached target framework name for this appdomain.  This could be set
 617         // either by a host in native, a host in managed using an AppDomainSetup, or by the
 618         // TargetFrameworkAttribute on the executable (VS emits its target framework moniker using this
 619         // attribute starting in version 4).
 620         [SecuritySafeCritical]
 621         internal String GetTargetFrameworkName()
 622         {
 623             String targetFrameworkName = _FusionStore.TargetFrameworkName;
 624
 625             if (targetFrameworkName == null && IsDefaultAppDomain() && !_FusionStore.CheckedForTargetFrameworkName)
 626             {
 627                 // This should only be run in the default appdomain.  All other appdomains should have
 628                 // values copied from the default appdomain and/or specified by the host.
 629                 Assembly assembly = Assembly.GetEntryAssembly();
 630                 if (assembly != null)
 631                 {
 632                     TargetFrameworkAttribute[] attrs = (TargetFrameworkAttribute[])assembly.GetCustomAttributes(typeof(TargetFrameworkAttribute));
 633                     if (attrs != null && attrs.Length > 0)
 634                     {
 635                         Contract.Assert(attrs.Length == 1);
 636                         targetFrameworkName = attrs[0].FrameworkName;
 637                         _FusionStore.TargetFrameworkName = targetFrameworkName;
 638                     }
 639                 }
 640                 _FusionStore.CheckedForTargetFrameworkName = true;
 641             }
 642
 643             return targetFrameworkName;
 644         }
 645
 646         /// <summary>
 647         ///     Returns the setting of the corresponding compatibility config switch (see CreateAppDomainManager for the impact).
 648         /// </summary>
 649         [SecuritySafeCritical]
 650         internal bool DisableFusionUpdatesFromADManager()
 651         {
 652             return DisableFusionUpdatesFromADManager(GetNativeHandle());
 653         }
 654
 655         /// <summary>
 656         ///     Returns whether the current AppDomain follows the AppX rules.
 657         /// </summary>
 658         [SecuritySafeCritical]
 659         [Pure]
 660         internal static bool IsAppXModel()
 661         {
 662 #if FEATURE_APPX
 663             return (Flags & APPX_FLAGS.APPX_FLAGS_APPX_MODEL) != 0;
 664 #else
 665             return false;
 666 #endif
 667         }
 668
 669         /// <summary>
 670         ///     Returns the setting of the AppXDevMode config switch.
 671         /// </summary>
 672         [SecuritySafeCritical]
 673         [Pure]
 674         internal static bool IsAppXDesignMode()
 675         {
 676 #if FEATURE_APPX
 677             return (Flags & APPX_FLAGS.APPX_FLAGS_APPX_MASK) == (APPX_FLAGS.APPX_FLAGS_APPX_MODEL | APPX_FLAGS.APPX_FLAGS_APPX_DESIGN_MODE);
 678 #else
 679             return false;
 680 #endif
 681         }
 682
 683         /// <summary>
 684         ///     Checks (and throws on failure) if the domain supports Assembly.LoadFrom.
 685         /// </summary>
 686         [SecuritySafeCritical]
 687         [Pure]
 688         internal static void CheckLoadFromSupported()
 689         {
 690 #if FEATURE_APPX
 691             if (IsAppXModel())
 692                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_AppX", "Assembly.LoadFrom"));
 693 #endif
 694         }
 695
 696         /// <summary>
 697         ///     Checks (and throws on failure) if the domain supports Assembly.LoadFile.
 698         /// </summary>
 699         [SecuritySafeCritical]
 700         [Pure]
 701         internal static void CheckLoadFileSupported()
 702         {
 703 #if FEATURE_APPX
 704             if (IsAppXModel())
 705                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_AppX", "Assembly.LoadFile"));
 706 #endif
 707         }
 708
 709         /// <summary>
 710         ///     Checks (and throws on failure) if the domain supports Assembly.ReflectionOnlyLoad.
 711         /// </summary>
 712         [SecuritySafeCritical]
 713         [Pure]
 714         internal static void CheckReflectionOnlyLoadSupported()
 715         {
 716 #if FEATURE_APPX
 717             if (IsAppXModel())
 718                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_AppX", "Assembly.ReflectionOnlyLoad"));
 719 #endif
 720         }
 721
 722         /// <summary>
 723         ///     Checks (and throws on failure) if the domain supports Assembly.LoadWithPartialName.
 724         /// </summary>
 725         [SecuritySafeCritical]
 726         [Pure]
 727         internal static void CheckLoadWithPartialNameSupported(StackCrawlMark stackMark)
 728         {
 729 #if FEATURE_APPX
 730             if (IsAppXModel())
 731             {
 732                 RuntimeAssembly callingAssembly = RuntimeAssembly.GetExecutingAssembly(ref stackMark);
 733                 bool callerIsFxAssembly = callingAssembly != null && callingAssembly.IsFrameworkAssembly();
 734                 if (!callerIsFxAssembly)
 735                 {
 736                     throw new NotSupportedException(Environment.GetResourceString("NotSupported_AppX", "Assembly.LoadWithPartialName"));
 737                 }
 738             }
 739 #endif
 740         }
 741
 742         /// <summary>
 743         ///     Checks (and throws on failure) if the domain supports DefinePInvokeMethod.
 744         /// </summary>
 745         [SecuritySafeCritical]
 746         [Pure]
 747         internal static void CheckDefinePInvokeSupported()
 748         {
 749             // We don't want users to use DefinePInvokeMethod in RefEmit to bypass app store validation on allowed native libraries.
 750 #if FEATURE_APPX
 751             if (IsAppXModel())
 752                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_AppX", "DefinePInvokeMethod"));
 753 #endif
 754         }
 755
 756         /// <summary>
 757         ///     Checks (and throws on failure) if the domain supports Assembly.Load(byte[] ...).
 758         /// </summary>
 759         [SecuritySafeCritical]
 760         [Pure]
 761         internal static void CheckLoadByteArraySupported()
 762         {
 763 #if FEATURE_APPX
 764             if (IsAppXModel())
 765                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_AppX", "Assembly.Load(byte[], ...)"));
 766 #endif
 767         }
 768
 769         /// <summary>
 770         ///     Checks (and throws on failure) if the domain supports AppDomain.CreateDomain.
 771         /// </summary>
 772         [SecuritySafeCritical]
 773         [Pure]
 774         internal static void CheckCreateDomainSupported()
 775         {
 776 #if FEATURE_APPX
 777             // Can create a new domain in an AppX process only when DevMode is enabled and
 778             // AssemblyLoadingCompat is not enabled (since there is no multi-domain support
 779             // for LoadFrom and LoadFile in AppX.
 780             if(IsAppXModel())
 781             {
 782                 if (!IsAppXDesignMode())
 783                 {
 784                     throw new NotSupportedException(Environment.GetResourceString("NotSupported_AppX", "AppDomain.CreateDomain"));
 785                 }
 786             }
 787 #endif
 788         }
 789
 790         /// <summary>
 791         ///     Get the name of the assembly and type that act as the AppDomainManager for this domain
 792         /// </summary>
 793         [SecuritySafeCritical]
 794         internal void GetAppDomainManagerType(out string assembly, out string type)
 795         {
 796             // We can't just use our parameters because we need to ensure that the strings used for hte QCall
 797             // are on the stack.
 798             string localAssembly = null;
 799             string localType = null;
 800
 801             GetAppDomainManagerType(GetNativeHandle(),
 802                                     JitHelpers.GetStringHandleOnStack(ref localAssembly),
 803                                     JitHelpers.GetStringHandleOnStack(ref localType));
 804
 805             assembly = localAssembly;
 806             type = localType;
 807         }
 808
 809         /// <summary>
 810         ///     Set the assembly and type which act as the AppDomainManager for this domain
 811         /// </summary>
 812         [SecuritySafeCritical]
 813         private void SetAppDomainManagerType(string assembly, string type)
 814         {
 815             Contract.Assert(assembly != null, "assembly != null");
 816             Contract.Assert(type != null, "type != null");
 817             SetAppDomainManagerType(GetNativeHandle(), assembly, type);
 818         }
 819
 820 #if FEATURE_APTCA
 821         internal String[] PartialTrustVisibleAssemblies
 822         {
 823             get { return _aptcaVisibleAssemblies; }
 824
 825             [SecuritySafeCritical]
 826             set
 827             {
 828                 _aptcaVisibleAssemblies = value;
 829
 830                 // Build up the canonical representaiton of this list to allow the VM to do optimizations in
 831                 // common cases
 832                 string canonicalConditionalAptcaList = null;
 833                 if (value != null)
 834                 {
 835                     StringBuilder conditionalAptcaListBuilder = StringBuilderCache.Acquire();
 836                     for (int i = 0; i < value.Length; ++i)
 837                     {
 838                         if (value[i] != null)
 839                         {
 840                             conditionalAptcaListBuilder.Append(value[i].ToUpperInvariant());
 841                             if (i != value.Length - 1)
 842                             {
 843                                 conditionalAptcaListBuilder.Append(';');
 844                             }
 845                         }
 846                     }
 847
 848                     canonicalConditionalAptcaList = StringBuilderCache.GetStringAndRelease(conditionalAptcaListBuilder);
 849                 }
 850
 851                 SetCanonicalConditionalAptcaList(canonicalConditionalAptcaList);
 852             }
 853         }
 854
 855         [SecurityCritical]
 856         [ResourceExposure(ResourceScope.None)]
 857         [SuppressUnmanagedCodeSecurity]
 858         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
 859         private static extern void SetCanonicalConditionalAptcaList(AppDomainHandle appDomain, string canonicalList);
 860
 861         [SecurityCritical]
 862         private void SetCanonicalConditionalAptcaList(string canonicalList)
 863         {
 864             SetCanonicalConditionalAptcaList(GetNativeHandle(), canonicalList);
 865         }
 866 #endif // FEATURE_APTCA
 867
 868 #if FEATURE_CLICKONCE
 869         /// <summary>
 870         ///    If the CLR is being started up to run a ClickOnce applicaiton, setup the default AppDomain
 871         ///    with information about that application.
 872         /// </summary>
 873         private void SetupDefaultClickOnceDomain(string fullName, string[] manifestPaths, string[] activationData)
 874         {
 875             Contract.Requires(fullName != null, "fullName != null");
 876             FusionStore.ActivationArguments = new ActivationArguments(fullName, manifestPaths, activationData);
 877         }
 878 #endif // FEATURE_CLICKONCE
 879
 880         /// <summary>
 881         ///     Called for every AppDomain (including the default domain) to initialize the security of the AppDomain)
 882         /// </summary>
 883         [SecurityCritical]
 884         private void InitializeDomainSecurity(Evidence providedSecurityInfo,
 885                                               Evidence creatorsSecurityInfo,
 886                                               bool generateDefaultEvidence,
 887                                               IntPtr parentSecurityDescriptor,
 888                                               bool publishAppDomain)
 889         {
 890             AppDomainSetup adSetup = FusionStore;
 891
 892 #if FEATURE_CAS_POLICY
 893             // If the AppDomain is setup to use legacy CAS policy, then set that bit in the application
 894             // security descriptor.
 895             if (CompatibilitySwitches.IsNetFx40LegacySecurityPolicy)
 896             {
 897                 SetLegacyCasPolicyEnabled();
 898             }
 899 #endif // FEATURE_CAS_POLICY
 900
 901 #if FEATURE_CLICKONCE
 902
 903             // Check if the domain manager set an ActivationContext (Debug-In-Zone for example)
 904             // or if this is an AppDomain with an ApplicationTrust.
 905             if (adSetup.ActivationArguments != null) {
 906                 // Merge the new evidence with the manifest's evidence if applicable
 907                 ActivationContext activationContext = null;
 908                 ApplicationIdentity appIdentity = null;
 909                 string[] activationData = null;
 910                 CmsUtils.CreateActivationContext(adSetup.ActivationArguments.ApplicationFullName,
 911                                                  adSetup.ActivationArguments.ApplicationManifestPaths,
 912                                                  adSetup.ActivationArguments.UseFusionActivationContext,
 913                                                  out appIdentity, out activationContext);
 914                 activationData = adSetup.ActivationArguments.ActivationData;
 915                 providedSecurityInfo = CmsUtils.MergeApplicationEvidence(providedSecurityInfo,
 916                                                                          appIdentity,
 917                                                                          activationContext,
 918                                                                          activationData,
 919                                                                          adSetup.ApplicationTrust);
 920                 SetupApplicationHelper(providedSecurityInfo, creatorsSecurityInfo, appIdentity, activationContext, activationData);
 921             }
 922             else
 923 #endif // FEATURE_CLICKONCE
 924             {
 925                 bool runtimeSuppliedHomogenousGrant = false;
 926                 ApplicationTrust appTrust = adSetup.ApplicationTrust;
 927
 928 #if FEATURE_CAS_POLICY
 929                 // In non-legacy CAS mode, domains should be homogenous.  If the host has not specified a sandbox
 930                 // of their own, we'll set it up to be fully trusted.  We must read the IsLegacyCasPolicy
 931                 // enabled property here rathern than just reading the switch from above because the entire
 932                 // process may also be opted into legacy CAS policy mode.
 933                 if (appTrust == null && !IsLegacyCasPolicyEnabled) {
 934                     _IsFastFullTrustDomain = true;
 935                     runtimeSuppliedHomogenousGrant = true;
 936                 }
 937 #endif // FEATURE_CAS_POLICY
 938
 939                 if (appTrust != null) {
 940                     SetupDomainSecurityForHomogeneousDomain(appTrust, runtimeSuppliedHomogenousGrant);
 941                 }
 942                 else if (_IsFastFullTrustDomain) {
 943                     SetSecurityHomogeneousFlag(GetNativeHandle(), runtimeSuppliedHomogenousGrant);
 944                 }
 945             }
 946
 947             // Get the evidence supplied for the domain.  If no evidence was supplied, it means that we want
 948             // to use the default evidence creation strategy for this domain
 949             Evidence newAppDomainEvidence = (providedSecurityInfo != null ? providedSecurityInfo : creatorsSecurityInfo);
 950             if (newAppDomainEvidence == null && generateDefaultEvidence) {
 951 #if FEATURE_CAS_POLICY
 952                 newAppDomainEvidence = new Evidence(new AppDomainEvidenceFactory(this));
 953 #else // !FEATURE_CAS_POLICY
 954                 newAppDomainEvidence = new Evidence();
 955 #endif // FEATURE_CAS_POLICY
 956             }
 957
 958 #if FEATURE_CAS_POLICY
 959             if (_domainManager != null) {
 960                 // Give the host a chance to alter the AppDomain evidence
 961                 HostSecurityManager securityManager = _domainManager.HostSecurityManager;
 962                 if (securityManager != null) {
 963                     nSetHostSecurityManagerFlags (securityManager.Flags);
 964                     if ((securityManager.Flags & HostSecurityManagerOptions.HostAppDomainEvidence) == HostSecurityManagerOptions.HostAppDomainEvidence) {
 965                         newAppDomainEvidence = securityManager.ProvideAppDomainEvidence(newAppDomainEvidence);
 966                         // If this is a disconnected evidence collection, then attach it to the AppDomain,
 967                         // allowing the host security manager to get callbacks for delay generated evidence
 968                         if (newAppDomainEvidence != null && newAppDomainEvidence.Target == null) {
 969                             newAppDomainEvidence.Target = new AppDomainEvidenceFactory(this);
 970                         }
 971                     }
 972                 }
 973             }
 974
 975 #endif // FEATURE_CAS_POLICY
 976
 977             // Set the evidence on the managed side
 978             _SecurityIdentity = newAppDomainEvidence;
 979
 980             // Set the evidence of the AppDomain in the VM.
 981             // Also, now that the initialization is complete, signal that to the security system.
 982             // Finish the AppDomain initialization and resolve the policy for the AppDomain evidence.
 983             SetupDomainSecurity(newAppDomainEvidence,
 984                                 parentSecurityDescriptor,
 985                                 publishAppDomain);
 986
 987 #if FEATURE_CAS_POLICY
 988             // The AppDomain is now resolved. Go ahead and set the PolicyLevel
 989             // from the HostSecurityManager if specified.
 990             if (_domainManager != null)
 991                 RunDomainManagerPostInitialization(_domainManager);
 992 #endif // FEATURE_CAS_POLICY
 993         }
 994
 995 #if FEATURE_CAS_POLICY
 996         [System.Security.SecurityCritical]  // auto-generated
 997         private void RunDomainManagerPostInitialization (AppDomainManager domainManager)
 998         {
 999             // force creation of the HostExecutionContextManager for the current AppDomain
1000             HostExecutionContextManager contextManager = domainManager.HostExecutionContextManager;
1001
1002             if (IsLegacyCasPolicyEnabled)
1003             {
1004 #pragma warning disable 618
1005                 HostSecurityManager securityManager = domainManager.HostSecurityManager;
1006                 if (securityManager != null)
1007                 {
1008                     if ((securityManager.Flags & HostSecurityManagerOptions.HostPolicyLevel) == HostSecurityManagerOptions.HostPolicyLevel)
1009                     {
1010                         // set AppDomain policy if specified
1011                         PolicyLevel level = securityManager.DomainPolicy;
1012                         if (level != null)
1013                             SetAppDomainPolicy(level);
1014                     }
1015                 }
1016 #pragma warning restore 618
1017             }
1018         }
1019 #endif
1020
1021
1022 #if FEATURE_CLICKONCE
1023
1024         [System.Security.SecurityCritical]  // auto-generated
1025         private void SetupApplicationHelper (Evidence providedSecurityInfo, Evidence creatorsSecurityInfo, ApplicationIdentity appIdentity, ActivationContext activationContext, string[] activationData) {
1026             Contract.Requires(providedSecurityInfo != null);
1027             HostSecurityManager securityManager = AppDomain.CurrentDomain.HostSecurityManager;
1028             ApplicationTrust appTrust = securityManager.DetermineApplicationTrust(providedSecurityInfo, creatorsSecurityInfo, new TrustManagerContext());
1029             if (appTrust == null || !appTrust.IsApplicationTrustedToRun)
1030                 throw new PolicyException(Environment.GetResourceString("Policy_NoExecutionPermission"),
1031                                           System.__HResults.CORSEC_E_NO_EXEC_PERM,
1032                                           null);
1033
1034             // The application is trusted to run. Set up the AppDomain according to the manifests.
1035             if (activationContext != null)
1036                 SetupDomainForApplication(activationContext, activationData);
1037             SetupDomainSecurityForApplication(appIdentity, appTrust);
1038         }
1039
1040         [System.Security.SecurityCritical]  // auto-generated
1041         [ResourceExposure(ResourceScope.None)]
1042         [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
1043         private void SetupDomainForApplication(ActivationContext activationContext, string[] activationData) {
1044             Contract.Requires(activationContext != null);
1045             if (IsDefaultAppDomain()) {
1046                 // make the ActivationArguments available off the AppDomain object.
1047                 AppDomainSetup adSetup = this.FusionStore;
1048                 adSetup.ActivationArguments = new ActivationArguments(activationContext, activationData);
1049
1050                 // set the application base to point at where the application resides
1051                 string entryPointPath = CmsUtils.GetEntryPointFullPath(activationContext);
1052                 if (!String.IsNullOrEmpty(entryPointPath))
1053                     adSetup.SetupDefaults(entryPointPath);
1054                 else
1055                     adSetup.ApplicationBase = activationContext.ApplicationDirectory;
1056
1057                 // update fusion context
1058                 SetupFusionStore(adSetup, null);
1059             }
1060
1061             // perform app data directory migration.
1062             activationContext.PrepareForExecution();
1063             activationContext.SetApplicationState(ActivationContext.ApplicationState.Starting);
1064             // set current app data directory.
1065             activationContext.SetApplicationState(ActivationContext.ApplicationState.Running);
1066
1067             // make data directory path available.
1068             IPermission permission = null;
1069             string dataDirectory = activationContext.DataDirectory;
1070             if (dataDirectory != null && dataDirectory.Length > 0)
1071                 permission = new FileIOPermission(FileIOPermissionAccess.PathDiscovery, dataDirectory);
1072             this.SetData("DataDirectory", dataDirectory, permission);
1073
1074             _activationContext = activationContext;
1075         }
1076
1077         [System.Security.SecurityCritical]  // auto-generated
1078         private void SetupDomainSecurityForApplication(ApplicationIdentity appIdentity,
1079                                                        ApplicationTrust appTrust)
1080         {
1081             // Set the Application trust on the managed side.
1082             _applicationIdentity = appIdentity;
1083             SetupDomainSecurityForHomogeneousDomain(appTrust, false);
1084         }
1085 #endif // FEATURE_CLICKONCE
1086
1087         [System.Security.SecurityCritical]  // auto-generated
1088         private void SetupDomainSecurityForHomogeneousDomain(ApplicationTrust appTrust,
1089                                                              bool runtimeSuppliedHomogenousGrantSet)
1090         {
1091             // If the CLR has supplied the homogenous grant set (that is, this domain would have been
1092             // heterogenous in v2.0), then we need to strip the ApplicationTrust from the AppDomainSetup of
1093             // the current domain.  This prevents code which does:
1094             //   AppDomain.CreateDomain(..., AppDomain.CurrentDomain.SetupInformation);
1095             //
1096             // From looking like it is trying to create a homogenous domain intentionally, and therefore
1097             // having its evidence check bypassed.
1098             if (runtimeSuppliedHomogenousGrantSet)
1099             {
1100                 BCLDebug.Assert(_FusionStore.ApplicationTrust != null, "Expected to find runtime supplied ApplicationTrust");
1101 #if FEATURE_CAS_POLICY
1102                 _FusionStore.ApplicationTrust = null;
1103 #endif // FEATURE_CAS_POLICY
1104             }
1105
1106             _applicationTrust = appTrust;
1107
1108             // Set the homogeneous bit in the VM's ApplicationSecurityDescriptor.
1109             SetSecurityHomogeneousFlag(GetNativeHandle(),
1110                                        runtimeSuppliedHomogenousGrantSet);
1111         }
1112
1113         // This method is called from CorHost2::ExecuteApplication to activate a ClickOnce application in the default AppDomain.
1114 #if FEATURE_CLICKONCE
1115         [System.Security.SecuritySafeCritical]  // auto-generated
1116         private int ActivateApplication () {
1117             ObjectHandle oh = Activator.CreateInstance(AppDomain.CurrentDomain.ActivationContext);
1118             return (int) oh.Unwrap();
1119         }
1120 #endif //FEATURE_CLICKONCE
1121
1122         public AppDomainManager DomainManager {
1123             [System.Security.SecurityCritical]  // auto-generated_required
1124             get {
1125                 return _domainManager;
1126             }
1127         }
1128
1129 #if FEATURE_CAS_POLICY
1130         internal HostSecurityManager HostSecurityManager {
1131             [System.Security.SecurityCritical]  // auto-generated
1132             get {
1133                 HostSecurityManager securityManager = null;
1134                 AppDomainManager domainManager = AppDomain.CurrentDomain.DomainManager;
1135                 if (domainManager != null)
1136                     securityManager = domainManager.HostSecurityManager;
1137
1138                 if (securityManager == null)
1139                     securityManager = new HostSecurityManager();
1140                 return securityManager;
1141             }
1142         }
1143 #endif // FEATURE_CAS_POLICY
1144 #if FEATURE_REFLECTION_ONLY_LOAD
1145         private Assembly ResolveAssemblyForIntrospection(Object sender, ResolveEventArgs args)
1146         {
1147             Contract.Requires(args != null);
1148             return Assembly.ReflectionOnlyLoad(ApplyPolicy(args.Name));
1149         }
1150
1151         // Helper class for method code:EnableResolveAssembliesForIntrospection
1152         private class NamespaceResolverForIntrospection
1153         {
1154             private IEnumerable<string> _packageGraphFilePaths;
1155             public NamespaceResolverForIntrospection(IEnumerable<string> packageGraphFilePaths)
1156             {
1157                 _packageGraphFilePaths = packageGraphFilePaths;
1158             }
1159
1160             [System.Security.SecurityCritical]
1161             public void ResolveNamespace(
1162                 object sender,
1163                 System.Runtime.InteropServices.WindowsRuntime.NamespaceResolveEventArgs args)
1164             {
1165                 Contract.Requires(args != null);
1166
1167                 IEnumerable<string> fileNames = System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMetadata.ResolveNamespace(
1168                     args.NamespaceName,
1169                     null,   // windowsSdkFilePath ... Use OS installed .winmd files
1170                     _packageGraphFilePaths);
1171                 foreach (string fileName in fileNames)
1172                 {
1173                     args.ResolvedAssemblies.Add(Assembly.ReflectionOnlyLoadFrom(fileName));
1174                 }
1175             }
1176         }
1177
1178         // Called only by native function code:ValidateWorker
1179         [System.Security.SecuritySafeCritical]
1180         private void EnableResolveAssembliesForIntrospection(string verifiedFileDirectory)
1181         {
1182             CurrentDomain.ReflectionOnlyAssemblyResolve += new ResolveEventHandler(ResolveAssemblyForIntrospection);
1183
1184             string[] packageGraphFilePaths = null;
1185             if (verifiedFileDirectory != null)
1186                 packageGraphFilePaths = new string[] { verifiedFileDirectory };
1187             NamespaceResolverForIntrospection namespaceResolver = new NamespaceResolverForIntrospection(packageGraphFilePaths);
1188
1189             System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMetadata.ReflectionOnlyNamespaceResolve +=
1190                 new EventHandler<System.Runtime.InteropServices.WindowsRuntime.NamespaceResolveEventArgs>(namespaceResolver.ResolveNamespace);
1191         }
1192 #endif // FEATURE_REFLECTION_ONLY_LOAD
1193
1194
1195         /**********************************************
1196         * If an AssemblyName has a public key specified, the assembly is assumed
1197         * to have a strong name and a hash will be computed when the assembly
1198         * is saved.
1199         **********************************************/
1200         [System.Security.SecuritySafeCritical]  // auto-generated
1201         [ResourceExposure(ResourceScope.None)]
1202         [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
1203         [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
1204         public AssemblyBuilder DefineDynamicAssembly(
1205             AssemblyName            name,
1206             AssemblyBuilderAccess   access)
1207         {
1208             Contract.Ensures(Contract.Result<AssemblyBuilder>() != null);
1209
1210             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
1211             return InternalDefineDynamicAssembly(name, access, null,
1212                                                  null, null, null, null, ref stackMark, null, SecurityContextSource.CurrentAssembly);
1213         }
1214
1215         [System.Security.SecuritySafeCritical]  // auto-generated
1216         [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
1217         public AssemblyBuilder DefineDynamicAssembly(
1218             AssemblyName            name,
1219             AssemblyBuilderAccess   access,
1220             IEnumerable<CustomAttributeBuilder> assemblyAttributes)
1221         {
1222             Contract.Ensures(Contract.Result<AssemblyBuilder>() != null);
1223
1224             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
1225             return InternalDefineDynamicAssembly(name,
1226                                                  access,
1227                                                  null, null, null, null, null,
1228                                                  ref stackMark,
1229                                                  assemblyAttributes, SecurityContextSource.CurrentAssembly);
1230         }
1231
1232         [MethodImplAttribute(MethodImplOptions.NoInlining)] // Due to the stack crawl mark
1233         [SecuritySafeCritical]
1234         public AssemblyBuilder DefineDynamicAssembly(AssemblyName name,
1235                                                      AssemblyBuilderAccess access,
1236                                                      IEnumerable<CustomAttributeBuilder> assemblyAttributes,
1237                                                      SecurityContextSource securityContextSource)
1238         {
1239             Contract.Ensures(Contract.Result<AssemblyBuilder>() != null);
1240
1241             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
1242             return InternalDefineDynamicAssembly(name,
1243                                                  access,
1244                                                  null, null, null, null, null,
1245                                                  ref stackMark,
1246                                                  assemblyAttributes,
1247                                                  securityContextSource);
1248         }
1249
1250         [System.Security.SecuritySafeCritical]  // auto-generated
1251         [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
1252         public AssemblyBuilder DefineDynamicAssembly(
1253             AssemblyName            name,
1254             AssemblyBuilderAccess   access,
1255             String                  dir)
1256         {
1257             Contract.Ensures(Contract.Result<AssemblyBuilder>() != null);
1258
1259             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
1260             return InternalDefineDynamicAssembly(name, access, dir,
1261                                                  null, null, null, null,
1262                                                  ref stackMark,
1263                                                  null,
1264                                                  SecurityContextSource.CurrentAssembly);
1265         }
1266
1267         [System.Security.SecuritySafeCritical]  // auto-generated
1268         [ResourceExposure(ResourceScope.None)]
1269         [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
1270         [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
1271         [Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default.  See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
1272         public AssemblyBuilder DefineDynamicAssembly(
1273             AssemblyName            name,
1274             AssemblyBuilderAccess   access,
1275             Evidence                evidence)
1276         {
1277             Contract.Ensures(Contract.Result<AssemblyBuilder>() != null);
1278
1279             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
1280             return InternalDefineDynamicAssembly(name, access, null,
1281                                                  evidence, null, null, null,
1282                                                  ref stackMark,
1283                                                  null,
1284                                                  SecurityContextSource.CurrentAssembly);
1285         }
1286
1287         [System.Security.SecuritySafeCritical]  // auto-generated
1288         [ResourceExposure(ResourceScope.None)]
1289         [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
1290         [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
1291         [Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default.  See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
1292         public AssemblyBuilder DefineDynamicAssembly(
1293             AssemblyName            name,
1294             AssemblyBuilderAccess   access,
1295             PermissionSet           requiredPermissions,
1296             PermissionSet           optionalPermissions,
1297             PermissionSet           refusedPermissions)
1298         {
1299             Contract.Ensures(Contract.Result<AssemblyBuilder>() != null);
1300
1301             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
1302             return InternalDefineDynamicAssembly(name, access, null, null,
1303                                                  requiredPermissions,
1304                                                  optionalPermissions,
1305                                                  refusedPermissions,
1306                                                  ref stackMark,
1307                                                  null,
1308                                                  SecurityContextSource.CurrentAssembly);
1309         }
1310
1311         [System.Security.SecuritySafeCritical]  // auto-generated
1312         [ResourceExposure(ResourceScope.Machine)]
1313         [ResourceConsumption(ResourceScope.Machine)]
1314         [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
1315         [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of DefineDynamicAssembly which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkId=155570 for more information.")]
1316         public AssemblyBuilder DefineDynamicAssembly(
1317             AssemblyName            name,
1318             AssemblyBuilderAccess   access,
1319             String                  dir,
1320             Evidence                evidence)
1321         {
1322             Contract.Ensures(Contract.Result<AssemblyBuilder>() != null);
1323
1324             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
1325             return InternalDefineDynamicAssembly(name, access, dir, evidence,
1326                                                  null, null, null, ref stackMark, null, SecurityContextSource.CurrentAssembly);
1327         }
1328
1329         [System.Security.SecuritySafeCritical]  // auto-generated
1330         [ResourceExposure(ResourceScope.Machine)]
1331         [ResourceConsumption(ResourceScope.Machine)]
1332         [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
1333         [Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
1334         public AssemblyBuilder DefineDynamicAssembly(
1335             AssemblyName            name,
1336             AssemblyBuilderAccess   access,
1337             String                  dir,
1338             PermissionSet           requiredPermissions,
1339             PermissionSet           optionalPermissions,
1340             PermissionSet           refusedPermissions)
1341         {
1342             Contract.Ensures(Contract.Result<AssemblyBuilder>() != null);
1343
1344             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
1345             return InternalDefineDynamicAssembly(name, access, dir, null,
1346                                                  requiredPermissions,
1347                                                  optionalPermissions,
1348                                                  refusedPermissions,
1349                                                  ref stackMark,
1350                                                  null,
1351                                                  SecurityContextSource.CurrentAssembly);
1352         }
1353
1354         [System.Security.SecuritySafeCritical]  // auto-generated
1355         [ResourceExposure(ResourceScope.None)]
1356         [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
1357         [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
1358         [Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
1359         public AssemblyBuilder DefineDynamicAssembly(
1360             AssemblyName            name,
1361             AssemblyBuilderAccess   access,
1362             Evidence                evidence,
1363             PermissionSet           requiredPermissions,
1364             PermissionSet           optionalPermissions,
1365             PermissionSet           refusedPermissions)
1366         {
1367             Contract.Ensures(Contract.Result<AssemblyBuilder>() != null);
1368
1369             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
1370             return InternalDefineDynamicAssembly(name, access, null,
1371                                                  evidence,
1372                                                  requiredPermissions,
1373                                                  optionalPermissions,
1374                                                  refusedPermissions,
1375                                                  ref stackMark,
1376                                                  null,
1377                                                  SecurityContextSource.CurrentAssembly);
1378         }
1379
1380         [System.Security.SecuritySafeCritical]  // auto-generated
1381         [ResourceExposure(ResourceScope.Machine)]
1382         [ResourceConsumption(ResourceScope.Machine)]
1383         [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
1384         [Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default.  Please see http://go.microsoft.com/fwlink/?LinkId=155570 for more information.")]
1385         public AssemblyBuilder DefineDynamicAssembly(
1386             AssemblyName            name,
1387             AssemblyBuilderAccess   access,
1388             String                  dir,
1389             Evidence                evidence,
1390             PermissionSet           requiredPermissions,
1391             PermissionSet           optionalPermissions,
1392             PermissionSet           refusedPermissions)
1393         {
1394             Contract.Ensures(Contract.Result<AssemblyBuilder>() != null);
1395
1396             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
1397             return InternalDefineDynamicAssembly(name, access, dir,
1398                                                  evidence,
1399                                                  requiredPermissions,
1400                                                  optionalPermissions,
1401                                                  refusedPermissions,
1402                                                  ref stackMark,
1403                                                  null,
1404                                                  SecurityContextSource.CurrentAssembly);
1405         }
1406
1407
1408         [System.Security.SecuritySafeCritical]  // auto-generated
1409         [ResourceExposure(ResourceScope.Machine)]
1410         [ResourceConsumption(ResourceScope.Machine)]
1411         [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
1412         [Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
1413         public AssemblyBuilder DefineDynamicAssembly(
1414             AssemblyName            name,
1415             AssemblyBuilderAccess   access,
1416             String                  dir,
1417             Evidence                evidence,
1418             PermissionSet           requiredPermissions,
1419             PermissionSet           optionalPermissions,
1420             PermissionSet           refusedPermissions,
1421             bool                    isSynchronized)
1422         {
1423             Contract.Ensures(Contract.Result<AssemblyBuilder>() != null);
1424
1425             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
1426             return InternalDefineDynamicAssembly(name,
1427                                                  access,
1428                                                  dir,
1429                                                  evidence,
1430                                                  requiredPermissions,
1431                                                  optionalPermissions,
1432                                                  refusedPermissions,
1433                                                  ref stackMark,
1434                                                  null,
1435                                                  SecurityContextSource.CurrentAssembly);
1436         }
1437
1438         [System.Security.SecuritySafeCritical]  // auto-generated
1439         [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
1440         [Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
1441         public AssemblyBuilder DefineDynamicAssembly(
1442                     AssemblyName name,
1443                     AssemblyBuilderAccess access,
1444                     String dir,
1445                     Evidence evidence,
1446                     PermissionSet requiredPermissions,
1447                     PermissionSet optionalPermissions,
1448                     PermissionSet refusedPermissions,
1449                     bool isSynchronized,
1450                     IEnumerable<CustomAttributeBuilder> assemblyAttributes)
1451         {
1452             Contract.Ensures(Contract.Result<AssemblyBuilder>() != null);
1453
1454             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
1455             return InternalDefineDynamicAssembly(name,
1456                                                  access,
1457                                                  dir,
1458                                                  evidence,
1459                                                  requiredPermissions,
1460                                                  optionalPermissions,
1461                                                  refusedPermissions,
1462                                                  ref stackMark,
1463                                                  assemblyAttributes,
1464                                                  SecurityContextSource.CurrentAssembly);
1465         }
1466
1467         [System.Security.SecuritySafeCritical]  // auto-generated
1468         [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
1469         public AssemblyBuilder DefineDynamicAssembly(
1470                     AssemblyName name,
1471                     AssemblyBuilderAccess access,
1472                     String dir,
1473                     bool isSynchronized,
1474                     IEnumerable<CustomAttributeBuilder> assemblyAttributes)
1475         {
1476             Contract.Ensures(Contract.Result<AssemblyBuilder>() != null);
1477
1478             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
1479             return InternalDefineDynamicAssembly(name,
1480                                                  access,
1481                                                  dir,
1482                                                  null,
1483                                                  null,
1484                                                  null,
1485                                                  null,
1486                                                  ref stackMark,
1487                                                  assemblyAttributes,
1488                                                  SecurityContextSource.CurrentAssembly);
1489         }
1490
1491         [System.Security.SecurityCritical]  // auto-generated
1492         [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
1493         private AssemblyBuilder InternalDefineDynamicAssembly(
1494             AssemblyName name,
1495             AssemblyBuilderAccess access,
1496             String dir,
1497             Evidence evidence,
1498             PermissionSet requiredPermissions,
1499             PermissionSet optionalPermissions,
1500             PermissionSet refusedPermissions,
1501             ref StackCrawlMark stackMark,
1502             IEnumerable<CustomAttributeBuilder> assemblyAttributes,
1503             SecurityContextSource securityContextSource)
1504         {
1505             return AssemblyBuilder.InternalDefineDynamicAssembly(name,
1506                                                                  access,
1507                                                                  dir,
1508                                                                  evidence,
1509                                                                  requiredPermissions,
1510                                                                  optionalPermissions,
1511                                                                  refusedPermissions,
1512                                                                  ref stackMark,
1513                                                                  assemblyAttributes,
1514                                                                  securityContextSource);
1515         }
1516
1517         [System.Security.SecuritySafeCritical]  // auto-generated
1518         [ResourceExposure(ResourceScope.None)]
1519         [MethodImplAttribute(MethodImplOptions.InternalCall)]
1520         private extern String nApplyPolicy(AssemblyName an);
1521
1522         // Return the assembly name that results from applying policy.
1523         [ComVisible(false)]
1524         public String ApplyPolicy(String assemblyName)
1525         {
1526             AssemblyName asmName = new AssemblyName(assemblyName);
1527
1528             byte[] pk = asmName.GetPublicKeyToken();
1529             if (pk == null)
1530                 pk = asmName.GetPublicKey();
1531
1532             // Simply-named assemblies cannot have policy, so for those,
1533             // we simply return the passed-in assembly name.
1534             if ((pk == null) || (pk.Length == 0))
1535                 return assemblyName;
1536             else
1537                 return nApplyPolicy(asmName);
1538         }
1539
1540
1541         public ObjectHandle CreateInstance(String assemblyName,
1542                                            String typeName)
1543
1544         {
1545             // jit does not check for that, so we should do it ...
1546             if (this == null)
1547                 throw new NullReferenceException();
1548
1549             if (assemblyName == null)
1550                 throw new ArgumentNullException("assemblyName");
1551             Contract.EndContractBlock();
1552
1553             return Activator.CreateInstance(assemblyName,
1554                                             typeName);
1555         }
1556
1557         [System.Security.SecurityCritical]  // auto-generated
1558         internal ObjectHandle InternalCreateInstanceWithNoSecurity (string assemblyName, string typeName) {
1559             PermissionSet.s_fullTrust.Assert();
1560             return CreateInstance(assemblyName, typeName);
1561         }
1562
1563         [ResourceExposure(ResourceScope.Machine)]
1564         [ResourceConsumption(ResourceScope.Machine)]
1565         public ObjectHandle CreateInstanceFrom(String assemblyFile,
1566                                                String typeName)
1567
1568         {
1569             // jit does not check for that, so we should do it ...
1570             if (this == null)
1571                 throw new NullReferenceException();
1572             Contract.EndContractBlock();
1573
1574             return Activator.CreateInstanceFrom(assemblyFile,
1575                                                 typeName);
1576         }
1577
1578         [System.Security.SecurityCritical]  // auto-generated
1579         [ResourceExposure(ResourceScope.Machine)]
1580         [ResourceConsumption(ResourceScope.Machine)]
1581         internal ObjectHandle InternalCreateInstanceFromWithNoSecurity (string assemblyName, string typeName) {
1582             PermissionSet.s_fullTrust.Assert();
1583             return CreateInstanceFrom(assemblyName, typeName);
1584         }
1585
1586 #if FEATURE_COMINTEROP
1587         // The first parameter should be named assemblyFile, but it was incorrectly named in a previous
1588         //  release, and the compatibility police won't let us change the name now.
1589         [ResourceExposure(ResourceScope.Machine)]
1590         [ResourceConsumption(ResourceScope.Machine)]
1591         public ObjectHandle CreateComInstanceFrom(String assemblyName,
1592                                                   String typeName)
1593
1594         {
1595             if (this == null)
1596                 throw new NullReferenceException();
1597             Contract.EndContractBlock();
1598
1599             return Activator.CreateComInstanceFrom(assemblyName,
1600                                                    typeName);
1601         }
1602
1603         [ResourceExposure(ResourceScope.Machine)]
1604         [ResourceConsumption(ResourceScope.Machine)]
1605         public ObjectHandle CreateComInstanceFrom(String assemblyFile,
1606                                                   String typeName,
1607                                                   byte[] hashValue,
1608                                                   AssemblyHashAlgorithm hashAlgorithm)
1609
1610         {
1611             if (this == null)
1612                 throw new NullReferenceException();
1613             Contract.EndContractBlock();
1614
1615             return Activator.CreateComInstanceFrom(assemblyFile,
1616                                                    typeName,
1617                                                    hashValue,
1618                                                    hashAlgorithm);
1619         }
1620
1621 #endif // FEATURE_COMINTEROP
1622
1623         public ObjectHandle CreateInstance(String assemblyName,
1624                                            String typeName,
1625                                            Object[] activationAttributes)
1626
1627         {
1628             // jit does not check for that, so we should do it ...
1629             if (this == null)
1630                 throw new NullReferenceException();
1631
1632             if (assemblyName == null)
1633                 throw new ArgumentNullException("assemblyName");
1634             Contract.EndContractBlock();
1635
1636             return Activator.CreateInstance(assemblyName,
1637                                             typeName,
1638                                             activationAttributes);
1639         }
1640
1641         [ResourceExposure(ResourceScope.Machine)]
1642         [ResourceConsumption(ResourceScope.Machine)]
1643         public ObjectHandle CreateInstanceFrom(String assemblyFile,
1644                                                String typeName,
1645                                                Object[] activationAttributes)
1646
1647         {
1648             // jit does not check for that, so we should do it ...
1649             if (this == null)
1650                 throw new NullReferenceException();
1651             Contract.EndContractBlock();
1652
1653             return Activator.CreateInstanceFrom(assemblyFile,
1654                                                 typeName,
1655                                                 activationAttributes);
1656         }
1657
1658         [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of CreateInstance which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
1659         public ObjectHandle CreateInstance(String assemblyName,
1660                                            String typeName,
1661                                            bool ignoreCase,
1662                                            BindingFlags bindingAttr,
1663                                            Binder binder,
1664                                            Object[] args,
1665                                            CultureInfo culture,
1666                                            Object[] activationAttributes,
1667                                            Evidence securityAttributes)
1668         {
1669             // jit does not check for that, so we should do it ...
1670             if (this == null)
1671                 throw new NullReferenceException();
1672
1673             if (assemblyName == null)
1674                 throw new ArgumentNullException("assemblyName");
1675             Contract.EndContractBlock();
1676
1677 #if FEATURE_CAS_POLICY
1678             if (securityAttributes != null && !IsLegacyCasPolicyEnabled)
1679             {
1680                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit"));
1681             }
1682 #endif // FEATURE_CAS_POLICY
1683
1684 #pragma warning disable 618
1685             return Activator.CreateInstance(assemblyName,
1686                                             typeName,
1687                                             ignoreCase,
1688                                             bindingAttr,
1689                                             binder,
1690                                             args,
1691                                             culture,
1692                                             activationAttributes,
1693                                             securityAttributes);
1694 #pragma warning restore 618
1695         }
1696
1697         public ObjectHandle CreateInstance(string assemblyName,
1698                                            string typeName,
1699                                            bool ignoreCase,
1700                                            BindingFlags bindingAttr,
1701                                            Binder binder,
1702                                            object[] args,
1703                                            CultureInfo culture,
1704                                            object[] activationAttributes)
1705         {
1706             // jit does not check for that, so we should do it ...
1707             if (this == null)
1708                 throw new NullReferenceException();
1709
1710             if (assemblyName == null)
1711                 throw new ArgumentNullException("assemblyName");
1712             Contract.EndContractBlock();
1713
1714             return Activator.CreateInstance(assemblyName,
1715                                             typeName,
1716                                             ignoreCase,
1717                                             bindingAttr,
1718                                             binder,
1719                                             args,
1720                                             culture,
1721                                             activationAttributes);
1722         }
1723
1724         [System.Security.SecurityCritical]  // auto-generated
1725         internal ObjectHandle InternalCreateInstanceWithNoSecurity (string assemblyName,
1726                                                                     string typeName,
1727                                                                     bool ignoreCase,
1728                                                                     BindingFlags bindingAttr,
1729                                                                     Binder binder,
1730                                                                     Object[] args,
1731                                                                     CultureInfo culture,
1732                                                                     Object[] activationAttributes,
1733                                                                     Evidence securityAttributes)
1734         {
1735 #if FEATURE_CAS_POLICY
1736             Contract.Assert(IsLegacyCasPolicyEnabled || securityAttributes == null);
1737 #endif // FEATURE_CAS_POLICY
1738
1739             PermissionSet.s_fullTrust.Assert();
1740 #pragma warning disable 618
1741             return CreateInstance(assemblyName, typeName, ignoreCase, bindingAttr, binder, args, culture, activationAttributes, securityAttributes);
1742 #pragma warning restore 618
1743         }
1744
1745         [ResourceExposure(ResourceScope.Machine)]
1746         [ResourceConsumption(ResourceScope.Machine)]
1747         [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of CreateInstanceFrom which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
1748         public ObjectHandle CreateInstanceFrom(String assemblyFile,
1749                                                String typeName,
1750                                                bool ignoreCase,
1751                                                BindingFlags bindingAttr,
1752                                                Binder binder,
1753                                                Object[] args,
1754                                                CultureInfo culture,
1755                                                Object[] activationAttributes,
1756                                                Evidence securityAttributes)
1757
1758         {
1759             // jit does not check for that, so we should do it ...
1760             if (this == null)
1761                 throw new NullReferenceException();
1762             Contract.EndContractBlock();
1763
1764 #if FEATURE_CAS_POLICY
1765             if (securityAttributes != null && !IsLegacyCasPolicyEnabled)
1766             {
1767                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit"));
1768             }
1769 #endif // FEATURE_CAS_POLICY
1770
1771             return Activator.CreateInstanceFrom(assemblyFile,
1772                                                 typeName,
1773                                                 ignoreCase,
1774                                                 bindingAttr,
1775                                                 binder,
1776                                                 args,
1777                                                 culture,
1778                                                 activationAttributes,
1779                                                 securityAttributes);
1780         }
1781
1782         [ResourceExposure(ResourceScope.Machine)]
1783         [ResourceConsumption(ResourceScope.Machine)]
1784         public ObjectHandle CreateInstanceFrom(string assemblyFile,
1785                                                string typeName,
1786                                                bool ignoreCase,
1787                                                BindingFlags bindingAttr,
1788                                                Binder binder,
1789                                                object[] args,
1790                                                CultureInfo culture,
1791                                                object[] activationAttributes)
1792         {
1793             // jit does not check for that, so we should do it ...
1794             if (this == null)
1795                 throw new NullReferenceException();
1796             Contract.EndContractBlock();
1797
1798             return Activator.CreateInstanceFrom(assemblyFile,
1799                                                 typeName,
1800                                                 ignoreCase,
1801                                                 bindingAttr,
1802                                                 binder,
1803                                                 args,
1804                                                 culture,
1805                                                 activationAttributes);
1806         }
1807
1808         [System.Security.SecurityCritical]  // auto-generated
1809         [ResourceExposure(ResourceScope.Machine)]
1810         [ResourceConsumption(ResourceScope.Machine)]
1811         internal ObjectHandle InternalCreateInstanceFromWithNoSecurity (string assemblyName,
1812                                                                         string typeName,
1813                                                                         bool ignoreCase,
1814                                                                         BindingFlags bindingAttr,
1815                                                                         Binder binder,
1816                                                                         Object[] args,
1817                                                                         CultureInfo culture,
1818                                                                         Object[] activationAttributes,
1819                                                                         Evidence securityAttributes)
1820         {
1821 #if FEATURE_CAS_POLICY
1822             Contract.Assert(IsLegacyCasPolicyEnabled || securityAttributes == null);
1823 #endif // FEATURE_CAS_POLICY
1824
1825             PermissionSet.s_fullTrust.Assert();
1826 #pragma warning disable 618
1827             return CreateInstanceFrom(assemblyName, typeName, ignoreCase, bindingAttr, binder, args, culture, activationAttributes, securityAttributes);
1828 #pragma warning restore 618
1829         }
1830
1831         [System.Security.SecuritySafeCritical]  // auto-generated
1832         [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
1833         public Assembly Load(AssemblyName assemblyRef)
1834         {
1835             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
1836             return RuntimeAssembly.InternalLoadAssemblyName(assemblyRef, null, null, ref stackMark, true /*thrownOnFileNotFound*/, false, false);
1837         }
1838
1839         [System.Security.SecuritySafeCritical]  // auto-generated
1840         [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
1841         public Assembly Load(String assemblyString)
1842         {
1843             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
1844             return RuntimeAssembly.InternalLoad(assemblyString, null, ref stackMark, false);
1845         }
1846
1847         [System.Security.SecuritySafeCritical]  // auto-generated
1848         [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
1849         public Assembly Load(byte[] rawAssembly)
1850         {
1851             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
1852             return RuntimeAssembly.nLoadImage(rawAssembly,
1853                                        null, // symbol store
1854                                        null, // evidence
1855                                        ref stackMark,
1856                                        false,
1857                                        SecurityContextSource.CurrentAssembly);
1858
1859         }
1860
1861         [System.Security.SecuritySafeCritical]  // auto-generated
1862         [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
1863         public Assembly Load(byte[] rawAssembly,
1864                              byte[] rawSymbolStore)
1865         {
1866             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
1867             return RuntimeAssembly.nLoadImage(rawAssembly,
1868                                        rawSymbolStore,
1869                                        null, // evidence
1870                                        ref stackMark,
1871                                        false, // fIntrospection
1872                                        SecurityContextSource.CurrentAssembly);
1873         }
1874
1875         [System.Security.SecuritySafeCritical]  // auto-generated
1876 #pragma warning disable 618
1877         [SecurityPermissionAttribute(SecurityAction.Demand, ControlEvidence = true)]
1878 #pragma warning restore 618
1879         [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
1880         [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of Load which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkId=155570 for more information.")]
1881         public Assembly Load(byte[] rawAssembly,
1882                              byte[] rawSymbolStore,
1883                              Evidence securityEvidence)
1884         {
1885 #if FEATURE_CAS_POLICY
1886             if (securityEvidence != null && !IsLegacyCasPolicyEnabled)
1887             {
1888                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit"));
1889             }
1890 #endif // FEATURE_CAS_POLICY
1891
1892             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
1893             return RuntimeAssembly.nLoadImage(rawAssembly,
1894                                        rawSymbolStore,
1895                                        securityEvidence,
1896                                        ref stackMark,
1897                                        false, // fIntrospection
1898                                        SecurityContextSource.CurrentAssembly);
1899         }
1900
1901         [System.Security.SecuritySafeCritical]  // auto-generated
1902         [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
1903         [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of Load which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
1904         public Assembly Load(AssemblyName assemblyRef,
1905                              Evidence assemblySecurity)
1906         {
1907             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
1908             return RuntimeAssembly.InternalLoadAssemblyName(assemblyRef, assemblySecurity, null, ref stackMark, true /*thrownOnFileNotFound*/, false, false);
1909         }
1910
1911         [System.Security.SecuritySafeCritical]  // auto-generated
1912         [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
1913         [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of Load which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
1914         public Assembly Load(String assemblyString,
1915                              Evidence assemblySecurity)
1916         {
1917             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
1918             return RuntimeAssembly.InternalLoad(assemblyString, assemblySecurity, ref stackMark, false);
1919         }
1920
1921         [ResourceExposure(ResourceScope.Machine)]
1922         [ResourceConsumption(ResourceScope.Machine)]
1923         public int ExecuteAssembly(String assemblyFile)
1924         {
1925             return ExecuteAssembly(assemblyFile, (string[])null);
1926         }
1927
1928         [ResourceExposure(ResourceScope.Machine)]
1929         [ResourceConsumption(ResourceScope.Machine)]
1930         [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of ExecuteAssembly which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
1931         public int ExecuteAssembly(String assemblyFile,
1932                                    Evidence assemblySecurity)
1933         {
1934             return ExecuteAssembly(assemblyFile, assemblySecurity, null);
1935         }
1936
1937         [ResourceExposure(ResourceScope.Machine)]
1938         [ResourceConsumption(ResourceScope.Machine)]
1939         [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of ExecuteAssembly which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
1940         public int ExecuteAssembly(String assemblyFile,
1941                                    Evidence assemblySecurity,
1942                                    String[] args)
1943         {
1944 #if FEATURE_CAS_POLICY
1945             if (assemblySecurity != null && !IsLegacyCasPolicyEnabled)
1946             {
1947                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit"));
1948             }
1949 #endif // FEATURE_CAS_POLICY
1950
1951             RuntimeAssembly assembly = (RuntimeAssembly)Assembly.LoadFrom(assemblyFile, assemblySecurity);
1952
1953             if (args == null)
1954                 args = new String[0];
1955
1956             return nExecuteAssembly(assembly, args);
1957         }
1958
1959         [ResourceExposure(ResourceScope.Machine)]
1960         [ResourceConsumption(ResourceScope.Machine)]
1961         public int ExecuteAssembly(string assemblyFile, string[] args)
1962         {
1963             RuntimeAssembly assembly = (RuntimeAssembly)Assembly.LoadFrom(assemblyFile);
1964
1965             if (args == null)
1966                 args = new String[0];
1967
1968             return nExecuteAssembly(assembly, args);
1969         }
1970
1971         [ResourceExposure(ResourceScope.Machine)]
1972         [ResourceConsumption(ResourceScope.Machine)]
1973         [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of ExecuteAssembly which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
1974         public int ExecuteAssembly(String assemblyFile,
1975                                    Evidence assemblySecurity,
1976                                    String[] args,
1977                                    byte[] hashValue,
1978                                    AssemblyHashAlgorithm hashAlgorithm)
1979         {
1980 #if FEATURE_CAS_POLICY
1981             if (assemblySecurity != null && !IsLegacyCasPolicyEnabled)
1982             {
1983                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit"));
1984             }
1985 #endif // FEATURE_CAS_POLICY
1986
1987             RuntimeAssembly assembly = (RuntimeAssembly)Assembly.LoadFrom(assemblyFile,
1988                                                                           assemblySecurity,
1989                                                                           hashValue,
1990                                                                           hashAlgorithm);
1991             if (args == null)
1992                 args = new String[0];
1993
1994             return nExecuteAssembly(assembly, args);
1995         }
1996
1997         [ResourceExposure(ResourceScope.Machine)]
1998         [ResourceConsumption(ResourceScope.Machine)]
1999         public int ExecuteAssembly(string assemblyFile,
2000                                    string[] args,
2001                                    byte[] hashValue,
2002                                    AssemblyHashAlgorithm hashAlgorithm)
2003         {
2004             RuntimeAssembly assembly = (RuntimeAssembly)Assembly.LoadFrom(assemblyFile,
2005                                                                           hashValue,
2006                                                                           hashAlgorithm);
2007             if (args == null)
2008                 args = new String[0];
2009
2010             return nExecuteAssembly(assembly, args);
2011         }
2012
2013         #if FEATURE_CORECLR
2014         [System.Security.SecurityCritical] // auto-generated
2015         #endif
2016         public int ExecuteAssemblyByName(String assemblyName)
2017         {
2018             return ExecuteAssemblyByName(assemblyName, (string[])null);
2019         }
2020
2021         [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of ExecuteAssemblyByName which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
2022         public int ExecuteAssemblyByName(String assemblyName,
2023                                          Evidence assemblySecurity)
2024         {
2025 #pragma warning disable 618
2026             return ExecuteAssemblyByName(assemblyName, assemblySecurity, null);
2027 #pragma warning restore 618
2028         }
2029
2030         [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of ExecuteAssemblyByName which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
2031         public int ExecuteAssemblyByName(String assemblyName,
2032                                          Evidence assemblySecurity,
2033                                          params String[] args)
2034         {
2035 #if FEATURE_CAS_POLICY
2036             if (assemblySecurity != null && !IsLegacyCasPolicyEnabled)
2037             {
2038                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit"));
2039             }
2040 #endif // FEATURE_CAS_POLICY
2041
2042             RuntimeAssembly assembly = (RuntimeAssembly)Assembly.Load(assemblyName, assemblySecurity);
2043
2044             if (args == null)
2045                 args = new String[0];
2046
2047             return nExecuteAssembly(assembly, args);
2048         }
2049
2050         public int ExecuteAssemblyByName(string assemblyName, params string[] args)
2051         {
2052             RuntimeAssembly assembly = (RuntimeAssembly)Assembly.Load(assemblyName);
2053
2054             if (args == null)
2055                 args = new String[0];
2056
2057             return nExecuteAssembly(assembly, args);
2058         }
2059
2060         [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of ExecuteAssemblyByName which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
2061         public int ExecuteAssemblyByName(AssemblyName assemblyName,
2062                                          Evidence assemblySecurity,
2063                                          params String[] args)
2064         {
2065 #if FEATURE_CAS_POLICY
2066             if (assemblySecurity != null && !IsLegacyCasPolicyEnabled)
2067             {
2068                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit"));
2069             }
2070 #endif // FEATURE_CAS_POLICY
2071
2072             RuntimeAssembly assembly = (RuntimeAssembly)Assembly.Load(assemblyName, assemblySecurity);
2073
2074             if (args == null)
2075                 args = new String[0];
2076
2077             return nExecuteAssembly(assembly, args);
2078         }
2079
2080         public int ExecuteAssemblyByName(AssemblyName assemblyName, params string[] args)
2081         {
2082             RuntimeAssembly assembly = (RuntimeAssembly)Assembly.Load(assemblyName);
2083
2084             if (args == null)
2085                 args = new String[0];
2086
2087             return nExecuteAssembly(assembly, args);
2088         }
2089
2090         public static AppDomain CurrentDomain
2091         {
2092             get {
2093                 Contract.Ensures(Contract.Result<AppDomain>() != null);
2094                 return Thread.GetDomain();
2095             }
2096         }
2097
2098 #if FEATURE_CAS_POLICY
2099         public Evidence Evidence
2100         {
2101             [System.Security.SecuritySafeCritical]  // auto-generated
2102             [SecurityPermissionAttribute(SecurityAction.Demand, ControlEvidence = true)]
2103             get {
2104                 return EvidenceNoDemand;
2105             }
2106         }
2107
2108         internal Evidence EvidenceNoDemand {
2109             [SecurityCritical]
2110             get {
2111                 if (_SecurityIdentity == null) {
2112                     if (!IsDefaultAppDomain() && nIsDefaultAppDomainForEvidence()) {
2113 #if !FEATURE_CORECLR
2114                         //
2115                         // V1.x compatibility: If this is an AppDomain created
2116                         // by the default appdomain without an explicit evidence
2117                         // then reuse the evidence of the default AppDomain.
2118                         //
2119                         return GetDefaultDomain().Evidence;
2120 #else
2121                        Contract.Assert(false,"This code should not be called for core CLR");
2122
2123                         // This operation is not allowed
2124                         throw new InvalidOperationException();
2125 #endif
2126                     }
2127                     else {
2128                         // We can't cache this value, since the VM needs to differentiate between AppDomains
2129                         // which have no user supplied evidence and those which do and it uses the presence
2130                         // of Evidence on the domain to make that switch.
2131                         return new Evidence(new AppDomainEvidenceFactory(this));
2132                     }
2133                 }
2134                 else {
2135                     return _SecurityIdentity.Clone();
2136                 }
2137             }
2138         }
2139
2140         internal Evidence InternalEvidence
2141         {
2142             get {
2143                     return _SecurityIdentity;
2144             }
2145         }
2146
2147         internal EvidenceBase GetHostEvidence(Type type)
2148         {
2149             if (_SecurityIdentity != null)
2150             {
2151                 return _SecurityIdentity.GetHostEvidence(type);
2152             }
2153             else
2154             {
2155                 return new Evidence(new AppDomainEvidenceFactory(this)).GetHostEvidence(type);
2156             }
2157         }
2158 #endif // FEATURE_CAS_POLICY
2159
2160         public String FriendlyName
2161         {
2162             [System.Security.SecuritySafeCritical]  // auto-generated
2163             get { return nGetFriendlyName(); }
2164         }
2165
2166         public String BaseDirectory
2167         {
2168 #if FEATURE_CORECLR
2169             [System.Security.SecurityCritical]
2170 #endif
2171             [ResourceExposure(ResourceScope.Machine)]
2172             [ResourceConsumption(ResourceScope.Machine)]
2173             get {
2174                 return FusionStore.ApplicationBase;
2175             }
2176         }
2177
2178 #if FEATURE_FUSION
2179         public String RelativeSearchPath
2180         {
2181             [ResourceExposure(ResourceScope.Machine)]
2182             [ResourceConsumption(ResourceScope.Machine)]
2183             get { return FusionStore.PrivateBinPath; }
2184         }
2185
2186         public bool ShadowCopyFiles
2187         {
2188             get {
2189                 String s = FusionStore.ShadowCopyFiles;
2190                 if((s != null) &&
2191                    (String.Compare(s, "true", StringComparison.OrdinalIgnoreCase) == 0))
2192                     return true;
2193                 else
2194                     return false;
2195             }
2196         }
2197 #endif
2198
2199         [System.Security.SecuritySafeCritical]  // auto-generated
2200         public override String ToString()
2201         {
2202             StringBuilder sb = StringBuilderCache.Acquire();
2203
2204             String fn = nGetFriendlyName();
2205             if (fn != null) {
2206                 sb.Append(Environment.GetResourceString("Loader_Name") + fn);
2207                 sb.Append(Environment.NewLine);
2208             }
2209
2210             if(_Policies == null || _Policies.Length == 0)
2211                 sb.Append(Environment.GetResourceString("Loader_NoContextPolicies")
2212                           + Environment.NewLine);
2213             else {
2214                 sb.Append(Environment.GetResourceString("Loader_ContextPolicies")
2215                           + Environment.NewLine);
2216                 for(int i = 0;i < _Policies.Length; i++) {
2217                     sb.Append(_Policies[i]);
2218                     sb.Append(Environment.NewLine);
2219                 }
2220             }
2221
2222             return StringBuilderCache.GetStringAndRelease(sb);
2223         }
2224
2225         public Assembly[] GetAssemblies()
2226         {
2227             return nGetAssemblies(false /* forIntrospection */);
2228         }
2229
2230
2231         public Assembly[] ReflectionOnlyGetAssemblies()
2232         {
2233             return nGetAssemblies(true /* forIntrospection */);
2234         }
2235
2236         [System.Security.SecuritySafeCritical]  // auto-generated
2237         [ResourceExposure(ResourceScope.None)]
2238         [MethodImplAttribute(MethodImplOptions.InternalCall)]
2239         private extern Assembly[] nGetAssemblies(bool forIntrospection);
2240
2241         // this is true when we've removed the handles etc so really can't do anything
2242         [System.Security.SecurityCritical]  // auto-generated
2243         [ResourceExposure(ResourceScope.None)]
2244         [MethodImplAttribute(MethodImplOptions.InternalCall)]
2245         internal extern bool IsUnloadingForcedFinalize();
2246
2247     // this is true when we've just started going through the finalizers and are forcing objects to finalize
2248     // so must be aware that certain infrastructure may have gone away
2249         [System.Security.SecuritySafeCritical]  // auto-generated
2250         [ResourceExposure(ResourceScope.None)]
2251         [MethodImplAttribute(MethodImplOptions.InternalCall)]
2252         public extern bool IsFinalizingForUnload();
2253
2254         [System.Security.SecurityCritical]  // auto-generated
2255         [MethodImplAttribute(MethodImplOptions.InternalCall)]
2256         internal static extern void PublishAnonymouslyHostedDynamicMethodsAssembly(RuntimeAssembly assemblyHandle);
2257
2258 #if  FEATURE_FUSION
2259         // Appends the following string to the private path. Valid paths
2260         // are of the form "bin;util/i386" etc.
2261         [System.Security.SecurityCritical]  // auto-generated_required
2262         [Obsolete("AppDomain.AppendPrivatePath has been deprecated. Please investigate the use of AppDomainSetup.PrivateBinPath instead. http://go.microsoft.com/fwlink/?linkid=14202")]
2263         [ResourceExposure(ResourceScope.Machine)]
2264         [ResourceConsumption(ResourceScope.Machine)]
2265         public void AppendPrivatePath(String path)
2266         {
2267             if(path == null || path.Length == 0)
2268                 return;
2269
2270             String current = FusionStore.Value[(int) AppDomainSetup.LoaderInformation.PrivateBinPathValue];
2271             StringBuilder appendPath = StringBuilderCache.Acquire();
2272
2273             if(current != null && current.Length > 0) {
2274                 // See if the last character is a separator
2275                 appendPath.Append(current);
2276                 if((current[current.Length-1] != Path.PathSeparator) &&
2277                    (path[0] != Path.PathSeparator))
2278                     appendPath.Append(Path.PathSeparator);
2279             }
2280             appendPath.Append(path);
2281
2282             String result = StringBuilderCache.GetStringAndRelease(appendPath);
2283             InternalSetPrivateBinPath(result);
2284         }
2285
2286
2287         [System.Security.SecurityCritical]  // auto-generated_required
2288         [Obsolete("AppDomain.ClearPrivatePath has been deprecated. Please investigate the use of AppDomainSetup.PrivateBinPath instead. http://go.microsoft.com/fwlink/?linkid=14202")]
2289         [ResourceExposure(ResourceScope.None)]
2290         [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
2291         public void ClearPrivatePath()
2292         {
2293             InternalSetPrivateBinPath(String.Empty);
2294         }
2295
2296         [System.Security.SecurityCritical]  // auto-generated_required
2297         [Obsolete("AppDomain.ClearShadowCopyPath has been deprecated. Please investigate the use of AppDomainSetup.ShadowCopyDirectories instead. http://go.microsoft.com/fwlink/?linkid=14202")]
2298         [ResourceExposure(ResourceScope.None)]
2299         [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
2300         public void ClearShadowCopyPath()
2301         {
2302             InternalSetShadowCopyPath(String.Empty);
2303         }
2304
2305         [System.Security.SecurityCritical]  // auto-generated_required
2306         [Obsolete("AppDomain.SetCachePath has been deprecated. Please investigate the use of AppDomainSetup.CachePath instead. http://go.microsoft.com/fwlink/?linkid=14202")]
2307         [ResourceExposure(ResourceScope.Machine)]
2308         [ResourceConsumption(ResourceScope.Machine)]
2309         public void SetCachePath(String path)
2310         {
2311             InternalSetCachePath(path);
2312         }
2313 #endif // FEATURE_FUSION
2314
2315         [System.Security.SecurityCritical]  // auto-generated_required
2316         [ResourceExposure(ResourceScope.AppDomain)]
2317         [ResourceConsumption(ResourceScope.AppDomain)]
2318         public void SetData (string name, object data) {
2319 #if FEATURE_CORECLR
2320             if (!name.Equals("LOCATION_URI"))
2321             {
2322                 // Only LOCATION_URI can be set using AppDomain.SetData
2323                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_SetData_OnlyLocationURI", name));
2324             }
2325 #endif // FEATURE_CORECLR
2326             SetDataHelper(name, data, null);
2327         }
2328
2329         [System.Security.SecurityCritical]  // auto-generated_required
2330         [ResourceExposure(ResourceScope.AppDomain)]
2331         [ResourceConsumption(ResourceScope.AppDomain)]
2332         public void SetData (string name, object data, IPermission permission) {
2333 #if FEATURE_CORECLR
2334             if (!name.Equals("LOCATION_URI"))
2335             {
2336                 // Only LOCATION_URI can be set using AppDomain.SetData
2337                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_SetData_OnlyLocationURI", name));
2338             }
2339 #endif // FEATURE_CORECLR
2340             SetDataHelper(name, data, permission);
2341         }
2342
2343         [System.Security.SecurityCritical]  // auto-generated
2344         [ResourceExposure(ResourceScope.AppDomain)]
2345         [ResourceConsumption(ResourceScope.Machine, ResourceScope.AppDomain)]
2346         private void SetDataHelper (string name, object data, IPermission permission) {
2347             if (name == null)
2348                 throw new ArgumentNullException("name");
2349             Contract.EndContractBlock();
2350
2351             //
2352             // Synopsis:
2353             //   IgnoreSystemPolicy is provided as a legacy flag to allow callers to
2354             //   skip enterprise, machine and user policy levels. When this flag is set,
2355             //   any demands triggered in this AppDomain will be evaluated against the
2356             //   AppDomain CAS policy level that is set on the AppDomain.
2357             // Security Requirements:
2358             //   The caller needs to be fully trusted in order to be able to set
2359             //   this legacy mode.
2360             // Remarks:
2361             //   There needs to be an AppDomain policy level set before this compat
2362             //   switch can be set on the AppDomain.
2363             //
2364 #if FEATURE_FUSION
2365             if (name.Equals(TargetFrameworkNameAppCompatSetting)) {
2366                 _FusionStore.TargetFrameworkName = (String) data;
2367                 return;
2368             }
2369 #if FEATURE_CAS_POLICY
2370             if (name.Equals("IgnoreSystemPolicy")) {
2371                 lock (this) {
2372                     if (!_HasSetPolicy)
2373                         throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_SetData"));
2374                 }
2375                 new PermissionSet(PermissionState.Unrestricted).Demand();
2376             }
2377 #endif
2378             int key = AppDomainSetup.Locate(name);
2379
2380             if(key == -1) {
2381                 lock (((ICollection)LocalStore).SyncRoot) {
2382                     LocalStore[name] = new object[] {data, permission};
2383                 }
2384             }
2385             else {
2386                 if (permission != null)
2387                     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_SetData"));
2388                 // Be sure to call these properties, not Value, since
2389                 // these do more than call Value.
2390                 switch(key) {
2391                 case (int) AppDomainSetup.LoaderInformation.DynamicBaseValue:
2392                     FusionStore.DynamicBase = (string) data;
2393                     break;
2394                 case (int) AppDomainSetup.LoaderInformation.DevPathValue:
2395                     FusionStore.DeveloperPath = (string) data;
2396                     break;
2397                 case (int) AppDomainSetup.LoaderInformation.ShadowCopyDirectoriesValue:
2398                     FusionStore.ShadowCopyDirectories = (string) data;
2399                     break;
2400                 case (int) AppDomainSetup.LoaderInformation.DisallowPublisherPolicyValue:
2401                     if(data != null)
2402                         FusionStore.DisallowPublisherPolicy = true;
2403                     else
2404                         FusionStore.DisallowPublisherPolicy = false;
2405                     break;
2406                 case (int) AppDomainSetup.LoaderInformation.DisallowCodeDownloadValue:
2407                     if (data != null)
2408                          FusionStore.DisallowCodeDownload = true;
2409                     else
2410                         FusionStore.DisallowCodeDownload = false;
2411                     break;
2412                 case (int) AppDomainSetup.LoaderInformation.DisallowBindingRedirectsValue:
2413                     if(data != null)
2414                         FusionStore.DisallowBindingRedirects = true;
2415                     else
2416                         FusionStore.DisallowBindingRedirects = false;
2417                     break;
2418                 case (int) AppDomainSetup.LoaderInformation.DisallowAppBaseProbingValue:
2419                     if(data != null)
2420                         FusionStore.DisallowApplicationBaseProbing = true;
2421                     else
2422                         FusionStore.DisallowApplicationBaseProbing = false;
2423                     break;
2424                 case (int) AppDomainSetup.LoaderInformation.ConfigurationBytesValue:
2425                     FusionStore.SetConfigurationBytes((byte[]) data);
2426                     break;
2427                 default:
2428                     FusionStore.Value[key] = (string) data;
2429                     break;
2430                 }
2431             }
2432 #else // FEATURE_FUSION
2433 #if FEATURE_CORECLR
2434             // SetData should only be used to set values that don't already exist.
2435             {
2436                 object[] currentVal;
2437                 lock (((ICollection)LocalStore).SyncRoot) {
2438                     LocalStore.TryGetValue(name, out currentVal);
2439                 }
2440                 if (currentVal != null && currentVal[0] != null)
2441                 {
2442                     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_SetData_OnlyOnce"));
2443                 }
2444             }
2445
2446 #endif // FEATURE_CORECLR
2447             lock (((ICollection)LocalStore).SyncRoot) {
2448                 LocalStore[name] = new object[] {data, permission};
2449             }
2450 #endif // FEATURE_FUSION
2451         }
2452
2453         [Pure]
2454         #if FEATURE_CORECLR
2455         [System.Security.SecurityCritical] // auto-generated
2456         #else
2457         [System.Security.SecuritySafeCritical]
2458         #endif
2459         [ResourceExposure(ResourceScope.AppDomain)]
2460         [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
2461         public Object GetData(string name)
2462         {
2463             if(name == null)
2464                 throw new ArgumentNullException("name");
2465             Contract.EndContractBlock();
2466
2467             int key = AppDomainSetup.Locate(name);
2468             if(key == -1)
2469             {
2470 #if FEATURE_LOADER_OPTIMIZATION
2471                 if(name.Equals(AppDomainSetup.LoaderOptimizationKey))
2472                     return FusionStore.LoaderOptimization;
2473                 else
2474 #endif // FEATURE_LOADER_OPTIMIZATION
2475                 {
2476                     object[] data;
2477                     lock (((ICollection)LocalStore).SyncRoot) {
2478                         LocalStore.TryGetValue(name, out data);
2479                     }
2480                     if (data == null)
2481                         return null;
2482                     if (data[1] != null) {
2483                         IPermission permission = (IPermission) data[1];
2484                         permission.Demand();
2485                     }
2486                     return data[0];
2487                 }
2488             }
2489            else {
2490                 // Be sure to call these properties, not Value, so
2491                 // that the appropriate permission demand will be done
2492                 switch(key) {
2493                 case (int) AppDomainSetup.LoaderInformation.ApplicationBaseValue:
2494                     return FusionStore.ApplicationBase;
2495                 case (int) AppDomainSetup.LoaderInformation.ApplicationNameValue:
2496                     return FusionStore.ApplicationName;
2497 #if FEATURE_FUSION
2498                 case (int) AppDomainSetup.LoaderInformation.ConfigurationFileValue:
2499                     return FusionStore.ConfigurationFile;
2500                 case (int) AppDomainSetup.LoaderInformation.DynamicBaseValue:
2501                     return FusionStore.DynamicBase;
2502                 case (int) AppDomainSetup.LoaderInformation.DevPathValue:
2503                     return FusionStore.DeveloperPath;
2504                 case (int) AppDomainSetup.LoaderInformation.PrivateBinPathValue:
2505                     return FusionStore.PrivateBinPath;
2506                 case (int) AppDomainSetup.LoaderInformation.PrivateBinPathProbeValue:
2507                     return FusionStore.PrivateBinPathProbe;
2508                 case (int) AppDomainSetup.LoaderInformation.ShadowCopyDirectoriesValue:
2509                     return FusionStore.ShadowCopyDirectories;
2510                 case (int) AppDomainSetup.LoaderInformation.ShadowCopyFilesValue:
2511                     return FusionStore.ShadowCopyFiles;
2512                 case (int) AppDomainSetup.LoaderInformation.CachePathValue:
2513                     return FusionStore.CachePath;
2514                 case (int) AppDomainSetup.LoaderInformation.LicenseFileValue:
2515                     return FusionStore.LicenseFile;
2516                 case (int) AppDomainSetup.LoaderInformation.DisallowPublisherPolicyValue:
2517                     return FusionStore.DisallowPublisherPolicy;
2518                 case (int) AppDomainSetup.LoaderInformation.DisallowCodeDownloadValue:
2519                     return FusionStore.DisallowCodeDownload;
2520                 case (int) AppDomainSetup.LoaderInformation.DisallowBindingRedirectsValue:
2521                     return FusionStore.DisallowBindingRedirects;
2522                 case (int) AppDomainSetup.LoaderInformation.DisallowAppBaseProbingValue:
2523                     return FusionStore.DisallowApplicationBaseProbing;
2524                 case (int) AppDomainSetup.LoaderInformation.ConfigurationBytesValue:
2525                     return FusionStore.GetConfigurationBytes();
2526 #endif //FEATURE_FUSION
2527
2528                 default:
2529                     Contract.Assert(false, "Need to handle new LoaderInformation value in AppDomain.GetData()");
2530                     return null;
2531                 }
2532             }
2533
2534         }
2535
2536         // The compat flags are set at domain creation time to indicate that the given breaking
2537         // change should not be used in this domain.
2538         //
2539         // After the domain has been created, this Nullable boolean returned by this method should
2540         // always have a value.  Code in the runtime uses this to know if it is safe to cache values
2541         // that might change if the compatibility switches have not been set yet.
2542         public Nullable<bool> IsCompatibilitySwitchSet(String value)
2543         {
2544             Nullable<bool> fReturn;
2545
2546             if (_compatFlagsInitialized == false)
2547             {
2548                 fReturn = new Nullable<bool>();
2549             }
2550             else
2551             {
2552                 fReturn  = new Nullable<bool>(_compatFlags != null && _compatFlags.ContainsKey(value));
2553             }
2554
2555             return fReturn;
2556         }
2557
2558         [Obsolete("AppDomain.GetCurrentThreadId has been deprecated because it does not provide a stable Id when managed threads are running on fibers (aka lightweight threads). To get a stable identifier for a managed thread, use the ManagedThreadId property on Thread.  http://go.microsoft.com/fwlink/?linkid=14202", false)]
2559         [DllImport(Microsoft.Win32.Win32Native.KERNEL32)]
2560         [ResourceExposure(ResourceScope.Process)]
2561         public static extern int GetCurrentThreadId();
2562
2563 #if FEATURE_REMOTING
2564         [System.Security.SecuritySafeCritical]  // auto-generated
2565         [SecurityPermissionAttribute( SecurityAction.Demand, ControlAppDomain = true ),
2566          ReliabilityContract(Consistency.MayCorruptAppDomain, Cer.MayFail)]
2567         public static void Unload(AppDomain domain)
2568         {
2569             if (domain == null)
2570                 throw new ArgumentNullException("domain");
2571             Contract.EndContractBlock();
2572
2573             try {
2574                 Int32 domainID = AppDomain.GetIdForUnload(domain);
2575                 if (domainID==0)
2576                     throw new CannotUnloadAppDomainException();
2577                 AppDomain.nUnload(domainID);
2578             }
2579             catch(Exception e) {
2580                 throw e;    // throw it again to reset stack trace
2581             }
2582         }
2583 #endif
2584
2585         // Explicitly set policy for a domain (providing policy hasn't been set
2586         // previously). Making this call will guarantee that previously loaded
2587         // assemblies will be granted permissions based on the default machine
2588         // policy that was in place prior to this call.
2589 #if FEATURE_CAS_POLICY
2590         [System.Security.SecurityCritical]  // auto-generated_required
2591         [Obsolete("AppDomain policy levels are obsolete and will be removed in a future release of the .NET Framework. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
2592         public void SetAppDomainPolicy(PolicyLevel domainPolicy)
2593         {
2594             if (domainPolicy == null)
2595                 throw new ArgumentNullException("domainPolicy");
2596             Contract.EndContractBlock();
2597
2598             if (!IsLegacyCasPolicyEnabled)
2599             {
2600                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyExplicit"));
2601             }
2602
2603             // Check that policy has not been set previously.
2604             lock (this) {
2605                 if (_HasSetPolicy)
2606                     throw new PolicyException(Environment.GetResourceString("Policy_PolicyAlreadySet"));
2607                 _HasSetPolicy = true;
2608
2609                 // Make sure that the loader allows us to change security policy
2610                 // at this time (this will throw if not.)
2611                 nChangeSecurityPolicy();
2612             }
2613
2614             // Add the new policy level.
2615             SecurityManager.PolicyManager.AddLevel(domainPolicy);
2616         }
2617 #endif //#if !FEATURE_CAS_POLICY
2618 #if FEATURE_CLICKONCE
2619         public ActivationContext ActivationContext {
2620             [System.Security.SecurityCritical]  // auto-generated_required
2621             get {
2622                 return _activationContext;
2623             }
2624         }
2625
2626         public ApplicationIdentity ApplicationIdentity {
2627             [System.Security.SecurityCritical]  // auto-generated_required
2628             get {
2629                 return _applicationIdentity;
2630             }
2631         }
2632 #endif // FEATURE_CLICKONCE
2633
2634
2635 #if FEATURE_CLICKONCE
2636         public ApplicationTrust ApplicationTrust {
2637             [System.Security.SecurityCritical]  // auto-generated_required
2638 #else // FEATURE_CLICKONCE
2639         internal ApplicationTrust ApplicationTrust {
2640 #endif // FEATURE_CLICKONCE
2641             get {
2642                 if (_applicationTrust == null && _IsFastFullTrustDomain) {
2643                     _applicationTrust = new ApplicationTrust(new PermissionSet(PermissionState.Unrestricted));
2644                 }
2645
2646                 return _applicationTrust;
2647             }
2648         }
2649
2650 #if FEATURE_IMPERSONATION
2651         // Set the default principal object to be attached to threads if they
2652         // attempt to bind to a principal while executing in this appdomain. The
2653         // default can only be set once.
2654         [System.Security.SecuritySafeCritical]  // auto-generated
2655         [SecurityPermissionAttribute(SecurityAction.Demand, Flags=SecurityPermissionFlag.ControlPrincipal)]
2656         public void SetThreadPrincipal(IPrincipal principal)
2657         {
2658             if (principal == null)
2659                 throw new ArgumentNullException("principal");
2660             Contract.EndContractBlock();
2661
2662             lock (this) {
2663                 // Check that principal has not been set previously.
2664                 if (_DefaultPrincipal != null)
2665                     throw new PolicyException(Environment.GetResourceString("Policy_PrincipalTwice"));
2666
2667                 _DefaultPrincipal = principal;
2668             }
2669         }
2670 #endif // FEATURE_IMPERSONATION
2671
2672 #if FEATURE_CAS_POLICY
2673         // Similar to the above, but sets the class of principal to be created
2674         // instead.
2675         [System.Security.SecuritySafeCritical]  // auto-generated
2676         [SecurityPermissionAttribute(SecurityAction.Demand, Flags=SecurityPermissionFlag.ControlPrincipal)]
2677         public void SetPrincipalPolicy(PrincipalPolicy policy)
2678         {
2679             _PrincipalPolicy = policy;
2680         }
2681 #endif
2682
2683
2684 #if FEATURE_REMOTING
2685         // This method gives AppDomain an infinite life time by preventing a lease from being
2686         // created
2687         [System.Security.SecurityCritical]  // auto-generated_required
2688         public override Object InitializeLifetimeService()
2689         {
2690             return null;
2691         }
2692         // This is useful for requesting execution of some code
2693         // in another appDomain ... the delegate may be defined
2694         // on a marshal-by-value object or a marshal-by-ref or
2695         // contextBound object.
2696         public void DoCallBack(CrossAppDomainDelegate callBackDelegate)
2697         {
2698             if (callBackDelegate == null)
2699                 throw new ArgumentNullException("callBackDelegate");
2700             Contract.EndContractBlock();
2701
2702             callBackDelegate();
2703         }
2704 #endif
2705
2706
2707         public String DynamicDirectory
2708         {
2709             [System.Security.SecuritySafeCritical]  // auto-generated
2710             [ResourceExposure(ResourceScope.Machine)]
2711             [ResourceConsumption(ResourceScope.Machine)]
2712             get {
2713                 String dyndir = GetDynamicDir();
2714                 if (dyndir != null)
2715                     FileIOPermission.QuickDemand(FileIOPermissionAccess.PathDiscovery, dyndir);
2716
2717                 return dyndir;
2718             }
2719         }
2720
2721 #if FEATURE_CAS_POLICY
2722         [ResourceExposure(ResourceScope.None)]
2723         [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
2724         public static AppDomain CreateDomain(String friendlyName,
2725                                              Evidence securityInfo) // Optional
2726         {
2727             return CreateDomain(friendlyName,
2728                                 securityInfo,
2729                                 null);
2730         }
2731
2732         [ResourceExposure(ResourceScope.Machine)]
2733         [ResourceConsumption(ResourceScope.Machine)]
2734         public static AppDomain CreateDomain(String friendlyName,
2735                                              Evidence securityInfo, // Optional
2736                                              String appBasePath,
2737                                              String appRelativeSearchPath,
2738                                              bool shadowCopyFiles)
2739         {
2740             AppDomainSetup info = new AppDomainSetup();
2741             info.ApplicationBase = appBasePath;
2742             info.PrivateBinPath = appRelativeSearchPath;
2743             if(shadowCopyFiles)
2744                 info.ShadowCopyFiles = "true";
2745
2746             return CreateDomain(friendlyName,
2747                                 securityInfo,
2748                                 info);
2749         }
2750 #endif // #if FEATURE_CAS_POLICY    (not exposed in core)
2751
2752
2753         [System.Security.SecurityCritical]  // auto-generated
2754         [ResourceExposure(ResourceScope.Machine)]
2755         [MethodImplAttribute(MethodImplOptions.InternalCall)]
2756         extern private String GetDynamicDir();
2757
2758         // Private helpers called from unmanaged code.
2759
2760 #if FEATURE_REMOTING
2761
2762         [ResourceExposure(ResourceScope.None)]
2763         [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
2764         public static AppDomain CreateDomain(String friendlyName)
2765         {
2766             return CreateDomain(friendlyName, null, null);
2767         }
2768
2769
2770         // Marshal a single object into a serialized blob.
2771         [System.Security.SecurityCritical]  // auto-generated
2772         private static byte[] MarshalObject(Object o)
2773         {
2774             CodeAccessPermission.Assert(true);
2775
2776             return Serialize(o);
2777         }
2778
2779         // Marshal two objects into serialized blobs.
2780         [System.Security.SecurityCritical]  // auto-generated
2781         private static byte[] MarshalObjects(Object o1, Object o2, out byte[] blob2)
2782         {
2783             CodeAccessPermission.Assert(true);
2784
2785             byte[] blob1 = Serialize(o1);
2786             blob2 = Serialize(o2);
2787             return blob1;
2788         }
2789
2790         // Unmarshal a single object from a serialized blob.
2791         [System.Security.SecurityCritical]  // auto-generated
2792         private static Object UnmarshalObject(byte[] blob)
2793         {
2794             CodeAccessPermission.Assert(true);
2795
2796             return Deserialize(blob);
2797         }
2798
2799         // Unmarshal two objects from serialized blobs.
2800         [System.Security.SecurityCritical]  // auto-generated
2801         private static Object UnmarshalObjects(byte[] blob1, byte[] blob2, out Object o2)
2802         {
2803             CodeAccessPermission.Assert(true);
2804
2805             Object o1 = Deserialize(blob1);
2806             o2 = Deserialize(blob2);
2807             return o1;
2808         }
2809
2810         // Helper routines.
2811         [System.Security.SecurityCritical]  // auto-generated
2812         private static byte[] Serialize(Object o)
2813         {
2814             if (o == null)
2815             {
2816                 return null;
2817             }
2818             else if (o is ISecurityEncodable)
2819             {
2820                 SecurityElement element = ((ISecurityEncodable)o).ToXml();
2821                 MemoryStream ms = new MemoryStream( 4096 );
2822                 ms.WriteByte( 0 );
2823                 StreamWriter writer = new StreamWriter( ms, Encoding.UTF8 );
2824                 element.ToWriter( writer );
2825                 writer.Flush();
2826                 return ms.ToArray();
2827             }
2828             else
2829             {
2830                 MemoryStream ms = new MemoryStream();
2831                 ms.WriteByte( 1 );
2832                 CrossAppDomainSerializer.SerializeObject(o, ms);
2833                 return ms.ToArray();
2834             }
2835         }
2836
2837         [System.Security.SecurityCritical]  // auto-generated
2838         private static Object Deserialize(byte[] blob)
2839         {
2840             if (blob == null)
2841                 return null;
2842
2843             if (blob[0] == 0)
2844             {
2845                 Parser parser = new Parser( blob, Tokenizer.ByteTokenEncoding.UTF8Tokens, 1 );
2846                 SecurityElement root = parser.GetTopElement();
2847                 if (root.Tag.Equals( "IPermission" ) || root.Tag.Equals( "Permission" ))
2848                 {
2849                     IPermission ip = System.Security.Util.XMLUtil.CreatePermission( root, PermissionState.None, false );
2850
2851                     if (ip == null)
2852                     {
2853                         return null;
2854                     }
2855
2856                     ip.FromXml( root );
2857
2858                     return ip;
2859                 }
2860                 else if (root.Tag.Equals( "PermissionSet" ))
2861                 {
2862                     PermissionSet permissionSet = new PermissionSet();
2863
2864                     permissionSet.FromXml( root, false, false );
2865
2866                     return permissionSet;
2867                 }
2868                 else if (root.Tag.Equals( "PermissionToken" ))
2869                 {
2870                     PermissionToken pToken = new PermissionToken();
2871
2872                     pToken.FromXml( root );
2873
2874                     return pToken;
2875                 }
2876                 else
2877                 {
2878                     return null;
2879                 }
2880
2881             }
2882             else
2883             {
2884                 Object obj = null;
2885                 using(MemoryStream stream = new MemoryStream( blob, 1, blob.Length - 1 )) {
2886                     obj = CrossAppDomainSerializer.DeserializeObject(stream);
2887                 }
2888
2889                 Contract.Assert( !(obj is IPermission), "IPermission should be xml deserialized" );
2890                 Contract.Assert( !(obj is PermissionSet), "PermissionSet should be xml deserialized" );
2891
2892                 return obj;
2893             }
2894         }
2895
2896 #endif // FEATURE_REMOTING
2897
2898 #if FEATURE_LEGACYNETCFFAS
2899         public static IAppDomainPauseManager PauseManager
2900         {
2901             [System.Security.SecurityCritical]
2902             get
2903             {
2904                 return AppDomainPauseManager.Instance;
2905             }
2906         }
2907 #endif // FEATURE_LEGACYNETCFFAS
2908
2909 #if !FEATURE_CORECLR
2910         //
2911         // Called by the VM if ICLRExecutionManager::Pause is called with the PAUSE_APP_DOMAINS flag.
2912         // This mimics the behavior of the CoreCLR FAS (fast application switching) model, to ensure
2913         // that code that depends on things happening in a particular order will work.
2914         //
2915         [System.Security.SecurityCritical]
2916         internal static void Pause()
2917         {
2918             AppDomainPauseManager.Instance.Pausing();
2919             AppDomainPauseManager.Instance.Paused();
2920         }
2921
2922         //
2923         // Called by the VM if ICLRExecutionManager::Resume is called after ICLRExecutionManager::Pause
2924         // was called with the PAUSE_APP_DOMAINS flag.
2925         // This mimics the behavior of the CoreCLR FAS (fast application switching) model, to ensure
2926         // that code that depends on things happening in a particular order will work.
2927         //
2928         [System.Security.SecurityCritical]
2929         internal static void Resume()
2930         {
2931             if (AppDomainPauseManager.IsPaused)
2932             {
2933                 AppDomainPauseManager.Instance.Resuming();
2934                 AppDomainPauseManager.Instance.Resumed();
2935             }
2936         }
2937 #endif
2938
2939         private AppDomain() {
2940             throw new NotSupportedException(Environment.GetResourceString(ResId.NotSupported_Constructor));
2941         }
2942
2943         [System.Security.SecuritySafeCritical]  // auto-generated
2944         [ResourceExposure(ResourceScope.None)]
2945         [MethodImplAttribute(MethodImplOptions.InternalCall)]
2946         private extern int _nExecuteAssembly(RuntimeAssembly assembly, String[] args);
2947         internal int nExecuteAssembly(RuntimeAssembly assembly, String[] args)
2948         {
2949             return _nExecuteAssembly(assembly, args);
2950         }
2951
2952 #if FEATURE_VERSIONING
2953         [MethodImplAttribute(MethodImplOptions.InternalCall)]
2954         internal extern void nCreateContext();
2955
2956         [System.Security.SecurityCritical]
2957         [ResourceExposure(ResourceScope.None)]
2958         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
2959         [SuppressUnmanagedCodeSecurity]
2960         private static extern void nSetupBindingPaths(String trustedPlatformAssemblies, String platformResourceRoots, String appPath, String appNiPaths, String appLocalWinMD);
2961
2962         #if FEATURE_CORECLR
2963         [System.Security.SecurityCritical] // auto-generated
2964         #endif
2965         internal void SetupBindingPaths(String trustedPlatformAssemblies, String platformResourceRoots, String appPath, String appNiPaths, String appLocalWinMD)
2966         {
2967             nSetupBindingPaths(trustedPlatformAssemblies, platformResourceRoots, appPath, appNiPaths, appLocalWinMD);
2968         }
2969 #endif // FEATURE_VERSIONING
2970
2971 #if FEATURE_REMOTING
2972         internal void CreateRemotingData()
2973         {
2974                     lock(this) {
2975                         if (_RemotingData == null)
2976                             _RemotingData = new DomainSpecificRemotingData();
2977                     }
2978         }
2979
2980         internal DomainSpecificRemotingData RemotingData
2981         {
2982             get
2983             {
2984                 if (_RemotingData == null)
2985                     CreateRemotingData();
2986
2987                 return _RemotingData;
2988             }
2989         }
2990 #endif // FEATURE_REMOTING
2991
2992         [System.Security.SecurityCritical]  // auto-generated
2993         [ResourceExposure(ResourceScope.None)]
2994         [MethodImplAttribute(MethodImplOptions.InternalCall)]
2995         private extern String nGetFriendlyName();
2996         [System.Security.SecurityCritical]  // auto-generated
2997         [ResourceExposure(ResourceScope.None)]
2998         [MethodImplAttribute(MethodImplOptions.InternalCall)]
2999         private extern bool nIsDefaultAppDomainForEvidence();
3000
3001         // support reliability for certain event handlers, if the target
3002         // methods also participate in this discipline.  If caller passes
3003         // an existing MulticastDelegate, then we could use a MDA to indicate
3004         // that reliability is not guaranteed.  But if it is a single cast
3005         // scenario, we can make it work.
3006
3007         public event EventHandler ProcessExit
3008         {
3009             [System.Security.SecuritySafeCritical]  // auto-generated_required
3010             add
3011             {
3012                 if (value != null)
3013                 {
3014                     RuntimeHelpers.PrepareContractedDelegate(value);
3015                     lock(this)
3016                         _processExit += value;
3017                 }
3018             }
3019             remove
3020             {
3021                 lock(this)
3022                     _processExit -= value;
3023             }
3024         }
3025
3026
3027         public event EventHandler DomainUnload
3028         {
3029             [System.Security.SecuritySafeCritical]  // auto-generated_required
3030             add
3031             {
3032                 if (value != null)
3033                 {
3034                     RuntimeHelpers.PrepareContractedDelegate(value);
3035                     lock(this)
3036                         _domainUnload += value;
3037                 }
3038             }
3039 #if FEATURE_CORECLR
3040             [System.Security.SecuritySafeCritical]
3041 #endif
3042             remove
3043             {
3044                 lock(this)
3045                     _domainUnload -= value;
3046             }
3047         }
3048
3049
3050         public event UnhandledExceptionEventHandler UnhandledException
3051         {
3052             [System.Security.SecurityCritical]  // auto-generated_required
3053             add
3054             {
3055                 if (value != null)
3056                 {
3057                     RuntimeHelpers.PrepareContractedDelegate(value);
3058                     lock(this)
3059                         _unhandledException += value;
3060                 }
3061             }
3062             [System.Security.SecurityCritical]  // auto-generated_required
3063             remove
3064             {
3065                 lock(this)
3066                     _unhandledException -= value;
3067             }
3068         }
3069
3070 #if FEATURE_EXCEPTION_NOTIFICATIONS
3071         // This is the event managed code can wireup against to be notified
3072         // about first chance exceptions.
3073         //
3074         // To register/unregister the callback, the code must be SecurityCritical.
3075         public event EventHandler<FirstChanceExceptionEventArgs> FirstChanceException
3076         {
3077             [System.Security.SecurityCritical]  // auto-generated_required
3078             add
3079             {
3080                 if (value != null)
3081                 {
3082                     RuntimeHelpers.PrepareContractedDelegate(value);
3083                     lock(this)
3084                         _firstChanceException += value;
3085                 }
3086             }
3087             [System.Security.SecurityCritical]  // auto-generated_required
3088             remove
3089             {
3090                 lock(this)
3091                     _firstChanceException -= value;
3092             }
3093         }
3094 #endif // FEATURE_EXCEPTION_NOTIFICATIONS
3095
3096         private void OnAssemblyLoadEvent(RuntimeAssembly LoadedAssembly)
3097         {
3098             AssemblyLoadEventHandler eventHandler = AssemblyLoad;
3099             if (eventHandler != null) {
3100                 AssemblyLoadEventArgs ea = new AssemblyLoadEventArgs(LoadedAssembly);
3101                 eventHandler(this, ea);
3102             }
3103         }
3104
3105         // This method is called by the VM.
3106         [System.Security.SecurityCritical]
3107         private RuntimeAssembly OnResourceResolveEvent(RuntimeAssembly assembly, String resourceName)
3108         {
3109             ResolveEventHandler eventHandler = _ResourceResolve;
3110             if ( eventHandler == null)
3111                 return null;
3112
3113             Delegate[] ds = eventHandler.GetInvocationList();
3114             int len = ds.Length;
3115             for (int i = 0; i < len; i++) {
3116                 Assembly asm = ((ResolveEventHandler)ds[i])(this, new ResolveEventArgs(resourceName, assembly));
3117                 RuntimeAssembly ret = GetRuntimeAssembly(asm);
3118                 if (ret != null)
3119                     return ret;
3120             }
3121
3122             return null;
3123         }
3124
3125         // This method is called by the VM
3126         [System.Security.SecurityCritical]
3127         private RuntimeAssembly OnTypeResolveEvent(RuntimeAssembly assembly, String typeName)
3128         {
3129             ResolveEventHandler eventHandler = _TypeResolve;
3130             if (eventHandler == null)
3131                 return null;
3132
3133             Delegate[] ds = eventHandler.GetInvocationList();
3134             int len = ds.Length;
3135             for (int i = 0; i < len; i++) {
3136                 Assembly asm = ((ResolveEventHandler)ds[i])(this, new ResolveEventArgs(typeName, assembly));
3137                 RuntimeAssembly ret = GetRuntimeAssembly(asm);
3138                 if (ret != null)
3139                     return ret;
3140             }
3141
3142             return null;
3143         }
3144
3145         // This method is called by the VM.
3146         [System.Security.SecurityCritical]
3147         private RuntimeAssembly OnAssemblyResolveEvent(RuntimeAssembly assembly, String assemblyFullName)
3148         {
3149             ResolveEventHandler eventHandler = _AssemblyResolve;
3150
3151             if (eventHandler == null)
3152             {
3153                 return null;
3154             }
3155
3156             Delegate[] ds = eventHandler.GetInvocationList();
3157             int len = ds.Length;
3158             for (int i = 0; i < len; i++) {
3159                 Assembly asm = ((ResolveEventHandler)ds[i])(this, new ResolveEventArgs(assemblyFullName, assembly));
3160                 RuntimeAssembly ret = GetRuntimeAssembly(asm);
3161                 if (ret != null)
3162                     return ret;
3163             }
3164
3165             return null;
3166         }
3167
3168 #if FEATURE_REFLECTION_ONLY_LOAD
3169
3170         private RuntimeAssembly OnReflectionOnlyAssemblyResolveEvent(RuntimeAssembly  assembly, String assemblyFullName)
3171         {
3172             ResolveEventHandler eventHandler = ReflectionOnlyAssemblyResolve;
3173             if (eventHandler != null) {
3174
3175                 Delegate[] ds = eventHandler.GetInvocationList();
3176                 int len = ds.Length;
3177                 for (int i = 0; i < len; i++) {
3178                     Assembly asm = ((ResolveEventHandler)ds[i])(this, new ResolveEventArgs(assemblyFullName, assembly));
3179                     RuntimeAssembly ret = GetRuntimeAssembly(asm);
3180                     if (ret != null)
3181                         return ret;
3182                 }
3183             }
3184
3185             return null;
3186         }
3187
3188 #if FEATURE_COMINTEROP
3189         // Called by VM - code:CLRPrivTypeCacheReflectionOnlyWinRT::RaiseNamespaceResolveEvent
3190         private RuntimeAssembly[] OnReflectionOnlyNamespaceResolveEvent(RuntimeAssembly assembly, string namespaceName)
3191         {
3192             return System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMetadata.OnReflectionOnlyNamespaceResolveEvent(this, assembly, namespaceName);
3193         }
3194 #endif // FEATURE_COMINTEROP
3195
3196 #endif // FEATURE_REFLECTION_ONLY_LOAD
3197
3198 #if FEATURE_COMINTEROP
3199         // Called by VM - code:CLRPrivTypeCacheWinRT::RaiseDesignerNamespaceResolveEvent
3200         private string[] OnDesignerNamespaceResolveEvent(string namespaceName)
3201         {
3202             return System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMetadata.OnDesignerNamespaceResolveEvent(this, namespaceName);
3203         }
3204 #endif // FEATURE_COMINTEROP
3205
3206         internal AppDomainSetup FusionStore
3207         {
3208             get {
3209                 Contract.Assert(_FusionStore != null,
3210                                 "Fusion store has not been correctly setup in this domain");
3211                 return _FusionStore;
3212             }
3213         }
3214
3215         internal static RuntimeAssembly GetRuntimeAssembly(Assembly asm)
3216         {
3217             if (asm == null)
3218                 return null;
3219
3220             RuntimeAssembly rtAssembly = asm as RuntimeAssembly;
3221             if (rtAssembly != null)
3222                 return rtAssembly;
3223
3224             AssemblyBuilder ab = asm as AssemblyBuilder;
3225             if (ab != null)
3226                 return ab.InternalAssembly;
3227
3228             return null;
3229         }
3230
3231         [ResourceExposure(ResourceScope.AppDomain)]
3232         private Dictionary<String, Object[]> LocalStore
3233         {
3234             get {
3235                 if (_LocalStore != null)
3236                     return _LocalStore;
3237                 else {
3238                     _LocalStore = new Dictionary<String, Object[]>();
3239                     return _LocalStore;
3240                 }
3241             }
3242         }
3243
3244 #if FEATURE_FUSION
3245         private void TurnOnBindingRedirects()
3246         {
3247             _FusionStore.DisallowBindingRedirects = false;
3248         }
3249 #endif
3250
3251         // This will throw a CannotUnloadAppDomainException if the appdomain is
3252         // in another process.
3253 #if FEATURE_REMOTING
3254         [System.Security.SecurityCritical]  // auto-generated
3255         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
3256         internal static Int32 GetIdForUnload(AppDomain domain)
3257         {
3258             if (RemotingServices.IsTransparentProxy(domain))
3259             {
3260                 return RemotingServices.GetServerDomainIdForProxy(domain);
3261             }
3262             else
3263                 return domain.Id;
3264         }
3265 #endif
3266
3267         // Used to determine if server object context is valid in
3268         // x-domain remoting scenarios.
3269         [System.Security.SecurityCritical]  // auto-generated
3270         [ResourceExposure(ResourceScope.None)]
3271         [MethodImplAttribute(MethodImplOptions.InternalCall)]
3272         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
3273         internal static extern bool IsDomainIdValid(Int32 id);
3274
3275 #if FEATURE_REMOTING
3276         [System.Security.SecurityCritical]  // auto-generated
3277         [ResourceExposure(ResourceScope.None)]
3278         [MethodImplAttribute(MethodImplOptions.InternalCall)]
3279         static internal extern AppDomain GetDefaultDomain();
3280 #endif
3281
3282 #if FEATURE_IMPERSONATION
3283         // Internal routine to retrieve the default principal object. If this is
3284         // called before the principal has been explicitly set, it will
3285         // automatically allocate a default principal based on the policy set by
3286         // SetPrincipalPolicy.
3287         internal IPrincipal GetThreadPrincipal()
3288         {
3289             IPrincipal principal = null;
3290             if (_DefaultPrincipal == null) {
3291 #if FEATURE_CAS_POLICY
3292                 switch (_PrincipalPolicy) {
3293                 case PrincipalPolicy.NoPrincipal:
3294                     principal = null;
3295                     break;
3296                 case PrincipalPolicy.UnauthenticatedPrincipal:
3297                     principal = new GenericPrincipal(new GenericIdentity("", ""),
3298                                                      new String[] {""});
3299                     break;
3300 #if !FEATURE_PAL && FEATURE_IMPERSONATION
3301                 case PrincipalPolicy.WindowsPrincipal:
3302                     principal = new WindowsPrincipal(WindowsIdentity.GetCurrent());
3303                     break;
3304 #endif // !FEATURE_PAL && FEATURE_IMPERSONATION
3305                 default:
3306                     principal = null;
3307                     break;
3308                     }
3309 #else
3310                 principal = new GenericPrincipal(new GenericIdentity("", ""),
3311                                                  new String[] {""});
3312
3313 #endif
3314             }
3315             else
3316                 principal = _DefaultPrincipal;
3317
3318             return principal;
3319         }
3320 #endif // FEATURE_IMPERSONATION
3321
3322 #if FEATURE_REMOTING
3323
3324         [System.Security.SecurityCritical]  // auto-generated
3325         internal void CreateDefaultContext()
3326         {
3327                 lock(this) {
3328                     // if it has not been created we ask the Context class to
3329                     // create a new default context for this appdomain.
3330                     if (_DefaultContext == null)
3331                         _DefaultContext = Context.CreateDefaultContext();
3332                 }
3333         }
3334
3335         [System.Security.SecurityCritical]  // auto-generated
3336         internal Context GetDefaultContext()
3337         {
3338             if (_DefaultContext == null)
3339                 CreateDefaultContext();
3340             return _DefaultContext;
3341         }
3342
3343         // Ensure that evidence provided when creating an AppDomain would not have been used to create a
3344         // sandbox in legacy CAS mode.  If it could have been used to create a sandbox, and we're not in CAS
3345         // mode, then we throw an exception to prevent acciental creation of unsandboxed domains where a
3346         // sandbox would have been expected.
3347         [SecuritySafeCritical]
3348         internal static void CheckDomainCreationEvidence(AppDomainSetup creationDomainSetup,
3349                                                          Evidence creationEvidence)
3350         {
3351             if (creationEvidence != null && !CurrentDomain.IsLegacyCasPolicyEnabled)
3352             {
3353                 if (creationDomainSetup == null || creationDomainSetup.ApplicationTrust == null)
3354                 {
3355                     // We allow non-null evidence in CAS mode to support the common pattern of passing in
3356                     // AppDomain.CurrentDomain.Evidence.  Since the zone evidence must have been changed
3357                     // if the user has any expectation of sandboxing the domain under legacy CAS policy,
3358                     // we use a zone comparison to check for this pattern.  A strict comparison will not
3359                     // work, since MSDN samples for creating a domain show using a modified version of the
3360                     // current domain's evidence and we would capturce people who copied and pasted these
3361                     // samples without intending to sandbox.
3362                     Zone creatorsZone = CurrentDomain.EvidenceNoDemand.GetHostEvidence<Zone>();
3363                     SecurityZone creatorsSecurityZone = creatorsZone != null ?
3364                         creatorsZone.SecurityZone :
3365                         SecurityZone.MyComputer;
3366
3367                     Zone suppliedZone = creationEvidence.GetHostEvidence<Zone>();
3368                     if (suppliedZone != null)
3369                     {
3370                         if (suppliedZone.SecurityZone != creatorsSecurityZone &&
3371                             suppliedZone.SecurityZone != SecurityZone.MyComputer)
3372                         {
3373                             throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit"));
3374                         }
3375                     }
3376                 }
3377             }
3378         }
3379
3380 #if FEATURE_CAS_POLICY
3381         [System.Security.SecuritySafeCritical]  // auto-generated
3382         [SecurityPermissionAttribute( SecurityAction.Demand, ControlAppDomain = true )]
3383         public static AppDomain CreateDomain(String friendlyName,
3384                                       Evidence securityInfo,
3385                                       AppDomainSetup info)
3386         {
3387             return InternalCreateDomain(friendlyName, securityInfo, info);
3388         }
3389 #else
3390         internal static AppDomain CreateDomain(String friendlyName,
3391                                       Evidence securityInfo,
3392                                       AppDomainSetup info)
3393         {
3394             return InternalCreateDomain(friendlyName, securityInfo, info);
3395         }
3396 #endif
3397
3398         [System.Security.SecurityCritical]  // auto-generated
3399         internal static AppDomain InternalCreateDomain(String friendlyName,
3400                                       Evidence securityInfo,
3401                                       AppDomainSetup info)
3402         {
3403             if (friendlyName == null)
3404                 throw new ArgumentNullException(Environment.GetResourceString("ArgumentNull_String"));
3405
3406             Contract.EndContractBlock();
3407
3408             AppDomain.CheckCreateDomainSupported();
3409
3410             if (info == null)
3411                 info = new AppDomainSetup();
3412             if (info.TargetFrameworkName == null)
3413                 info.TargetFrameworkName = AppDomain.CurrentDomain.GetTargetFrameworkName();
3414
3415             AppDomainManager domainManager = AppDomain.CurrentDomain.DomainManager;
3416             if (domainManager != null)
3417                 return domainManager.CreateDomain(friendlyName, securityInfo, info);
3418
3419             // No AppDomainManager is set up for this domain
3420
3421             // If evidence is provided, we check to make sure that is allowed.
3422             if (securityInfo != null)
3423             {
3424                 new SecurityPermission(SecurityPermissionFlag.ControlEvidence).Demand();
3425
3426                 // If we're potentially trying to sandbox without using a homogenous domain, we need to reject
3427                 // the domain creation.
3428                 CheckDomainCreationEvidence(info, securityInfo);
3429             }
3430
3431             return nCreateDomain(friendlyName,
3432                                  info,
3433                                  securityInfo,
3434                                  securityInfo == null ? AppDomain.CurrentDomain.InternalEvidence : null,
3435                                  AppDomain.CurrentDomain.GetSecurityDescriptor());
3436         }
3437 #endif // FEATURE_REMOTING
3438
3439 #if FEATURE_CAS_POLICY
3440
3441 #if !FEATURE_PAL
3442         [ResourceExposure(ResourceScope.Machine)]
3443         [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
3444         public static AppDomain CreateDomain (string friendlyName,
3445                                               Evidence securityInfo,
3446                                               AppDomainSetup info,
3447                                               PermissionSet grantSet,
3448                                               params StrongName[] fullTrustAssemblies)
3449         {
3450             if (info == null)
3451                 throw new ArgumentNullException("info");
3452             if (info.ApplicationBase == null)
3453                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_AppDomainSandboxAPINeedsExplicitAppBase"));
3454             Contract.EndContractBlock();
3455
3456             if (fullTrustAssemblies == null)
3457             {
3458                 fullTrustAssemblies = new StrongName[0];
3459             }
3460
3461             info.ApplicationTrust = new ApplicationTrust(grantSet, fullTrustAssemblies);
3462             return CreateDomain(friendlyName, securityInfo, info);
3463         }
3464
3465 #endif // !FEATURE_PAL
3466
3467         [ResourceExposure(ResourceScope.Machine)]
3468         [ResourceConsumption(ResourceScope.Machine)]
3469         public static AppDomain CreateDomain(String friendlyName,
3470                                              Evidence securityInfo, // Optional
3471                                              String appBasePath,
3472                                              String appRelativeSearchPath,
3473                                              bool shadowCopyFiles,
3474                                              AppDomainInitializer adInit,
3475                                              string[] adInitArgs)
3476         {
3477             AppDomainSetup info = new AppDomainSetup();
3478             info.ApplicationBase = appBasePath;
3479             info.PrivateBinPath = appRelativeSearchPath;
3480             info.AppDomainInitializer=adInit;
3481             info.AppDomainInitializerArguments=adInitArgs;
3482             if(shadowCopyFiles)
3483                 info.ShadowCopyFiles = "true";
3484
3485             return CreateDomain(friendlyName,
3486                                 securityInfo,
3487                                 info);
3488         }
3489 #endif // FEATURE_CAS_POLICY
3490
3491 #if FEATURE_CORECLR
3492         [System.Security.SecurityCritical]
3493         [ResourceExposure(ResourceScope.None)]
3494         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
3495         [SuppressUnmanagedCodeSecurity]
3496         private static extern void nSetNativeDllSearchDirectories(string paths);
3497 #endif
3498
3499         [System.Security.SecurityCritical]  // auto-generated
3500         [ResourceExposure(ResourceScope.None)]
3501         [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
3502         private void SetupFusionStore(AppDomainSetup info, AppDomainSetup oldInfo)
3503         {
3504             Contract.Requires(info != null);
3505
3506 #if FEATURE_FUSION
3507             if (oldInfo == null) {
3508
3509        // Create the application base and configuration file from the imagelocation
3510             // passed in or use the Win32 Image name.
3511             if(info.Value[(int) AppDomainSetup.LoaderInformation.ApplicationBaseValue] == null ||
3512                info.Value[(int) AppDomainSetup.LoaderInformation.ConfigurationFileValue] == null )
3513 #else
3514             if (info.ApplicationBase == null)
3515 #endif
3516
3517             {
3518 #if FEATURE_FUSION
3519                 AppDomain defaultDomain = GetDefaultDomain();
3520                 if (this == defaultDomain) {
3521                     // The default domain gets its defaults from the main process.
3522                     info.SetupDefaults(RuntimeEnvironment.GetModuleFileName(), imageLocationAlreadyNormalized : true);
3523                 }
3524                 else {
3525                     // Other domains get their defaults from the default domain. This way, a host process
3526                     // can use AppDomainManager to set up the defaults for every domain created in the process.
3527                     if (info.Value[(int) AppDomainSetup.LoaderInformation.ConfigurationFileValue] == null)
3528                         info.ConfigurationFile = defaultDomain.FusionStore.Value[(int) AppDomainSetup.LoaderInformation.ConfigurationFileValue];
3529                     if (info.Value[(int) AppDomainSetup.LoaderInformation.ApplicationBaseValue] == null)
3530                         info.ApplicationBase = defaultDomain.FusionStore.Value[(int) AppDomainSetup.LoaderInformation.ApplicationBaseValue];
3531                     if (info.Value[(int) AppDomainSetup.LoaderInformation.ApplicationNameValue] == null)
3532                         info.ApplicationName = defaultDomain.FusionStore.Value[(int) AppDomainSetup.LoaderInformation.ApplicationNameValue];
3533                 }
3534 #else
3535                 info.SetupDefaults(RuntimeEnvironment.GetModuleFileName(), imageLocationAlreadyNormalized : true);
3536 #endif
3537
3538             }
3539
3540 #if FEATURE_FUSION
3541             // If there is no relative path then check the
3542             // environment
3543             if(info.Value[(int) AppDomainSetup.LoaderInformation.PrivateBinPathValue] == null)
3544                 info.PrivateBinPath = Environment.nativeGetEnvironmentVariable(AppDomainSetup.PrivateBinPathEnvironmentVariable);
3545
3546             // Add the developer path if it exists on this
3547             // machine.
3548             if(info.DeveloperPath == null)
3549                 info.DeveloperPath = RuntimeEnvironment.GetDeveloperPath();
3550
3551             }
3552
3553             // Set up the fusion context
3554             IntPtr fusionContext = GetFusionContext();
3555             info.SetupFusionContext(fusionContext, oldInfo);
3556
3557             // Set loader optimization policy
3558 #else
3559 #if FEATURE_VERSIONING
3560             nCreateContext();
3561 #endif // FEATURE_VERSIONING
3562 #endif // FEATURE_FUSION
3563
3564 #if FEATURE_LOADER_OPTIMIZATION
3565             if (info.LoaderOptimization != LoaderOptimization.NotSpecified || (oldInfo != null && info.LoaderOptimization != oldInfo.LoaderOptimization))
3566                 UpdateLoaderOptimization(info.LoaderOptimization);
3567 #endif
3568
3569
3570
3571             // This must be the last action taken
3572             _FusionStore = info;
3573         }
3574
3575         // used to package up evidence, so it can be serialized
3576         //   for the call to InternalRemotelySetupRemoteDomain
3577         [Serializable]
3578         private class EvidenceCollection
3579         {
3580             public Evidence ProvidedSecurityInfo;
3581             public Evidence CreatorsSecurityInfo;
3582         }
3583
3584         private static void RunInitializer(AppDomainSetup setup)
3585         {
3586             if (setup.AppDomainInitializer!=null)
3587             {
3588                 string[] args=null;
3589                 if (setup.AppDomainInitializerArguments!=null)
3590                     args=(string[])setup.AppDomainInitializerArguments.Clone();
3591                 setup.AppDomainInitializer(args);
3592             }
3593         }
3594
3595         // Used to switch into other AppDomain and call SetupRemoteDomain.
3596         //   We cannot simply call through the proxy, because if there
3597         //   are any remoting sinks registered, they can add non-mscorlib
3598         //   objects to the message (causing an assembly load exception when
3599         //   we try to deserialize it on the other side)
3600         [System.Security.SecurityCritical]  // auto-generated
3601         private static object PrepareDataForSetup(String friendlyName,
3602                                                         AppDomainSetup setup,
3603                                                         Evidence providedSecurityInfo,
3604                                                         Evidence creatorsSecurityInfo,
3605                                                         IntPtr parentSecurityDescriptor,
3606                                                         string sandboxName,
3607                                                         string[] propertyNames,
3608                                                         string[] propertyValues)
3609         {
3610             byte[] serializedEvidence = null;
3611             bool generateDefaultEvidence = false;
3612
3613 #if FEATURE_CAS_POLICY
3614             // serialize evidence
3615             EvidenceCollection evidenceCollection = null;
3616
3617             if (providedSecurityInfo != null || creatorsSecurityInfo != null)
3618             {
3619                 // If we're just passing through AppDomain.CurrentDomain.Evidence, and that evidence is just
3620                 // using the standard runtime AppDomainEvidenceFactory, don't waste time serializing it and
3621                 // deserializing it back -- instead, we can recreate a new AppDomainEvidenceFactory in the new
3622                 // domain.  We only want to do this if there is no HostSecurityManager, otherwise the
3623                 // HostSecurityManager could have added additional evidence on top of our standard factory.
3624                 HostSecurityManager hsm = CurrentDomain.DomainManager != null ? CurrentDomain.DomainManager.HostSecurityManager : null;
3625                 bool hostMayContributeEvidence = hsm != null &&
3626                                                  hsm.GetType() != typeof(HostSecurityManager) &&
3627                                                  (hsm.Flags & HostSecurityManagerOptions.HostAppDomainEvidence) == HostSecurityManagerOptions.HostAppDomainEvidence;
3628                 if (!hostMayContributeEvidence)
3629                 {
3630                     if (providedSecurityInfo != null &&
3631                         providedSecurityInfo.IsUnmodified &&
3632                         providedSecurityInfo.Target != null &&
3633                         providedSecurityInfo.Target is AppDomainEvidenceFactory)
3634                     {
3635                         providedSecurityInfo = null;
3636                         generateDefaultEvidence = true;
3637                     }
3638                     if (creatorsSecurityInfo != null &&
3639                         creatorsSecurityInfo.IsUnmodified &&
3640                         creatorsSecurityInfo.Target != null &&
3641                         creatorsSecurityInfo.Target is AppDomainEvidenceFactory)
3642                     {
3643                         creatorsSecurityInfo = null;
3644                         generateDefaultEvidence = true;
3645                     }
3646                 }
3647             }
3648             if ((providedSecurityInfo != null) ||
3649                 (creatorsSecurityInfo != null)) {
3650                 evidenceCollection = new EvidenceCollection();
3651                 evidenceCollection.ProvidedSecurityInfo = providedSecurityInfo;
3652                 evidenceCollection.CreatorsSecurityInfo = creatorsSecurityInfo;
3653             }
3654
3655             if (evidenceCollection != null) {
3656                 serializedEvidence =
3657                     CrossAppDomainSerializer.SerializeObject(evidenceCollection).GetBuffer();
3658             }
3659 #endif // FEATURE_CAS_POLICY
3660
3661             AppDomainInitializerInfo initializerInfo = null;
3662             if (setup!=null && setup.AppDomainInitializer!=null)
3663                 initializerInfo=new AppDomainInitializerInfo(setup.AppDomainInitializer);
3664
3665             // will travel x-Ad, drop non-agile data
3666             AppDomainSetup newSetup = new AppDomainSetup(setup, false);
3667
3668 #if FEATURE_CORECLR
3669             // Remove the special AppDomainCompatSwitch entries from the set of name value pairs
3670             // And add them to the AppDomainSetup
3671             //
3672             // This is only supported on CoreCLR through ICLRRuntimeHost2.CreateAppDomainWithManager
3673             // Desktop code should use System.AppDomain.CreateDomain() or
3674             // System.AppDomainManager.CreateDomain() and add the flags to the AppDomainSetup
3675             List<String> compatList = new List<String>();
3676
3677             if(propertyNames!=null && propertyValues != null)
3678             {
3679                 for (int i=0; i<propertyNames.Length; i++)
3680                 {
3681                     if(String.Compare(propertyNames[i], "AppDomainCompatSwitch", StringComparison.OrdinalIgnoreCase) == 0)
3682                     {
3683                         compatList.Add(propertyValues[i]);
3684                         propertyNames[i] = null;
3685                         propertyValues[i] = null;
3686                     }
3687
3688                 }
3689
3690                 if (compatList.Count > 0)
3691                 {
3692                     newSetup.SetCompatibilitySwitches(compatList);
3693                 }
3694             }
3695 #endif // FEATURE_CORECLR
3696
3697
3698             return new Object[]
3699             {
3700                 friendlyName,
3701                 newSetup,
3702                 parentSecurityDescriptor,
3703                 generateDefaultEvidence,
3704                 serializedEvidence,
3705                 initializerInfo,
3706                 sandboxName,
3707                 propertyNames,
3708                 propertyValues
3709             };
3710         } // PrepareDataForSetup
3711
3712
3713         [System.Security.SecurityCritical]  // auto-generated
3714         [MethodImplAttribute(MethodImplOptions.NoInlining)]
3715         private static Object Setup(Object arg)
3716         {
3717             Contract.Requires(arg != null && arg is Object[]);
3718             Contract.Requires(((Object[])arg).Length >= 8);
3719
3720             Object[] args=(Object[])arg;
3721             String           friendlyName               = (String)args[0];
3722             AppDomainSetup   setup                      = (AppDomainSetup)args[1];
3723             IntPtr           parentSecurityDescriptor   = (IntPtr)args[2];
3724             bool             generateDefaultEvidence    = (bool)args[3];
3725             byte[]           serializedEvidence         = (byte[])args[4];
3726             AppDomainInitializerInfo initializerInfo    = (AppDomainInitializerInfo)args[5];
3727             string           sandboxName                = (string)args[6];
3728             string[]         propertyNames              = (string[])args[7]; // can contain null elements
3729             string[]         propertyValues             = (string[])args[8]; // can contain null elements
3730             // extract evidence
3731             Evidence providedSecurityInfo = null;
3732             Evidence creatorsSecurityInfo = null;
3733
3734
3735             AppDomain ad = AppDomain.CurrentDomain;
3736             AppDomainSetup newSetup=new AppDomainSetup(setup,false);
3737
3738             if(propertyNames!=null && propertyValues != null)
3739             {
3740                 for (int i=0; i<propertyNames.Length; i++)
3741                 {
3742
3743                     if(propertyNames[i]=="APPBASE") // make sure in [....] with Fusion
3744                     {
3745                         if(propertyValues[i]==null)
3746                             throw new ArgumentNullException("APPBASE");
3747
3748                         if (Path.IsRelative(propertyValues[i]))
3749                             throw new ArgumentException( Environment.GetResourceString( "Argument_AbsolutePathRequired" ) );
3750
3751                         newSetup.ApplicationBase = NormalizePath(propertyValues[i], fullCheck: true);
3752                     }
3753 #if FEATURE_CAS_POLICY
3754                     else if(propertyNames[i]=="LOCATION_URI" && providedSecurityInfo==null)
3755                     {
3756                         providedSecurityInfo=new Evidence();
3757                         providedSecurityInfo.AddHostEvidence(new Url(propertyValues[i]));
3758                         ad.SetDataHelper(propertyNames[i],propertyValues[i],null);
3759                     }
3760 #endif // FEATURE_CAS_POLICY
3761 #if FEATURE_LOADER_OPTIMIZATION
3762                     else
3763                     if(propertyNames[i]=="LOADER_OPTIMIZATION")
3764                     {
3765                         if(propertyValues[i]==null)
3766                             throw new ArgumentNullException("LOADER_OPTIMIZATION");
3767
3768                         switch(propertyValues[i])
3769                         {
3770                             case "SingleDomain": newSetup.LoaderOptimization=LoaderOptimization.SingleDomain;break;
3771                             case "MultiDomain": newSetup.LoaderOptimization=LoaderOptimization.MultiDomain;break;
3772                             case "MultiDomainHost": newSetup.LoaderOptimization=LoaderOptimization.MultiDomainHost;break;
3773                             case "NotSpecified": newSetup.LoaderOptimization=LoaderOptimization.NotSpecified;break;
3774                             default: throw new ArgumentException(Environment.GetResourceString("Argument_UnrecognizedLoaderOptimization"), "LOADER_OPTIMIZATION");
3775                         }
3776                     }
3777 #endif // FEATURE_LOADER_OPTIMIZATION
3778 #if FEATURE_CORECLR
3779                     else
3780                     if(propertyNames[i]=="NATIVE_DLL_SEARCH_DIRECTORIES")
3781                     {
3782                         if(propertyValues[i]==null)
3783                             throw new ArgumentNullException("NATIVE_DLL_SEARCH_DIRECTORIES");
3784                         ad.SetDataHelper(propertyNames[i],propertyValues[i],null);
3785                         string paths = (string)propertyValues[i];
3786                         if( paths.Length==0 )
3787                             continue;
3788                         nSetNativeDllSearchDirectories(paths);
3789                     }
3790                     else
3791                     if(propertyNames[i]=="TRUSTED_PLATFORM_ASSEMBLIES")
3792                     {
3793                         if(propertyValues[i]==null)
3794                             throw new ArgumentNullException("TRUSTED_PLATFORM_ASSEMBLIES");
3795
3796                         StringBuilder normalisedAppPathList = new StringBuilder();
3797                         foreach(string path in propertyValues[i].Split(Path.PathSeparator))
3798                         {
3799
3800                             if( path.Length==0 )                  // skip empty dirs
3801                                 continue;
3802
3803                             if (Path.IsRelative(path))
3804                                 throw new ArgumentException( Environment.GetResourceString( "Argument_AbsolutePathRequired" ) );
3805
3806                             string appPath = NormalizePath(path, fullCheck: true);
3807
3808                             normalisedAppPathList.Append(appPath);
3809                             normalisedAppPathList.Append(Path.PathSeparator);
3810                         }
3811                         // Strip the last separator
3812                         if (normalisedAppPathList.Length > 0)
3813                         {
3814                             normalisedAppPathList.Remove(normalisedAppPathList.Length - 1, 1);
3815                         }
3816                         ad.SetDataHelper(propertyNames[i],normalisedAppPathList.ToString(),null);        // not supported by fusion, so set explicitly
3817                     }
3818                     else
3819                     if(propertyNames[i]=="PLATFORM_RESOURCE_ROOTS")
3820                     {
3821                         if(propertyValues[i]==null)
3822                             throw new ArgumentNullException("PLATFORM_RESOURCE_ROOTS");
3823
3824                         StringBuilder normalisedAppPathList = new StringBuilder();
3825                         foreach(string path in propertyValues[i].Split(Path.PathSeparator))
3826                         {
3827
3828                             if( path.Length==0 )                  // skip empty dirs
3829                                 continue;
3830
3831                             if (Path.IsRelative(path))
3832                                 throw new ArgumentException( Environment.GetResourceString( "Argument_AbsolutePathRequired" ) );
3833
3834                             string appPath = NormalizePath(path, fullCheck: true);
3835
3836                             normalisedAppPathList.Append(appPath);
3837                             normalisedAppPathList.Append(Path.PathSeparator);
3838                         }
3839                         // Strip the last separator
3840                         if (normalisedAppPathList.Length > 0)
3841                         {
3842                             normalisedAppPathList.Remove(normalisedAppPathList.Length - 1, 1);
3843                         }
3844                         ad.SetDataHelper(propertyNames[i],normalisedAppPathList.ToString(),null);        // not supported by fusion, so set explicitly
3845                     }
3846                     else
3847                     if(propertyNames[i]=="APP_PATHS")
3848                     {
3849                         if(propertyValues[i]==null)
3850                             throw new ArgumentNullException("APP_PATHS");
3851
3852                         StringBuilder normalisedAppPathList = new StringBuilder();
3853                         foreach(string path in propertyValues[i].Split(Path.PathSeparator))
3854                         {
3855
3856                             if( path.Length==0 )                  // skip empty dirs
3857                                 continue;
3858
3859                             if (Path.IsRelative(path))
3860                                 throw new ArgumentException( Environment.GetResourceString( "Argument_AbsolutePathRequired" ) );
3861
3862                             string appPath = NormalizePath(path, fullCheck: true);
3863
3864                             normalisedAppPathList.Append(appPath);
3865                             normalisedAppPathList.Append(Path.PathSeparator);
3866                         }
3867                         // Strip the last separator
3868                         if (normalisedAppPathList.Length > 0)
3869                         {
3870                             normalisedAppPathList.Remove(normalisedAppPathList.Length - 1, 1);
3871                         }
3872                         ad.SetDataHelper(propertyNames[i],normalisedAppPathList.ToString(),null);        // not supported by fusion, so set explicitly
3873                     }
3874                     else
3875                     if(propertyNames[i]=="APP_NI_PATHS")
3876                     {
3877                         if(propertyValues[i]==null)
3878                             throw new ArgumentNullException("APP_NI_PATHS");
3879
3880                         StringBuilder normalisedAppPathList = new StringBuilder();
3881                         foreach(string path in propertyValues[i].Split(Path.PathSeparator))
3882                         {
3883
3884                             if( path.Length==0 )                  // skip empty dirs
3885                                 continue;
3886
3887                             if (Path.IsRelative(path))
3888                                 throw new ArgumentException( Environment.GetResourceString( "Argument_AbsolutePathRequired" ) );
3889
3890                             string appPath = NormalizePath(path, fullCheck: true);
3891
3892                             normalisedAppPathList.Append(appPath);
3893                             normalisedAppPathList.Append(Path.PathSeparator);
3894                         }
3895                         // Strip the last separator
3896                         if (normalisedAppPathList.Length > 0)
3897                         {
3898                             normalisedAppPathList.Remove(normalisedAppPathList.Length - 1, 1);
3899                         }
3900                         ad.SetDataHelper(propertyNames[i],normalisedAppPathList.ToString(),null);        // not supported by fusion, so set explicitly
3901                     }
3902                     else
3903                     if(propertyNames[i]!= null)
3904                     {
3905                         ad.SetDataHelper(propertyNames[i],propertyValues[i],null);     // just propagate
3906                     }
3907 #endif
3908
3909                 }
3910             }
3911
3912 #if !FEATURE_CORECLR
3913             AppDomainSortingSetupInfo sortingSetup = newSetup._AppDomainSortingSetupInfo;
3914
3915             if(sortingSetup != null)
3916             {
3917                 if(sortingSetup._pfnIsNLSDefinedString == IntPtr.Zero || sortingSetup._pfnCompareStringEx == IntPtr.Zero || sortingSetup._pfnLCMapStringEx == IntPtr.Zero || sortingSetup._pfnFindNLSStringEx == IntPtr.Zero
3918                     || sortingSetup._pfnCompareStringOrdinal == IntPtr.Zero || sortingSetup._pfnGetNLSVersionEx == IntPtr.Zero)
3919                 {
3920
3921                     if(!(sortingSetup._pfnIsNLSDefinedString == IntPtr.Zero && sortingSetup._pfnCompareStringEx == IntPtr.Zero && sortingSetup._pfnLCMapStringEx == IntPtr.Zero && sortingSetup._pfnFindNLSStringEx == IntPtr.Zero
3922                         && sortingSetup._pfnCompareStringOrdinal == IntPtr.Zero && sortingSetup._pfnGetNLSVersionEx == IntPtr.Zero))
3923                     {
3924                         // Some functions defined but not all of them.
3925                         throw new ArgumentException(Environment.GetResourceString("ArgumentException_NotAllCustomSortingFuncsDefined"));
3926                     }
3927
3928                 }
3929             }
3930 #endif
3931
3932             ad.SetupFusionStore(newSetup, null); // makes FusionStore a ref to newSetup
3933
3934             // technically, we don't need this, newSetup refers to the same object as FusionStore
3935             // but it's confusing since it isn't immediately obvious whether we have a ref or a copy
3936             AppDomainSetup adSetup = ad.FusionStore;
3937
3938 #if FEATURE_CORECLR
3939
3940 #if !FEATURE_FT_CORECLR
3941             BCLDebug.Assert(sandboxName == "Internet", "Sandbox is not Internet");
3942 #endif // !FEATURE_FT_CORECLR
3943
3944             adSetup.InternalSetApplicationTrust(sandboxName);
3945 #endif // FEATURE_CORECLR
3946
3947 #if !FEATURE_CORECLR  // not used by coreclr
3948             if (serializedEvidence != null) {
3949                 EvidenceCollection evidenceCollection = (EvidenceCollection)
3950                     CrossAppDomainSerializer.DeserializeObject(new MemoryStream(serializedEvidence));
3951                 providedSecurityInfo  = evidenceCollection.ProvidedSecurityInfo;
3952                 creatorsSecurityInfo  = evidenceCollection.CreatorsSecurityInfo;
3953             }
3954 #endif
3955             // set up the friendly name
3956             ad.nSetupFriendlyName(friendlyName);
3957
3958 #if FEATURE_COMINTEROP
3959             if (setup != null && setup.SandboxInterop)
3960             {
3961                 ad.nSetDisableInterfaceCache();
3962             }
3963 #endif // FEATURE_COMINTEROP
3964
3965             // set up the AppDomainManager for this domain and initialize security.
3966             if (adSetup.AppDomainManagerAssembly != null && adSetup.AppDomainManagerType != null)
3967             {
3968                 ad.SetAppDomainManagerType(adSetup.AppDomainManagerAssembly, adSetup.AppDomainManagerType);
3969             }
3970
3971 #if FEATURE_APTCA
3972             // set any conditial-aptca visible assemblies
3973             ad.PartialTrustVisibleAssemblies = adSetup.PartialTrustVisibleAssemblies;
3974 #endif // FEATURE_APTCA
3975
3976             ad.CreateAppDomainManager(); // could modify FusionStore's object
3977             ad.InitializeDomainSecurity(providedSecurityInfo,
3978                                         creatorsSecurityInfo,
3979                                         generateDefaultEvidence,
3980                                         parentSecurityDescriptor,
3981                                         true);
3982
3983             // can load user code now
3984             if(initializerInfo!=null)
3985                 adSetup.AppDomainInitializer=initializerInfo.Unwrap();
3986             RunInitializer(adSetup);
3987
3988             // Activate the application if needed.
3989 #if FEATURE_CLICKONCE
3990             ObjectHandle oh = null;
3991             if (adSetup.ActivationArguments != null && adSetup.ActivationArguments.ActivateInstance)
3992                 oh = Activator.CreateInstance(ad.ActivationContext);
3993             return RemotingServices.MarshalInternal(oh, null, null);
3994 #else
3995             return null;
3996 #endif // FEATURE_CLICKONCE
3997         }
3998
3999         [SecuritySafeCritical]
4000         internal static string NormalizePath(string path, bool fullCheck)
4001         {
4002             // We have to directly hit LegacyNormalizePath to avoid loading quirks for
4003             // the AppDomain. (Once we have runtime support for long paths we can
4004             // use the new normalization in path, but we still need to go in directly
4005             // to avoid quirks.)
4006             return  Path.LegacyNormalizePath(
4007                 path: path,
4008                 fullCheck: fullCheck,
4009                 maxPathLength: PathInternal.MaxShortPath,
4010                 expandShortPaths: true);
4011         }
4012
4013 #if FEATURE_APTCA
4014         // Called from DomainAssembly in Conditional APTCA cases
4015         [PermissionSet(SecurityAction.Assert, Unrestricted = true)]
4016         [SecuritySafeCritical]
4017         private bool IsAssemblyOnAptcaVisibleList(RuntimeAssembly assembly)
4018         {
4019             if (_aptcaVisibleAssemblies == null)
4020                 return false;
4021
4022             AssemblyName assemblyName = assembly.GetName();
4023             String name = assemblyName.GetNameWithPublicKey();
4024
4025             name = name.ToUpperInvariant();
4026
4027             int index = Array.BinarySearch<string>(_aptcaVisibleAssemblies, name,
4028                                                    StringComparer.OrdinalIgnoreCase);
4029             return (index >=0);
4030
4031         }
4032
4033         //Used to binary search the list of C-APTCA strings for an AssemblyName.  It compares assembly name
4034         //and public key token.
4035         private class CAPTCASearcher : IComparer
4036         {
4037             int IComparer.Compare(object /*string*/lhs, object /*AssemblyName*/rhs)
4038             {
4039                 AssemblyName captcaEntry = new AssemblyName((string)lhs);
4040                 AssemblyName comparand = (AssemblyName)rhs;
4041                 int nameComp = string.Compare(captcaEntry.Name,
4042                                               comparand.Name,
4043                                               StringComparison.OrdinalIgnoreCase);
4044                 if (nameComp != 0)
4045                 {
4046                     return nameComp;
4047                 }
4048
4049                 //simple names match.  Compare public key tokens.
4050                 byte[] lhsKey = captcaEntry.GetPublicKeyToken();
4051                 byte[] rhsKey = comparand.GetPublicKeyToken();
4052
4053                 // We require both sides have a public key token
4054                 if (lhsKey == null)
4055                 {
4056                     return -1;
4057                 }
4058                 if (rhsKey == null)
4059                 {
4060                     return 1;
4061                 }
4062                 if (lhsKey.Length < rhsKey.Length)
4063                 {
4064                     return -1;
4065                 }
4066                 if (lhsKey.Length > rhsKey.Length)
4067                 {
4068                     return 1;
4069                 }
4070
4071                 // Tokens seem valid - make sure the compare correctly
4072                 for (int i = 0; i < lhsKey.Length; ++i)
4073                 {
4074                     byte lhsByte = lhsKey[i];
4075                     byte rhsByte = rhsKey[i];
4076
4077                     if (lhsByte < rhsByte)
4078                     {
4079                         return -1;
4080                     }
4081                     if (lhsByte > rhsByte)
4082                     {
4083                         return 1;
4084                     }
4085                 }
4086
4087                 //They match.
4088                 return 0;
4089             }
4090         }
4091
4092         [System.Security.SecurityCritical]
4093         private unsafe bool IsAssemblyOnAptcaVisibleListRaw(char * namePtr, int nameLen, byte * keyTokenPtr,
4094                                                             int keyTokenLen)
4095         {
4096             //This version is used for checking ngen dependencies against the C-APTCA list.  It lets us
4097             //reject ngen images that depend on an assembly that has been disabled in the current domain.
4098             //Since we only have the public key token in the ngen image, we'll check against that.  The
4099             //rationale is that if you have a public key token collision in your process you have many
4100             //problems.  Since the source of this public key token is an ngen image for a full trust
4101             //assembly, there is essentially no risk to the reduced check.
4102             if (_aptcaVisibleAssemblies == null)
4103                 return false;
4104
4105             string name = new string(namePtr, 0, nameLen);
4106             byte[] keyToken = new byte[keyTokenLen];
4107             for( int i = 0; i < keyToken.Length; ++i )
4108                 keyToken[i] = keyTokenPtr[i];
4109
4110             AssemblyName asmName = new AssemblyName();
4111             asmName.Name = name;
4112             asmName.SetPublicKeyToken(keyToken);
4113             try
4114             {
4115                 int index = Array.BinarySearch(_aptcaVisibleAssemblies, asmName, new CAPTCASearcher());
4116                 return (index >= 0);
4117             }
4118             catch (InvalidOperationException) { /* Can happen for poorly formed assembly names */ return false; }
4119         }
4120
4121 #endif
4122
4123         // This routine is called from unmanaged code to
4124         // set the default fusion context.
4125         [System.Security.SecurityCritical]  // auto-generated
4126         private void SetupDomain(bool allowRedirects, String path, String configFile, String[] propertyNames, String[] propertyValues)
4127         {
4128             // It is possible that we could have multiple threads initializing
4129             // the default domain. We will just take the winner of these two.
4130             // (eg. one thread doing a com call and another doing attach for IJW)
4131             lock (this) {
4132                 if(_FusionStore == null) {
4133                     AppDomainSetup setup = new AppDomainSetup();
4134 #if FEATURE_CORECLR
4135                     // always use internet permission set
4136                     setup.InternalSetApplicationTrust("Internet");
4137 #endif // FEATURE_CORECLR
4138 #if FEATURE_FUSION
4139                     setup.SetupDefaults(RuntimeEnvironment.GetModuleFileName(), imageLocationAlreadyNormalized : true);
4140                     if(path != null)
4141                         setup.Value[(int) AppDomainSetup.LoaderInformation.ApplicationBaseValue] = path;
4142                     if(configFile != null)
4143                         setup.Value[(int) AppDomainSetup.LoaderInformation.ConfigurationFileValue] = configFile;
4144
4145                     // Default fusion context starts with binding redirects turned off.
4146                     if (!allowRedirects)
4147                         setup.DisallowBindingRedirects = true;
4148 #endif
4149
4150 #if !FEATURE_CORECLR
4151                     if (propertyNames != null) {
4152                         BCLDebug.Assert(propertyValues != null, "propertyValues != null");
4153                         BCLDebug.Assert(propertyNames.Length == propertyValues.Length, "propertyNames.Length == propertyValues.Length");
4154
4155                         for (int i = 0; i < propertyNames.Length; ++i) {
4156                             if (String.Equals(propertyNames[i], "PARTIAL_TRUST_VISIBLE_ASSEMBLIES", StringComparison.Ordinal)) {
4157                                 // The value of the PARTIAL_TRUST_VISIBLE_ASSEMBLIES property is a semicolon
4158                                 // delimited list of assembly names to add to the
4159                                 // PartialTrustVisibleAssemblies setting of the domain setup
4160                                 if (propertyValues[i] != null) {
4161                                     if (propertyValues[i].Length > 0) {
4162                                         setup.PartialTrustVisibleAssemblies = propertyValues[i].Split(';');
4163                                     }
4164                                     else {
4165                                         setup.PartialTrustVisibleAssemblies = new string[0];
4166                                     }
4167                                 }
4168                             }
4169                             else {
4170                                 // In v4 we disallow anything but PARTIAL_TRUST_VISIBLE_ASSEMBLIES to come
4171                                 // in via the default domain properties.  That restriction could be lifted
4172                                 // in a future release, at which point this assert should be removed.
4173                                 //
4174                                 // This should be kept in [....] with the real externally facing filter code
4175                                 // in CorHost2::SetPropertiesForDefaultAppDomain
4176                                 BCLDebug.Assert(false, "Unexpected default domain property");
4177                             }
4178                         }
4179                     }
4180 #endif // !FEATURE_CORECLR
4181
4182 #if FEATURE_APTCA
4183                     // Propigate the set of conditional APTCA assemblies that will be used in the default
4184                     // domain onto the domain itself and also into the VM
4185                     PartialTrustVisibleAssemblies = setup.PartialTrustVisibleAssemblies;
4186 #endif // FEATURE_APTCA
4187
4188                     SetupFusionStore(setup, null);
4189                 }
4190             }
4191         }
4192
4193 #if FEATURE_LOADER_OPTIMIZATION
4194        [System.Security.SecurityCritical]  // auto-generated
4195        private void SetupLoaderOptimization(LoaderOptimization policy)
4196         {
4197             if(policy != LoaderOptimization.NotSpecified) {
4198                 Contract.Assert(FusionStore.LoaderOptimization == LoaderOptimization.NotSpecified,
4199                                 "It is illegal to change the Loader optimization on a domain");
4200
4201                 FusionStore.LoaderOptimization = policy;
4202                 UpdateLoaderOptimization(FusionStore.LoaderOptimization);
4203             }
4204         }
4205 #endif
4206
4207 #if FEATURE_FUSION
4208         [System.Security.SecurityCritical]  // auto-generated
4209         [ResourceExposure(ResourceScope.None)]
4210         [MethodImplAttribute(MethodImplOptions.InternalCall)]
4211         internal extern IntPtr GetFusionContext();
4212 #endif // FEATURE_FUSION
4213
4214         [System.Security.SecurityCritical]  // auto-generated
4215         [ResourceExposure(ResourceScope.None)]
4216         [MethodImplAttribute(MethodImplOptions.InternalCall)]
4217         internal extern IntPtr GetSecurityDescriptor();
4218
4219 #if FEATURE_REMOTING
4220         [System.Security.SecurityCritical]  // auto-generated
4221         [ResourceExposure(ResourceScope.None)]
4222         [MethodImplAttribute(MethodImplOptions.InternalCall)]
4223         internal static extern AppDomain nCreateDomain(String friendlyName,
4224                                                       AppDomainSetup setup,
4225                                                       Evidence providedSecurityInfo,
4226                                                       Evidence creatorsSecurityInfo,
4227                                                       IntPtr parentSecurityDescriptor);
4228
4229         [System.Security.SecurityCritical]  // auto-generated
4230         [ResourceExposure(ResourceScope.None)]
4231         [MethodImplAttribute(MethodImplOptions.InternalCall)]
4232         internal static extern ObjRef nCreateInstance(String friendlyName,
4233                                                       AppDomainSetup setup,
4234                                                       Evidence providedSecurityInfo,
4235                                                       Evidence creatorsSecurityInfo,
4236                                                       IntPtr parentSecurityDescriptor);
4237 #endif
4238
4239         [SecurityCritical]
4240         private void SetupDomainSecurity(Evidence appDomainEvidence,
4241                                          IntPtr creatorsSecurityDescriptor,
4242                                          bool publishAppDomain)
4243         {
4244             Evidence stackEvidence = appDomainEvidence;
4245             SetupDomainSecurity(GetNativeHandle(),
4246                                 JitHelpers.GetObjectHandleOnStack(ref stackEvidence),
4247                                 creatorsSecurityDescriptor,
4248                                 publishAppDomain);
4249
4250         }
4251
4252         [SecurityCritical]
4253         [ResourceExposure(ResourceScope.None)]
4254         [SuppressUnmanagedCodeSecurity]
4255         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
4256         private static extern void SetupDomainSecurity(AppDomainHandle appDomain,
4257                                                        ObjectHandleOnStack appDomainEvidence,
4258                                                        IntPtr creatorsSecurityDescriptor,
4259                                                        [MarshalAs(UnmanagedType.Bool)] bool publishAppDomain);
4260
4261         [System.Security.SecurityCritical]  // auto-generated
4262         [ResourceExposure(ResourceScope.None)]
4263         [MethodImplAttribute(MethodImplOptions.InternalCall)]
4264         private extern void nSetupFriendlyName(string friendlyName);
4265
4266 #if FEATURE_COMINTEROP
4267         [ResourceExposure(ResourceScope.None)]
4268         [MethodImplAttribute(MethodImplOptions.InternalCall)]
4269         private extern void nSetDisableInterfaceCache();
4270 #endif // FEATURE_COMINTEROP
4271
4272 #if FEATURE_LOADER_OPTIMIZATION
4273         [System.Security.SecurityCritical]  // auto-generated
4274         [ResourceExposure(ResourceScope.None)]
4275         [MethodImplAttribute(MethodImplOptions.InternalCall)]
4276         internal extern void UpdateLoaderOptimization(LoaderOptimization optimization);
4277 #endif
4278
4279 #if FEATURE_FUSION
4280         //
4281         // This is just designed to prevent compiler warnings.
4282         // This field is used from native, but we need to prevent the compiler warnings.
4283         //
4284
4285         [System.Security.SecurityCritical]  // auto-generated_required
4286         [Obsolete("AppDomain.SetShadowCopyPath has been deprecated. Please investigate the use of AppDomainSetup.ShadowCopyDirectories instead. http://go.microsoft.com/fwlink/?linkid=14202")]
4287         [ResourceExposure(ResourceScope.Machine)]
4288         [ResourceConsumption(ResourceScope.Machine)]
4289         public void SetShadowCopyPath(String path)
4290         {
4291             InternalSetShadowCopyPath(path);
4292         }
4293
4294         [System.Security.SecurityCritical]  // auto-generated_required
4295         [Obsolete("AppDomain.SetShadowCopyFiles has been deprecated. Please investigate the use of AppDomainSetup.ShadowCopyFiles instead. http://go.microsoft.com/fwlink/?linkid=14202")]
4296         public void SetShadowCopyFiles()
4297         {
4298             InternalSetShadowCopyFiles();
4299         }
4300
4301         [System.Security.SecurityCritical]  // auto-generated_required
4302         [Obsolete("AppDomain.SetDynamicBase has been deprecated. Please investigate the use of AppDomainSetup.DynamicBase instead. http://go.microsoft.com/fwlink/?linkid=14202")]
4303         [ResourceExposure(ResourceScope.Machine)]
4304         [ResourceConsumption(ResourceScope.Machine)]
4305         public void SetDynamicBase(String path)
4306         {
4307             InternalSetDynamicBase(path);
4308         }
4309 #endif // FEATURE_FUSION
4310
4311         public AppDomainSetup SetupInformation
4312         {
4313             get {
4314                 return new AppDomainSetup(FusionStore,true);
4315             }
4316         }
4317
4318 #if FEATURE_FUSION
4319         [System.Security.SecurityCritical]  // auto-generated
4320         [ResourceExposure(ResourceScope.Machine)]
4321         [ResourceConsumption(ResourceScope.Machine)]
4322         internal void InternalSetShadowCopyPath(String path)
4323         {
4324             if (path != null)
4325             {
4326                 IntPtr fusionContext = GetFusionContext();
4327                 AppDomainSetup.UpdateContextProperty(fusionContext, AppDomainSetup.ShadowCopyDirectoriesKey, path);
4328             }
4329             FusionStore.ShadowCopyDirectories = path;
4330         }
4331
4332         [System.Security.SecurityCritical]  // auto-generated
4333         internal void InternalSetShadowCopyFiles()
4334         {
4335             IntPtr fusionContext = GetFusionContext();
4336             AppDomainSetup.UpdateContextProperty(fusionContext, AppDomainSetup.ShadowCopyFilesKey, "true");
4337             FusionStore.ShadowCopyFiles = "true";
4338         }
4339
4340         [System.Security.SecurityCritical]  // auto-generated
4341         [ResourceExposure(ResourceScope.Machine)]
4342         [ResourceConsumption(ResourceScope.Machine)]
4343         internal void InternalSetCachePath(String path)
4344         {
4345             FusionStore.CachePath = path;
4346             if (FusionStore.Value[(int) AppDomainSetup.LoaderInformation.CachePathValue] != null)
4347             {
4348                 IntPtr fusionContext = GetFusionContext();
4349                 AppDomainSetup.UpdateContextProperty(fusionContext, AppDomainSetup.CachePathKey,
4350                                                      FusionStore.Value[(int) AppDomainSetup.LoaderInformation.CachePathValue]);
4351             }
4352         }
4353
4354         [System.Security.SecurityCritical]  // auto-generated
4355         [ResourceExposure(ResourceScope.Machine)]
4356         [ResourceConsumption(ResourceScope.Machine)]
4357         internal void InternalSetPrivateBinPath(String path)
4358         {
4359             IntPtr fusionContext = GetFusionContext();
4360             AppDomainSetup.UpdateContextProperty(fusionContext, AppDomainSetup.PrivateBinPathKey, path);
4361             FusionStore.PrivateBinPath = path;
4362         }
4363
4364         [System.Security.SecurityCritical]  // auto-generated
4365         [ResourceExposure(ResourceScope.Machine)]
4366         [ResourceConsumption(ResourceScope.Machine)]
4367         internal void InternalSetDynamicBase(String path)
4368         {
4369             FusionStore.DynamicBase = path;
4370             if (FusionStore.Value[(int) AppDomainSetup.LoaderInformation.DynamicBaseValue] != null)
4371             {
4372                 IntPtr fusionContext = GetFusionContext();
4373                 AppDomainSetup.UpdateContextProperty(fusionContext, AppDomainSetup.DynamicBaseKey,
4374                                                      FusionStore.Value[(int) AppDomainSetup.LoaderInformation.DynamicBaseValue]);
4375             }
4376         }
4377 #endif // FEATURE_FUSION
4378
4379         [System.Security.SecurityCritical]  // auto-generated
4380         [ResourceExposure(ResourceScope.None)]
4381         [MethodImplAttribute(MethodImplOptions.InternalCall)]
4382         internal extern String IsStringInterned(String str);
4383
4384         [System.Security.SecurityCritical]  // auto-generated
4385         [ResourceExposure(ResourceScope.None)]
4386         [MethodImplAttribute(MethodImplOptions.InternalCall)]
4387         internal extern String GetOrInternString(String str);
4388
4389         [SecurityCritical]
4390         [ResourceExposure(ResourceScope.None)]
4391         [SuppressUnmanagedCodeSecurity]
4392         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
4393         private static extern void GetGrantSet(AppDomainHandle domain, ObjectHandleOnStack retGrantSet);
4394
4395 #if FEATURE_CAS_POLICY
4396         [SecurityCritical]
4397         [ResourceExposure(ResourceScope.None)]
4398         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
4399         [SuppressUnmanagedCodeSecurity]
4400         [return: MarshalAs(UnmanagedType.Bool)]
4401         private static extern bool GetIsLegacyCasPolicyEnabled(AppDomainHandle domain);
4402 #endif // FEATURE_CAS_POLICY
4403
4404         public PermissionSet PermissionSet
4405         {
4406             // SecurityCritical because permissions can contain sensitive information such as paths
4407             [SecurityCritical]
4408             get
4409             {
4410                 PermissionSet grantSet = null;
4411                 GetGrantSet(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref grantSet));
4412
4413                 if (grantSet != null)
4414                 {
4415                     return grantSet.Copy();
4416                 }
4417                 else
4418                 {
4419                     return new PermissionSet(PermissionState.Unrestricted);
4420                 }
4421             }
4422         }
4423
4424         public bool IsFullyTrusted
4425         {
4426             [SecuritySafeCritical]
4427             get
4428             {
4429                 PermissionSet grantSet = null;
4430                 GetGrantSet(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref grantSet));
4431
4432                 return grantSet == null || grantSet.IsUnrestricted();
4433             }
4434         }
4435
4436         public bool IsHomogenous
4437         {
4438             get
4439             {
4440                 // Homogenous AppDomains always have an ApplicationTrust associated with them
4441                 return _IsFastFullTrustDomain || _applicationTrust != null;
4442             }
4443         }
4444
4445 #if FEATURE_CAS_POLICY
4446         internal bool IsLegacyCasPolicyEnabled
4447         {
4448             [SecuritySafeCritical]
4449             get
4450             {
4451                 return GetIsLegacyCasPolicyEnabled(GetNativeHandle());
4452             }
4453         }
4454
4455         // Determine what this homogenous domain thinks the grant set should be for a specific set of evidence
4456         [SecuritySafeCritical]
4457         internal PermissionSet GetHomogenousGrantSet(Evidence evidence)
4458         {
4459             Contract.Assert(evidence != null);
4460             Contract.Assert(IsHomogenous);
4461             Contract.Assert(evidence.GetHostEvidence<GacInstalled>() == null);
4462
4463             if (_IsFastFullTrustDomain)
4464             {
4465                 return new PermissionSet(PermissionState.Unrestricted);
4466             }
4467
4468             // If the ApplicationTrust's full trust list calls out the assembly, then it is fully trusted
4469             if (evidence.GetDelayEvaluatedHostEvidence<StrongName>() != null)
4470             {
4471                 foreach (StrongName fullTrustAssembly in ApplicationTrust.FullTrustAssemblies)
4472                 {
4473                     StrongNameMembershipCondition sn = new StrongNameMembershipCondition(fullTrustAssembly.PublicKey,
4474                                                                                          fullTrustAssembly.Name,
4475                                                                                          fullTrustAssembly.Version);
4476
4477                     object usedEvidence = null;
4478                     if ((sn as IReportMatchMembershipCondition).Check(evidence, out usedEvidence))
4479                     {
4480                         IDelayEvaluatedEvidence delayEvidence = usedEvidence as IDelayEvaluatedEvidence;
4481                         if (usedEvidence != null)
4482                         {
4483                             delayEvidence.MarkUsed();
4484                         }
4485
4486                         return new PermissionSet(PermissionState.Unrestricted);
4487                     }
4488                 }
4489             }
4490
4491             // Otherwise, the grant set is just the default grant set
4492             return ApplicationTrust.DefaultGrantSet.PermissionSet.Copy();
4493         }
4494 #endif // FEATURE_CAS_POLICY
4495
4496         [System.Security.SecurityCritical]  // auto-generated
4497         [ResourceExposure(ResourceScope.None)]
4498         [MethodImplAttribute(MethodImplOptions.InternalCall)]
4499         private extern void nChangeSecurityPolicy();
4500
4501         [System.Security.SecurityCritical]  // auto-generated
4502         [MethodImplAttribute(MethodImplOptions.InternalCall),
4503          ReliabilityContract(Consistency.MayCorruptAppDomain, Cer.MayFail),
4504          ResourceExposure(ResourceScope.None)]
4505         internal static extern void nUnload(Int32 domainInternal);
4506
4507         public Object CreateInstanceAndUnwrap(String assemblyName,
4508                                               String typeName)
4509         {
4510             ObjectHandle oh = CreateInstance(assemblyName, typeName);
4511             if (oh == null)
4512                 return null;
4513
4514             return oh.Unwrap();
4515         } // CreateInstanceAndUnwrap
4516
4517
4518         public Object CreateInstanceAndUnwrap(String assemblyName,
4519                                               String typeName,
4520                                               Object[] activationAttributes)
4521         {
4522             ObjectHandle oh = CreateInstance(assemblyName, typeName, activationAttributes);
4523             if (oh == null)
4524                 return null;
4525
4526             return oh.Unwrap();
4527         } // CreateInstanceAndUnwrap
4528
4529
4530         [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of CreateInstanceAndUnwrap which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
4531         public Object CreateInstanceAndUnwrap(String assemblyName,
4532                                               String typeName,
4533                                               bool ignoreCase,
4534                                               BindingFlags bindingAttr,
4535                                               Binder binder,
4536                                               Object[] args,
4537                                               CultureInfo culture,
4538                                               Object[] activationAttributes,
4539                                               Evidence securityAttributes)
4540         {
4541 #pragma warning disable 618
4542             ObjectHandle oh = CreateInstance(assemblyName, typeName, ignoreCase, bindingAttr,
4543                 binder, args, culture, activationAttributes, securityAttributes);
4544 #pragma warning restore 618
4545
4546             if (oh == null)
4547                 return null;
4548
4549             return oh.Unwrap();
4550         } // CreateInstanceAndUnwrap
4551
4552         public object CreateInstanceAndUnwrap(string assemblyName,
4553                                               string typeName,
4554                                               bool ignoreCase,
4555                                               BindingFlags bindingAttr,
4556                                               Binder binder,
4557                                               object[] args,
4558                                               CultureInfo culture,
4559                                               object[] activationAttributes)
4560         {
4561             ObjectHandle oh = CreateInstance(assemblyName,
4562                                              typeName,
4563                                              ignoreCase,
4564                                              bindingAttr,
4565                                              binder,
4566                                              args,
4567                                              culture,
4568                                              activationAttributes);
4569
4570             if (oh == null)
4571             {
4572                 return null;
4573             }
4574
4575             return oh.Unwrap();
4576         }
4577
4578         // The first parameter should be named assemblyFile, but it was incorrectly named in a previous
4579         //  release, and the compatibility police won't let us change the name now.
4580         [ResourceExposure(ResourceScope.Machine)]
4581         [ResourceConsumption(ResourceScope.Machine)]
4582         public Object CreateInstanceFromAndUnwrap(String assemblyName,
4583                                                   String typeName)
4584         {
4585             ObjectHandle oh = CreateInstanceFrom(assemblyName, typeName);
4586             if (oh == null)
4587                 return null;
4588
4589             return oh.Unwrap();
4590         } // CreateInstanceAndUnwrap
4591
4592
4593         // The first parameter should be named assemblyFile, but it was incorrectly named in a previous
4594         //  release, and the compatibility police won't let us change the name now.
4595         [ResourceExposure(ResourceScope.Machine)]
4596         [ResourceConsumption(ResourceScope.Machine)]
4597         public Object CreateInstanceFromAndUnwrap(String assemblyName,
4598                                                   String typeName,
4599                                                   Object[] activationAttributes)
4600         {
4601             ObjectHandle oh = CreateInstanceFrom(assemblyName, typeName, activationAttributes);
4602             if (oh == null)
4603                 return null;
4604
4605             return oh.Unwrap();
4606         } // CreateInstanceAndUnwrap
4607
4608
4609         // The first parameter should be named assemblyFile, but it was incorrectly named in a previous
4610         //  release, and the compatibility police won't let us change the name now.
4611         [ResourceExposure(ResourceScope.Machine)]
4612         [ResourceConsumption(ResourceScope.Machine)]
4613         [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of CreateInstanceFromAndUnwrap which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
4614         public Object CreateInstanceFromAndUnwrap(String assemblyName,
4615                                                   String typeName,
4616                                                   bool ignoreCase,
4617                                                   BindingFlags bindingAttr,
4618                                                   Binder binder,
4619                                                   Object[] args,
4620                                                   CultureInfo culture,
4621                                                   Object[] activationAttributes,
4622                                                   Evidence securityAttributes)
4623         {
4624 #pragma warning disable 618
4625             ObjectHandle oh = CreateInstanceFrom(assemblyName, typeName, ignoreCase, bindingAttr,
4626                 binder, args, culture, activationAttributes, securityAttributes);
4627 #pragma warning restore 618
4628
4629             if (oh == null)
4630                 return null;
4631
4632             return oh.Unwrap();
4633         } // CreateInstanceAndUnwrap
4634
4635         [ResourceExposure(ResourceScope.Machine)]
4636         [ResourceConsumption(ResourceScope.Machine)]
4637         public object CreateInstanceFromAndUnwrap(string assemblyFile,
4638                                                   string typeName,
4639                                                   bool ignoreCase,
4640                                                   BindingFlags bindingAttr,
4641                                                   Binder binder,
4642                                                   object[] args,
4643                                                   CultureInfo culture,
4644                                                   object[] activationAttributes)
4645         {
4646             ObjectHandle oh = CreateInstanceFrom(assemblyFile,
4647                                                  typeName,
4648                                                  ignoreCase,
4649                                                  bindingAttr,
4650                                                  binder,
4651                                                  args,
4652                                                  culture,
4653                                                  activationAttributes);
4654             if (oh == null)
4655             {
4656                 return null;
4657             }
4658
4659             return oh.Unwrap();
4660         }
4661
4662         public Int32 Id
4663         {
4664             [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
4665             get {
4666                 return GetId();
4667             }
4668         }
4669
4670         [System.Security.SecuritySafeCritical]  // auto-generated
4671         [ResourceExposure(ResourceScope.None)]
4672         [MethodImplAttribute(MethodImplOptions.InternalCall)]
4673         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
4674         internal extern Int32 GetId();
4675
4676         internal const Int32 DefaultADID = 1;
4677
4678         public bool IsDefaultAppDomain()
4679         {
4680             if (GetId()==DefaultADID)
4681                 return true;
4682             return false;
4683         }
4684
4685         [ResourceExposure(ResourceScope.Machine)]
4686         [ResourceConsumption(ResourceScope.Machine)]
4687         private static AppDomainSetup InternalCreateDomainSetup(String imageLocation)
4688         {
4689             int i = imageLocation.LastIndexOf('\\');
4690
4691             Contract.Assert(i != -1, "invalid image location");
4692
4693             AppDomainSetup info = new AppDomainSetup();
4694
4695             info.ApplicationBase = imageLocation.Substring(0, i+1);
4696
4697             StringBuilder config = new StringBuilder(imageLocation.Substring(i+1));
4698             config.Append(AppDomainSetup.ConfigurationExtension);
4699             info.ConfigurationFile = config.ToString();
4700
4701             return info;
4702         }
4703
4704         // Used by the validator for testing but not executing an assembly
4705 #if FEATURE_REMOTING
4706         [ResourceExposure(ResourceScope.Machine)]
4707         [ResourceConsumption(ResourceScope.Machine)]
4708         private static AppDomain InternalCreateDomain(String imageLocation)
4709         {
4710             AppDomainSetup info = InternalCreateDomainSetup(imageLocation);
4711             return CreateDomain("Validator",
4712                                 null,
4713                                 info);
4714         }
4715 #endif
4716
4717 #if FEATURE_APPDOMAIN_RESOURCE_MONITORING
4718         [System.Security.SecurityCritical]  // auto-generated
4719         [ResourceExposure(ResourceScope.None)]
4720         [MethodImplAttribute(MethodImplOptions.InternalCall)]
4721         private static extern void nEnableMonitoring();
4722
4723         [System.Security.SecurityCritical]  // auto-generated
4724         [ResourceExposure(ResourceScope.None)]
4725         [MethodImplAttribute(MethodImplOptions.InternalCall)]
4726         private static extern bool nMonitoringIsEnabled();
4727
4728         // return -1 if ARM is not supported.
4729         [System.Security.SecurityCritical]  // auto-generated
4730         [ResourceExposure(ResourceScope.None)]
4731         [MethodImplAttribute(MethodImplOptions.InternalCall)]
4732         private extern Int64 nGetTotalProcessorTime();
4733
4734         // return -1 if ARM is not supported.
4735         [System.Security.SecurityCritical]  // auto-generated
4736         [ResourceExposure(ResourceScope.None)]
4737         [MethodImplAttribute(MethodImplOptions.InternalCall)]
4738         private extern Int64 nGetTotalAllocatedMemorySize();
4739
4740         // return -1 if ARM is not supported.
4741         [System.Security.SecurityCritical]  // auto-generated
4742         [ResourceExposure(ResourceScope.None)]
4743         [MethodImplAttribute(MethodImplOptions.InternalCall)]
4744         private extern Int64 nGetLastSurvivedMemorySize();
4745
4746         // return -1 if ARM is not supported.
4747         [System.Security.SecurityCritical]  // auto-generated
4748         [ResourceExposure(ResourceScope.None)]
4749         [MethodImplAttribute(MethodImplOptions.InternalCall)]
4750         private static extern Int64 nGetLastSurvivedProcessMemorySize();
4751
4752         public static bool MonitoringIsEnabled
4753         {
4754             [System.Security.SecurityCritical]
4755             get {
4756                 return nMonitoringIsEnabled();
4757             }
4758
4759             [System.Security.SecurityCritical]
4760             set {
4761                 if (value == false)
4762                 {
4763                     throw new ArgumentException(Environment.GetResourceString("Arg_MustBeTrue"));
4764                 }
4765                 else
4766                 {
4767                     nEnableMonitoring();
4768                 }
4769             }
4770         }
4771
4772         // Gets the total processor time for this AppDomain.
4773         // Throws NotSupportedException if ARM is not enabled.
4774         public TimeSpan MonitoringTotalProcessorTime
4775         {
4776             [System.Security.SecurityCritical]
4777             get {
4778                 Int64 i64ProcessorTime = nGetTotalProcessorTime();
4779                 if (i64ProcessorTime == -1)
4780                 {
4781                     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_WithoutARM"));
4782                 }
4783                 return new TimeSpan(i64ProcessorTime);
4784             }
4785         }
4786
4787         // Gets the number of bytes allocated in this AppDomain since
4788         // the AppDomain was created.
4789         // Throws NotSupportedException if ARM is not enabled.
4790         public Int64 MonitoringTotalAllocatedMemorySize
4791         {
4792             [System.Security.SecurityCritical]
4793             get {
4794                 Int64 i64AllocatedMemory = nGetTotalAllocatedMemorySize();
4795                 if (i64AllocatedMemory == -1)
4796                 {
4797                     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_WithoutARM"));
4798                 }
4799                 return i64AllocatedMemory;
4800             }
4801         }
4802
4803         // Gets the number of bytes survived after the last collection
4804         // that are known to be held by this AppDomain. After a full
4805         // collection this number is accurate and complete. After an
4806         // ephemeral collection this number is potentially incomplete.
4807         // Throws NotSupportedException if ARM is not enabled.
4808         public Int64 MonitoringSurvivedMemorySize
4809         {
4810             [System.Security.SecurityCritical]
4811             get {
4812                 Int64 i64LastSurvivedMemory = nGetLastSurvivedMemorySize();
4813                 if (i64LastSurvivedMemory == -1)
4814                 {
4815                     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_WithoutARM"));
4816                 }
4817                 return i64LastSurvivedMemory;
4818             }
4819         }
4820
4821         // Gets the total bytes survived from the last collection. After
4822         // a full collection this number represents the number of the bytes
4823         // being held live in managed heaps. (This number should be close
4824         // to the number obtained from GC.GetTotalMemory for a full collection.)
4825         // After an ephemeral collection this number represents the number
4826         // of bytes being held live in ephemeral generations.
4827         // Throws NotSupportedException if ARM is not enabled.
4828         public static Int64 MonitoringSurvivedProcessMemorySize
4829         {
4830             [System.Security.SecurityCritical]
4831             get {
4832                 Int64 i64LastSurvivedProcessMemory = nGetLastSurvivedProcessMemorySize();
4833                 if (i64LastSurvivedProcessMemory == -1)
4834                 {
4835                     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_WithoutARM"));
4836                 }
4837                 return i64LastSurvivedProcessMemory;
4838             }
4839         }
4840 #endif
4841
4842 #if FEATURE_FUSION
4843         [System.Security.SecurityCritical]  // auto-generated
4844         [ResourceExposure(ResourceScope.Machine)]
4845         [ResourceConsumption(ResourceScope.Machine)]
4846         private void InternalSetDomainContext(String imageLocation)
4847         {
4848             SetupFusionStore(InternalCreateDomainSetup(imageLocation), null);
4849         }
4850 #endif
4851
4852 #if !FEATURE_CORECLR
4853         // this method is required so Object.GetType is not made virtual by the compiler
4854         // _AppDomain.GetType()
4855         public new Type GetType()
4856         {
4857             return base.GetType();
4858         }
4859
4860         void _AppDomain.GetTypeInfoCount(out uint pcTInfo)
4861         {
4862             throw new NotImplementedException();
4863         }
4864
4865         void _AppDomain.GetTypeInfo(uint iTInfo, uint lcid, IntPtr ppTInfo)
4866         {
4867             throw new NotImplementedException();
4868         }
4869
4870         void _AppDomain.GetIDsOfNames([In] ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
4871         {
4872             throw new NotImplementedException();
4873         }
4874
4875         // If you implement this method, make sure to include _AppDomain.Invoke in VM\DangerousAPIs.h and
4876         // include _AppDomain in SystemDomain::IsReflectionInvocationMethod in AppDomain.cpp.
4877         void _AppDomain.Invoke(uint dispIdMember, [In] ref Guid riid, uint lcid, short wFlags, IntPtr pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr)
4878         {
4879             throw new NotImplementedException();
4880         }
4881 #endif
4882     }
4883
4884     //  CallBacks provide a facility to request execution of some code
4885     //  in another context/appDomain.
4886     //  CrossAppDomainDelegate type is defined for appdomain call backs.
4887     //  The delegate used to request a callbak through the DoCallBack method
4888     //  must be of CrossContextDelegate type.
4889 #if FEATURE_REMOTING
4890 [System.Runtime.InteropServices.ComVisible(true)]
4891     public delegate void CrossAppDomainDelegate();
4892 #endif
4893
4894     /// <summary>
4895     ///     Handle used to marshal an AppDomain to the VM (eg QCall). When marshaled via a QCall, the target
4896     ///     method in the VM will recieve a QCall::AppDomainHandle parameter.
4897     /// </summary>
4898     internal struct AppDomainHandle
4899     {
4900         private IntPtr m_appDomainHandle;
4901
4902         // Note: generall an AppDomainHandle should not be directly constructed, instead the
4903         // code:System.AppDomain.GetNativeHandle method should be called to get the handle for a specific
4904         // AppDomain.
4905         internal AppDomainHandle(IntPtr domainHandle)
4906         {
4907             m_appDomainHandle = domainHandle;
4908         }
4909     }
4910 }