Massive refactoring to introduce the concept of IBackend

4 files changed, 1307 insertions, 0 deletions

diff --git a/src/WixToolset.Core.WindowsInstaller/Unbind/ExtractCabinetsCommand.cs b/src/WixToolset.Core.WindowsInstaller/Unbind/ExtractCabinetsCommand.cs
new file mode 100644
index 00000000..229e75b4
--- /dev/null
+++ b/src/WixToolset.Core.WindowsInstaller/Unbind/ExtractCabinetsCommand.cs
@@ -0,0 +1,146 @@
+// 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.Core.WindowsInstaller.Unbind
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Specialized;
+    using System.Globalization;
+    using System.IO;
+    using WixToolset.Core.Cab;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+    using WixToolset.Msi;
+
+    internal class ExtractCabinetsCommand
+    {
+        public ExtractCabinetsCommand(Output output, Database database, string inputFilePath, string exportBasePath, string intermediateFolder)
+        {
+            this.Output = output;
+            this.Database = database;
+            this.InputFilePath = inputFilePath;
+            this.ExportBasePath = exportBasePath;
+            this.IntermediateFolder = intermediateFolder;
+        }
+
+        private Output Output { get; }
+
+        private Database Database { get; }
+
+        private string InputFilePath { get; }
+
+        private string ExportBasePath { get; }
+
+        private string IntermediateFolder { get; }
+
+        public void Execute()
+        {
+            string databaseBasePath = Path.GetDirectoryName(this.InputFilePath);
+            StringCollection cabinetFiles = new StringCollection();
+            SortedList embeddedCabinets = new SortedList();
+
+            // index all of the cabinet files
+            if (OutputType.Module == this.Output.Type)
+            {
+                embeddedCabinets.Add(0, "MergeModule.CABinet");
+            }
+            else if (null != this.Output.Tables["Media"])
+            {
+                foreach (MediaRow mediaRow in this.Output.Tables["Media"].Rows)
+                {
+                    if (null != mediaRow.Cabinet)
+                    {
+                        if (OutputType.Product == this.Output.Type ||
+                            (OutputType.Transform == this.Output.Type && RowOperation.Add == mediaRow.Operation))
+                        {
+                            if (mediaRow.Cabinet.StartsWith("#", StringComparison.Ordinal))
+                            {
+                                embeddedCabinets.Add(mediaRow.DiskId, mediaRow.Cabinet.Substring(1));
+                            }
+                            else
+                            {
+                                cabinetFiles.Add(Path.Combine(databaseBasePath, mediaRow.Cabinet));
+                            }
+                        }
+                    }
+                }
+            }
+
+            // extract the embedded cabinet files from the database
+            if (0 < embeddedCabinets.Count)
+            {
+                using (View streamsView = this.Database.OpenView("SELECT `Data` FROM `_Streams` WHERE `Name` = ?"))
+                {
+                    foreach (int diskId in embeddedCabinets.Keys)
+                    {
+                        using (Record record = new Record(1))
+                        {
+                            record.SetString(1, (string)embeddedCabinets[diskId]);
+                            streamsView.Execute(record);
+                        }
+
+                        using (Record record = streamsView.Fetch())
+                        {
+                            if (null != record)
+                            {
+                                // since the cabinets are stored in case-sensitive streams inside the msi, but the file system is not case-sensitive,
+                                // embedded cabinets must be extracted to a canonical file name (like their diskid) to ensure extraction will always work
+                                string cabinetFile = Path.Combine(this.IntermediateFolder, String.Concat("Media", Path.DirectorySeparatorChar, diskId.ToString(CultureInfo.InvariantCulture), ".cab"));
+
+                                // ensure the parent directory exists
+                                System.IO.Directory.CreateDirectory(Path.GetDirectoryName(cabinetFile));
+
+                                using (FileStream fs = System.IO.File.Create(cabinetFile))
+                                {
+                                    int bytesRead;
+                                    byte[] buffer = new byte[512];
+
+                                    while (0 != (bytesRead = record.GetStream(1, buffer, buffer.Length)))
+                                    {
+                                        fs.Write(buffer, 0, bytesRead);
+                                    }
+                                }
+
+                                cabinetFiles.Add(cabinetFile);
+                            }
+                            else
+                            {
+                                // TODO: warning about missing embedded cabinet
+                            }
+                        }
+                    }
+                }
+            }
+
+            // extract the cabinet files
+            if (0 < cabinetFiles.Count)
+            {
+                string fileDirectory = Path.Combine(this.ExportBasePath, "File");
+
+                // delete the directory and its files to prevent cab extraction due to an existing file
+                if (Directory.Exists(fileDirectory))
+                {
+                    Directory.Delete(fileDirectory, true);
+                }
+
+                // ensure the directory exists or extraction will fail
+                Directory.CreateDirectory(fileDirectory);
+
+                foreach (string cabinetFile in cabinetFiles)
+                {
+                    using (var extractCab = new WixExtractCab())
+                    {
+                        try
+                        {
+                            extractCab.Extract(cabinetFile, fileDirectory);
+                        }
+                        catch (FileNotFoundException)
+                        {
+                            throw new WixException(WixErrors.FileNotFound(new SourceLineNumber(this.InputFilePath), cabinetFile));
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindDatabaseCommand.cs b/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindDatabaseCommand.cs
new file mode 100644
index 00000000..208be874
--- /dev/null
+++ b/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindDatabaseCommand.cs
@@ -0,0 +1,791 @@
+// 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.Core.WindowsInstaller.Unbind
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.IO;
+    using System.Text.RegularExpressions;
+    using WixToolset.Core.Native;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+    using WixToolset.Msi;
+
+    internal class UnbindDatabaseCommand
+    {
+        public UnbindDatabaseCommand(Messaging messaging, Database database, string databasePath, OutputType outputType, string exportBasePath, string intermediateFolder, bool isAdminImage, bool suppressDemodularization, bool skipSummaryInfo)
+        {
+            this.Messaging = messaging;
+            this.Database = database;
+            this.DatabasePath = databasePath;
+            this.OutputType = outputType;
+            this.ExportBasePath = exportBasePath;
+            this.IntermediateFolder = intermediateFolder;
+            this.IsAdminImage = isAdminImage;
+            this.SuppressDemodularization = suppressDemodularization;
+            this.SkipSummaryInfo = skipSummaryInfo;
+
+            this.TableDefinitions = WindowsInstallerStandard.GetTableDefinitions();
+        }
+
+        public Messaging Messaging { get; }
+
+        public Database Database { get; }
+
+        public string DatabasePath { get; }
+
+        public OutputType OutputType { get; }
+
+        public string ExportBasePath { get; }
+
+        public string IntermediateFolder { get; }
+
+        public bool IsAdminImage { get; }
+
+        public bool SuppressDemodularization { get; }
+
+        public bool SkipSummaryInfo { get; }
+
+        public TableDefinitionCollection TableDefinitions { get; }
+
+        private int SectionCount { get; set; }
+
+        public Output Execute()
+        {
+            string modularizationGuid = null;
+            Output output = new Output(new SourceLineNumber(this.DatabasePath));
+            View validationView = null;
+
+            // set the output type
+            output.Type = this.OutputType;
+
+            // get the codepage
+            this.Database.Export("_ForceCodepage", this.IntermediateFolder, "_ForceCodepage.idt");
+            using (StreamReader sr = File.OpenText(Path.Combine(this.IntermediateFolder, "_ForceCodepage.idt")))
+            {
+                string line;
+
+                while (null != (line = sr.ReadLine()))
+                {
+                    string[] data = line.Split('\t');
+
+                    if (2 == data.Length)
+                    {
+                        output.Codepage = Convert.ToInt32(data[0], CultureInfo.InvariantCulture);
+                    }
+                }
+            }
+
+            // get the summary information table if it exists; it won't if unbinding a transform
+            if (!this.SkipSummaryInfo)
+            {
+                using (SummaryInformation summaryInformation = new SummaryInformation(this.Database))
+                {
+                    Table table = new Table(null, this.TableDefinitions["_SummaryInformation"]);
+
+                    for (int i = 1; 19 >= i; i++)
+                    {
+                        string value = summaryInformation.GetProperty(i);
+
+                        if (0 < value.Length)
+                        {
+                            Row row = table.CreateRow(output.SourceLineNumbers);
+                            row[0] = i;
+                            row[1] = value;
+                        }
+                    }
+
+                    output.Tables.Add(table);
+                }
+            }
+
+            try
+            {
+                // open a view on the validation table if it exists
+                if (this.Database.TableExists("_Validation"))
+                {
+                    validationView = this.Database.OpenView("SELECT * FROM `_Validation` WHERE `Table` = ? AND `Column` = ?");
+                }
+
+                // get the normal tables
+                using (View tablesView = this.Database.OpenExecuteView("SELECT * FROM _Tables"))
+                {
+                    while (true)
+                    {
+                        using (Record tableRecord = tablesView.Fetch())
+                        {
+                            if (null == tableRecord)
+                            {
+                                break;
+                            }
+
+                            string tableName = tableRecord.GetString(1);
+
+                            using (View tableView = this.Database.OpenExecuteView(String.Format(CultureInfo.InvariantCulture, "SELECT * FROM `{0}`", tableName)))
+                            {
+                                List<ColumnDefinition> columns;
+                                using (Record columnNameRecord = tableView.GetColumnInfo(MsiInterop.MSICOLINFONAMES),
+                                              columnTypeRecord = tableView.GetColumnInfo(MsiInterop.MSICOLINFOTYPES))
+                                {
+                                    // index the primary keys
+                                    HashSet<string> tablePrimaryKeys = new HashSet<string>();
+                                    using (Record primaryKeysRecord = this.Database.PrimaryKeys(tableName))
+                                    {
+                                        int primaryKeysFieldCount = primaryKeysRecord.GetFieldCount();
+
+                                        for (int i = 1; i <= primaryKeysFieldCount; i++)
+                                        {
+                                            tablePrimaryKeys.Add(primaryKeysRecord.GetString(i));
+                                        }
+                                    }
+
+                                    int columnCount = columnNameRecord.GetFieldCount();
+                                    columns = new List<ColumnDefinition>(columnCount);
+                                    for (int i = 1; i <= columnCount; i++)
+                                    {
+                                        string columnName = columnNameRecord.GetString(i);
+                                        string idtType = columnTypeRecord.GetString(i);
+
+                                        ColumnType columnType;
+                                        int length;
+                                        bool nullable;
+
+                                        ColumnCategory columnCategory = ColumnCategory.Unknown;
+                                        ColumnModularizeType columnModularizeType = ColumnModularizeType.None;
+                                        bool primary = tablePrimaryKeys.Contains(columnName);
+                                        bool minValueSet = false;
+                                        int minValue = -1;
+                                        bool maxValueSet = false;
+                                        int maxValue = -1;
+                                        string keyTable = null;
+                                        bool keyColumnSet = false;
+                                        int keyColumn = -1;
+                                        string category = null;
+                                        string set = null;
+                                        string description = null;
+
+                                        // get the column type, length, and whether its nullable
+                                        switch (Char.ToLower(idtType[0], CultureInfo.InvariantCulture))
+                                        {
+                                            case 'i':
+                                                columnType = ColumnType.Number;
+                                                break;
+                                            case 'l':
+                                                columnType = ColumnType.Localized;
+                                                break;
+                                            case 's':
+                                                columnType = ColumnType.String;
+                                                break;
+                                            case 'v':
+                                                columnType = ColumnType.Object;
+                                                break;
+                                            default:
+                                                // TODO: error
+                                                columnType = ColumnType.Unknown;
+                                                break;
+                                        }
+                                        length = Convert.ToInt32(idtType.Substring(1), CultureInfo.InvariantCulture);
+                                        nullable = Char.IsUpper(idtType[0]);
+
+                                        // try to get validation information
+                                        if (null != validationView)
+                                        {
+                                            using (Record validationRecord = new Record(2))
+                                            {
+                                                validationRecord.SetString(1, tableName);
+                                                validationRecord.SetString(2, columnName);
+
+                                                validationView.Execute(validationRecord);
+                                            }
+
+                                            using (Record validationRecord = validationView.Fetch())
+                                            {
+                                                if (null != validationRecord)
+                                                {
+                                                    string validationNullable = validationRecord.GetString(3);
+                                                    minValueSet = !validationRecord.IsNull(4);
+                                                    minValue = (minValueSet ? validationRecord.GetInteger(4) : -1);
+                                                    maxValueSet = !validationRecord.IsNull(5);
+                                                    maxValue = (maxValueSet ? validationRecord.GetInteger(5) : -1);
+                                                    keyTable = (!validationRecord.IsNull(6) ? validationRecord.GetString(6) : null);
+                                                    keyColumnSet = !validationRecord.IsNull(7);
+                                                    keyColumn = (keyColumnSet ? validationRecord.GetInteger(7) : -1);
+                                                    category = (!validationRecord.IsNull(8) ? validationRecord.GetString(8) : null);
+                                                    set = (!validationRecord.IsNull(9) ? validationRecord.GetString(9) : null);
+                                                    description = (!validationRecord.IsNull(10) ? validationRecord.GetString(10) : null);
+
+                                                    // check the validation nullable value against the column definition
+                                                    if (null == validationNullable)
+                                                    {
+                                                        // TODO: warn for illegal validation nullable column
+                                                    }
+                                                    else if ((nullable && "Y" != validationNullable) || (!nullable && "N" != validationNullable))
+                                                    {
+                                                        // TODO: warn for mismatch between column definition and validation nullable
+                                                    }
+
+                                                    // convert category to ColumnCategory
+                                                    if (null != category)
+                                                    {
+                                                        try
+                                                        {
+                                                            columnCategory = (ColumnCategory)Enum.Parse(typeof(ColumnCategory), category, true);
+                                                        }
+                                                        catch (ArgumentException)
+                                                        {
+                                                            columnCategory = ColumnCategory.Unknown;
+                                                        }
+                                                    }
+                                                }
+                                                else
+                                                {
+                                                    // TODO: warn about no validation information
+                                                }
+                                            }
+                                        }
+
+                                        // guess the modularization type
+                                        if ("Icon" == keyTable && 1 == keyColumn)
+                                        {
+                                            columnModularizeType = ColumnModularizeType.Icon;
+                                        }
+                                        else if ("Condition" == columnName)
+                                        {
+                                            columnModularizeType = ColumnModularizeType.Condition;
+                                        }
+                                        else if (ColumnCategory.Formatted == columnCategory || ColumnCategory.FormattedSDDLText == columnCategory)
+                                        {
+                                            columnModularizeType = ColumnModularizeType.Property;
+                                        }
+                                        else if (ColumnCategory.Identifier == columnCategory)
+                                        {
+                                            columnModularizeType = ColumnModularizeType.Column;
+                                        }
+
+                                        columns.Add(new ColumnDefinition(columnName, columnType, length, primary, nullable, columnModularizeType, (ColumnType.Localized == columnType), minValueSet, minValue, maxValueSet, maxValue, keyTable, keyColumnSet, keyColumn, columnCategory, set, description, true, true));
+                                    }
+                                }
+
+                                TableDefinition tableDefinition = new TableDefinition(tableName, columns, false, false);
+
+                                // use our table definitions if core properties are the same; this allows us to take advantage
+                                // of wix concepts like localizable columns which current code assumes
+                                if (this.TableDefinitions.Contains(tableName) && 0 == tableDefinition.CompareTo(this.TableDefinitions[tableName]))
+                                {
+                                    tableDefinition = this.TableDefinitions[tableName];
+                                }
+
+                                Table table = new Table(null, tableDefinition);
+
+                                while (true)
+                                {
+                                    using (Record rowRecord = tableView.Fetch())
+                                    {
+                                        if (null == rowRecord)
+                                        {
+                                            break;
+                                        }
+
+                                        int recordCount = rowRecord.GetFieldCount();
+                                        Row row = table.CreateRow(output.SourceLineNumbers);
+
+                                        for (int i = 0; recordCount > i && row.Fields.Length > i; i++)
+                                        {
+                                            if (rowRecord.IsNull(i + 1))
+                                            {
+                                                if (!row.Fields[i].Column.Nullable)
+                                                {
+                                                    // TODO: display an error for a null value in a non-nullable field OR
+                                                    // display a warning and put an empty string in the value to let the compiler handle it
+                                                    // (the second option is risky because the later code may make certain assumptions about
+                                                    // the contents of a row value)
+                                                }
+                                            }
+                                            else
+                                            {
+                                                switch (row.Fields[i].Column.Type)
+                                                {
+                                                    case ColumnType.Number:
+                                                        bool success = false;
+                                                        int intValue = rowRecord.GetInteger(i + 1);
+                                                        if (row.Fields[i].Column.IsLocalizable)
+                                                        {
+                                                            success = row.BestEffortSetField(i, Convert.ToString(intValue, CultureInfo.InvariantCulture));
+                                                        }
+                                                        else
+                                                        {
+                                                            success = row.BestEffortSetField(i, intValue);
+                                                        }
+
+                                                        if (!success)
+                                                        {
+                                                            this.Messaging.OnMessage(WixWarnings.BadColumnDataIgnored(row.SourceLineNumbers, Convert.ToString(intValue, CultureInfo.InvariantCulture), tableName, row.Fields[i].Column.Name));
+                                                        }
+                                                        break;
+                                                    case ColumnType.Object:
+                                                        string sourceFile = "FILE NOT EXPORTED, USE THE dark.exe -x OPTION TO EXPORT BINARIES";
+
+                                                        if (null != this.ExportBasePath)
+                                                        {
+                                                            string relativeSourceFile = Path.Combine(tableName, row.GetPrimaryKey('.'));
+                                                            sourceFile = Path.Combine(this.ExportBasePath, relativeSourceFile);
+
+                                                            // ensure the parent directory exists
+                                                            System.IO.Directory.CreateDirectory(Path.Combine(this.ExportBasePath, tableName));
+
+                                                            using (FileStream fs = System.IO.File.Create(sourceFile))
+                                                            {
+                                                                int bytesRead;
+                                                                byte[] buffer = new byte[512];
+
+                                                                while (0 != (bytesRead = rowRecord.GetStream(i + 1, buffer, buffer.Length)))
+                                                                {
+                                                                    fs.Write(buffer, 0, bytesRead);
+                                                                }
+                                                            }
+                                                        }
+
+                                                        row[i] = sourceFile;
+                                                        break;
+                                                    default:
+                                                        string value = rowRecord.GetString(i + 1);
+
+                                                        switch (row.Fields[i].Column.Category)
+                                                        {
+                                                            case ColumnCategory.Guid:
+                                                                value = value.ToUpper(CultureInfo.InvariantCulture);
+                                                                break;
+                                                        }
+
+                                                        // de-modularize
+                                                        if (!this.SuppressDemodularization && OutputType.Module == output.Type && ColumnModularizeType.None != row.Fields[i].Column.ModularizeType)
+                                                        {
+                                                            Regex modularization = new Regex(@"\.[0-9A-Fa-f]{8}_[0-9A-Fa-f]{4}_[0-9A-Fa-f]{4}_[0-9A-Fa-f]{4}_[0-9A-Fa-f]{12}");
+
+                                                            if (null == modularizationGuid)
+                                                            {
+                                                                Match match = modularization.Match(value);
+                                                                if (match.Success)
+                                                                {
+                                                                    modularizationGuid = String.Concat('{', match.Value.Substring(1).Replace('_', '-'), '}');
+                                                                }
+                                                            }
+
+                                                            value = modularization.Replace(value, String.Empty);
+                                                        }
+
+                                                        // escape "$(" for the preprocessor
+                                                        value = value.Replace("$(", "$$(");
+
+                                                        // escape things that look like wix variables
+                                                        MatchCollection matches = Common.WixVariableRegex.Matches(value);
+                                                        for (int j = matches.Count - 1; 0 <= j; j--)
+                                                        {
+                                                            value = value.Insert(matches[j].Index, "!");
+                                                        }
+
+                                                        row[i] = value;
+                                                        break;
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+
+                                output.Tables.Add(table);
+                            }
+
+                        }
+                    }
+                }
+            }
+            finally
+            {
+                if (null != validationView)
+                {
+                    validationView.Close();
+                }
+            }
+
+            // set the modularization guid as the PackageCode
+            if (null != modularizationGuid)
+            {
+                Table table = output.Tables["_SummaryInformation"];
+
+                foreach (Row row in table.Rows)
+                {
+                    if (9 == (int)row[0]) // PID_REVNUMBER
+                    {
+                        row[1] = modularizationGuid;
+                    }
+                }
+            }
+
+            if (this.IsAdminImage)
+            {
+                GenerateWixFileTable(this.DatabasePath, output);
+                GenerateSectionIds(output);
+            }
+
+            return output;
+        }
+
+        /// <summary>
+        /// Generates the WixFile table based on a path to an admin image msi and an Output.
+        /// </summary>
+        /// <param name="databaseFile">The path to the msi database file in an admin image.</param>
+        /// <param name="output">The Output that represents the msi database.</param>
+        private void GenerateWixFileTable(string databaseFile, Output output)
+        {
+            string adminRootPath = Path.GetDirectoryName(databaseFile);
+
+            Hashtable componentDirectoryIndex = new Hashtable();
+            Table componentTable = output.Tables["Component"];
+            foreach (Row row in componentTable.Rows)
+            {
+                componentDirectoryIndex.Add(row[0], row[2]);
+            }
+
+            // Index full source paths for all directories
+            Hashtable directoryDirectoryParentIndex = new Hashtable();
+            Hashtable directoryFullPathIndex = new Hashtable();
+            Hashtable directorySourceNameIndex = new Hashtable();
+            Table directoryTable = output.Tables["Directory"];
+            foreach (Row row in directoryTable.Rows)
+            {
+                directoryDirectoryParentIndex.Add(row[0], row[1]);
+                if (null == row[1])
+                {
+                    directoryFullPathIndex.Add(row[0], adminRootPath);
+                }
+                else
+                {
+                    directorySourceNameIndex.Add(row[0], GetAdminSourceName((string)row[2]));
+                }
+            }
+
+            foreach (DictionaryEntry directoryEntry in directoryDirectoryParentIndex)
+            {
+                if (!directoryFullPathIndex.ContainsKey(directoryEntry.Key))
+                {
+                    GetAdminFullPath((string)directoryEntry.Key, directoryDirectoryParentIndex, directorySourceNameIndex, directoryFullPathIndex);
+                }
+            }
+
+            Table fileTable = output.Tables["File"];
+            Table wixFileTable = output.EnsureTable(this.TableDefinitions["WixFile"]);
+            foreach (Row row in fileTable.Rows)
+            {
+                WixFileRow wixFileRow = new WixFileRow(null, this.TableDefinitions["WixFile"]);
+                wixFileRow.File = (string)row[0];
+                wixFileRow.Directory = (string)componentDirectoryIndex[(string)row[1]];
+                wixFileRow.Source = Path.Combine((string)directoryFullPathIndex[wixFileRow.Directory], GetAdminSourceName((string)row[2]));
+
+                if (!File.Exists(wixFileRow.Source))
+                {
+                    throw new WixException(WixErrors.WixFileNotFound(wixFileRow.Source));
+                }
+
+                wixFileTable.Rows.Add(wixFileRow);
+            }
+        }
+
+        /// <summary>
+        /// Gets the full path of a directory. Populates the full path index with the directory's full path and all of its parent directorie's full paths.
+        /// </summary>
+        /// <param name="directory">The directory identifier.</param>
+        /// <param name="directoryDirectoryParentIndex">The Hashtable containing all the directory to directory parent mapping.</param>
+        /// <param name="directorySourceNameIndex">The Hashtable containing all the directory to source name mapping.</param>
+        /// <param name="directoryFullPathIndex">The Hashtable containing a mapping between all of the directories and their previously calculated full paths.</param>
+        /// <returns>The full path to the directory.</returns>
+        private string GetAdminFullPath(string directory, Hashtable directoryDirectoryParentIndex, Hashtable directorySourceNameIndex, Hashtable directoryFullPathIndex)
+        {
+            string parent = (string)directoryDirectoryParentIndex[directory];
+            string sourceName = (string)directorySourceNameIndex[directory];
+
+            string parentFullPath;
+            if (directoryFullPathIndex.ContainsKey(parent))
+            {
+                parentFullPath = (string)directoryFullPathIndex[parent];
+            }
+            else
+            {
+                parentFullPath = GetAdminFullPath(parent, directoryDirectoryParentIndex, directorySourceNameIndex, directoryFullPathIndex);
+            }
+
+            if (null == sourceName)
+            {
+                sourceName = String.Empty;
+            }
+
+            string fullPath = Path.Combine(parentFullPath, sourceName);
+            directoryFullPathIndex.Add(directory, fullPath);
+
+            return fullPath;
+        }
+
+        /// <summary>
+        /// Get the source name in an admin image.
+        /// </summary>
+        /// <param name="value">The Filename value.</param>
+        /// <returns>The source name of the directory in an admin image.</returns>
+        private static string GetAdminSourceName(string value)
+        {
+            string name = null;
+            string[] names;
+            string shortname = null;
+            string shortsourcename = null;
+            string sourcename = null;
+
+            names = Common.GetNames(value);
+
+            if (null != names[0] && "." != names[0])
+            {
+                if (null != names[1])
+                {
+                    shortname = names[0];
+                }
+                else
+                {
+                    name = names[0];
+                }
+            }
+
+            if (null != names[1])
+            {
+                name = names[1];
+            }
+
+            if (null != names[2])
+            {
+                if (null != names[3])
+                {
+                    shortsourcename = names[2];
+                }
+                else
+                {
+                    sourcename = names[2];
+                }
+            }
+
+            if (null != names[3])
+            {
+                sourcename = names[3];
+            }
+
+            if (null != sourcename)
+            {
+                return sourcename;
+            }
+            else if (null != shortsourcename)
+            {
+                return shortsourcename;
+            }
+            else if (null != name)
+            {
+                return name;
+            }
+            else
+            {
+                return shortname;
+            }
+        }
+
+        /// <summary>
+        /// Creates section ids on rows which form logical groupings of resources.
+        /// </summary>
+        /// <param name="output">The Output that represents the msi database.</param>
+        private void GenerateSectionIds(Output output)
+        {
+            // First assign and index section ids for the tables that are in their own sections.
+            AssignSectionIdsToTable(output.Tables["Binary"], 0);
+            Hashtable componentSectionIdIndex = AssignSectionIdsToTable(output.Tables["Component"], 0);
+            Hashtable customActionSectionIdIndex = AssignSectionIdsToTable(output.Tables["CustomAction"], 0);
+            AssignSectionIdsToTable(output.Tables["Directory"], 0);
+            Hashtable featureSectionIdIndex = AssignSectionIdsToTable(output.Tables["Feature"], 0);
+            AssignSectionIdsToTable(output.Tables["Icon"], 0);
+            Hashtable digitalCertificateSectionIdIndex = AssignSectionIdsToTable(output.Tables["MsiDigitalCertificate"], 0);
+            AssignSectionIdsToTable(output.Tables["Property"], 0);
+
+            // Now handle all the tables that rely on the first set of indexes but also produce their own indexes. Order matters here.
+            Hashtable fileSectionIdIndex = ConnectTableToSectionAndIndex(output.Tables["File"], componentSectionIdIndex, 1, 0);
+            Hashtable appIdSectionIdIndex = ConnectTableToSectionAndIndex(output.Tables["Class"], componentSectionIdIndex, 2, 5);
+            Hashtable odbcDataSourceSectionIdIndex = ConnectTableToSectionAndIndex(output.Tables["ODBCDataSource"], componentSectionIdIndex, 1, 0);
+            Hashtable odbcDriverSectionIdIndex = ConnectTableToSectionAndIndex(output.Tables["ODBCDriver"], componentSectionIdIndex, 1, 0);
+            Hashtable registrySectionIdIndex = ConnectTableToSectionAndIndex(output.Tables["Registry"], componentSectionIdIndex, 5, 0);
+            Hashtable serviceInstallSectionIdIndex = ConnectTableToSectionAndIndex(output.Tables["ServiceInstall"], componentSectionIdIndex, 11, 0);
+
+            // Now handle all the tables which only rely on previous indexes and order does not matter.
+            foreach (Table table in output.Tables)
+            {
+                switch (table.Name)
+                {
+                    case "WixFile":
+                    case "MsiFileHash":
+                        ConnectTableToSection(table, fileSectionIdIndex, 0);
+                        break;
+                    case "MsiAssembly":
+                    case "MsiAssemblyName":
+                        ConnectTableToSection(table, componentSectionIdIndex, 0);
+                        break;
+                    case "MsiPackageCertificate":
+                    case "MsiPatchCertificate":
+                        ConnectTableToSection(table, digitalCertificateSectionIdIndex, 1);
+                        break;
+                    case "CreateFolder":
+                    case "FeatureComponents":
+                    case "MoveFile":
+                    case "ReserveCost":
+                    case "ODBCTranslator":
+                        ConnectTableToSection(table, componentSectionIdIndex, 1);
+                        break;
+                    case "TypeLib":
+                        ConnectTableToSection(table, componentSectionIdIndex, 2);
+                        break;
+                    case "Shortcut":
+                    case "Environment":
+                        ConnectTableToSection(table, componentSectionIdIndex, 3);
+                        break;
+                    case "RemoveRegistry":
+                        ConnectTableToSection(table, componentSectionIdIndex, 4);
+                        break;
+                    case "ServiceControl":
+                        ConnectTableToSection(table, componentSectionIdIndex, 5);
+                        break;
+                    case "IniFile":
+                    case "RemoveIniFile":
+                        ConnectTableToSection(table, componentSectionIdIndex, 7);
+                        break;
+                    case "AppId":
+                        ConnectTableToSection(table, appIdSectionIdIndex, 0);
+                        break;
+                    case "Condition":
+                        ConnectTableToSection(table, featureSectionIdIndex, 0);
+                        break;
+                    case "ODBCSourceAttribute":
+                        ConnectTableToSection(table, odbcDataSourceSectionIdIndex, 0);
+                        break;
+                    case "ODBCAttribute":
+                        ConnectTableToSection(table, odbcDriverSectionIdIndex, 0);
+                        break;
+                    case "AdminExecuteSequence":
+                    case "AdminUISequence":
+                    case "AdvtExecuteSequence":
+                    case "AdvtUISequence":
+                    case "InstallExecuteSequence":
+                    case "InstallUISequence":
+                        ConnectTableToSection(table, customActionSectionIdIndex, 0);
+                        break;
+                    case "LockPermissions":
+                    case "MsiLockPermissions":
+                        foreach (Row row in table.Rows)
+                        {
+                            string lockObject = (string)row[0];
+                            string tableName = (string)row[1];
+                            switch (tableName)
+                            {
+                                case "File":
+                                    row.SectionId = (string)fileSectionIdIndex[lockObject];
+                                    break;
+                                case "Registry":
+                                    row.SectionId = (string)registrySectionIdIndex[lockObject];
+                                    break;
+                                case "ServiceInstall":
+                                    row.SectionId = (string)serviceInstallSectionIdIndex[lockObject];
+                                    break;
+                            }
+                        }
+                        break;
+                }
+            }
+
+            // Now pass the output to each unbinder extension to allow them to analyze the output and determine thier proper section ids.
+            //foreach (IUnbinderExtension extension in this.unbinderExtensions)
+            //{
+            //    extension.GenerateSectionIds(output);
+            //}
+        }
+
+        /// <summary>
+        /// Creates new section ids on all the rows in a table.
+        /// </summary>
+        /// <param name="table">The table to add sections to.</param>
+        /// <param name="rowPrimaryKeyIndex">The index of the column which is used by other tables to reference this table.</param>
+        /// <returns>A Hashtable containing the tables key for each row paired with its assigned section id.</returns>
+        private Hashtable AssignSectionIdsToTable(Table table, int rowPrimaryKeyIndex)
+        {
+            Hashtable hashtable = new Hashtable();
+            if (null != table)
+            {
+                foreach (Row row in table.Rows)
+                {
+                    row.SectionId = GetNewSectionId();
+                    hashtable.Add(row[rowPrimaryKeyIndex], row.SectionId);
+                }
+            }
+            return hashtable;
+        }
+
+        /// <summary>
+        /// Connects a table's rows to an already sectioned table.
+        /// </summary>
+        /// <param name="table">The table containing rows that need to be connected to sections.</param>
+        /// <param name="sectionIdIndex">A hashtable containing keys to map table to its section.</param>
+        /// <param name="rowIndex">The index of the column which is used as the foreign key in to the sectionIdIndex.</param>
+        private static void ConnectTableToSection(Table table, Hashtable sectionIdIndex, int rowIndex)
+        {
+            if (null != table)
+            {
+                foreach (Row row in table.Rows)
+                {
+                    if (sectionIdIndex.ContainsKey(row[rowIndex]))
+                    {
+                        row.SectionId = (string)sectionIdIndex[row[rowIndex]];
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Connects a table's rows to an already sectioned table and produces an index for other tables to connect to it.
+        /// </summary>
+        /// <param name="table">The table containing rows that need to be connected to sections.</param>
+        /// <param name="sectionIdIndex">A hashtable containing keys to map table to its section.</param>
+        /// <param name="rowIndex">The index of the column which is used as the foreign key in to the sectionIdIndex.</param>
+        /// <param name="rowPrimaryKeyIndex">The index of the column which is used by other tables to reference this table.</param>
+        /// <returns>A Hashtable containing the tables key for each row paired with its assigned section id.</returns>
+        private static Hashtable ConnectTableToSectionAndIndex(Table table, Hashtable sectionIdIndex, int rowIndex, int rowPrimaryKeyIndex)
+        {
+            Hashtable newHashTable = new Hashtable();
+            if (null != table)
+            {
+                foreach (Row row in table.Rows)
+                {
+                    if (!sectionIdIndex.ContainsKey(row[rowIndex]))
+                    {
+                        continue;
+                    }
+
+                    row.SectionId = (string)sectionIdIndex[row[rowIndex]];
+                    if (null != row[rowPrimaryKeyIndex])
+                    {
+                        newHashTable.Add(row[rowPrimaryKeyIndex], row.SectionId);
+                    }
+                }
+            }
+            return newHashTable;
+        }
+
+        /// <summary>
+        /// Creates a new section identifier to be used when adding a section to an output.
+        /// </summary>
+        /// <returns>A string representing a new section id.</returns>
+        private string GetNewSectionId()
+        {
+            this.SectionCount++;
+            return "wix.section." + this.SectionCount.ToString(CultureInfo.InvariantCulture);
+        }
+    }
+}
diff --git a/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindMsiOrMsmCommand.cs b/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindMsiOrMsmCommand.cs
new file mode 100644
index 00000000..f04dcefe
--- /dev/null
+++ b/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindMsiOrMsmCommand.cs
@@ -0,0 +1,53 @@
+// 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.Core.WindowsInstaller.Unbind
+{
+    using System;
+    using System.ComponentModel;
+    using WixToolset.Core.Native;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+    using WixToolset.Msi;
+
+    internal class UnbindMsiOrMsmCommand
+    {
+        public UnbindMsiOrMsmCommand(IUnbindContext context)
+        {
+            this.Context = context;
+        }
+
+        public IUnbindContext Context { get; }
+
+        public Output Execute()
+        {
+            Output output;
+
+            try
+            {
+                using (Database database = new Database(this.Context.InputFilePath, OpenDatabase.ReadOnly))
+                {
+                    var unbindCommand = new UnbindDatabaseCommand(this.Context.Messaging, database, this.Context.InputFilePath, OutputType.Product, this.Context.ExportBasePath, this.Context.IntermediateFolder, this.Context.IsAdminImage, this.Context.SuppressDemodularization, skipSummaryInfo: false);
+                    output = unbindCommand.Execute();
+
+                    // extract the files from the cabinets
+                    if (!String.IsNullOrEmpty(this.Context.ExportBasePath) && !this.Context.SuppressExtractCabinets)
+                    {
+                        var extractCommand = new ExtractCabinetsCommand(output, database, this.Context.InputFilePath, this.Context.ExportBasePath, this.Context.IntermediateFolder);
+                        extractCommand.Execute();
+                    }
+                }
+            }
+            catch (Win32Exception e)
+            {
+                if (0x6E == e.NativeErrorCode) // ERROR_OPEN_FAILED
+                {
+                    throw new WixException(WixErrors.OpenDatabaseFailed(this.Context.InputFilePath));
+                }
+
+                throw;
+            }
+
+            return output;
+        }
+    }
+}
diff --git a/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindTranformCommand.cs b/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindTranformCommand.cs
new file mode 100644
index 00000000..c0eda9c7
--- /dev/null
+++ b/src/WixToolset.Core.WindowsInstaller/Unbind/UnbindTranformCommand.cs
@@ -0,0 +1,317 @@
+// 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.Core.WindowsInstaller.Unbind
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using System.Globalization;
+    using System.IO;
+    using System.Linq;
+    using System.Text.RegularExpressions;
+    using WixToolset.Core.Native;
+    using WixToolset.Core.WindowsInstaller.Databases;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+    using WixToolset.Extensibility;
+    using WixToolset.Msi;
+
+    internal class UnbindTransformCommand
+    {
+        public UnbindTransformCommand(Messaging messaging, string transformFile, string exportBasePath, string intermediateFolder)
+        {
+            this.Messaging = messaging;
+            this.TransformFile = transformFile;
+            this.ExportBasePath = exportBasePath;
+            this.IntermediateFolder = intermediateFolder;
+
+            this.TableDefinitions = WindowsInstallerStandard.GetTableDefinitions();
+        }
+
+        private Messaging Messaging { get; }
+
+        private string TransformFile { get; }
+
+        private string ExportBasePath { get; }
+
+        private string IntermediateFolder { get; }
+
+        private TableDefinitionCollection TableDefinitions { get; }
+
+        private string EmptyFile { get; set; }
+        
+        public Output Execute()
+        {
+            Output transform = new Output(new SourceLineNumber(this.TransformFile));
+            transform.Type = OutputType.Transform;
+
+            // get the summary information table
+            using (SummaryInformation summaryInformation = new SummaryInformation(this.TransformFile))
+            {
+                Table table = transform.EnsureTable(this.TableDefinitions["_SummaryInformation"]);
+
+                for (int i = 1; 19 >= i; i++)
+                {
+                    string value = summaryInformation.GetProperty(i);
+
+                    if (0 < value.Length)
+                    {
+                        Row row = table.CreateRow(transform.SourceLineNumbers);
+                        row[0] = i;
+                        row[1] = value;
+                    }
+                }
+            }
+
+            // create a schema msi which hopefully matches the table schemas in the transform
+            Output schemaOutput = new Output(null);
+            string msiDatabaseFile = Path.Combine(this.IntermediateFolder, "schema.msi");
+            foreach (TableDefinition tableDefinition in this.TableDefinitions)
+            {
+                // skip unreal tables and the Patch table
+                if (!tableDefinition.Unreal && "Patch" != tableDefinition.Name)
+                {
+                    schemaOutput.EnsureTable(tableDefinition);
+                }
+            }
+
+            Hashtable addedRows = new Hashtable();
+            Table transformViewTable;
+
+            // Bind the schema msi.
+            this.GenerateDatabase(schemaOutput, msiDatabaseFile);
+
+            // apply the transform to the database and retrieve the modifications
+            using (Database msiDatabase = new Database(msiDatabaseFile, OpenDatabase.Transact))
+            {
+                // apply the transform with the ViewTransform option to collect all the modifications
+                msiDatabase.ApplyTransform(this.TransformFile, TransformErrorConditions.All | TransformErrorConditions.ViewTransform);
+
+                // unbind the database
+                var unbindCommand = new UnbindDatabaseCommand(this.Messaging, msiDatabase, msiDatabaseFile, OutputType.Product, this.ExportBasePath, this.IntermediateFolder, false, false, skipSummaryInfo: true);
+                Output transformViewOutput = unbindCommand.Execute();
+
+                // index the added and possibly modified rows (added rows may also appears as modified rows)
+                transformViewTable = transformViewOutput.Tables["_TransformView"];
+                Hashtable modifiedRows = new Hashtable();
+                foreach (Row row in transformViewTable.Rows)
+                {
+                    string tableName = (string)row[0];
+                    string columnName = (string)row[1];
+                    string primaryKeys = (string)row[2];
+
+                    if ("INSERT" == columnName)
+                    {
+                        string index = String.Concat(tableName, ':', primaryKeys);
+
+                        addedRows.Add(index, null);
+                    }
+                    else if ("CREATE" != columnName && "DELETE" != columnName && "DROP" != columnName && null != primaryKeys) // modified row
+                    {
+                        string index = String.Concat(tableName, ':', primaryKeys);
+
+                        modifiedRows[index] = row;
+                    }
+                }
+
+                // create placeholder rows for modified rows to make the transform insert the updated values when its applied
+                foreach (Row row in modifiedRows.Values)
+                {
+                    string tableName = (string)row[0];
+                    string columnName = (string)row[1];
+                    string primaryKeys = (string)row[2];
+
+                    string index = String.Concat(tableName, ':', primaryKeys);
+
+                    // ignore information for added rows
+                    if (!addedRows.Contains(index))
+                    {
+                        Table table = schemaOutput.Tables[tableName];
+                        this.CreateRow(table, primaryKeys, true);
+                    }
+                }
+            }
+
+            // Re-bind the schema output with the placeholder rows.
+            this.GenerateDatabase(schemaOutput, msiDatabaseFile);
+
+            // apply the transform to the database and retrieve the modifications
+            using (Database msiDatabase = new Database(msiDatabaseFile, OpenDatabase.Transact))
+            {
+                try
+                {
+                    // apply the transform
+                    msiDatabase.ApplyTransform(this.TransformFile, TransformErrorConditions.All);
+
+                    // commit the database to guard against weird errors with streams
+                    msiDatabase.Commit();
+                }
+                catch (Win32Exception ex)
+                {
+                    if (0x65B == ex.NativeErrorCode)
+                    {
+                        // this commonly happens when the transform was built
+                        // against a database schema different from the internal
+                        // table definitions
+                        throw new WixException(WixErrors.TransformSchemaMismatch());
+                    }
+                }
+
+                // unbind the database
+                var unbindCommand = new UnbindDatabaseCommand(this.Messaging, msiDatabase, msiDatabaseFile, OutputType.Product, this.ExportBasePath, this.IntermediateFolder, false, false, skipSummaryInfo: true);
+                Output output = unbindCommand.Execute();
+
+                // index all the rows to easily find modified rows
+                Hashtable rows = new Hashtable();
+                foreach (Table table in output.Tables)
+                {
+                    foreach (Row row in table.Rows)
+                    {
+                        rows.Add(String.Concat(table.Name, ':', row.GetPrimaryKey('\t', " ")), row);
+                    }
+                }
+
+                // process the _TransformView rows into transform rows
+                foreach (Row row in transformViewTable.Rows)
+                {
+                    string tableName = (string)row[0];
+                    string columnName = (string)row[1];
+                    string primaryKeys = (string)row[2];
+
+                    Table table = transform.EnsureTable(this.TableDefinitions[tableName]);
+
+                    if ("CREATE" == columnName) // added table
+                    {
+                        table.Operation = TableOperation.Add;
+                    }
+                    else if ("DELETE" == columnName) // deleted row
+                    {
+                        Row deletedRow = this.CreateRow(table, primaryKeys, false);
+                        deletedRow.Operation = RowOperation.Delete;
+                    }
+                    else if ("DROP" == columnName) // dropped table
+                    {
+                        table.Operation = TableOperation.Drop;
+                    }
+                    else if ("INSERT" == columnName) // added row
+                    {
+                        string index = String.Concat(tableName, ':', primaryKeys);
+                        Row addedRow = (Row)rows[index];
+                        addedRow.Operation = RowOperation.Add;
+                        table.Rows.Add(addedRow);
+                    }
+                    else if (null != primaryKeys) // modified row
+                    {
+                        string index = String.Concat(tableName, ':', primaryKeys);
+
+                        // the _TransformView table includes information for added rows
+                        // that looks like modified rows so it sometimes needs to be ignored
+                        if (!addedRows.Contains(index))
+                        {
+                            Row modifiedRow = (Row)rows[index];
+
+                            // mark the field as modified
+                            int indexOfModifiedValue = -1;
+                            for (int i = 0; i < modifiedRow.TableDefinition.Columns.Count; ++i)
+                            {
+                                if (columnName.Equals(modifiedRow.TableDefinition.Columns[i].Name, StringComparison.Ordinal))
+                                {
+                                    indexOfModifiedValue = i;
+                                    break;
+                                }
+                            }
+                            modifiedRow.Fields[indexOfModifiedValue].Modified = true;
+
+                            // move the modified row into the transform the first time its encountered
+                            if (RowOperation.None == modifiedRow.Operation)
+                            {
+                                modifiedRow.Operation = RowOperation.Modify;
+                                table.Rows.Add(modifiedRow);
+                            }
+                        }
+                    }
+                    else // added column
+                    {
+                        ColumnDefinition column = table.Definition.Columns.Single(c => c.Name.Equals(columnName, StringComparison.Ordinal));
+                        column.Added = true;
+                    }
+                }
+            }
+
+            return transform;
+        }
+
+        private void GenerateDatabase(Output output, string databaseFile)
+        {
+            var command = new GenerateDatabaseCommand();
+            command.Extensions = Array.Empty<IBinderExtension>();
+            command.Output = output;
+            command.OutputPath = databaseFile;
+            command.KeepAddedColumns = true;
+            command.UseSubDirectory = false;
+            command.SuppressAddingValidationRows = true;
+            command.TableDefinitions = this.TableDefinitions;
+            command.TempFilesLocation = this.IntermediateFolder;
+            command.Codepage = -1;
+            command.Execute();
+        }
+
+        /// <summary>
+        /// Create a deleted or modified row.
+        /// </summary>
+        /// <param name="table">The table containing the row.</param>
+        /// <param name="primaryKeys">The primary keys of the row.</param>
+        /// <param name="setRequiredFields">Option to set all required fields with placeholder values.</param>
+        /// <returns>The new row.</returns>
+        private Row CreateRow(Table table, string primaryKeys, bool setRequiredFields)
+        {
+            Row row = table.CreateRow(null);
+
+            string[] primaryKeyParts = primaryKeys.Split('\t');
+            int primaryKeyPartIndex = 0;
+
+            for (int i = 0; i < table.Definition.Columns.Count; i++)
+            {
+                ColumnDefinition columnDefinition = table.Definition.Columns[i];
+
+                if (columnDefinition.PrimaryKey)
+                {
+                    if (ColumnType.Number == columnDefinition.Type && !columnDefinition.IsLocalizable)
+                    {
+                        row[i] = Convert.ToInt32(primaryKeyParts[primaryKeyPartIndex++], CultureInfo.InvariantCulture);
+                    }
+                    else
+                    {
+                        row[i] = primaryKeyParts[primaryKeyPartIndex++];
+                    }
+                }
+                else if (setRequiredFields)
+                {
+                    if (ColumnType.Number == columnDefinition.Type && !columnDefinition.IsLocalizable)
+                    {
+                        row[i] = 1;
+                    }
+                    else if (ColumnType.Object == columnDefinition.Type)
+                    {
+                        if (null == this.EmptyFile)
+                        {
+                            this.EmptyFile = Path.GetTempFileName() + ".empty";
+                            using (FileStream fileStream = File.Create(this.EmptyFile))
+                            {
+                            }
+                        }
+
+                        row[i] = this.EmptyFile;
+                    }
+                    else
+                    {
+                        row[i] = "1";
+                    }
+                }
+            }
+
+            return row;
+        }
+    }
+}