Пример #1
0
        private void CheckApplicationPayload(CommitApplicationParams commitParams)
        {
            if (commitParams.AppGroup == null && commitParams.appType != AppType.CustomHostSpecified)
            {
                string path = Path.Combine(commitParams.AppPayloadPath, commitParams.AppManifest.EntryPoints[0].CommandFile);
                if (!PlatformDetector.IsWin8orLater())
                {
                    SystemUtils.CheckSupportedImageAndCLRVersions(path);
                }
            }
            string str = (string)null;

            Store.IPathLock pathLock = (Store.IPathLock)null;
            try
            {
                pathLock = this._compStore.LockAssemblyPath(commitParams.AppManifest.Identity);
                str      = Path.GetDirectoryName(pathLock.Path);
                str      = Path.Combine(str, "manifests");
                str      = Path.Combine(str, Path.GetFileName(pathLock.Path) + ".manifest");
            }
            catch (DeploymentException ex)
            {
            }
            catch (COMException ex)
            {
            }
            finally
            {
                if (pathLock != null)
                {
                    pathLock.Dispose();
                }
            }
            if (string.IsNullOrEmpty(str) || !System.IO.File.Exists(str) || (string.IsNullOrEmpty(commitParams.AppManifestPath) || !System.IO.File.Exists(commitParams.AppManifestPath)))
            {
                return;
            }
            byte[] digestValue1 = ComponentVerifier.GenerateDigestValue(str, CMS_HASH_DIGESTMETHOD.CMS_HASH_DIGESTMETHOD_SHA1, CMS_HASH_TRANSFORM.CMS_HASH_TRANSFORM_IDENTITY);
            byte[] digestValue2 = ComponentVerifier.GenerateDigestValue(commitParams.AppManifestPath, CMS_HASH_DIGESTMETHOD.CMS_HASH_DIGESTMETHOD_SHA1, CMS_HASH_TRANSFORM.CMS_HASH_TRANSFORM_IDENTITY);
            bool   flag         = false;

            Logger.AddInternalState("In-place update check. Existing manifest path = " + str + ", Existing manifest hash=" + Encoding.UTF8.GetString(digestValue1) + ", New manifest path=" + commitParams.AppManifestPath + ", New manifest hash=" + Encoding.UTF8.GetString(digestValue2));
            if (digestValue1.Length == digestValue2.Length)
            {
                int index = 0;
                while (index < digestValue1.Length && (int)digestValue1[index] == (int)digestValue2[index])
                {
                    ++index;
                }
                if (index >= digestValue1.Length)
                {
                    flag = true;
                }
            }
            if (!flag)
            {
                throw new DeploymentException(ExceptionTypes.Subscription, Resources.GetString("Ex_ApplicationInplaceUpdate"));
            }
        }
Пример #2
0
 public static bool VerifyGACDependency(NativeMethods.IAssemblyCache AssemblyCache, bool targetOtherClr, NativeMethods.CCorRuntimeHost RuntimeHost, ReferenceIdentity refId, string tempDir)
 {
     if (string.Compare(refId.ProcessorArchitecture, "msil", StringComparison.OrdinalIgnoreCase) == 0 || !PlatformDetector.VerifyGACDependencyXP(refId, tempDir))
     {
         return(PlatformDetector.VerifyGACDependencyWhidbey(AssemblyCache, targetOtherClr, RuntimeHost, refId));
     }
     return(true);
 }
Пример #3
0
 private bool DeterminePlatformRequirementsCore(bool blocking)
 {
     try
     {
         Logger.AddMethodCall(this._log, "DeploymentManager.DeterminePlatformRequirementsCore(" + blocking.ToString() + ") called.");
         if (!blocking && this._cancellationPending)
         {
             return(true);
         }
         using (TempDirectory tempDirectory = this._subStore.AcquireTempDirectory())
             PlatformDetector.VerifyPlatformDependencies(this._actDesc.AppManifest, this._actDesc.DeployManifest, tempDirectory.Path);
     }
     catch (Exception ex)
     {
         this.LogError(Resources.GetString("Ex_DeterminePlatformRequirementsFailed"), ex);
         Logger.AddInternalState(this._log, "Exception thrown in  DeterminePlatformRequirementsCore(): " + ex.GetType().ToString() + " : " + ex.Message + "\r\n" + ex.StackTrace);
         throw;
     }
     return(false);
 }
Пример #4
0
        private static PlatformDetector.NetFX35SP1SKU GetPlatformNetFx35SKU(NativeMethods.IAssemblyCache AssemblyCache, bool targetOtherCLR, NativeMethods.CCorRuntimeHost RuntimeHost, string tempDir)
        {
            ReferenceIdentity refId1 = new ReferenceIdentity("Sentinel.v3.5Client, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a,processorArchitecture=msil");
            ReferenceIdentity refId2 = new ReferenceIdentity("System.Data.Entity, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089,processorArchitecture=msil");
            bool flag1 = false;
            bool flag2 = false;

            if (PlatformDetector.VerifyGACDependency(AssemblyCache, targetOtherCLR, RuntimeHost, refId1, tempDir))
            {
                flag1 = true;
            }
            if (PlatformDetector.VerifyGACDependency(AssemblyCache, targetOtherCLR, RuntimeHost, refId2, tempDir))
            {
                flag2 = true;
            }
            if (flag1 && !flag2)
            {
                return(PlatformDetector.NetFX35SP1SKU.Client35SP1);
            }
            return(flag1 & flag2 ? PlatformDetector.NetFX35SP1SKU.Full35SP1 : PlatformDetector.NetFX35SP1SKU.No35SP1);
        }
Пример #5
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();
                }
            }
        }
Пример #6
0
 public static bool IsWin8orLater()
 {
     PlatformDetector.OSDependency osd = new PlatformDetector.OSDependency(6U, 2U, 0U, (ushort)0, (ushort)0, (string)null, (string)null);
     return(PlatformDetector.VerifyOSDependency(ref osd));
 }
Пример #7
0
        public static bool CheckCompatibleFramework(CompatibleFramework framework, ref Version clrVersion, ref string clrVersionString, string clrProcArch)
        {
            Logger.AddMethodCall("CheckCompatibleFramework called targetVersion:" + framework.TargetVersion + " profile:" + framework.Profile);
            Version versionRequired    = new Version(framework.TargetVersion);
            string  setupKeyPath1      = (string)null;
            bool    detectInstallValue = false;
            string  setupKeyPath2;
            string  setupValueName;

            switch (versionRequired.Major)
            {
            case 2:
                setupKeyPath2      = "SOFTWARE\\Microsoft\\NET Framework Setup\\NDP\\v" + framework.TargetVersion;
                setupValueName     = "Install";
                detectInstallValue = true;
                break;

            case 3:
                if (versionRequired.Minor == 0)
                {
                    setupKeyPath2      = "SOFTWARE\\Microsoft\\NET Framework Setup\\NDP\\v3.0\\Setup";
                    setupValueName     = "InstallSuccess";
                    detectInstallValue = true;
                    break;
                }
                setupKeyPath2  = "SOFTWARE\\Microsoft\\NET Framework Setup\\NDP\\v" + versionRequired.ToString(2);
                setupValueName = "Version";
                if ("Client".Equals(framework.Profile, StringComparison.OrdinalIgnoreCase))
                {
                    setupKeyPath1 = "SOFTWARE\\Microsoft\\NET Framework Setup\\DotNetClient\\v" + versionRequired.ToString(2);
                    break;
                }
                break;

            default:
                setupKeyPath2 = "SOFTWARE\\Microsoft\\NET Framework Setup\\NDP\\v" + versionRequired.ToString(1);
                if (!string.IsNullOrEmpty(framework.Profile))
                {
                    setupKeyPath2 = setupKeyPath2 + "\\" + framework.Profile;
                }
                setupValueName = "TargetVersion";
                break;
            }
            bool flag = PlatformDetector.DetectFrameworkInRegistry(setupKeyPath2, setupValueName, versionRequired, detectInstallValue) || setupKeyPath1 != null && PlatformDetector.DetectFrameworkInRegistry(setupKeyPath1, setupValueName, versionRequired, detectInstallValue);

            if (!flag && versionRequired.Major >= 4)
            {
                flag = PlatformDetector.DetectTFMInRegistry(framework.SupportedRuntime, framework.TargetVersion, framework.Profile);
            }
            if (!flag)
            {
                return(false);
            }
            if (!NativeMethods.VerifyCLRVersionInfo(new Version(framework.SupportedRuntime), clrProcArch))
            {
                Logger.AddWarningInformation(string.Format((IFormatProvider)CultureInfo.CurrentUICulture, Resources.GetString("CLRMissingForFoundFramework"), new object[2]
                {
                    (object)framework.SupportedRuntime,
                    (object)PlatformDetector.FormatFrameworkString(framework)
                }));
                return(false);
            }
            clrVersionString = framework.SupportedRuntime;
            clrVersion       = new Version(clrVersionString);
            return(true);
        }
 public static uint MapNameToMask(string name, PlatformDetector.NameMap[] nmArray)
 {
     foreach (PlatformDetector.NameMap map in nmArray)
     {
         if (map.name == name)
         {
             return map.mask;
         }
     }
     return 0;
 }
 public static string MapMaskToName(uint mask, PlatformDetector.NameMap[] nmArray)
 {
     foreach (PlatformDetector.NameMap map in nmArray)
     {
         if (map.mask == mask)
         {
             return map.name;
         }
     }
     return null;
 }