Esempio n. 1
0
        private static async Task <IEnumerable <UpdateData> > GetUpdates(MachineType MachineType)
        {
            HashSet <UpdateData> updates = new HashSet <UpdateData>();

            CTAC[] ctacs = new CTAC[]
            {
                new CTAC(OSSkuId.PPIPro, "10.0.15063.534", MachineType, "WIS", "", "CB", "rs2_release", "Production", false),
                new CTAC(OSSkuId.PPIPro, "10.0.15063.534", MachineType, "WIF", "", "CB", "rs2_release", "Production", false),
                new CTAC(OSSkuId.PPIPro, "10.0.19041.84", MachineType, "Retail", "", "CB", "vb_release", "Production", false),
                new CTAC(OSSkuId.Professional, "10.0.16299.15", MachineType, "Retail", "", "CB", "rs3_release", "Production", true),
                new CTAC(OSSkuId.Professional, "10.0.17134.1", MachineType, "Retail", "", "CB", "rs4_release", "Production", true),
                new CTAC(OSSkuId.Professional, "10.0.17763.1217", MachineType, "Retail", "", "CB", "rs5_release", "Production", true),
                new CTAC(OSSkuId.Professional, "10.0.18362.836", MachineType, "Retail", "", "CB", "19h1_release", "Production", true),
                new CTAC(OSSkuId.Professional, "10.0.19041.84", MachineType, "Retail", "", "CB", "vb_release", "Production", false),
                new CTAC(OSSkuId.Professional, "10.0.19041.84", MachineType, "External", "ReleasePreview", "CB", "vb_release", "Production", false),
                new CTAC(OSSkuId.Professional, "10.0.19041.84", MachineType, "External", "FeaturePreview", "CB", "vb_release", "Production", false),
                new CTAC(OSSkuId.Professional, "10.0.19041.84", MachineType, "External", "Beta", "CB", "vb_release", "Production", false),
                new CTAC(OSSkuId.Professional, "10.0.19041.84", MachineType, "External", "Dev", "CB", "vb_release", "Production", false)
            };

            List <Task <IEnumerable <UpdateData> > > tasks = new List <Task <IEnumerable <UpdateData> > >();

            foreach (var ctac in ctacs)
            {
                tasks.Add(FE3Handler.GetUpdates(null, ctac, null, FileExchangeV3UpdateFilter.ProductRelease));
            }

            IEnumerable <UpdateData>[] datas = await Task.WhenAll(tasks);

            foreach (var data in datas)
            {
                AddUpdatesIfNotPresentAlready(updates, data);
            }

            return(updates);
        }
        public async static Task <string> GetBuildStringAsync(this UpdateData update)
        {
            try
            {
                CExtendedUpdateInfoXml.File deploymentCab = null;

                foreach (var file in update.Xml.Files.File)
                {
                    if (file.FileName.EndsWith("desktopdeployment.cab", StringComparison.InvariantCultureIgnoreCase))
                    {
                        deploymentCab = file;
                        break;
                    }
                }

                if (deploymentCab == null)
                {
                    return(null);
                }

                var fileDownloadInfo = await FE3Handler.GetFileUrl(update, deploymentCab.Digest);

                if (fileDownloadInfo == null)
                {
                    return(null);
                }

                string deploymentCabTemp = Path.GetTempFileName();
                await client.DownloadFileTaskAsync(new Uri(fileDownloadInfo.DownloadUrl), deploymentCabTemp);

                if (fileDownloadInfo.IsEncrypted)
                {
                    if (!fileDownloadInfo.Decrypt(deploymentCabTemp, deploymentCabTemp + ".decrypted"))
                    {
                        return(null);
                    }
                    File.Delete(deploymentCabTemp);
                    File.Move(deploymentCabTemp + ".decrypted", deploymentCabTemp);
                }

                string result = null;

                try
                {
                    using (var cabinet = new CabinetHandler(File.OpenRead(deploymentCabTemp)))
                    {
                        foreach (var file in cabinet.Files)
                        {
                            if (file.Equals("UpdateAgent.dll", StringComparison.InvariantCultureIgnoreCase))
                            {
                                byte[] buffer;
                                using (var dllstream = cabinet.OpenFile(file))
                                {
                                    buffer = new byte[dllstream.Length];
                                    await dllstream.ReadAsync(buffer, 0, (int)dllstream.Length);
                                }
                                result = GetBuildStringFromUpdateAgent(buffer);
                                break;
                            }
                        }
                    }
                }
                catch { }

                var reportedBuildNumberFromService = update.Xml.ExtendedProperties.ReleaseVersion.Split('.')[2];
                if (!string.IsNullOrEmpty(result) && result.Count(x => x == '.') >= 2)
                {
                    var elements = result.Split('.');
                    elements[2] = reportedBuildNumberFromService;
                    result      = string.Join(".", elements);
                }

                File.Delete(deploymentCabTemp);
                return(result);
            }
            catch
            {
                return(null);
            }
        }
 public static async Task <FileExchangeV3FileDownloadInformation> GetFileUrl(this UpdateData update, string Digest)
 {
     return(await FE3Handler.GetFileUrl(update, Digest));
 }
        private static async Task <HashSet <CompDBXmlClass.CompDB> > GetCompDBs(UpdateData update)
        {
            HashSet <CompDBXmlClass.CompDB>       neutralCompDB = new HashSet <CompDBXmlClass.CompDB>();
            HashSet <CExtendedUpdateInfoXml.File> metadataCabs  = new HashSet <CExtendedUpdateInfoXml.File>();

            foreach (CExtendedUpdateInfoXml.File file in update.Xml.Files.File)
            {
                if (file.PatchingType.Equals("metadata", StringComparison.InvariantCultureIgnoreCase))
                {
                    metadataCabs.Add(file);
                }
            }

            if (metadataCabs.Count == 0)
            {
                return(neutralCompDB);
            }

            if (metadataCabs.Count == 1 && metadataCabs.First().FileName.Contains("metadata", StringComparison.InvariantCultureIgnoreCase))
            {
                // This is the new metadata format where all metadata is in a single cab

                if (string.IsNullOrEmpty(update.CachedMetadata))
                {
                    var fileDownloadInfo = await FE3Handler.GetFileUrl(update, metadataCabs.First().Digest);

                    if (fileDownloadInfo == null)
                    {
                        return(neutralCompDB);
                    }

                    string metadataCabTemp = Path.GetTempFileName();

                    // Download the file
                    await client.DownloadFileTaskAsync(new Uri(fileDownloadInfo.DownloadUrl), metadataCabTemp);

                    if (fileDownloadInfo.IsEncrypted)
                    {
                        if (!fileDownloadInfo.Decrypt(metadataCabTemp, metadataCabTemp + ".decrypted"))
                        {
                            return(neutralCompDB);
                        }
                        metadataCabTemp += ".decrypted";
                    }

                    update.CachedMetadata = metadataCabTemp;
                }

                using (CabinetHandler cabinet = new CabinetHandler(File.OpenRead(update.CachedMetadata)))
                {
                    foreach (string file in cabinet.Files)
                    {
                        using (CabinetHandler cabinet2 = new CabinetHandler(cabinet.OpenFile(file)))
                        {
                            string xmlfile = cabinet2.Files.First();

                            using (Stream xmlstream = cabinet2.OpenFile(xmlfile))
                            {
                                neutralCompDB.Add(CompDBXmlClass.DeserializeCompDB(xmlstream));
                            }
                        }
                    }
                }
            }
            else
            {
                // This is the old format, each cab is a file in WU
                foreach (CExtendedUpdateInfoXml.File file in metadataCabs)
                {
                    var fileDownloadInfo = await FE3Handler.GetFileUrl(update, file.Digest);

                    if (fileDownloadInfo == null)
                    {
                        continue;
                    }

                    string metadataCabTemp = Path.GetTempFileName();

                    // Download the file
                    await client.DownloadFileTaskAsync(new Uri(fileDownloadInfo.DownloadUrl), metadataCabTemp);

                    if (fileDownloadInfo.IsEncrypted)
                    {
                        if (!fileDownloadInfo.Decrypt(metadataCabTemp, metadataCabTemp + ".decrypted"))
                        {
                            continue;
                        }
                        metadataCabTemp += ".decrypted";
                    }

                    update.CachedMetadata = metadataCabTemp;

                    using (CabinetHandler cabinet2 = new CabinetHandler(File.OpenRead(update.CachedMetadata)))
                    {
                        string xmlfile = cabinet2.Files.First();
                        using (Stream xmlstream = cabinet2.OpenFile(xmlfile))
                        {
                            neutralCompDB.Add(CompDBXmlClass.DeserializeCompDB(xmlstream));
                        }
                    }
                }
            }

            return(neutralCompDB);
        }
Esempio n. 5
0
        public static async Task <AvailableEdition[]> GetAvailableEditions(UpdateData UpdateData, string languagecode)
        {
            List <AvailableEdition> availableEditions = new List <AvailableEdition>();

            List <CExtendedUpdateInfoXml.File> metadataCabs = new List <CExtendedUpdateInfoXml.File>();

            foreach (var file in UpdateData.Xml.Files.File)
            {
                if (file.PatchingType.Equals("metadata", StringComparison.InvariantCultureIgnoreCase))
                {
                    metadataCabs.Add(file);
                }
            }

            if (metadataCabs.Count == 0)
            {
                goto exit;
            }

            if (metadataCabs.Count == 1 && metadataCabs[0].FileName.Contains("metadata", StringComparison.InvariantCultureIgnoreCase))
            {
                // This is the new metadata format where all metadata is in a single cab

                if (string.IsNullOrEmpty(UpdateData.CachedMetadata))
                {
                    var fileDownloadInfo = await FE3Handler.GetFileUrl(UpdateData, metadataCabs[0].Digest);

                    if (fileDownloadInfo == null)
                    {
                        goto exit;
                    }

                    string metadataCabTemp = Path.GetTempFileName();

                    // Download the file
                    WebClient client = new WebClient();
                    await client.DownloadFileTaskAsync(new Uri(fileDownloadInfo.DownloadUrl), metadataCabTemp);

                    if (fileDownloadInfo.IsEncrypted)
                    {
                        if (!await fileDownloadInfo.DecryptAsync(metadataCabTemp, metadataCabTemp + ".decrypted"))
                        {
                            goto exit;
                        }
                        metadataCabTemp += ".decrypted";
                    }

                    UpdateData.CachedMetadata = metadataCabTemp;
                }

                using (var cabinet = new CabinetHandler(File.OpenRead(UpdateData.CachedMetadata)))
                {
                    IEnumerable <string> potentialFiles = cabinet.Files.Where(x =>
                                                                              x.ToLower().Contains($"desktoptargetcompdb_") &&
                                                                              x.ToLower().Contains($"_{languagecode}") &&
                                                                              !x.ToLower().Contains("lxp") &&
                                                                              !x.ToLower().Contains($"desktoptargetcompdb_{languagecode}"));

                    foreach (var file in potentialFiles)
                    {
                        var edition = file.Split('_').Reverse().Skip(1).First();

                        if (availableEditions.Any(x => x.Edition == edition))
                        {
                            continue;
                        }

                        availableEditions.Add(new AvailableEdition()
                        {
                            Edition = edition
                        });
                    }
                }
            }
            else
            {
                IEnumerable <string> potentialFiles = metadataCabs.Select(x => x.FileName).Where(x =>
                                                                                                 x.ToLower().Contains($"desktoptargetcompdb_") &&
                                                                                                 x.ToLower().Contains($"_{languagecode}") &&
                                                                                                 !x.ToLower().Contains("lxp") &&
                                                                                                 !x.ToLower().Contains($"desktoptargetcompdb_{languagecode}"));

                // This is the old format, each cab is a file in WU
                foreach (var file in potentialFiles)
                {
                    var edition = file.Split('_').Reverse().Skip(1).First();

                    if (availableEditions.Any(x => x.Edition == edition))
                    {
                        continue;
                    }

                    availableEditions.Add(new AvailableEdition()
                    {
                        Edition = edition
                    });
                }
            }

            availableEditions.Sort((x, y) => x.Edition.CompareTo(y.Edition));

exit:
            return(availableEditions.ToArray());
        }