5 files changed, 2678 insertions, 0 deletions

diff --git a/src/dtf/WixToolset.Dtf.WindowsInstaller.Package/InstallPackage.cs b/src/dtf/WixToolset.Dtf.WindowsInstaller.Package/InstallPackage.cs
new file mode 100644
index 00000000..276732b7
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.WindowsInstaller.Package/InstallPackage.cs
@@ -0,0 +1,1169 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.WindowsInstaller.Package
+{
+using System;
+using System.IO;
+using System.Text;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Text.RegularExpressions;
+using WixToolset.Dtf.Compression;
+using WixToolset.Dtf.Compression.Cab;
+
+/// <summary>
+/// Handles status messages generated when operations are performed on an
+/// <see cref="InstallPackage"/> or <see cref="PatchPackage"/>.
+/// </summary>
+/// <example>
+/// <c>installPackage.Message += new InstallPackageMessageHandler(Console.WriteLine);</c>
+/// </example>
+public delegate void InstallPackageMessageHandler(string format, params object[] args);
+
+/// <summary>
+/// Provides access to powerful build, maintenance, and analysis operations on an
+/// installation package (.MSI or .MSM).
+/// </summary>
+public class InstallPackage : Database
+{
+    private string cabName;
+    private string cabMsg;
+
+    /// <summary>
+    /// Creates a new InstallPackage object.  The file source directory and working
+    /// directory are the same as the location as the package file.
+    /// </summary>
+    /// <param name="packagePath">Path to the install package to be created or opened</param>
+    /// <param name="openMode">Open mode for the database</param>
+    public InstallPackage(string packagePath, DatabaseOpenMode openMode)
+        : this(packagePath, openMode, null, null)
+    {
+    }
+    /// <summary>
+    /// Creates a new InstallPackage object, specifying an alternate file source
+    /// directory and/or working directory.
+    /// </summary>
+    /// <param name="packagePath">Path to the install package to be created or opened</param>
+    /// <param name="openMode">Open mode for the database</param>
+    /// <param name="sourceDir">Location to obtain source files and cabinets when extracting
+    /// or updating files in the working directory. This is often the location of an original
+    /// copy of the package that is not meant to be modified. If this parameter is null, it
+    /// defaults to the directory of <paramref name="packagePath"/>.</param>
+    /// <param name="workingDir">Location where files will be extracted to/updated from. Also
+    /// the location where a temporary folder is created during some operations. If this
+    /// parameter is null, it defaults to the directory of <paramref name="packagePath"/>.</param>
+    /// <remarks>If the source location is different than the working directory, then
+    /// no files will be modified at the source location.
+    /// </remarks>
+    public InstallPackage(string packagePath, DatabaseOpenMode openMode,
+        string sourceDir, string workingDir) : base(packagePath, openMode)
+    {
+        this.sourceDir  = (sourceDir  != null ? sourceDir  : Path.GetDirectoryName(packagePath));
+        this.workingDir = (workingDir != null ? workingDir : Path.GetDirectoryName(packagePath));
+        this.compressionLevel = CompressionLevel.Normal;
+
+        this.DeleteOnClose(this.TempDirectory);
+    }
+
+    /// <summary>
+    /// Handle this event to receive status messages when operations are performed
+    /// on the install package.
+    /// </summary>
+    /// <example>
+    /// <c>installPackage.Message += new InstallPackageMessageHandler(Console.WriteLine);</c>
+    /// </example>
+    public event InstallPackageMessageHandler Message;
+
+    /// <summary>
+    /// Sends a message to the <see cref="Message"/> event-handler.
+    /// </summary>
+    /// <param name="format">Message string, containing 0 or more format items</param>
+    /// <param name="args">Items to be formatted</param>
+    protected void LogMessage(string format, params object[] args)
+    {
+        if(this.Message != null)
+        {
+            this.Message(format, args);
+        }
+    }
+
+    /// <summary>
+    /// Gets or sets the location to obtain source files and cabinets when
+    /// extracting or updating files in the working directory. This is often
+    /// the location of an original copy of the package that is not meant
+    /// to be modified.
+    /// </summary>
+    public string SourceDirectory
+    {
+        get { return this.sourceDir; }
+        set { this.sourceDir = value; }
+    }
+    private string sourceDir;
+
+    /// <summary>
+    /// Gets or sets the location where files will be extracted to/updated from. Also
+    /// the location where a temporary folder is created during some operations.
+    /// </summary>
+    public string WorkingDirectory
+    {
+        get { return this.workingDir; }
+        set { this.workingDir = value; }
+    }
+    private string workingDir;
+
+    private const string TEMP_DIR_NAME = "WITEMP";
+
+    private string TempDirectory
+    {
+        get { return Path.Combine(this.WorkingDirectory, TEMP_DIR_NAME); }
+    }
+
+    /// <summary>
+    /// Gets the list of file keys that have the specified long file name.
+    /// </summary>
+    /// <param name="longFileName">File name to search for (case-insensitive)</param>
+    /// <returns>Array of file keys, or a 0-length array if none are found</returns>
+    [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase")]
+    public string[] FindFiles(string longFileName)
+    {
+        longFileName = longFileName.ToLowerInvariant();
+        ArrayList fileList = new ArrayList();
+        foreach(KeyValuePair<string, InstallPath> entry in this.Files)
+        {
+            if(((InstallPath) entry.Value).TargetName.ToLowerInvariant()
+               == longFileName)
+            {
+                fileList.Add(entry.Key);
+            }
+        }
+        return (string[]) fileList.ToArray(typeof(string));
+    }
+
+    /// <summary>
+    /// Gets the list of file keys whose long file names match a specified
+    /// regular-expression search pattern.
+    /// </summary>
+    /// <param name="pattern">Regular expression search pattern</param>
+    /// <returns>Array of file keys, or a 0-length array if none are found</returns>
+    public string[] FindFiles(Regex pattern)
+    {
+        ArrayList fileList = new ArrayList();
+        foreach (KeyValuePair<string, InstallPath> entry in this.Files)
+        {
+            if(pattern.IsMatch(((InstallPath) entry.Value).TargetName))
+            {
+                fileList.Add(entry.Key);
+            }
+        }
+        return (string[]) fileList.ToArray(typeof(string));
+    }
+
+    /// <summary>
+    /// Extracts all files to the <see cref="WorkingDirectory"/>. The files are extracted
+    /// to the relative directory matching their <see cref="InstallPath.SourcePath"/>.
+    /// </summary>
+    /// <remarks>If any files have the uncompressed attribute, they will be copied
+    /// from the <see cref="SourceDirectory"/>.</remarks>
+    public void ExtractFiles()
+    {
+        this.ExtractFiles(null);
+    }
+    /// <summary>
+    /// Extracts a specified list of files to the <see cref="WorkingDirectory"/>. The files
+    /// are extracted to the relative directory matching their <see cref="InstallPath.SourcePath"/>.
+    /// </summary>
+    /// <param name="fileKeys">List of file key strings to extract</param>
+    /// <remarks>If any files have the uncompressed attribute, they will be copied
+    /// from the <see cref="SourceDirectory"/>.</remarks>
+    public void ExtractFiles(ICollection<string> fileKeys)
+    {
+        this.ProcessFilesByMediaDisk(fileKeys,
+            new ProcessFilesOnOneMediaDiskHandler(this.ExtractFilesOnOneMediaDisk));
+    }
+
+    private bool IsMergeModule()
+    {
+        return this.CountRows("Media", "`LastSequence` >= 0") == 0 &&
+            this.CountRows("_Streams", "`Name` = 'MergeModule.CABinet'") != 0;
+    }
+
+    private delegate void ProcessFilesOnOneMediaDiskHandler(string mediaCab,
+        InstallPathMap compressedFileMap, InstallPathMap uncompressedFileMap);
+
+    private void ProcessFilesByMediaDisk(ICollection<string> fileKeys,
+        ProcessFilesOnOneMediaDiskHandler diskHandler)
+    {
+        if(this.IsMergeModule())
+        {
+            InstallPathMap files = new InstallPathMap();
+            foreach(string fileKey in this.Files.Keys)
+            {
+                if(fileKeys == null || fileKeys.Contains(fileKey))
+                {
+                    files[fileKey] = this.Files[fileKey];
+                }
+            }
+            diskHandler("#MergeModule.CABinet", files, new InstallPathMap());
+        }
+        else
+        {
+            bool defaultCompressed = ((this.SummaryInfo.WordCount & 0x2) != 0);
+
+            View fileView = null, mediaView = null;
+            Record fileRec = null;
+            try
+            {
+                fileView = this.OpenView("SELECT `File`, `Attributes`, `Sequence` " +
+                    "FROM `File` ORDER BY `Sequence`");
+                mediaView = this.OpenView("SELECT `DiskId`, `LastSequence`, `Cabinet` " +
+                    "FROM `Media` ORDER BY `DiskId`");
+                fileView.Execute();
+                mediaView.Execute();
+
+                int currentMediaDiskId = -1;
+                int currentMediaMaxSequence = -1;
+                string currentMediaCab = null;
+                InstallPathMap compressedFileMap = new InstallPathMap();
+                InstallPathMap uncompressedFileMap = new InstallPathMap();
+
+                while((fileRec = fileView.Fetch()) != null)
+                {
+                    string fileKey = (string) fileRec[1];
+
+                    if(fileKeys == null || fileKeys.Contains(fileKey))
+                    {
+                        int fileAttributes = fileRec.GetInteger(2);
+                        int fileSequence = fileRec.GetInteger(3);
+
+                        InstallPath fileInstallPath = this.Files[fileKey];
+                        if(fileInstallPath == null)
+                        {
+                            this.LogMessage("Could not get install path for source file: {0}", fileKey);
+                            throw new InstallerException("Could not get install path for source file: " + fileKey);
+                        }
+
+                        if(fileSequence > currentMediaMaxSequence)
+                        {
+                            if(currentMediaDiskId != -1)
+                            {
+                                diskHandler(currentMediaCab,
+                                    compressedFileMap, uncompressedFileMap);
+                                compressedFileMap.Clear();
+                                uncompressedFileMap.Clear();
+                            }
+
+                            while(fileSequence > currentMediaMaxSequence)
+                            {
+                                Record mediaRec = mediaView.Fetch();
+                                if(mediaRec == null)
+                                {
+                                    currentMediaDiskId = -1;
+                                    break;
+                                }
+                                using(mediaRec)
+                                {
+                                    currentMediaDiskId = mediaRec.GetInteger(1);
+                                    currentMediaMaxSequence = mediaRec.GetInteger(2);
+                                    currentMediaCab = (string) mediaRec[3];
+                                }
+                            }
+                            if(fileSequence > currentMediaMaxSequence) break;
+                        }
+
+                        if((fileAttributes & (int) WixToolset.Dtf.WindowsInstaller.FileAttributes.Compressed) != 0)
+                        {
+                            compressedFileMap[fileKey] = fileInstallPath;
+                        }
+                        else if ((fileAttributes & (int) WixToolset.Dtf.WindowsInstaller.FileAttributes.NonCompressed) != 0)
+                        {
+                            // Non-compressed files are located
+                            // in the same directory as the MSI, without any path.
+                            uncompressedFileMap[fileKey] = new InstallPath(fileInstallPath.SourceName);
+                        }
+                        else if(defaultCompressed)
+                        {
+                            compressedFileMap[fileKey] = fileInstallPath;
+                        }
+                        else
+                        {
+                            uncompressedFileMap[fileKey] = fileInstallPath;
+                        }
+                    }
+                    fileRec.Close();
+                    fileRec = null;
+                }
+                if(currentMediaDiskId != -1)
+                {
+                    diskHandler(currentMediaCab,
+                        compressedFileMap, uncompressedFileMap);
+                }
+            }
+            finally
+            {
+                if (fileRec != null) fileRec.Close();
+                if (fileView != null) fileView.Close();
+                if (mediaView != null) mediaView.Close();
+            }
+        }
+    }
+
+    [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase")]
+    private void ExtractFilesOnOneMediaDisk(string mediaCab,
+        InstallPathMap compressedFileMap, InstallPathMap uncompressedFileMap)
+    {
+        if(compressedFileMap.Count > 0)
+        {
+            string cabFile = null;
+            if(mediaCab.StartsWith("#", StringComparison.Ordinal))
+            {
+                mediaCab = mediaCab.Substring(1);
+
+                using(View streamView = this.OpenView("SELECT `Name`, `Data` FROM `_Streams` " +
+                      "WHERE `Name` = '{0}'", mediaCab))
+                {
+                    streamView.Execute();
+                    Record streamRec = streamView.Fetch();
+                    if(streamRec == null)
+                    {
+                        this.LogMessage("Stream not found: {0}", mediaCab);
+                        throw new InstallerException("Stream not found: " + mediaCab);
+                    }
+                    using(streamRec)
+                    {
+                        this.LogMessage("extract cab {0}", mediaCab);
+                        Directory.CreateDirectory(this.TempDirectory);
+                        cabFile = Path.Combine(this.TempDirectory,
+                            Path.GetFileNameWithoutExtension(mediaCab) + ".cab");
+                        streamRec.GetStream("Data", cabFile);
+                    }
+                }
+            }
+            else
+            {
+                cabFile = Path.Combine(this.SourceDirectory, mediaCab);
+            }
+
+            this.cabName = mediaCab;
+            this.cabMsg = "extract {0}\\{1} {2}";
+            new CabInfo(cabFile).UnpackFileSet(compressedFileMap.SourcePaths, this.WorkingDirectory,
+                this.CabinetProgress);
+            ClearReadOnlyAttribute(this.WorkingDirectory, compressedFileMap.Values);
+        }
+        foreach(InstallPath fileInstallPath in uncompressedFileMap.Values)
+        {
+            string sourcePath = Path.Combine(this.SourceDirectory, fileInstallPath.SourcePath);
+            string extractPath = Path.Combine(this.WorkingDirectory, fileInstallPath.SourcePath);
+            if(Path.GetFullPath(sourcePath).ToLowerInvariant() !=
+                Path.GetFullPath(extractPath).ToLowerInvariant())
+            {
+                if(!File.Exists(sourcePath))
+                {
+                    this.LogMessage("Error: Uncompressed file not found: {0}", sourcePath);
+                    throw new FileNotFoundException("Uncompressed file not found.", sourcePath);
+                }
+                else
+                {
+                    this.LogMessage("copy {0} {1}", sourcePath, extractPath);
+                    Directory.CreateDirectory(Path.GetDirectoryName(extractPath));
+                    File.Copy(sourcePath, extractPath, true);
+                }
+            }
+            else
+            {
+                if(!File.Exists(extractPath))
+                {
+                    this.LogMessage("Error: Uncompressed file not found: {0}", extractPath);
+                    throw new FileNotFoundException("Uncompressed file not found.", extractPath);
+                }
+            }
+        }
+    }
+
+    private void CabinetProgress(object sender, ArchiveProgressEventArgs e)
+    {
+        switch(e.ProgressType)
+        {
+            case ArchiveProgressType.StartFile:
+            {
+                string filePath = e.CurrentFileName;
+                if(this.filePathMap != null)
+                {
+                    InstallPath fileInstallPath = this.Files[e.CurrentFileName];
+                    if(fileInstallPath != null)
+                    {
+                        filePath = fileInstallPath.SourcePath;
+                    }
+                }
+                this.LogMessage(this.cabMsg, this.cabName, e.CurrentFileName,
+                    Path.Combine(this.WorkingDirectory, filePath));
+            }
+            break;
+        }
+    }
+
+    /// <summary>
+    /// Updates the install package with new files from the <see cref="WorkingDirectory"/>.  The
+    /// files must be in the relative directory matching their <see cref="InstallPath.SourcePath"/>.
+    /// This method re-compresses and packages the files if necessary, and also updates the
+    /// following data: File.FileSize, File.Version, File.Language, MsiFileHash.HashPart*
+    /// </summary>
+    /// <remarks>
+    /// The cabinet compression level used during re-cabbing can be configured with the
+    /// <see cref="CompressionLevel"/> property.
+    /// </remarks>
+    public void UpdateFiles()
+    {
+        this.UpdateFiles(null);
+    }
+    /// <summary>
+    /// Updates the install package with new files from the <see cref="WorkingDirectory"/>.  The
+    /// files must be in the relative directory matching their <see cref="InstallPath.SourcePath"/>.
+    /// This method re-compresses and packages the files if necessary, and also updates the
+    /// following data: File.FileSize, File.Version, File.Language, MsiFileHash.HashPart?.
+    /// </summary>
+    /// <param name="fileKeys">List of file key strings to update</param>
+    /// <remarks>
+    /// This method does not change the media structure of the package, so it may require extracting
+    /// and re-compressing a large cabinet just to update one file.
+    /// <p>The cabinet compression level used during re-cabbing can be configured with the
+    /// <see cref="CompressionLevel"/> property.</p>
+    /// </remarks>
+    public void UpdateFiles(ICollection<string> fileKeys)
+    {
+        this.ProcessFilesByMediaDisk(fileKeys,
+            new ProcessFilesOnOneMediaDiskHandler(this.UpdateFilesOnOneMediaDisk));
+    }
+
+    private void UpdateFilesOnOneMediaDisk(string mediaCab,
+        InstallPathMap compressedFileMap, InstallPathMap uncompressedFileMap)
+    {
+        if(compressedFileMap.Count > 0)
+        {
+            string cabFile = null;
+            bool cabFileIsTemp = false;
+            if(mediaCab.StartsWith("#", StringComparison.Ordinal))
+            {
+                cabFileIsTemp = true;
+                mediaCab = mediaCab.Substring(1);
+
+                using(View streamView = this.OpenView("SELECT `Name`, `Data` FROM `_Streams` " +
+                      "WHERE `Name` = '{0}'", mediaCab))
+                {
+                    streamView.Execute();
+                    Record streamRec = streamView.Fetch();
+                    if(streamRec == null)
+                    {
+                        this.LogMessage("Stream not found: {0}", mediaCab);
+                        throw new InstallerException("Stream not found: " + mediaCab);
+                    }
+                    using(streamRec)
+                    {
+                        this.LogMessage("extract cab {0}", mediaCab);
+                        Directory.CreateDirectory(this.TempDirectory);
+                        cabFile = Path.Combine(this.TempDirectory,
+                            Path.GetFileNameWithoutExtension(mediaCab) + ".cab");
+                        streamRec.GetStream("Data", cabFile);
+                    }
+                }
+            }
+            else
+            {
+                cabFile = Path.Combine(this.SourceDirectory, mediaCab);
+            }
+
+            CabInfo cab = new CabInfo(cabFile);
+            ArrayList fileKeyList = new ArrayList();
+            foreach (CabFileInfo fileInCab in cab.GetFiles())
+            {
+                string fileKey = fileInCab.Name;
+                if(this.Files[fileKey] != null)
+                {
+                    fileKeyList.Add(fileKey);
+                }
+            }
+            string[] fileKeys = (string[]) fileKeyList.ToArray(typeof(string));
+
+            Directory.CreateDirectory(this.TempDirectory);
+
+            ArrayList remainingFileKeys = new ArrayList(fileKeys);
+            foreach(string fileKey in fileKeys)
+            {
+                InstallPath fileInstallPath = compressedFileMap[fileKey];
+                if(fileInstallPath != null)
+                {
+                    UpdateFileStats(fileKey, fileInstallPath);
+
+                    string filePath = Path.Combine(this.WorkingDirectory, fileInstallPath.SourcePath);
+                    this.LogMessage("copy {0} {1}", filePath, fileKey);
+                    File.Copy(filePath, Path.Combine(this.TempDirectory, fileKey), true);
+                    remainingFileKeys.Remove(fileKey);
+                }
+            }
+
+            if(remainingFileKeys.Count > 0)
+            {
+                this.cabName = mediaCab;
+                this.cabMsg = "extract {0}\\{1}";
+                string[] remainingFileKeysArray = (string[]) remainingFileKeys.ToArray(typeof(string));
+                cab.UnpackFiles(remainingFileKeysArray, this.TempDirectory, remainingFileKeysArray,
+                    this.CabinetProgress);
+            }
+
+            ClearReadOnlyAttribute(this.TempDirectory, fileKeys);
+
+            if(!cabFileIsTemp)
+            {
+                cab = new CabInfo(Path.Combine(this.WorkingDirectory, mediaCab));
+            }
+            this.cabName = mediaCab;
+            this.cabMsg = "compress {0}\\{1}";
+            cab.PackFiles(this.TempDirectory, fileKeys, fileKeys,
+                this.CompressionLevel, this.CabinetProgress);
+
+            if(cabFileIsTemp)
+            {
+              using (Record streamRec = new Record(1))
+              {
+                  streamRec.SetStream(1, cabFile);
+                  this.Execute(String.Format(
+                      "UPDATE `_Streams` SET `Data` = ? WHERE `Name` = '{0}'", mediaCab),
+                      streamRec);
+              }
+            }
+        }
+
+        foreach (KeyValuePair<string, InstallPath> entry in uncompressedFileMap)
+        {
+            UpdateFileStats((string) entry.Key, (InstallPath) entry.Value);
+        }
+    }
+
+    private void UpdateFileStats(string fileKey, InstallPath fileInstallPath)
+    {
+        string filePath = Path.Combine(this.WorkingDirectory, fileInstallPath.SourcePath);
+        if(!File.Exists(filePath))
+        {
+            this.LogMessage("Updated source file not found: {0}", filePath);
+            throw new FileNotFoundException("Updated source file not found: " + filePath);
+        }
+
+        this.LogMessage("updatestats {0}", fileKey);
+
+        string version = Installer.GetFileVersion(filePath);
+        string language = Installer.GetFileLanguage(filePath);
+        long size = new FileInfo(filePath).Length;
+
+        this.Execute("UPDATE `File` SET `Version` = '{0}', `Language` = '{1}', " +
+            "`FileSize` = {2} WHERE `File` = '{3}'", version, language, size, fileKey);
+
+        if ((version == null || version.Length == 0) && this.Tables.Contains("MsiFileHash"))
+        {
+            int[] hash = new int[4];
+            Installer.GetFileHash(filePath, hash);
+            this.Execute("DELETE FROM `MsiFileHash` WHERE `File_` = '{0}'", fileKey);
+            this.Execute("INSERT INTO `MsiFileHash` (`File_`, `Options`, `HashPart1`, `HashPart2`, " +
+                "`HashPart3`, `HashPart4`) VALUES ('" + fileKey + "', 0, {0}, {1}, {2}, {3})",
+                hash[0], hash[1], hash[2], hash[3]);
+        }
+    }
+
+    /// <summary>
+    /// Consolidates a package by combining and re-compressing all files into a single
+    /// internal or external cabinet.
+    /// </summary>
+    /// <param name="mediaCabinet"></param>
+    /// <remarks>If an installation package was built from many merge modules, this
+    /// method can somewhat decrease package size, complexity, and installation time.
+    /// <p>This method will also convert a package with all or mostly uncompressed
+    /// files into a package where all files are compressed.</p>
+    /// <p>If the package contains any not-yet-applied binary file patches (for
+    /// example, a package generated by a call to <see cref="ApplyPatch"/>) then
+    /// this method will apply the patches before compressing the updated files.</p>
+    /// <p>This method edits the database summary information and the File, Media
+    /// and Patch tables as necessary to maintain a valid installation package.</p>
+    /// <p>The cabinet compression level used during re-cabbing can be configured with the
+    /// <see cref="CompressionLevel"/> property.</p>
+    /// </remarks>
+    public void Consolidate(string mediaCabinet)
+    {
+        this.LogMessage("Consolidating package");
+
+        Directory.CreateDirectory(this.TempDirectory);
+
+        this.LogMessage("Extracting/preparing files");
+        this.ProcessFilesByMediaDisk(null,
+            new ProcessFilesOnOneMediaDiskHandler(this.PrepareOneMediaDiskForConsolidation));
+
+        this.LogMessage("Applying any file patches");
+        ApplyFilePatchesForConsolidation();
+
+        this.LogMessage("Clearing PatchPackage, Patch, MsiPatchHeaders tables");
+        if (this.Tables.Contains("PatchPackage"))
+        {
+            this.Execute("DELETE FROM `PatchPackage` WHERE `PatchId` <> ''");
+        }
+        if (this.Tables.Contains("Patch"))
+        {
+            this.Execute("DELETE FROM `Patch` WHERE `File_` <> ''");
+        }
+        if (this.Tables.Contains("MsiPatchHeaders"))
+        {
+            this.Execute("DELETE FROM `MsiPatchHeaders` WHERE `StreamRef` <> ''");
+        }
+
+        this.LogMessage("Resequencing files");
+        ArrayList files = new ArrayList();
+        using(View fileView = this.OpenView("SELECT `File`, `Attributes`, `Sequence` " +
+              "FROM `File` ORDER BY `Sequence`"))
+        {
+            fileView.Execute();
+            
+            foreach (Record fileRec in fileView) using(fileRec)
+            {
+                files.Add(fileRec[1]);
+                int fileAttributes = fileRec.GetInteger(2);
+                fileAttributes &= ~(int) (WixToolset.Dtf.WindowsInstaller.FileAttributes.Compressed
+                    | WixToolset.Dtf.WindowsInstaller.FileAttributes.NonCompressed | WixToolset.Dtf.WindowsInstaller.FileAttributes.PatchAdded);
+                fileRec[2] = fileAttributes;
+                fileRec[3] = files.Count;
+                fileView.Update(fileRec);
+            }
+        }
+
+        bool internalCab = false;
+        if(mediaCabinet.StartsWith("#", StringComparison.Ordinal))
+        {
+            internalCab = true;
+            mediaCabinet = mediaCabinet.Substring(1);
+        }
+
+        this.LogMessage("Cabbing files");
+        string[] fileKeys = (string[]) files.ToArray(typeof(string));
+        string cabPath = Path.Combine(internalCab ? this.TempDirectory
+            : this.WorkingDirectory, mediaCabinet);
+        this.cabName = mediaCabinet;
+        this.cabMsg = "compress {0}\\{1}";
+        new CabInfo(cabPath).PackFiles(this.TempDirectory, fileKeys,
+            fileKeys, this.CompressionLevel, this.CabinetProgress);
+
+        this.DeleteEmbeddedCabs();
+
+        if(internalCab)
+        {
+            this.LogMessage("Inserting cab stream into MSI");
+            Record cabRec = new Record(1);
+            cabRec.SetStream(1, cabPath);
+            this.Execute("INSERT INTO `_Streams` (`Name`, `Data`) VALUES ('" + mediaCabinet + "', ?)", cabRec);
+        }
+
+        this.LogMessage("Inserting cab media record into MSI");
+        this.Execute("DELETE FROM `Media` WHERE `DiskId` <> 0");
+        this.Execute("INSERT INTO `Media` (`DiskId`, `LastSequence`, `Cabinet`) " +
+            "VALUES (1, " + files.Count + ", '" + (internalCab ? "#" : "") + mediaCabinet + "')");
+
+
+        this.LogMessage("Setting compressed flag on package summary info");
+        this.SummaryInfo.WordCount = this.SummaryInfo.WordCount | 2;
+        this.SummaryInfo.Persist();
+    }
+
+    private void DeleteEmbeddedCabs()
+    {
+        using (View view = this.OpenView("SELECT `Cabinet` FROM `Media` WHERE `Cabinet` <> ''"))
+        {
+            view.Execute();
+            
+            foreach (Record rec in view) using(rec)
+            {
+                string cab = rec.GetString(1);
+                if(cab.StartsWith("#", StringComparison.Ordinal))
+                {
+                    cab = cab.Substring(1);
+                    this.LogMessage("Deleting embedded cab stream: {0}", cab);
+                    this.Execute("DELETE FROM `_Streams` WHERE `Name` = '{0}'", cab);
+                }
+            }
+        }
+    }
+
+    private void PrepareOneMediaDiskForConsolidation(string mediaCab,
+        InstallPathMap compressedFileMap, InstallPathMap uncompressedFileMap)
+    {
+        if(compressedFileMap.Count > 0)
+        {
+            string cabFile = null;
+            if(mediaCab.StartsWith("#", StringComparison.Ordinal))
+            {
+                mediaCab = mediaCab.Substring(1);
+
+                using (View streamView = this.OpenView("SELECT `Name`, `Data` FROM `_Streams` " +
+                      "WHERE `Name` = '{0}'", mediaCab))
+                {
+                    streamView.Execute();
+                    Record streamRec = streamView.Fetch();
+                    if(streamRec == null)
+                    {
+                        this.LogMessage("Stream not found: {0}", mediaCab);
+                        throw new InstallerException("Stream not found: " + mediaCab);
+                    }
+                    using(streamRec)
+                    {
+                        this.LogMessage("extract cab {0}", mediaCab);
+                        cabFile = Path.Combine(this.TempDirectory,
+                            Path.GetFileNameWithoutExtension(mediaCab) + ".cab");
+                        streamRec.GetStream("Data", cabFile);
+                    }
+                }
+            }
+            else
+            {
+                cabFile = Path.Combine(this.SourceDirectory, mediaCab);
+            }
+            string[] fileKeys = new string[compressedFileMap.Keys.Count];
+            compressedFileMap.Keys.CopyTo(fileKeys, 0);
+            this.cabName = mediaCab;
+            this.cabMsg = "extract {0}\\{1}";
+            new CabInfo(cabFile).UnpackFiles(fileKeys, this.TempDirectory, fileKeys,
+                this.CabinetProgress);
+            ClearReadOnlyAttribute(this.TempDirectory, fileKeys);
+        }
+        foreach (KeyValuePair<string, InstallPath> entry in uncompressedFileMap)
+        {
+            string fileKey = (string) entry.Key;
+            InstallPath fileInstallPath = (InstallPath) entry.Value;
+
+            string filePath = Path.Combine(this.SourceDirectory, fileInstallPath.SourcePath);
+            this.LogMessage("copy {0} {1}", filePath, fileKey);
+            File.Copy(filePath, Path.Combine(this.TempDirectory, fileKey));
+        }
+    }
+
+    private void ClearReadOnlyAttribute(string baseDirectory, IEnumerable filePaths)
+    {
+        foreach(object filePath in filePaths)
+        {
+            string fullFilePath = Path.Combine(baseDirectory, filePath.ToString());
+            if (File.Exists(fullFilePath))
+            {
+                System.IO.FileAttributes fileAttributes = File.GetAttributes(fullFilePath);
+                if ((fileAttributes & System.IO.FileAttributes.ReadOnly) != 0)
+                {
+                    fileAttributes &= ~System.IO.FileAttributes.ReadOnly;
+                    File.SetAttributes(fullFilePath, fileAttributes);
+                }
+            }
+        }
+    }
+
+    private void ApplyFilePatchesForConsolidation()
+    {
+        if(this.Tables.Contains("Patch"))
+        {
+            using(View patchView = this.OpenView("SELECT `File_`, `Sequence` " +
+                  "FROM `Patch` ORDER BY `Sequence`"))
+            {
+                patchView.Execute();
+                Hashtable extractedPatchCabs = new Hashtable();
+                
+                foreach (Record patchRec in patchView) using(patchRec)
+                {
+                    string fileKey = (string) patchRec[1];
+                    int sequence = patchRec.GetInteger(2);
+                    this.LogMessage("patch {0}", fileKey);
+
+                    string tempPatchFile = Path.Combine(this.TempDirectory, fileKey + ".pat");
+                    ExtractFilePatch(fileKey, sequence, tempPatchFile, extractedPatchCabs);
+                    string filePath = Path.Combine(this.TempDirectory, fileKey);
+                    string oldFilePath = filePath + ".old";
+                    if(File.Exists(oldFilePath)) File.Delete(oldFilePath);
+                    File.Move(filePath, oldFilePath);
+                    Type.GetType("WixToolset.Dtf.WindowsInstaller.FilePatch")
+                        .GetMethod("ApplyPatchToFile",
+                        new Type[] { typeof(string), typeof(string), typeof(string) })
+                        .Invoke(null, new object[] { tempPatchFile, oldFilePath, filePath });
+                }
+            }
+        }
+    }
+
+    private void ExtractFilePatch(string fileKey, int sequence, string extractPath,
+        IDictionary extractedCabs)
+    {
+        string mediaCab = null;
+        using(View mediaView = this.OpenView("SELECT `DiskId`, `LastSequence`, `Cabinet` " +
+              "FROM `Media` ORDER BY `DiskId`"))
+        {
+            mediaView.Execute();
+            
+            foreach (Record mediaRec in mediaView) using(mediaRec)
+            {
+                int mediaMaxSequence = mediaRec.GetInteger(2);
+                if(mediaMaxSequence >= sequence)
+                {
+                    mediaCab = mediaRec.GetString(3);
+                    break;
+                }
+            }
+        }
+
+        if(mediaCab == null || mediaCab.Length == 0)
+        {
+            this.LogMessage("Could not find cabinet for file patch: {0}", fileKey);
+            throw new InstallerException("Could not find cabinet for file patch: " + fileKey);
+        }
+
+        if(!mediaCab.StartsWith("#", StringComparison.Ordinal))
+        {
+            this.LogMessage("Error: Patch cabinet {0} must be embedded", mediaCab);
+            throw new InstallerException("Patch cabinet " + mediaCab + " must be embedded.");
+        }
+        mediaCab = mediaCab.Substring(1);
+
+        string cabFile = (string) extractedCabs[mediaCab];
+        if(cabFile == null)
+        {
+            using(View streamView = this.OpenView("SELECT `Name`, `Data` FROM `_Streams` " +
+                  "WHERE `Name` = '{0}'", mediaCab))
+            {
+                streamView.Execute();
+                Record streamRec = streamView.Fetch();
+                if(streamRec == null)
+                {
+                    this.LogMessage("Stream not found: {0}", mediaCab);
+                    throw new InstallerException("Stream not found: " + mediaCab);
+                }
+                using(streamRec)
+                {
+                    this.LogMessage("extract cab {0}", mediaCab);
+                    Directory.CreateDirectory(this.TempDirectory);
+                    cabFile = Path.Combine(this.TempDirectory,
+                        Path.GetFileNameWithoutExtension(mediaCab) + ".cab");
+                    streamRec.GetStream("Data", cabFile);
+                }
+            }
+            extractedCabs[mediaCab] = cabFile;
+        }
+
+        this.LogMessage("extract patch {0}\\{1}", mediaCab, fileKey);
+        new CabInfo(cabFile).UnpackFile(fileKey, extractPath);
+    }
+
+    /// <summary>
+    /// Rebuilds the cached directory structure information accessed by the
+    /// <see cref="Directories"/> and <see cref="Files"/> properties. This
+    /// should be done after modifying the File, Component, or Directory
+    /// tables, or else the cached information may no longer be accurate.
+    /// </summary>
+    public void UpdateDirectories()
+    {
+        this.dirPathMap = null;
+        this.filePathMap = InstallPathMap.BuildFilePathMap(this,
+            InstallPathMap.BuildComponentPathMap(this, this.Directories), false);
+    }
+
+    /// <summary>
+    /// Gets a mapping from Directory keys to source/target paths.
+    /// </summary>
+    /// <remarks>
+    /// If the Directory table is modified, this mapping
+    /// will be outdated until you call <see cref="UpdateDirectories"/>.
+    /// </remarks>
+    public InstallPathMap Directories
+    {
+        get
+        {
+            if(this.dirPathMap == null)
+            {
+                this.dirPathMap = InstallPathMap.BuildDirectoryPathMap(this, false);
+            }
+            return this.dirPathMap;
+        }
+    }
+    private InstallPathMap dirPathMap;
+
+    /// <summary>
+    /// Gets a mapping from File keys to source/target paths.
+    /// </summary>
+    /// <remarks>
+    /// If the File, Component, or Directory tables are modified, this mapping
+    /// may be outdated until you call <see cref="UpdateDirectories"/>.
+    /// </remarks>
+    public InstallPathMap Files
+    {
+        get
+        {
+            if(this.filePathMap == null)
+            {
+                this.filePathMap = InstallPathMap.BuildFilePathMap(this,
+                    InstallPathMap.BuildComponentPathMap(this, this.Directories), false);
+            }
+            return this.filePathMap;
+        }
+    }
+    private InstallPathMap filePathMap;
+
+    /// <summary>
+    /// Gets or sets the compression level used by <see cref="UpdateFiles()"/>
+    /// and <see cref="Consolidate"/>.
+    /// </summary>
+    /// <remarks>
+    /// If the Directory table is modified, this mapping will be outdated
+    /// until you close and reopen the install package.
+    /// </remarks>
+    public CompressionLevel CompressionLevel
+    {
+        get { return this.compressionLevel; }
+        set { this.compressionLevel = value; }
+    }
+    private CompressionLevel compressionLevel;
+
+    /// <summary>
+    /// Applies a patch package to the database, resulting in an installation package that
+    /// has the patch built-in.
+    /// </summary>
+    /// <param name="patchPackage">The patch package to be applied</param>
+    /// <param name="transform">Optional name of the specific transform to apply.
+    /// This parameter is usually left null, which causes the patch to be searched for
+    /// a transform that is valid to apply to this database.</param>
+    /// <remarks>
+    /// If the patch contains any binary file patches, they will not immediately be applied
+    /// to the target files, though they will at installation time.
+    /// <p>After calling this method you can use <see cref="Consolidate"/> to apply
+    /// the file patches immediately and also discard any outdated files from the package.</p>
+    /// </remarks>
+    public void ApplyPatch(PatchPackage patchPackage, string transform)
+    {
+        if(patchPackage == null) throw new ArgumentNullException("patchPackage");
+
+        this.LogMessage("Applying patch file {0} to database {1}",
+            patchPackage.FilePath, this.FilePath);
+
+        if(transform == null)
+        {
+            this.LogMessage("No transform specified; searching for valid patch transform");
+            string[] validTransforms = patchPackage.GetValidTransforms(this);
+            if(validTransforms.Length == 0)
+            {
+                this.LogMessage("No valid patch transform was found");
+                throw new InvalidOperationException("No valid patch transform was found.");
+            }
+            transform = validTransforms[0];
+        }
+        this.LogMessage("Patch transform = {0}", transform);
+
+        string patchPrefix = Path.GetFileNameWithoutExtension(patchPackage.FilePath) + "_";
+
+        string specialTransform = "#" + transform;
+        Directory.CreateDirectory(this.TempDirectory);
+        this.LogMessage("Extracting substorage {0}", transform);
+        string transformFile = Path.Combine(this.TempDirectory,
+            patchPrefix + Path.GetFileNameWithoutExtension(transform) + ".mst");
+        patchPackage.ExtractTransform(transform, transformFile);
+        this.LogMessage("Extracting substorage {0}", specialTransform);
+        string specialTransformFile = Path.Combine(this.TempDirectory,
+            patchPrefix + Path.GetFileNameWithoutExtension(specialTransform) + ".mst");
+        patchPackage.ExtractTransform(specialTransform, specialTransformFile);
+
+        if (this.Tables.Contains("Patch") && !this.Tables["Patch"].Columns.Contains("_StreamRef"))
+        {
+            if(this.CountRows("Patch") > 0)
+            {
+                this.LogMessage("Warning: non-empty Patch table exists without StreamRef_ column; " +
+                    "patch transform may fail");
+            }
+            else
+            {
+                this.Execute("DROP TABLE `Patch`");
+                this.Execute("CREATE TABLE `Patch` (`File_` CHAR(72) NOT NULL, " +
+                    "`Sequence` INTEGER NOT NULL, `PatchSize` LONG NOT NULL, " +
+                    "`Attributes` INTEGER NOT NULL, `Header` OBJECT, `StreamRef_` CHAR(72)  " +
+                    "PRIMARY KEY `File_`, `Sequence`)");
+            }
+        }
+
+        this.LogMessage("Applying transform {0} to database", transform);
+        this.ApplyTransform(transformFile);
+        this.LogMessage("Applying transform {0} to database", specialTransform);
+        this.ApplyTransform(specialTransformFile);
+
+        if (this.Tables.Contains("MsiPatchHeaders") && this.CountRows("MsiPatchHeaders") > 0 &&
+            (!this.Tables.Contains("Patch") || this.CountRows("Patch", "`StreamRef_` <> ''") == 0))
+        {
+            this.LogMessage("Error: patch transform failed because of missing Patch.StreamRef_ column");
+            throw new InstallerException("Patch transform failed because of missing Patch.StreamRef_ column");
+        }
+
+        IList<int> mediaIds = this.ExecuteIntegerQuery("SELECT `Media_` FROM `PatchPackage` " +
+            "WHERE `PatchId` = '{0}'", patchPackage.PatchCode);
+        if (mediaIds.Count == 0)
+        {
+            this.LogMessage("Warning: PatchPackage Media record not found -- " +
+                "skipping inclusion of patch cabinet");
+        }
+        else
+        {
+            int patchMediaDiskId = mediaIds[0];
+            IList<string> patchCabinets = this.ExecuteStringQuery("SELECT `Cabinet` FROM `Media` " +
+                "WHERE `DiskId` = {0}", patchMediaDiskId);
+            if(patchCabinets.Count == 0)
+            {
+                this.LogMessage("Patch cabinet record not found");
+                throw new InstallerException("Patch cabinet record not found.");
+            }
+            string patchCabinet = patchCabinets[0];
+            this.LogMessage("Patch cabinet = {0}", patchCabinet);
+            if(!patchCabinet.StartsWith("#", StringComparison.Ordinal))
+            {
+                this.LogMessage("Error: Patch cabinet must be embedded");
+                throw new InstallerException("Patch cabinet must be embedded.");
+            }
+            patchCabinet = patchCabinet.Substring(1);
+
+            string renamePatchCabinet = patchPrefix + patchCabinet;
+
+            const int HIGH_DISKID = 30000; // Must not collide with other patch media DiskIDs
+            int renamePatchMediaDiskId = HIGH_DISKID;
+            while (this.CountRows("Media", "`DiskId` = " + renamePatchMediaDiskId) > 0) renamePatchMediaDiskId++;
+
+            // Since the patch cab is now embedded in the MSI, it shouldn't have a separate disk prompt/source
+            this.LogMessage("Renaming the patch media record");
+            int lastSeq = Convert.ToInt32(this.ExecuteScalar("SELECT `LastSequence` FROM `Media` WHERE `DiskId` = {0}", patchMediaDiskId));
+            this.Execute("DELETE FROM `Media` WHERE `DiskId` = {0}", patchMediaDiskId);
+            this.Execute("INSERT INTO `Media` (`DiskId`, `LastSequence`, `Cabinet`) VALUES ({0}, '{1}', '#{2}')",
+                renamePatchMediaDiskId, lastSeq, renamePatchCabinet);
+            this.Execute("UPDATE `PatchPackage` SET `Media_` = {0} WHERE `PatchId` = '{1}'", renamePatchMediaDiskId, patchPackage.PatchCode);
+
+            this.LogMessage("Copying patch cabinet: {0}", patchCabinet);
+            string patchCabFile = Path.Combine(this.TempDirectory,
+                Path.GetFileNameWithoutExtension(patchCabinet) + ".cab");
+            using(View streamView = patchPackage.OpenView("SELECT `Name`, `Data` FROM `_Streams` " +
+                  "WHERE `Name` = '{0}'", patchCabinet))
+            {
+                streamView.Execute();
+                Record streamRec = streamView.Fetch();
+                if(streamRec == null)
+                {
+                    this.LogMessage("Error: Patch cabinet not found");
+                    throw new InstallerException("Patch cabinet not found.");
+                }
+                using(streamRec)
+                {
+                    streamRec.GetStream(2, patchCabFile);
+                }
+            }
+            using(Record patchCabRec = new Record(2))
+            {
+                patchCabRec[1] = patchCabinet;
+                patchCabRec.SetStream(2, patchCabFile);
+                this.Execute("INSERT INTO `_Streams` (`Name`, `Data`) VALUES (?, ?)", patchCabRec);
+            }
+
+            this.LogMessage("Ensuring PatchFiles action exists in InstallExecuteSequence table");
+            if (this.Tables.Contains("InstallExecuteSequence"))
+            {
+                if(this.CountRows("InstallExecuteSequence", "`Action` = 'PatchFiles'") == 0)
+                {
+                    IList<int> installFilesSeqList = this.ExecuteIntegerQuery("SELECT `Sequence` " +
+                        "FROM `InstallExecuteSequence` WHERE `Action` = 'InstallFiles'");
+                    short installFilesSeq = (short) (installFilesSeqList.Count != 0 ?
+                        installFilesSeqList[0] : 0);
+                    this.Execute("INSERT INTO `InstallExecuteSequence` (`Action`, `Sequence`) " +
+                        "VALUES ('PatchFiles', {0})", installFilesSeq + 1);
+                }
+            }
+
+            // Patch-added files need to be marked always-compressed
+            this.LogMessage("Adjusting attributes of patch-added files");
+            using(View fileView = this.OpenView("SELECT `File`, `Attributes`, `Sequence` " +
+                  "FROM `File` ORDER BY `Sequence`"))
+            {
+                fileView.Execute();
+                
+                foreach (Record fileRec in fileView) using(fileRec)
+                {
+                    int fileAttributes = fileRec.GetInteger(2);
+                    if ((fileAttributes & (int) WixToolset.Dtf.WindowsInstaller.FileAttributes.PatchAdded) != 0)
+                    {
+                        fileAttributes = (fileAttributes | (int) WixToolset.Dtf.WindowsInstaller.FileAttributes.Compressed)
+                            & ~(int) WixToolset.Dtf.WindowsInstaller.FileAttributes.NonCompressed
+                            & ~(int) WixToolset.Dtf.WindowsInstaller.FileAttributes.PatchAdded;
+                        fileRec[2] = fileAttributes;
+                        fileView.Update(fileRec);
+                    }
+                }
+            }
+        }
+
+        this.LogMessage("Applying new summary info from patch package");
+        this.SummaryInfo.RevisionNumber = this.Property["PATCHNEWPACKAGECODE"];
+        this.SummaryInfo.Subject = this.Property["PATCHNEWSUMMARYSUBJECT"];
+        this.SummaryInfo.Comments = this.Property["PATCHNEWSUMMARYCOMMENTS"];
+        this.SummaryInfo.Persist();
+        this.Property["PATCHNEWPACKAGECODE"    ] = null;
+        this.Property["PATCHNEWSUMMARYSUBJECT" ] = null;
+        this.Property["PATCHNEWSUMMARYCOMMENTS"] = null;
+
+        this.LogMessage("Patch application finished");
+    }
+
+    /// <summary>
+    /// Accessor for getting and setting properties of the InstallPackage database.
+    /// </summary>
+    public InstallPackageProperties Property
+    {
+        get
+        {
+            if(this.properties == null)
+            {
+                this.properties = new InstallPackageProperties(this);
+            }
+            return this.properties;
+        }
+    }
+    private InstallPackageProperties properties = null;
+}
+
+/// <summary>
+/// Accessor for getting and setting properties of the <see cref="InstallPackage"/> database.
+/// </summary>
+public class InstallPackageProperties
+{
+    internal InstallPackageProperties(InstallPackage installPackage)
+    {
+        this.installPackage = installPackage;
+    }
+    private InstallPackage installPackage;
+
+    /// <summary>
+    /// Gets or sets a property in the database. When getting a property
+    /// that does not exist in the database, an empty string is returned.
+    /// To remove a property from the database, set it to an empty string.
+    /// </summary>
+    /// <remarks>
+    /// This has the same results as direct SQL queries on the Property table; it's only
+    /// meant to be a more convenient way of access.
+    /// </remarks>
+    public string this[string name]
+    {
+        get
+        {
+            IList<string> values = installPackage.ExecuteStringQuery(
+                "SELECT `Value` FROM `Property` WHERE `Property` = '{0}'", name);
+            return (values.Count != 0 ? values[0] : "");
+        }
+        set
+        {
+            Record propRec = new Record(name, (value != null ? value : ""));
+            installPackage.Execute("DELETE FROM `Property` WHERE `Property` = ?", propRec);
+            if(value != null && value.Length != 0)
+            {
+                installPackage.Execute("INSERT INTO `Property` (`Property`, `Value`) VALUES (?, ?)",
+                    propRec);
+            }
+        }
+    }
+}
+
+}
diff --git a/src/dtf/WixToolset.Dtf.WindowsInstaller.Package/InstallPath.cs b/src/dtf/WixToolset.Dtf.WindowsInstaller.Package/InstallPath.cs
new file mode 100644
index 00000000..e3ba81b5
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.WindowsInstaller.Package/InstallPath.cs
@@ -0,0 +1,1073 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.WindowsInstaller.Package
+{
+    using System;
+    using System.IO;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Globalization;
+
+    /// <summary>
+    /// Represents the installation path of a file or directory from an installer product database.
+    /// </summary>
+    public class InstallPath
+    {
+        /// <summary>
+        /// Creates a new InstallPath, specifying a filename.
+        /// </summary>
+        /// <param name="name">The name of the file or directory.  Not a full path.</param>
+        public InstallPath(string name) : this(name, false) { }
+
+        /// <summary>
+        /// Creates a new InstallPath, parsing out either the short or long filename.
+        /// </summary>
+        /// <param name="name">The name of the file or directory, in short|long syntax for a filename
+        /// or targetshort|targetlong:sourceshort|sourcelong syntax for a directory.</param>
+        /// <param name="useShortNames">true to parse the short part of the combined filename; false to parse the long part</param>
+        public InstallPath(string name, bool useShortNames)
+        {
+            if(name == null)
+            {
+                throw new ArgumentNullException();
+            }
+            this.parentPath = null;
+            ParseName(name, useShortNames);
+        }
+
+        private void ParseName(string name, bool useShortNames)
+        {
+            string[] parse = name.Split(new char[] { ':' }, 3);
+            if(parse.Length == 3)
+            {
+                // Syntax was targetshort:sourceshort|targetlong:sourcelong.
+                // Chnage it to targetshort|targetlong:sourceshort|sourcelong.
+                parse = name.Split(new char[] { ':', '|' }, 4);
+                if(parse.Length == 4)
+                    parse = new string[] { parse[0] + '|' + parse[2], parse[1] + '|' + parse[3] };
+                else
+                    parse = new string[] { parse[0] + '|' + parse[1], parse[1] + '|' + parse[2] };
+            }
+            string targetName = parse[0];
+            string sourceName = (parse.Length == 2 ? parse[1] : parse[0]);
+            parse = targetName.Split(new char[] { '|' }, 2);
+            if(parse.Length == 2) targetName = (useShortNames ? parse[0] : parse[1]);
+            parse = sourceName.Split(new char[] { '|' }, 2);
+            if(parse.Length == 2) sourceName = (useShortNames ? parse[0] : parse[1]);
+
+            this.SourceName = sourceName;
+            this.TargetName = targetName;
+        }
+
+        /// <summary>
+        /// Gets the path of the parent directory.
+        /// </summary>
+        public InstallPath ParentPath
+        {
+            get
+            {
+                return parentPath;
+            }
+        }
+        internal void SetParentPath(InstallPath value)
+        {
+            parentPath = value;
+            ResetSourcePath();
+            ResetTargetPath();
+        }
+        private InstallPath parentPath;
+
+        /// <summary>
+        /// Gets the set of child paths if this InstallPath object represents a a directory.
+        /// </summary>
+        public InstallPathCollection ChildPaths
+        {
+            get
+            {
+                if(childPaths == null)
+                {
+                    childPaths = new InstallPathCollection(this);
+                }
+                return childPaths;
+            }
+        }
+        private InstallPathCollection childPaths;
+
+        /// <summary>
+        /// Gets or sets the source name of the InstallPath.
+        /// </summary>
+        public string SourceName
+        {
+            get
+            {
+                return sourceName;
+            }
+            set
+            {
+                if(value == null)
+                {
+                    throw new ArgumentNullException();
+                }
+                sourceName = value;
+                ResetSourcePath();
+            }
+        }
+        private string sourceName;
+
+        /// <summary>
+        /// Gets or sets the target name of the install path.
+        /// </summary>
+        public string TargetName
+        {
+            get
+            {
+                return targetName;
+            }
+            set
+            {
+                if(value == null)
+                {
+                    throw new ArgumentNullException();
+                }
+                targetName = value;
+                ResetTargetPath();
+            }
+        }
+        private string targetName;
+
+        /// <summary>
+        /// Gets the full source path.
+        /// </summary>
+        public string SourcePath
+        {
+            get
+            {
+                if(sourcePath == null)
+                {
+                    if(parentPath != null)
+                    {
+                        sourcePath = (sourceName.Equals(".") ? parentPath.SourcePath
+                                      : Path.Combine(parentPath.SourcePath, sourceName));
+                    }
+                    else
+                    {
+                        sourcePath = sourceName;
+                    }
+                }
+                return sourcePath;
+            }
+            set
+            {
+                ResetSourcePath();
+                sourcePath = value;
+            }
+        }
+        private string sourcePath;
+
+        /// <summary>
+        /// Gets the full target path.
+        /// </summary>
+        public string TargetPath
+        {
+            get
+            {
+                if(targetPath == null)
+                {
+                    if(parentPath != null)
+                    {
+                        targetPath = (targetName.Equals(".") ? parentPath.TargetPath
+                                      : Path.Combine(parentPath.TargetPath, targetName));
+                    }
+                    else
+                    {
+                        targetPath = targetName;
+                    }
+                }
+                return targetPath;
+            }
+            set
+            {
+                ResetTargetPath();
+                targetPath = value;
+            }
+        }
+        private string targetPath;
+
+        private void ResetSourcePath()
+        {
+            if(sourcePath != null)
+            {
+                sourcePath = null;
+                if(childPaths != null)
+                {
+                    foreach(InstallPath ip in childPaths)
+                    {
+                        ip.ResetSourcePath();
+                    }
+                }
+            }
+        }
+
+        private void ResetTargetPath()
+        {
+            if(targetPath != null)
+            {
+                targetPath = null;
+                if(childPaths != null)
+                {
+                    foreach(InstallPath ip in childPaths)
+                    {
+                        ip.ResetTargetPath();
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets the full source path.
+        /// </summary>
+        /// <returns><see cref="SourcePath"/></returns>
+        public override String ToString()
+        {
+            return SourcePath;
+        }
+    }
+
+    /// <summary>
+    /// Represents a collection of InstallPaths that are the child paths of the same parent directory.
+    /// </summary>
+    public class InstallPathCollection : IList<InstallPath>
+    {
+        private InstallPath parentPath;
+        private List<InstallPath> items;
+
+        internal InstallPathCollection(InstallPath parentPath)
+        {
+            this.parentPath = parentPath;
+            this.items = new List<InstallPath>();
+        }
+
+        /// <summary>
+        /// Gets or sets the element at the specified index.
+        /// </summary>
+        public InstallPath this[int index]
+        {
+            get
+            {
+                return this.items[index];
+            }
+            set
+            {
+                this.OnSet(this.items[index], value);
+                this.items[index] = value;
+            }
+        }
+
+        /// <summary>
+        /// Adds a new child path to the collection.
+        /// </summary>
+        /// <param name="item">The InstallPath to add.</param>
+        public void Add(InstallPath item)
+        {
+            this.OnInsert(item);
+            this.items.Add(item);
+        }
+
+        /// <summary>
+        /// Removes a child path to the collection.
+        /// </summary>
+        /// <param name="item">The InstallPath to remove.</param>
+        public bool Remove(InstallPath item)
+        {
+            int index = this.items.IndexOf(item);
+            if (index >= 0)
+            {
+                this.OnRemove(item);
+                this.items.RemoveAt(index);
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Gets the index of a child path in the collection.
+        /// </summary>
+        /// <param name="item">The InstallPath to search for.</param>
+        /// <returns>The index of the item, or -1 if not found.</returns>
+        public int IndexOf(InstallPath item)
+        {
+            return this.items.IndexOf(item);
+        }
+
+        /// <summary>
+        /// Inserts a child path into the collection.
+        /// </summary>
+        /// <param name="index">The insertion index.</param>
+        /// <param name="item">The InstallPath to insert.</param>
+        public void Insert(int index, InstallPath item)
+        {
+            this.OnInsert(item);
+            this.items.Insert(index, item);
+        }
+
+        /// <summary>
+        /// Tests if the collection contains a child path.
+        /// </summary>
+        /// <param name="item">The InstallPath to search for.</param>
+        /// <returns>true if the item is found; false otherwise</returns>
+        public bool Contains(InstallPath item)
+        {
+            return this.items.Contains(item);
+        }
+
+        /// <summary>
+        /// Copies the collection into an array.
+        /// </summary>
+        /// <param name="array">The array to copy into.</param>
+        /// <param name="index">The starting index in the destination array.</param>
+        public void CopyTo(InstallPath[] array, int index)
+        {
+            this.items.CopyTo(array, index);
+        }
+
+        private void OnInsert(InstallPath item)
+        {
+            if (item.ParentPath != null)
+            {
+                item.ParentPath.ChildPaths.Remove(item);
+            }
+
+            item.SetParentPath(this.parentPath);
+        }
+
+        private void OnRemove(InstallPath item)
+        {
+            item.SetParentPath(null);
+        }
+
+        private void OnSet(InstallPath oldItem, InstallPath newItem)
+        {
+            this.OnRemove(oldItem);
+            this.OnInsert(newItem);
+        }
+
+        /// <summary>
+        /// Removes an item from the collection.
+        /// </summary>
+        /// <param name="index">The index of the item to remove.</param>
+        public void RemoveAt(int index)
+        {
+            this.OnRemove(this[index]);
+            this.items.RemoveAt(index);
+        }
+
+        /// <summary>
+        /// Removes all items from the collection.
+        /// </summary>
+        public void Clear()
+        {
+            foreach (InstallPath item in this)
+            {
+                this.OnRemove(item);
+            }
+
+            this.items.Clear();
+        }
+
+        /// <summary>
+        /// Gets the number of items in the collection.
+        /// </summary>
+        public int Count
+        {
+            get
+            {
+                return this.items.Count;
+            }
+        }
+
+        bool ICollection<InstallPath>.IsReadOnly
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Gets an enumerator over all items in the collection.
+        /// </summary>
+        /// <returns>An enumerator for the collection.</returns>
+        public IEnumerator<InstallPath> GetEnumerator()
+        {
+            return this.items.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return ((IEnumerable<InstallPath>) this).GetEnumerator();
+        }
+    }
+
+    /// <summary>
+    /// Represents a mapping of install paths for all directories, components, or files in
+    /// an installation database.
+    /// </summary>
+    public class InstallPathMap : IDictionary<string, InstallPath>
+    {
+        /// <summary>
+        /// Builds a mapping from File keys to installation paths.
+        /// </summary>
+        /// <param name="db">Installation database.</param>
+        /// <param name="componentPathMap">Component mapping returned by <see cref="BuildComponentPathMap"/>.</param>
+        /// <param name="useShortNames">true to use short file names; false to use long names</param>
+        /// <returns>An InstallPathMap with the described mapping.</returns>
+        public static InstallPathMap BuildFilePathMap(Database db, InstallPathMap componentPathMap,
+            bool useShortNames)
+        {
+            if(db == null)
+            {
+                throw new ArgumentNullException("db");
+            }
+
+            if(componentPathMap == null)
+            {
+                componentPathMap = BuildComponentPathMap(db, BuildDirectoryPathMap(db, useShortNames));
+            }
+
+            InstallPathMap filePathMap = new InstallPathMap();
+
+            using (View fileView = db.OpenView("SELECT `File`, `Component_`, `FileName` FROM `File`"))
+            {
+                fileView.Execute();
+
+                foreach (Record fileRec in fileView)
+                {
+                    using (fileRec)
+                    {
+                        string file = (string) fileRec[1];
+                        string comp = (string) fileRec[2];
+                        string fileName = (string) fileRec[3];
+
+                        InstallPath compPath = (InstallPath) componentPathMap[comp];
+                        if(compPath != null)
+                        {
+                            InstallPath filePath = new InstallPath(fileName, useShortNames);
+                            compPath.ChildPaths.Add(filePath);
+                            filePathMap[file] = filePath;
+                        }
+                    }
+                }
+            }
+
+            return filePathMap;
+        }
+
+        /// <summary>
+        /// Builds a mapping from Component keys to installation paths.
+        /// </summary>
+        /// <param name="db">Installation database.</param>
+        /// <param name="directoryPathMap">Directory mapping returned by
+        /// <see cref="BuildDirectoryPathMap(Database,bool)"/>.</param>
+        /// <returns>An InstallPathMap with the described mapping.</returns>
+        public static InstallPathMap BuildComponentPathMap(Database db, InstallPathMap directoryPathMap)
+        {
+            if(db == null)
+            {
+                throw new ArgumentNullException("db");
+            }
+
+            InstallPathMap compPathMap = new InstallPathMap();
+
+            using (View compView = db.OpenView("SELECT `Component`, `Directory_` FROM `Component`"))
+            {
+                compView.Execute();
+                
+                foreach (Record compRec in compView)
+                {
+                    using (compRec)
+                    {
+                        string comp = (string) compRec[1];
+                        InstallPath dirPath = (InstallPath) directoryPathMap[(string) compRec[2]];
+
+                        if (dirPath != null)
+                        {
+                            compPathMap[comp] = dirPath;
+                        }
+                    }
+                }
+            }
+
+            return compPathMap;
+        }
+
+        /// <summary>
+        /// Builds a mapping from Directory keys to installation paths.
+        /// </summary>
+        /// <param name="db">Installation database.</param>
+        /// <param name="useShortNames">true to use short directory names; false to use long names</param>
+        /// <returns>An InstallPathMap with the described mapping.</returns>
+        public static InstallPathMap BuildDirectoryPathMap(Database db, bool useShortNames)
+        {
+            return BuildDirectoryPathMap(db, useShortNames, null, null);
+        }
+
+        /// <summary>
+        /// Builds a mapping of Directory keys to directory paths, specifying root directories
+        /// for the source and target paths.
+        /// </summary>
+        /// <param name="db">Database containing the Directory table.</param>
+        /// <param name="useShortNames">true to use short directory names; false to use long names</param>
+        /// <param name="sourceRootDir">The root directory path of all source paths, or null to leave them relative.</param>
+        /// <param name="targetRootDir">The root directory path of all source paths, or null to leave them relative.</param>
+        /// <returns>An InstallPathMap with the described mapping.</returns>
+        public static InstallPathMap BuildDirectoryPathMap(Database db, bool useShortNames,
+            string sourceRootDir, string targetRootDir)
+        {
+            if(db == null)
+            {
+                throw new ArgumentNullException("db");
+            }
+
+            if(sourceRootDir == null) sourceRootDir = "";
+            if(targetRootDir == null) targetRootDir = "";
+
+            InstallPathMap dirMap = new InstallPathMap();
+            IDictionary dirTreeMap = new Hashtable();
+
+            using (View dirView = db.OpenView("SELECT `Directory`, `Directory_Parent`, `DefaultDir` FROM `Directory`"))
+            {
+                dirView.Execute();
+
+                foreach (Record dirRec in dirView) using (dirRec)
+                {
+                    string key = (string) dirRec[1];
+                    string parentKey = (string) dirRec[2];
+                    InstallPath dir = new InstallPath((string) dirRec[3], useShortNames);
+
+                    dirMap[key] = dir;
+
+                    InstallPathMap siblingDirs = (InstallPathMap) dirTreeMap[parentKey];
+                    if (siblingDirs == null)
+                    {
+                        siblingDirs = new InstallPathMap();
+                        dirTreeMap[parentKey] = siblingDirs;
+                    }
+                    siblingDirs.Add(key, dir);
+                }
+            }
+
+            foreach (KeyValuePair<string, InstallPath> entry in (InstallPathMap) dirTreeMap[""])
+            {
+                string key = (string) entry.Key;
+                InstallPath dir = (InstallPath) entry.Value;
+                LinkSubdirectories(key, dir, dirTreeMap);
+            }
+
+            InstallPath targetDirPath = (InstallPath) dirMap["TARGETDIR"];
+            if(targetDirPath != null)
+            {
+                targetDirPath.SourcePath = sourceRootDir;
+                targetDirPath.TargetPath = targetRootDir;
+            }
+
+            return dirMap;
+        }
+
+        private static void LinkSubdirectories(string key, InstallPath dir, IDictionary dirTreeMap)
+        {
+            InstallPathMap subDirs = (InstallPathMap) dirTreeMap[key];
+            if(subDirs != null)
+            {
+                foreach (KeyValuePair<string, InstallPath> entry in subDirs)
+                {
+                    string subKey = (string) entry.Key;
+                    InstallPath subDir = (InstallPath) entry.Value;
+                    dir.ChildPaths.Add(subDir);
+                    LinkSubdirectories(subKey, subDir, dirTreeMap);
+                }
+            }
+        }
+
+        private Dictionary<string, InstallPath> items;
+
+        /// <summary>
+        /// Creates a new empty InstallPathMap.
+        /// </summary>
+        public InstallPathMap()
+        {
+            this.items = new Dictionary<string,InstallPath>(StringComparer.Ordinal);
+        }
+
+        /// <summary>
+        /// Gets a mapping from keys to source paths.
+        /// </summary>
+        public IDictionary<string, string> SourcePaths
+        {
+            get
+            {
+                return new SourcePathMap(this);
+            }
+        }
+
+        /// <summary>
+        /// Gets a mapping from keys to target paths.
+        /// </summary>
+        public IDictionary<string, string> TargetPaths
+        {
+            get
+            {
+                return new TargetPathMap(this);
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets an install path for a direcotry, component, or file key.
+        /// </summary>
+        /// <param name="key">Depending on the type of InstallPathMap, this is the primary key from the
+        /// either the Directory, Component, or File table.</param>
+        /// <remarks>
+        /// Changing an install path does not modify the Database used to generate this InstallPathMap.
+        /// </remarks>
+        public InstallPath this[string key]
+        {
+            get
+            {
+                InstallPath value = null;
+                this.items.TryGetValue(key, out value);
+                return value;
+            }
+            set
+            {
+                this.items[key] = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets the collection of keys in the InstallPathMap. Depending on the type of InstallPathMap,
+        /// they are all directory, component, or file key strings.
+        /// </summary>
+        public ICollection<string> Keys
+        {
+            get
+            {
+                return this.items.Keys;
+            }
+        }
+
+        /// <summary>
+        /// Gets the collection of InstallPath values in the InstallPathMap.
+        /// </summary>
+        public ICollection<InstallPath> Values
+        {
+            get
+            {
+                return this.items.Values;
+            }
+        }
+
+        /// <summary>
+        /// Sets an install path for a direcotry, component, or file key.
+        /// </summary>
+        /// <param name="key">Depending on the type of InstallPathMap, this is the primary key from the
+        /// either the Directory, Component, or File table.</param>
+        /// <param name="installPath">The install path of the key item.</param>
+        /// <remarks>
+        /// Changing an install path does not modify the Database used to generate this InstallPathMap.
+        /// </remarks>
+        public void Add(string key, InstallPath installPath)
+        {
+            this.items.Add(key, installPath);
+        }
+
+        /// <summary>
+        /// Removes an install path from the map.
+        /// </summary>
+        /// <param name="key">Depending on the type of InstallPathMap, this is the primary key from the
+        /// either the Directory, Component, or File table.</param>
+        /// <returns>true if the item was removed, false if it did not exist</returns>
+        /// <remarks>
+        /// Changing an install path does not modify the Database used to generate this InstallPathMap.
+        /// </remarks>
+        public bool Remove(string key)
+        {
+            return this.items.Remove(key);
+        }
+
+        /// <summary>
+        /// Tests whether a direcotry, component, or file key exists in the map.
+        /// </summary>
+        /// <param name="key">Depending on the type of InstallPathMap, this is the primary key from the
+        /// either the Directory, Component, or File table.</param>
+        /// <returns>true if the key is found; false otherwise</returns>
+        public bool ContainsKey(string key)
+        {
+            return this.items.ContainsKey(key);
+        }
+
+        /*
+        public override string ToString()
+        {
+            System.Text.StringBuilder buf = new System.Text.StringBuilder();
+            foreach(KeyValuePair<string, InstallPath> entry in this)
+            {
+                buf.AppendFormat("{0}={1}", entry.Key, entry.Value);
+                buf.Append("\n");
+            }
+            return buf.ToString();
+        }
+        */
+
+        /// <summary>
+        /// Attempts to get a value from the dictionary.
+        /// </summary>
+        /// <param name="key">The key to lookup.</param>
+        /// <param name="value">Receives the value, or null if they key was not found.</param>
+        /// <returns>True if the value was found, else false.</returns>
+        public bool TryGetValue(string key, out InstallPath value)
+        {
+            return this.items.TryGetValue(key, out value);
+        }
+
+        void ICollection<KeyValuePair<string, InstallPath>>.Add(KeyValuePair<string, InstallPath> item)
+        {
+            ((ICollection<KeyValuePair<string, InstallPath>>) this.items).Add(item);
+        }
+
+        /// <summary>
+        /// Removes all entries from the dictionary.
+        /// </summary>
+        public void Clear()
+        {
+            this.items.Clear();
+        }
+
+        bool ICollection<KeyValuePair<string, InstallPath>>.Contains(KeyValuePair<string, InstallPath> item)
+        {
+            return ((ICollection<KeyValuePair<string, InstallPath>>) this.items).Contains(item);
+        }
+
+        void ICollection<KeyValuePair<string, InstallPath>>.CopyTo(KeyValuePair<string, InstallPath>[] array, int arrayIndex)
+        {
+            ((ICollection<KeyValuePair<string, InstallPath>>) this.items).CopyTo(array, arrayIndex);
+        }
+
+        /// <summary>
+        /// Gets the number of entries in the dictionary.
+        /// </summary>
+        public int Count
+        {
+            get
+            {
+                return this.items.Count;
+            }
+        }
+
+        bool ICollection<KeyValuePair<string, InstallPath>>.IsReadOnly
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        bool ICollection<KeyValuePair<string, InstallPath>>.Remove(KeyValuePair<string, InstallPath> item)
+        {
+            return ((ICollection<KeyValuePair<string, InstallPath>>) this.items).Remove(item);
+        }
+
+        /// <summary>
+        /// Gets an enumerator over all entries in the dictionary.
+        /// </summary>
+        /// <returns>An enumerator for the dictionary.</returns>
+        public IEnumerator<KeyValuePair<string, InstallPath>> GetEnumerator()
+        {
+            return this.items.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return this.items.GetEnumerator();
+        }
+    }
+
+    internal class SourcePathMap : IDictionary<string, string>
+    {
+        private const string RO_MSG =
+            "The SourcePathMap collection is read-only. " +
+            "Modify the InstallPathMap instead.";
+
+        private InstallPathMap map;
+
+        internal SourcePathMap(InstallPathMap map)
+        {
+            this.map = map;
+        }
+
+        public void Add(string key, string value)
+        {
+            throw new InvalidOperationException(RO_MSG);
+        }
+
+        public bool ContainsKey(string key)
+        {
+            return this.map.ContainsKey(key);
+        }
+
+        public ICollection<string> Keys
+        {
+            get
+            {
+                return this.map.Keys;
+            }
+        }
+
+        public bool Remove(string key)
+        {
+            throw new InvalidOperationException(RO_MSG);
+        }
+
+        public bool TryGetValue(string key, out string value)
+        {
+            InstallPath installPath;
+            if (this.map.TryGetValue(key, out installPath))
+            {
+                value = installPath.SourcePath;
+                return true;
+            }
+            else
+            {
+                value = null;
+                return false;
+            }
+        }
+
+        public ICollection<string> Values
+        {
+            get
+            {
+                List<string> values = new List<string>(this.Count);
+                foreach (KeyValuePair<string, InstallPath> entry in this.map)
+                {
+                    values.Add(entry.Value.SourcePath);
+                }
+                return values;
+            }
+        }
+
+        public string this[string key]
+        {
+            get
+            {
+                string value = null;
+                this.TryGetValue(key, out value);
+                return value;
+            }
+            set
+            {
+                throw new InvalidOperationException(RO_MSG);
+            }
+        }
+
+        public void Add(KeyValuePair<string, string> item)
+        {
+            throw new InvalidOperationException(RO_MSG);
+        }
+
+        public void Clear()
+        {
+            throw new InvalidOperationException(RO_MSG);
+        }
+
+        public bool Contains(KeyValuePair<string, string> item)
+        {
+            string value = this[item.Key];
+            return value == item.Value;
+        }
+
+        public void CopyTo(KeyValuePair<string, string>[] array, int arrayIndex)
+        {
+            foreach (KeyValuePair<string, string> entry in this)
+            {
+                array[arrayIndex] = entry;
+                arrayIndex++;
+            }
+        }
+
+        public int Count
+        {
+            get
+            {
+                return this.map.Count;
+            }
+        }
+
+        public bool IsReadOnly
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        public bool Remove(KeyValuePair<string, string> item)
+        {
+            throw new InvalidOperationException(RO_MSG);
+        }
+
+        public IEnumerator<KeyValuePair<string, string>> GetEnumerator()
+        {
+            foreach (KeyValuePair<string, InstallPath> entry in this.map)
+            {
+                yield return new KeyValuePair<string, string>(
+                    entry.Key, entry.Value.SourcePath);
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return this.GetEnumerator();
+        }
+    }
+
+    internal class TargetPathMap : IDictionary<string, string>
+    {
+        private const string RO_MSG =
+            "The TargetPathMap collection is read-only. " +
+            "Modify the InstallPathMap instead.";
+
+        private InstallPathMap map;
+
+        internal TargetPathMap(InstallPathMap map)
+        {
+            this.map = map;
+        }
+
+        public void Add(string key, string value)
+        {
+            throw new InvalidOperationException(RO_MSG);
+        }
+
+        public bool ContainsKey(string key)
+        {
+            return this.map.ContainsKey(key);
+        }
+
+        public ICollection<string> Keys
+        {
+            get
+            {
+                return this.map.Keys;
+            }
+        }
+
+        public bool Remove(string key)
+        {
+            throw new InvalidOperationException(RO_MSG);
+        }
+
+        public bool TryGetValue(string key, out string value)
+        {
+            InstallPath installPath;
+            if (this.map.TryGetValue(key, out installPath))
+            {
+                value = installPath.TargetPath;
+                return true;
+            }
+            else
+            {
+                value = null;
+                return false;
+            }
+        }
+
+        public ICollection<string> Values
+        {
+            get
+            {
+                List<string> values = new List<string>(this.Count);
+                foreach (KeyValuePair<string, InstallPath> entry in this.map)
+                {
+                    values.Add(entry.Value.TargetPath);
+                }
+                return values;
+            }
+        }
+
+        public string this[string key]
+        {
+            get
+            {
+                string value = null;
+                this.TryGetValue(key, out value);
+                return value;
+            }
+            set
+            {
+                throw new InvalidOperationException(RO_MSG);
+            }
+        }
+
+        public void Add(KeyValuePair<string, string> item)
+        {
+            throw new InvalidOperationException(RO_MSG);
+        }
+
+        public void Clear()
+        {
+            throw new InvalidOperationException(RO_MSG);
+        }
+
+        public bool Contains(KeyValuePair<string, string> item)
+        {
+            string value = this[item.Key];
+            return value == item.Value;
+        }
+
+        public void CopyTo(KeyValuePair<string, string>[] array, int arrayIndex)
+        {
+            foreach (KeyValuePair<string, string> entry in this)
+            {
+                array[arrayIndex] = entry;
+                arrayIndex++;
+            }
+        }
+
+        public int Count
+        {
+            get
+            {
+                return this.map.Count;
+            }
+        }
+
+        public bool IsReadOnly
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        public bool Remove(KeyValuePair<string, string> item)
+        {
+            throw new InvalidOperationException(RO_MSG);
+        }
+
+        public IEnumerator<KeyValuePair<string, string>> GetEnumerator()
+        {
+            foreach (KeyValuePair<string, InstallPath> entry in this.map)
+            {
+                yield return new KeyValuePair<string, string>(
+                    entry.Key, entry.Value.TargetPath);
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return this.GetEnumerator();
+        }
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.WindowsInstaller.Package/PatchPackage.cs b/src/dtf/WixToolset.Dtf.WindowsInstaller.Package/PatchPackage.cs
new file mode 100644
index 00000000..54bd2b93
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.WindowsInstaller.Package/PatchPackage.cs
@@ -0,0 +1,259 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.WindowsInstaller.Package
+{
+    using System;
+    using System.IO;
+    using System.Text;
+    using System.Collections;
+    using System.Globalization;
+    using System.Runtime.InteropServices;
+
+    /// <summary>
+    /// Provides access to convenient properties and operations on a patch package (.MSP).
+    /// </summary>
+    public class PatchPackage : Database
+    {
+        /// <summary>
+        /// Creates a new patch package object; opening the patch database in read-only mode.
+        /// </summary>
+        /// <param name="packagePath">Path to the patch package (.MSP)</param>
+        /// <remarks>The PatchPackage object only opens the patch database in read-only mode, because
+        /// transforms (sub-storages) cannot be read if the database is open in read-write mode.</remarks>
+        public PatchPackage(string packagePath)
+            : base(packagePath, (DatabaseOpenMode) ((int) DatabaseOpenMode.ReadOnly | 32))
+            // TODO: figure out what to do about DatabaseOpenMode.Patch
+        {
+        }
+
+        /// <summary>
+        /// Handle this event to receive status messages when operations are performed on the patch package.
+        /// </summary>
+        /// <example>
+        /// <c>patchPackage.Message += new InstallPackageMessageHandler(Console.WriteLine);</c>
+        /// </example>
+        public event InstallPackageMessageHandler Message;
+
+        /// <summary>
+        /// Sends a message to the <see cref="Message"/> event-handler.
+        /// </summary>
+        /// <param name="format">Message string, containing 0 or more format items</param>
+        /// <param name="args">Items to be formatted</param>
+        protected void LogMessage(string format, params object[] args)
+        {
+            if(this.Message != null)
+            {
+                this.Message(format, args);
+            }
+        }
+
+        /// <summary>
+        /// Gets the patch code (GUID) of the patch package.
+        /// </summary>
+        /// <remarks>
+        /// The patch code is stored in the RevisionNumber field of the patch summary information.
+        /// </remarks>
+        public string PatchCode
+        {
+            get
+            {
+                string guids = this.SummaryInfo.RevisionNumber;
+                return guids.Substring(0, guids.IndexOf('}') + 1);
+            }
+        }
+
+        /// <summary>
+        /// Gets the list of patch codes that are replaced by this patch package.
+        /// </summary>
+        /// <returns>Array of replaced patch codes (GUIDs)</returns>
+        /// <remarks>
+        /// The list of replaced patch codes is stored in the RevisionNumber field of the patch summary information.
+        /// </remarks>
+        public string[] GetReplacedPatchCodes()
+        {
+            ArrayList patchCodeList = new ArrayList();
+            string guids = this.SummaryInfo.RevisionNumber;
+            int thisGuid = guids.IndexOf('}') + 1;
+            int nextGuid = guids.IndexOf('}', thisGuid) + 1;
+            while(nextGuid > 0)
+            {
+                patchCodeList.Add(guids.Substring(thisGuid, (nextGuid - thisGuid)));
+                thisGuid = nextGuid;
+                nextGuid = guids.IndexOf('}', thisGuid) + 1;
+            }
+            return (string[]) patchCodeList.ToArray(typeof(string));
+        }
+
+        /// <summary>
+        /// Gets the list of product codes of products targeted by this patch package.
+        /// </summary>
+        /// <returns>Array of product codes (GUIDs)</returns>
+        /// <remarks>
+        /// The list of target product codes is stored in the Template field of the patch summary information.
+        /// </remarks>
+        public string[] GetTargetProductCodes()
+        {
+            string productList = this.SummaryInfo.Template;
+            return productList.Split(';');
+        }
+
+        /// <summary>
+        /// Gets the names of the transforms included in the patch package.
+        /// </summary>
+        /// <returns>Array of transform names</returns>
+        /// <remarks>
+        /// The returned list does not include the &quot;patch special transforms&quot; that are prefixed with &quot;#&quot;
+        /// <p>The list of transform names is stored in the LastSavedBy field of the patch summary information.</p>
+        /// </remarks>
+        public string[] GetTransforms()
+        {
+            return this.GetTransforms(false);
+        }
+        /// <summary>
+        /// Gets the names of the transforms included in the patch package.
+        /// </summary>
+        /// <param name="includeSpecialTransforms">Specifies whether to include the
+        /// &quot;patch special transforms&quot; that are prefixed with &quot;#&quot;</param>
+        /// <returns>Array of transform names</returns>
+        /// <remarks>
+        /// The list of transform names is stored in the LastSavedBy field of the patch summary information.
+        /// </remarks>
+        public string[] GetTransforms(bool includeSpecialTransforms)
+        {
+            ArrayList transformArray = new ArrayList();
+            string transformList = this.SummaryInfo.LastSavedBy;
+            foreach(string transform in transformList.Split(';', ':'))
+            {
+                if(transform.Length != 0 && (includeSpecialTransforms || !transform.StartsWith("#", StringComparison.Ordinal)))
+                {
+                    transformArray.Add(transform);
+                }
+            }
+            return (string[]) transformArray.ToArray(typeof(string));
+        }
+
+        /// <summary>
+        /// Gets information about the transforms included in the patch package.
+        /// </summary>
+        /// <returns>Array containing information about each transform</returns>
+        /// <remarks>
+        /// The returned info does not include the &quot;patch special transforms&quot; that are prefixed with &quot;#&quot;
+        /// </remarks>
+        public TransformInfo[] GetTransformsInfo()
+        {
+            return this.GetTransformsInfo(false);
+        }
+
+        /// <summary>
+        /// Gets information about the transforms included in the patch package.
+        /// </summary>
+        /// <param name="includeSpecialTransforms">Specifies whether to include the
+        /// &quot;patch special transforms&quot; that are prefixed with &quot;#&quot;</param>
+        /// <returns>Array containing information about each transform</returns>
+        public TransformInfo[] GetTransformsInfo(bool includeSpecialTransforms)
+        {
+            string[] transforms = this.GetTransforms(includeSpecialTransforms);
+            ArrayList transformInfoArray = new ArrayList(transforms.Length);
+            foreach(string transform in transforms)
+            {
+                transformInfoArray.Add(this.GetTransformInfo(transform));
+            }
+            return (TransformInfo[]) transformInfoArray.ToArray(typeof(TransformInfo));
+        }
+
+        /// <summary>
+        /// Gets information about a transforms included in the patch package.
+        /// </summary>
+        /// <param name="transform">Name of the transform to extract; this may optionally be a
+        /// special transform prefixed by &quot;#&quot;</param>
+        /// <returns>Information about the transform</returns>
+        public TransformInfo GetTransformInfo(string transform)
+        {
+            string tempTransformFile = null;
+            try
+            {
+                tempTransformFile = Path.GetTempFileName();
+                this.ExtractTransform(transform, tempTransformFile);
+                using(SummaryInfo transformSummInfo = new SummaryInfo(tempTransformFile, false))
+                {
+                    return new TransformInfo(transform, transformSummInfo);
+                }
+            }
+            finally
+            {
+                if(tempTransformFile != null && File.Exists(tempTransformFile))
+                {
+                    File.Delete(tempTransformFile);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Analyzes the transforms included in the patch package to find the ones that
+        /// are applicable to an install package.
+        /// </summary>
+        /// <param name="installPackage">The install package to validate the transforms against</param>
+        /// <returns>Array of valid transform names</returns>
+        /// <remarks>
+        /// The returned list does not include the &quot;patch special transforms&quot; that
+        /// are prefixed with &quot;#&quot; If a transform is valid, then its corresponding
+        /// special transform is assumed to be valid as well.
+        /// </remarks>
+        public string[] GetValidTransforms(InstallPackage installPackage)
+        {
+            ArrayList transformArray = new ArrayList();
+            string transformList = this.SummaryInfo.LastSavedBy;
+            foreach(string transform in transformList.Split(';', ':'))
+            {
+                if(transform.Length != 0 && !transform.StartsWith("#", StringComparison.Ordinal))
+                {
+                    this.LogMessage("Checking validity of transform {0}", transform);
+                    string tempTransformFile = null;
+                    try
+                    {
+                        tempTransformFile = Path.GetTempFileName();
+                        this.ExtractTransform(transform, tempTransformFile);
+                        if(installPackage.IsTransformValid(tempTransformFile))
+                        {
+                            this.LogMessage("Found valid transform: {0}", transform);
+                            transformArray.Add(transform);
+                        }
+                    }
+                    finally
+                    {
+                        if(tempTransformFile != null && File.Exists(tempTransformFile))
+                        {
+                            try { File.Delete(tempTransformFile); } 
+                            catch(IOException) { }
+                        }
+                    }
+                }
+            }
+            return (string[]) transformArray.ToArray(typeof(string));
+        }
+
+        /// <summary>
+        /// Extracts a transform (.MST) from a patch package.
+        /// </summary>
+        /// <param name="transform">Name of the transform to extract; this may optionally be a
+        /// special transform prefixed by &quot;#&quot;</param>
+        /// <param name="extractFile">Location where the transform will be extracted</param>
+        public void ExtractTransform(string transform, string extractFile)
+        {
+            using(View stgView = this.OpenView("SELECT `Name`, `Data` FROM `_Storages` WHERE `Name` = '{0}'", transform))
+            {
+                stgView.Execute();
+                Record stgRec = stgView.Fetch();
+                if(stgRec == null)
+                {
+                    this.LogMessage("Transform not found: {0}", transform);
+                    throw new InstallerException("Transform not found: " + transform);
+                }
+                using(stgRec)
+                {
+                    stgRec.GetStream("Data", extractFile);
+                }
+            }
+        }
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.WindowsInstaller.Package/TransformInfo.cs b/src/dtf/WixToolset.Dtf.WindowsInstaller.Package/TransformInfo.cs
new file mode 100644
index 00000000..0bf3d3f9
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.WindowsInstaller.Package/TransformInfo.cs
@@ -0,0 +1,154 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.WindowsInstaller.Package
+{
+    using System;
+    using System.IO;
+    using System.Globalization;
+
+    /// <summary>
+    /// Contains properties of a transform package (.MST).
+    /// </summary>
+    public class TransformInfo
+    {
+        /// <summary>
+        /// Reads transform information from a transform package.
+        /// </summary>
+        /// <param name="mstFile">Path to a transform package (.MST file).</param>
+        public TransformInfo(string mstFile)
+        {
+            this.name = Path.GetFileName(mstFile);
+            using (SummaryInfo transformSummInfo = new SummaryInfo(mstFile, false))
+            {
+                this.DecodeSummaryInfo(transformSummInfo);
+            }
+        }
+
+        /// <summary>
+        /// Reads transform information from the summary information of a transform package.
+        /// </summary>
+        /// <param name="name">Filename of the transform (optional).</param>
+        /// <param name="transformSummaryInfo">Handle to the summary information of a transform package (.MST file).</param>
+        public TransformInfo(string name, SummaryInfo transformSummaryInfo)
+        {
+            this.name = name;
+            this.DecodeSummaryInfo(transformSummaryInfo);
+        }
+
+        private void DecodeSummaryInfo(SummaryInfo transformSummaryInfo)
+        {
+            try
+            {
+                string[] rev = transformSummaryInfo.RevisionNumber.Split(new char[] { ';' }, 3);
+                this.targetProductCode = rev[0].Substring(0, 38);
+                this.targetProductVersion = rev[0].Substring(38);
+                this.upgradeProductCode = rev[1].Substring(0, 38);
+                this.upgradeProductVersion = rev[1].Substring(38);
+                this.upgradeCode = rev[2];
+
+                string[] templ = transformSummaryInfo.Template.Split(new Char[] { ';' }, 2);
+                this.targetPlatform = templ[0];
+                this.targetLanguage = 0;
+                if (templ.Length >= 2 && templ[1].Length > 0)
+                {
+                    this.targetLanguage = Int32.Parse(templ[1], CultureInfo.InvariantCulture.NumberFormat);
+                }
+
+                this.validateFlags = (TransformValidations) transformSummaryInfo.CharacterCount;
+            }
+            catch (Exception ex)
+            {
+                throw new InstallerException("Invalid transform summary info", ex);
+            }
+        }
+
+        /// <summary>
+        /// Gets the filename of the transform.
+        /// </summary>
+        public string Name
+        {
+            get { return this.name; }
+        }
+        private string name;
+
+        /// <summary>
+        /// Gets the target product code of the transform.
+        /// </summary>
+        public string TargetProductCode
+        {
+            get { return this.targetProductCode; }
+        }
+        private string targetProductCode;
+
+        /// <summary>
+        /// Gets the target product version of the transform.
+        /// </summary>
+        public string TargetProductVersion
+        {
+            get { return this.targetProductVersion; }
+        }
+        private string targetProductVersion;
+
+        /// <summary>
+        /// Gets the upgrade product code of the transform.
+        /// </summary>
+        public string UpgradeProductCode
+        {
+            get { return this.upgradeProductCode; }
+        }
+        private string upgradeProductCode;
+
+        /// <summary>
+        /// Gets the upgrade product version of the transform.
+        /// </summary>
+        public string UpgradeProductVersion
+        {
+            get { return this.upgradeProductVersion; }
+        }
+        private string upgradeProductVersion;
+
+        /// <summary>
+        /// Gets the upgrade code of the transform.
+        /// </summary>
+        public string UpgradeCode
+        {
+            get { return this.upgradeCode; }
+        }
+        private string upgradeCode;
+
+        /// <summary>
+        /// Gets the target platform of the transform.
+        /// </summary>
+        public string TargetPlatform
+        {
+            get { return this.targetPlatform; }
+        }
+        private string targetPlatform;
+
+        /// <summary>
+        /// Gets the target language of the transform, or 0 if the transform is language-neutral.
+        /// </summary>
+        public int TargetLanguage
+        {
+            get { return this.targetLanguage; }
+        }
+        private int targetLanguage;
+
+        /// <summary>
+        /// Gets the validation flags specified when the transform was generated.
+        /// </summary>
+        public TransformValidations Validations
+        {
+            get { return this.validateFlags; }
+        }
+        private TransformValidations validateFlags;
+
+        /// <summary>
+        /// Returns the name of the transform.
+        /// </summary>
+        public override string ToString()
+        {
+            return (this.Name != null ? this.Name : "MST");
+        }
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.WindowsInstaller.Package/WixToolset.Dtf.WindowsInstaller.Package.csproj b/src/dtf/WixToolset.Dtf.WindowsInstaller.Package/WixToolset.Dtf.WindowsInstaller.Package.csproj
new file mode 100644
index 00000000..28ded687
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.WindowsInstaller.Package/WixToolset.Dtf.WindowsInstaller.Package.csproj
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. -->
+
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <RootNamespace>WixToolset.Dtf.WindowsInstaller</RootNamespace>
+    <AssemblyName>WixToolset.Dtf.WindowsInstaller.Package</AssemblyName>
+    <TargetFrameworks>netstandard2.0;net20</TargetFrameworks>
+    <Description>Extended managed libraries for Windows Installer</Description>
+    <CreateDocumentationFile>true</CreateDocumentationFile>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\WixToolset.Dtf.WindowsInstaller\WixToolset.Dtf.WindowsInstaller.csproj" />
+    <ProjectReference Include="..\WixToolset.Dtf.Compression\WixToolset.Dtf.Compression.csproj" />
+    <ProjectReference Include="..\WixToolset.Dtf.Compression.Cab\WixToolset.Dtf.Compression.Cab.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
+    <PackageReference Include="Nerdbank.GitVersioning" Version="3.3.37" PrivateAssets="All" />
+  </ItemGroup>
+</Project>