Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/mscorlib/system/deployment/cdf.cs

@@ -0,0 +1,67 @@
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Collections;
+using System.Globalization;
+using System.Threading;
+
+/*
+    These are the basic interfaces common to all CDF-based data sources.
+    Sections with various keys are the norm.
+
+ */
+
+namespace System.Deployment.Internal.Isolation
+{
+    [ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown),Guid("285a8862-c84a-11d7-850f-005cd062464f")]
+    internal interface ISection
+    {
+        object _NewEnum { [return:MarshalAs(UnmanagedType.Interface)] get; }
+        uint Count { get; }
+        uint SectionID { get; }
+        string SectionName { [return:MarshalAs(UnmanagedType.LPWStr)] get; }
+    }
+
+    [ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown),Guid("285a8871-c84a-11d7-850f-005cd062464f")]
+    internal interface ISectionWithStringKey
+    {
+        void Lookup([MarshalAs(UnmanagedType.LPWStr)] string wzStringKey, [MarshalAs(UnmanagedType.Interface)] out object ppUnknown);
+        bool IsCaseInsensitive { get; }
+    }
+
+    [ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown),Guid("285a8876-c84a-11d7-850f-005cd062464f")]
+    internal interface ISectionWithReferenceIdentityKey
+    {
+        void Lookup(IReferenceIdentity ReferenceIdentityKey, [MarshalAs(UnmanagedType.Interface)] out object ppUnknown);
+    }
+
+    [ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown),Guid("285a8861-c84a-11d7-850f-005cd062464f")]
+    internal interface ISectionEntry
+    {
+        object GetField(uint fieldId);
+        string GetFieldName(uint fieldId);
+    }
+
+    [ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown),Guid("00000100-0000-0000-C000-000000000046")]
+    internal interface IEnumUnknown
+    {
+        [PreserveSig]
+        int Next(uint celt, [Out, MarshalAs(UnmanagedType.LPArray, ArraySubType=UnmanagedType.IUnknown)] object[] rgelt, ref uint celtFetched);
+        [PreserveSig]
+        int Skip(uint celt);
+        [PreserveSig]
+        int Reset();
+        [PreserveSig]
+        int Clone(out IEnumUnknown enumUnknown);
+    }
+
+    [ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown),Guid("285a8860-c84a-11d7-850f-005cd062464f")]
+    internal interface ICDF
+    {
+        ISection GetRootSection(uint SectionId);
+        ISectionEntry GetRootSectionEntry(uint SectionId);
+        object _NewEnum { [return:MarshalAs(UnmanagedType.Interface)] get; }
+        uint Count { get; }
+        object GetItem(uint SectionId);
+    }
+}

mcs/class/referencesource/mscorlib/system/deployment/cmsutils.cs

@@ -0,0 +1,200 @@
+using Microsoft.Win32;
+using System;
+using System.Deployment.Internal;
+using System.Deployment.Internal.Isolation;
+using System.Deployment.Internal.Isolation.Manifest;
+using System.IO;
+using System.Globalization;
+using System.Runtime.Hosting;
+using System.Runtime.InteropServices;
+using System.Security.Permissions;
+using System.Security.Policy;
+using System.Text;
+using System.Runtime.Versioning;
+using System.Diagnostics.Contracts;
+
+namespace System.Deployment.Internal.Isolation.Manifest {
+    [System.Security.SecuritySafeCritical]  // auto-generated
+    [SecurityPermissionAttribute(SecurityAction.Assert, Flags = SecurityPermissionFlag.UnmanagedCode)]
+    internal static class CmsUtils {
+
+        internal static void GetEntryPoint (ActivationContext activationContext, out string fileName, out string parameters) {
+            parameters = null;
+            fileName = null;
+
+            ICMS appManifest = activationContext.ApplicationComponentManifest;
+            if (appManifest == null || appManifest.EntryPointSection == null)
+                throw new ArgumentException(Environment.GetResourceString("Argument_NoMain"));
+
+            IEnumUnknown refEnum = (IEnumUnknown) appManifest.EntryPointSection._NewEnum;
+            uint count = 0;
+            Object[] entries = new Object[1];
+            // Look for the first entry point. ClickOnce semantic validation ensures exactly one entry point is present.
+            if (refEnum.Next(1, entries, ref count) == 0 && count == 1) {
+                IEntryPointEntry iref= (IEntryPointEntry) entries[0];
+                EntryPointEntry reference = iref.AllData;
+                if (reference.CommandLine_File != null && reference.CommandLine_File.Length > 0) {
+                    fileName = reference.CommandLine_File;
+                } else {
+                    // Locate the dependent assembly that is being refered to. Well-formed manifests should have an identity.
+                    IAssemblyReferenceEntry refEntry = null;
+                    object assemblyObj = null;
+                    if (reference.Identity != null) {
+                        ((ISectionWithReferenceIdentityKey)appManifest.AssemblyReferenceSection).Lookup(reference.Identity, out assemblyObj);
+                        refEntry = (IAssemblyReferenceEntry) assemblyObj;
+                        fileName = refEntry.DependentAssembly.Codebase;
+                    }
+                }
+                parameters = reference.CommandLine_Parameters;
+            }
+        }
+
+        internal static IAssemblyReferenceEntry[] GetDependentAssemblies(ActivationContext activationContext)
+        {
+            IAssemblyReferenceEntry[] entries = null;
+            ICMS appManifest = activationContext.ApplicationComponentManifest;
+            if (appManifest == null)
+                return null;
+            
+            ISection dependencySection =  appManifest.AssemblyReferenceSection;
+            uint count = (dependencySection != null) ? dependencySection.Count : 0;
+            if (count > 0)
+            {
+                uint fetched = 0;
+                entries = new IAssemblyReferenceEntry[count];
+                IEnumUnknown dependencyEnum = (IEnumUnknown)dependencySection._NewEnum;
+                int hr = dependencyEnum.Next(count, entries, ref fetched);
+                if (fetched != count || hr < 0)
+                    return null; //
+            }
+            return entries;
+        }
+                    
+
+        [ResourceExposure(ResourceScope.Machine)]
+        [ResourceConsumption(ResourceScope.Machine)]
+        internal static string GetEntryPointFullPath (ActivationArguments activationArguments) {
+            return GetEntryPointFullPath(activationArguments.ActivationContext);
+        }
+
+        [ResourceExposure(ResourceScope.Machine)]
+        [ResourceConsumption(ResourceScope.Machine)]
+        internal static string GetEntryPointFullPath (ActivationContext activationContext) {
+            string file, parameters;
+            GetEntryPoint(activationContext, out file, out parameters);
+
+            if (!String.IsNullOrEmpty(file)) {
+                string directoryName = activationContext.ApplicationDirectory;
+                if (directoryName == null || directoryName.Length == 0) {
+                    // If we were passed a relative path, assume the app base is the current working directory
+                    StringBuilder sb = new StringBuilder(Path.MAX_PATH + 1);
+                    if (Win32Native.GetCurrentDirectory(sb.Capacity, sb) == 0)
+                        System.IO.__Error.WinIOError();
+                    directoryName = sb.ToString();
+                }
+
+                file = Path.Combine(directoryName, file);
+            }
+
+            return file;
+        }
+
+        internal static bool CompareIdentities (ActivationContext activationContext1, ActivationContext activationContext2) {
+            if (activationContext1 == null || activationContext2 == null)
+                return activationContext1 == activationContext2;
+            return IsolationInterop.AppIdAuthority.AreDefinitionsEqual(0, activationContext1.Identity.Identity, activationContext2.Identity.Identity);
+        }
+
+        internal static bool CompareIdentities (ApplicationIdentity applicationIdentity1, ApplicationIdentity applicationIdentity2, ApplicationVersionMatch versionMatch) {
+            if (applicationIdentity1 == null || applicationIdentity2 == null)
+                return applicationIdentity1 == applicationIdentity2;
+            uint flags;
+            switch (versionMatch) {
+            case ApplicationVersionMatch.MatchExactVersion:
+                flags = 0;
+                break;
+            case ApplicationVersionMatch.MatchAllVersions:
+                flags = (uint) IAPPIDAUTHORITY_ARE_DEFINITIONS_EQUAL_FLAGS.IAPPIDAUTHORITY_ARE_DEFINITIONS_EQUAL_FLAG_IGNORE_VERSION;
+                break;
+            default:
+                throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)versionMatch), "versionMatch");
+            }
+            return IsolationInterop.AppIdAuthority.AreDefinitionsEqual(flags, applicationIdentity1.Identity, applicationIdentity2.Identity);
+        }
+
+        internal static string GetFriendlyName (ActivationContext activationContext) {
+            ICMS deplManifest = activationContext.DeploymentComponentManifest;
+            IMetadataSectionEntry metadataSectionEntry = (IMetadataSectionEntry) deplManifest.MetadataSectionEntry;
+            IDescriptionMetadataEntry descriptionMetadataEntry = metadataSectionEntry.DescriptionData;
+            string friendlyName = String.Empty;
+            if (descriptionMetadataEntry != null) {
+                DescriptionMetadataEntry entry = descriptionMetadataEntry.AllData;
+                friendlyName = (entry.Publisher != null ? String.Format("{0} {1}", entry.Publisher, entry.Product) : entry.Product);
+            }
+            return friendlyName;
+        }
+
+        [ResourceExposure(ResourceScope.Machine)]
+        [ResourceConsumption(ResourceScope.Machine)]
+        internal static void CreateActivationContext (string fullName, string[] manifestPaths, bool useFusionActivationContext, out ApplicationIdentity applicationIdentity, out ActivationContext activationContext) {
+            applicationIdentity = new ApplicationIdentity(fullName);
+            activationContext = null;
+            if (useFusionActivationContext) {
+                if (manifestPaths != null)
+                    activationContext = new ActivationContext(applicationIdentity, manifestPaths);
+                else
+                    activationContext = new ActivationContext(applicationIdentity);
+            }
+        }
+
+        //
+        // Helper method to create an application evidence used in app model activation.
+        // There are basically 2 cases where this method is called:
+        //   a) It is called in CreateInstanceHelper. In this case, it gathers 
+        //      the application evidence passed to the CreateDomainHelper call.
+        //   b) It is also called in the server domain. In that case, the domain could
+        //      be either the default domain (in which case the input evidence is null)
+        //      or a domain created via CreateDomainHelper in which case the application
+        //      evidence already contains the application identity and possibly the activation
+        //      context.
+        //
+
+        internal static Evidence MergeApplicationEvidence (Evidence evidence, ApplicationIdentity applicationIdentity, ActivationContext activationContext, string[] activationData)
+        {
+            return MergeApplicationEvidence(evidence,
+                                            applicationIdentity,
+                                            activationContext,
+                                            activationData,
+                                            null);
+        }
+
+        internal static Evidence MergeApplicationEvidence(Evidence evidence,
+                                                          ApplicationIdentity applicationIdentity,
+                                                          ActivationContext activationContext,
+                                                          string[] activationData,
+                                                          ApplicationTrust applicationTrust)
+        {
+            Evidence appEvidence = new Evidence();
+
+            ActivationArguments activationArgs = (activationContext == null ? new ActivationArguments(applicationIdentity, activationData) : new ActivationArguments(activationContext, activationData));
+            appEvidence = new Evidence();
+            appEvidence.AddHostEvidence(activationArgs);
+
+            if (applicationTrust != null)
+                appEvidence.AddHostEvidence(applicationTrust);
+
+            if (activationContext != null)
+            {
+                Evidence asiEvidence = new ApplicationSecurityInfo(activationContext).ApplicationEvidence;
+                if (asiEvidence != null)
+                    appEvidence.MergeWithNoDuplicates(asiEvidence);
+            }
+
+            if (evidence != null)
+                appEvidence.MergeWithNoDuplicates(evidence);
+
+            return appEvidence;
+        }
+    }
+}
+

mcs/class/referencesource/mscorlib/system/deployment/isolationinterop.cs.REMOVED.git-id

@@ -0,0 +1 @@
+dc4a7da89a021819015ef554a1eacc82a6928599