コード例 #1
0
        public static void VerifyPlatformDependencies(AssemblyManifest appManifest, AssemblyManifest deployManifest, string tempDir)
        {
            Logger.AddMethodCall("VerifyPlatformDependencies called.");
            string      str1        = (string)null;
            Uri         supportUrl1 = deployManifest.Description.SupportUri;
            bool        flag1       = false;
            DependentOS dependentOs = appManifest.DependentOS;

            if (dependentOs != null)
            {
                PlatformDetector.OSDependency osd = new PlatformDetector.OSDependency((uint)dependentOs.MajorVersion, (uint)dependentOs.MinorVersion, (uint)dependentOs.BuildNumber, (ushort)dependentOs.ServicePackMajor, (ushort)dependentOs.ServicePackMinor, (string)null, (string)null);
                if (!PlatformDetector.VerifyOSDependency(ref osd))
                {
                    StringBuilder stringBuilder = new StringBuilder();
                    string        str2          = ((int)dependentOs.MajorVersion).ToString() + "." + (object)dependentOs.MinorVersion + "." + (object)dependentOs.BuildNumber + "." + (object)dependentOs.ServicePackMajor + (object)dependentOs.ServicePackMinor;
                    stringBuilder.AppendFormat(Resources.GetString("PlatformMicrosoftWindowsOperatingSystem"), (object)str2);
                    string str3 = stringBuilder.ToString();
                    if (dependentOs.SupportUrl != (Uri)null)
                    {
                        supportUrl1 = dependentOs.SupportUrl;
                    }
                    throw new DependentPlatformMissingException(string.Format((IFormatProvider)CultureInfo.CurrentUICulture, Resources.GetString("ErrorMessage_PlatformDetectionFailed"), new object[1] {
                        (object)str3
                    }), supportUrl1);
                }
            }
            if (PlatformDetector.IsWin8orLater() && !appManifest.EntryPoints[0].HostInBrowser)
            {
                flag1 = true;
            }
            Version clrVersion            = Constants.V2CLRVersion;
            string  clrVersionString      = clrVersion.ToString(3);
            string  processorArchitecture = appManifest.Identity.ProcessorArchitecture;
            Uri     supportUrl2           = supportUrl1;

            if (appManifest.CLRDependentAssembly != null)
            {
                clrVersion            = appManifest.CLRDependentAssembly.Identity.Version;
                clrVersionString      = clrVersion.ToString(3);
                processorArchitecture = appManifest.CLRDependentAssembly.Identity.ProcessorArchitecture;
                if (appManifest.CLRDependentAssembly.SupportUrl != (Uri)null)
                {
                    supportUrl2 = appManifest.CLRDependentAssembly.SupportUrl;
                }
                if (appManifest.CLRDependentAssembly.Description != null)
                {
                    str1 = appManifest.CLRDependentAssembly.Description;
                }
            }
            if (deployManifest.CompatibleFrameworks != null)
            {
                bool flag2 = false;
                for (int index = 0; index < deployManifest.CompatibleFrameworks.Frameworks.Count; ++index)
                {
                    if (PlatformDetector.CheckCompatibleFramework(deployManifest.CompatibleFrameworks.Frameworks[index], ref clrVersion, ref clrVersionString, processorArchitecture))
                    {
                        flag2 = true;
                        break;
                    }
                }
                if (!flag2)
                {
                    Uri supportUrl3 = !(deployManifest.CompatibleFrameworks.SupportUrl != (Uri)null) ? supportUrl2 : deployManifest.CompatibleFrameworks.SupportUrl;
                    if (flag1)
                    {
                        return;
                    }
                    throw new CompatibleFrameworkMissingException(string.Format((IFormatProvider)CultureInfo.CurrentUICulture, Resources.GetString("ErrorMessage_CompatiblePlatformDetectionFailed"), new object[1]
                    {
                        (object)PlatformDetector.FormatFrameworkString(deployManifest.CompatibleFrameworks.Frameworks[0])
                    }), supportUrl3, deployManifest.CompatibleFrameworks);
                }
            }
            else
            {
                if (clrVersion >= Constants.V4CLRVersion)
                {
                    throw new InvalidDeploymentException(ExceptionTypes.ManifestSemanticValidation, Resources.GetString("Ex_SemanticallyInvalidDeploymentManifest"), (Exception) new InvalidDeploymentException(ExceptionTypes.InvalidManifest, Resources.GetString("Ex_DepMissingCompatibleFrameworks")));
                }
                if (!NativeMethods.VerifyCLRVersionInfo(clrVersion, processorArchitecture))
                {
                    StringBuilder stringBuilder = new StringBuilder();
                    if (str1 == null)
                    {
                        stringBuilder.AppendFormat(Resources.GetString("PlatformMicrosoftCommonLanguageRuntime"), (object)clrVersionString);
                        str1 = stringBuilder.ToString();
                    }
                    Uri supportUrl3 = supportUrl2;
                    if (flag1)
                    {
                        return;
                    }
                    throw new SupportedRuntimeMissingException(string.Format((IFormatProvider)CultureInfo.CurrentUICulture, Resources.GetString("ErrorMessage_PlatformDetectionFailed"), new object[1] {
                        (object)str1
                    }), supportUrl3, clrVersionString);
                }
            }
            Logger.AddPhaseInformation(Resources.GetString("CompatibleRuntimeFound"), new object[1]
            {
                (object)clrVersionString
            });
            bool flag3 = false;

            if (clrVersion < Constants.V4CLRVersion)
            {
                flag3 = true;
            }
            NativeMethods.CCorRuntimeHost RuntimeHost = (NativeMethods.CCorRuntimeHost)null;
            try
            {
                NativeMethods.IAssemblyCache assemblyCacheInterface = NativeMethods.GetAssemblyCacheInterface(clrVersionString, flag3, out RuntimeHost);
                if (assemblyCacheInterface == null || flag3 && RuntimeHost == null)
                {
                    StringBuilder stringBuilder = new StringBuilder();
                    stringBuilder.AppendFormat(Resources.GetString("PlatformMicrosoftCommonLanguageRuntime"), (object)clrVersionString);
                    throw new DependentPlatformMissingException(string.Format((IFormatProvider)CultureInfo.CurrentUICulture, Resources.GetString("ErrorMessage_PlatformDetectionFailed"), new object[1]
                    {
                        (object)stringBuilder.ToString()
                    }), supportUrl2);
                }
                bool flag2 = false;
                bool flag4 = false;
                if (flag3 && !PolicyKeys.SkipSKUDetection())
                {
                    foreach (DependentAssembly dependentAssembly in appManifest.DependentAssemblies)
                    {
                        if (dependentAssembly.IsPreRequisite && PlatformDetector.IsNetFX35SP1ClientSignatureAsm(dependentAssembly.Identity))
                        {
                            flag2 = true;
                        }
                        if (dependentAssembly.IsPreRequisite && PlatformDetector.IsNetFX35SP1FullSignatureAsm(dependentAssembly.Identity))
                        {
                            flag4 = true;
                        }
                    }
                    if (PlatformDetector.GetPlatformNetFx35SKU(assemblyCacheInterface, flag3, RuntimeHost, tempDir) == PlatformDetector.NetFX35SP1SKU.Client35SP1 && !flag2 && !flag4)
                    {
                        throw new DependentPlatformMissingException(string.Format((IFormatProvider)CultureInfo.CurrentUICulture, Resources.GetString("ErrorMessage_PlatformDetectionFailed"), new object[1]
                        {
                            (object)".NET Framework 3.5 SP1"
                        }));
                    }
                }
                foreach (DependentAssembly dependentAssembly in appManifest.DependentAssemblies)
                {
                    if (dependentAssembly.IsPreRequisite && !PlatformDetector.IsCLRDependencyText(dependentAssembly.Identity.Name))
                    {
                        if (!flag3 && (PlatformDetector.IsNetFX35SP1ClientSignatureAsm(dependentAssembly.Identity) || PlatformDetector.IsNetFX35SP1FullSignatureAsm(dependentAssembly.Identity) || "framework".Equals(dependentAssembly.Group, StringComparison.OrdinalIgnoreCase)))
                        {
                            Logger.AddPhaseInformation(Resources.GetString("SkippingSentinalDependentAssembly"), new object[1]
                            {
                                (object)dependentAssembly.Identity.ToString()
                            });
                        }
                        else if (!PlatformDetector.VerifyGACDependency(assemblyCacheInterface, flag3, RuntimeHost, dependentAssembly.Identity, tempDir))
                        {
                            string description;
                            if (dependentAssembly.Description != null)
                            {
                                description = dependentAssembly.Description;
                            }
                            else
                            {
                                ReferenceIdentity identity      = dependentAssembly.Identity;
                                StringBuilder     stringBuilder = new StringBuilder();
                                stringBuilder.AppendFormat(Resources.GetString("PlatformDependentAssemblyVersion"), (object)identity.Name, (object)identity.Version);
                                description = stringBuilder.ToString();
                            }
                            if (dependentAssembly.SupportUrl != (Uri)null)
                            {
                                supportUrl1 = dependentAssembly.SupportUrl;
                            }
                            throw new DependentPlatformMissingException(string.Format((IFormatProvider)CultureInfo.CurrentUICulture, Resources.GetString("ErrorMessage_PlatformGACDetectionFailed"), new object[1]
                            {
                                (object)description
                            }), supportUrl1);
                        }
                    }
                }
            }
            finally
            {
                if (RuntimeHost != null)
                {
                    RuntimeHost.Dispose();
                }
            }
        }
コード例 #2
0
        public static void VerifyPlatformDependencies(AssemblyManifest appManifest, AssemblyManifest deployManifest, string tempDir)
        {
            Logger.AddMethodCall("VerifyPlatformDependencies called.");
            string      description = null;
            Uri         supportUri  = deployManifest.Description.SupportUri;
            DependentOS dependentOS = appManifest.DependentOS;

            if (dependentOS != null)
            {
                OSDependency osd = new OSDependency(dependentOS.MajorVersion, dependentOS.MinorVersion, dependentOS.BuildNumber, dependentOS.ServicePackMajor, dependentOS.ServicePackMinor, null, null);
                if (!VerifyOSDependency(ref osd))
                {
                    StringBuilder builder = new StringBuilder();
                    string        str2    = string.Concat(new object[] { dependentOS.MajorVersion, ".", dependentOS.MinorVersion, ".", dependentOS.BuildNumber, ".", dependentOS.ServicePackMajor, dependentOS.ServicePackMinor });
                    builder.AppendFormat(Resources.GetString("PlatformMicrosoftWindowsOperatingSystem"), str2);
                    description = builder.ToString();
                    if (dependentOS.SupportUrl != null)
                    {
                        supportUri = dependentOS.SupportUrl;
                    }
                    throw new DependentPlatformMissingException(string.Format(CultureInfo.CurrentUICulture, Resources.GetString("ErrorMessage_PlatformDetectionFailed"), new object[] { description }), supportUri);
                }
            }
            Version v    = Constants.V2CLRVersion;
            string  str3 = v.ToString(3);
            string  processorArchitecture = appManifest.Identity.ProcessorArchitecture;
            Uri     supportUrl            = supportUri;

            if (appManifest.CLRDependentAssembly != null)
            {
                v    = appManifest.CLRDependentAssembly.Identity.Version;
                str3 = v.ToString(3);
                processorArchitecture = appManifest.CLRDependentAssembly.Identity.ProcessorArchitecture;
                if (appManifest.CLRDependentAssembly.SupportUrl != null)
                {
                    supportUrl = appManifest.CLRDependentAssembly.SupportUrl;
                }
                if (appManifest.CLRDependentAssembly.Description != null)
                {
                    description = appManifest.CLRDependentAssembly.Description;
                }
            }
            if (deployManifest.CompatibleFrameworks == null)
            {
                if (v >= Constants.V4CLRVersion)
                {
                    throw new InvalidDeploymentException(ExceptionTypes.ManifestSemanticValidation, Resources.GetString("Ex_SemanticallyInvalidDeploymentManifest"), new InvalidDeploymentException(ExceptionTypes.InvalidManifest, Resources.GetString("Ex_DepMissingCompatibleFrameworks")));
                }
                if (!VerifyCLRVersionInfo(v, processorArchitecture))
                {
                    StringBuilder builder2 = new StringBuilder();
                    if (description == null)
                    {
                        builder2.AppendFormat(Resources.GetString("PlatformMicrosoftCommonLanguageRuntime"), str3);
                        description = builder2.ToString();
                    }
                    supportUri = supportUrl;
                    throw new SupportedRuntimeMissingException(string.Format(CultureInfo.CurrentUICulture, Resources.GetString("ErrorMessage_PlatformDetectionFailed"), new object[] { description }), supportUri, str3);
                }
            }
            else
            {
                bool flag = false;
                for (int i = 0; i < deployManifest.CompatibleFrameworks.Frameworks.Count; i++)
                {
                    if (CheckCompatibleFramework(deployManifest.CompatibleFrameworks.Frameworks[i], ref v, ref str3, processorArchitecture))
                    {
                        flag = true;
                        break;
                    }
                }
                if (!flag)
                {
                    if (deployManifest.CompatibleFrameworks.SupportUrl != null)
                    {
                        supportUri = deployManifest.CompatibleFrameworks.SupportUrl;
                    }
                    else
                    {
                        supportUri = supportUrl;
                    }
                    throw new CompatibleFrameworkMissingException(string.Format(CultureInfo.CurrentUICulture, Resources.GetString("ErrorMessage_CompatiblePlatformDetectionFailed"), new object[] { FormatFrameworkString(deployManifest.CompatibleFrameworks.Frameworks[0]) }), supportUri, deployManifest.CompatibleFrameworks);
                }
            }
            Logger.AddPhaseInformation(Resources.GetString("CompatibleRuntimeFound"), new object[] { str3 });
            bool fetchRuntimeHost = false;

            if (v < Constants.V4CLRVersion)
            {
                fetchRuntimeHost = true;
            }
            using (System.Deployment.Application.NativeMethods.CCorRuntimeHost host = null)
            {
                System.Deployment.Application.NativeMethods.IAssemblyCache assemblyCache = System.Deployment.Application.NativeMethods.GetAssemblyCacheInterface(str3, fetchRuntimeHost, out host);
                if ((assemblyCache == null) || (fetchRuntimeHost && (host == null)))
                {
                    StringBuilder builder3 = new StringBuilder();
                    builder3.AppendFormat(Resources.GetString("PlatformMicrosoftCommonLanguageRuntime"), str3);
                    description = builder3.ToString();
                    supportUri  = supportUrl;
                    throw new DependentPlatformMissingException(string.Format(CultureInfo.CurrentUICulture, Resources.GetString("ErrorMessage_PlatformDetectionFailed"), new object[] { description }), supportUri);
                }
                bool flag3 = false;
                bool flag4 = false;
                if (fetchRuntimeHost && !PolicyKeys.SkipSKUDetection())
                {
                    foreach (DependentAssembly assembly in appManifest.DependentAssemblies)
                    {
                        if (assembly.IsPreRequisite && IsNetFX35SP1ClientSignatureAsm(assembly.Identity))
                        {
                            flag3 = true;
                        }
                        if (assembly.IsPreRequisite && IsNetFX35SP1FullSignatureAsm(assembly.Identity))
                        {
                            flag4 = true;
                        }
                    }
                    if (((GetPlatformNetFx35SKU(assemblyCache, fetchRuntimeHost, host, tempDir) == NetFX35SP1SKU.Client35SP1) && !flag3) && !flag4)
                    {
                        description = ".NET Framework 3.5 SP1";
                        throw new DependentPlatformMissingException(string.Format(CultureInfo.CurrentUICulture, Resources.GetString("ErrorMessage_PlatformDetectionFailed"), new object[] { description }));
                    }
                }
                foreach (DependentAssembly assembly2 in appManifest.DependentAssemblies)
                {
                    if (assembly2.IsPreRequisite && !IsCLRDependencyText(assembly2.Identity.Name))
                    {
                        if (!fetchRuntimeHost && ((IsNetFX35SP1ClientSignatureAsm(assembly2.Identity) || IsNetFX35SP1FullSignatureAsm(assembly2.Identity)) || "framework".Equals(assembly2.Group, StringComparison.OrdinalIgnoreCase)))
                        {
                            Logger.AddPhaseInformation(Resources.GetString("SkippingSentinalDependentAssembly"), new object[] { assembly2.Identity.ToString() });
                        }
                        else if (!VerifyGACDependency(assemblyCache, fetchRuntimeHost, host, assembly2.Identity, tempDir))
                        {
                            if (assembly2.Description != null)
                            {
                                description = assembly2.Description;
                            }
                            else
                            {
                                ReferenceIdentity identity = assembly2.Identity;
                                StringBuilder     builder4 = new StringBuilder();
                                builder4.AppendFormat(Resources.GetString("PlatformDependentAssemblyVersion"), identity.Name, identity.Version);
                                description = builder4.ToString();
                            }
                            if (assembly2.SupportUrl != null)
                            {
                                supportUri = assembly2.SupportUrl;
                            }
                            throw new DependentPlatformMissingException(string.Format(CultureInfo.CurrentUICulture, Resources.GetString("ErrorMessage_PlatformGACDetectionFailed"), new object[] { description }), supportUri);
                        }
                    }
                }
            }
        }