/// <summary>
        /// Create an UpdateFile object with metadata from the XML blob and URLs from the url data array
        /// </summary>
        /// <param name="xdoc">The XML element that holds file metadata</param>
        /// <param name="metadataSource">The metadata source that contains files URL information.</param>
        /// <returns></returns>
        public static List <UpdateFile> Parse(XDocument xdoc, IMetadataSource metadataSource)
        {
            var parsedFiles = new List <UpdateFile>();

            // Grab all File elements from the XML
            var fileElements = xdoc.Descendants(XName.Get("File", "http://schemas.microsoft.com/msus/2002/12/Update"));

            foreach (var fileElement in fileElements)
            {
                // Create a new UpdateFile from the File element
                parsedFiles.Add(new UpdateFile(fileElement));
            }

            // Find URLs for the parsed files. Urls are matched by file digest.
            foreach (var file in parsedFiles)
            {
                foreach (var hash in file.Digests)
                {
                    if (metadataSource.HasFile(hash.DigestBase64))
                    {
                        file.Urls.Add(metadataSource.GetFile(hash.DigestBase64));
                        break;
                    }
                }
            }

            return(parsedFiles);
        }
Beispiel #2
0
        /// <summary>
        /// Print files from the store
        /// </summary>
        /// <param name="options">Print options, including filters</param>
        public void PrintFiles(QueryMetadataOptions options)
        {
            if (!string.IsNullOrEmpty(options.FileHash))
            {
                var hashBytes = new byte[options.FileHash.Length / 2];
                for (var i = 0; i < hashBytes.Length; i++)
                {
                    hashBytes[i] = System.Convert.ToByte(options.FileHash.Substring(i * 2, 2), 16);
                }

                var hashBase64 = Convert.ToBase64String(hashBytes);

                if (!MetadataSource.HasFile(hashBase64))
                {
                    ConsoleOutput.WriteRed($"Cannot find file hash {options.FileHash}");
                }

                var file = MetadataSource.GetFile(hashBase64);

                foreach (var update in MetadataSource.UpdatesIndex.Values)
                {
                    if (update.HasFiles)
                    {
                        foreach (var updateFile in update.Files)
                        {
                            if (updateFile.Digests.Any(d => d.HexString.Equals(options.FileHash, StringComparison.OrdinalIgnoreCase)))
                            {
                                PrintUpdateMetadata(update, MetadataSource);
                                break;
                            }
                        }
                    }
                }
            }
            else if (options.IdFilter.Count() > 0)
            {
                var idFilter = FilterBuilder.StringGuidsToGuids(options.IdFilter);
                if (idFilter == null)
                {
                    ConsoleOutput.WriteRed("The update ID filter must contain only GUIDs!");
                    return;
                }

                var update = MetadataSource.UpdatesIndex.Values.FirstOrDefault(u => u.Identity.ID.Equals(idFilter[0]));
                if (update == null)
                {
                    ConsoleOutput.WriteRed($"Cannot find update with GUID {idFilter[0]}");
                    return;
                }

                var files = GetAllUpdateFiles(MetadataSource, update);
                PrintFileDetails(files);
            }
        }