/// <summary>
/// Add a row to the <paramref name="index"/> using the primary key.
/// </summary>
/// <param name="index">The indexed rows.</param>
/// <param name="row">The row to index.</param>
private void AddIndexedRow(IDictionary index, Row row)
{
string primaryKey = row.GetPrimaryKey('/');
if (null != primaryKey)
{
// Overriding WixActionRows have a primary key defined and take precedence in the index.
if (row is WixActionRow)
{
WixActionRow currentRow = (WixActionRow)row;
if (index.Contains(primaryKey))
{
// If the current row is not overridable, see if the indexed row is.
if (!currentRow.Overridable)
{
WixActionRow indexedRow = index[primaryKey] as WixActionRow;
if (null != indexedRow && indexedRow.Overridable)
{
// The indexed key is overridable and should be replaced
// (not removed and re-added which results in two Array.Copy
// operations for SortedList, or may be re-hashing in other
// implementations of IDictionary).
index[primaryKey] = currentRow;
}
}
// If we got this far, the row does not need to be indexed.
return;
}
}
// Nothing else should be added more than once.
if (!index.Contains(primaryKey))
{
index.Add(primaryKey, row);
}
else if (this.showPedanticMessages)
{
this.OnMessage(WixWarnings.DuplicatePrimaryKey(row.SourceLineNumbers, primaryKey, row.Table.Name));
}
}
else // use the string representation of the row as its primary key (it may not be unique)
{
// this is provided for compatibility with unreal tables with no primary key
// all real tables must specify at least one column as the primary key
primaryKey = row.ToString();
index[primaryKey] = row;
}
}
/// <summary>
/// Determines if the given row can be ignored when comparing results.
/// </summary>
/// <param name="row">The row to check.</param>
/// <returns>True if the row can be ignored; otherwise, false.</returns>
private static bool Ignore(Row row)
{
if ("_SummaryInformation" == row.Table.Name)
{
// check timestamp and version-dependent fields
switch ((int)row[0])
{
case 9:
case 12:
case 13:
case 18:
return true;
}
}
else if ("Property" == row.Table.Name)
{
switch ((string)row[0])
{
case "ProductCode":
return true;
}
}
else if ("MsiPatchMetadata" == row.Table.Name)
{
switch (row.GetPrimaryKey('/'))
{
case "/CreationTimeUTC":
return true;
}
}
return false;
}
/// <summary>
/// Set the primary feature for a component.
/// </summary>
/// <param name="row">The row which specifies a primary feature.</param>
/// <param name="featureColumnIndex">The index of the column contaning the feature identifier.</param>
/// <param name="componentColumnIndex">The index of the column containing the component identifier.</param>
private void SetPrimaryFeature(Row row, int featureColumnIndex, int componentColumnIndex)
{
// only products contain primary features
if (OutputType.Product == this.outputType)
{
Field featureField = row.Fields[featureColumnIndex];
Field componentField = row.Fields[componentColumnIndex];
Wix.ComponentRef componentRef = (Wix.ComponentRef)this.core.GetIndexedElement("FeatureComponents", Convert.ToString(featureField.Data), Convert.ToString(componentField.Data));
if (null != componentRef)
{
componentRef.Primary = Wix.YesNoType.yes;
}
else
{
this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, row.TableDefinition.Name, row.GetPrimaryKey(DecompilerCore.PrimaryKeyDelimiter), featureField.Column.Name, Convert.ToString(featureField.Data), componentField.Column.Name, Convert.ToString(componentField.Data), "FeatureComponents"));
}
}
}
/// <summary>
/// Add a row to the <paramref name="index"/> using the primary key.
/// </summary>
/// <param name="index">The indexed rows.</param>
/// <param name="row">The row to index.</param>
private void AddIndexedRow(IDictionary index, Row row)
{
string primaryKey = row.GetPrimaryKey('/');
if (null != primaryKey)
{
// Overriding WixActionRows have a primary key defined and take precedence in the index.
if (row is WixActionRow)
{
WixActionRow currentRow = (WixActionRow)row;
if (index.Contains(primaryKey))
{
// If the current row is not overridable, see if the indexed row is.
if (!currentRow.Overridable)
{
WixActionRow indexedRow = index[primaryKey] as WixActionRow;
if (null != indexedRow && indexedRow.Overridable)
{
// The indexed key is overridable and should be replaced
// (not removed and re-added which results in two Array.Copy
// operations for SortedList, or may be re-hashing in other
// implementations of IDictionary).
index[primaryKey] = currentRow;
}
}
// If we got this far, the row does not need to be indexed.
return;
}
}
// Nothing else should be added more than once.
if (!index.Contains(primaryKey))
{
index.Add(primaryKey, row);
}
else if (this.showPedanticMessages)
{
this.OnMessage(WixWarnings.DuplicatePrimaryKey(row.SourceLineNumbers, primaryKey, row.Table.Name));
}
}
else // use the string representation of the row as its primary key (it may not be unique)
{
// this is provided for compatibility with unreal tables with no primary key
// all real tables must specify at least one column as the primary key
primaryKey = row.ToString();
index[primaryKey] = row;
}
}
/// <summary>
/// Index an element by its corresponding row.
/// </summary>
/// <param name="row">The row corresponding to the element.</param>
/// <param name="element">The element to index.</param>
public void IndexElement(Row row, ISchemaElement element)
{
this.elements.Add(String.Concat(row.TableDefinition.Name, ':', row.GetPrimaryKey(PrimaryKeyDelimiter)), element);
}
/// <summary>
/// Gets the element corresponding to the row it came from.
/// </summary>
/// <param name="row">The row corresponding to the element.</param>
/// <returns>The indexed element.</returns>
public ISchemaElement GetIndexedElement(Row row)
{
return(this.GetIndexedElement(row.TableDefinition.Name, row.GetPrimaryKey(PrimaryKeyDelimiter)));
}
/// <summary>
/// Index an element by its corresponding row.
/// </summary>
/// <param name="row">The row corresponding to the element.</param>
/// <param name="element">The element to index.</param>
public void IndexElement(Row row, ISchemaElement element)
{
this.elements.Add(String.Concat(row.TableDefinition.Name, ':', row.GetPrimaryKey(PrimaryKeyDelimiter)), element);
}
/// <summary>
/// Gets the element corresponding to the row it came from.
/// </summary>
/// <param name="row">The row corresponding to the element.</param>
/// <returns>The indexed element.</returns>
public ISchemaElement GetIndexedElement(Row row)
{
return this.GetIndexedElement(row.TableDefinition.Name, row.GetPrimaryKey(PrimaryKeyDelimiter));
}
/// <summary>
/// Unbind an MSI database file.
/// </summary>
/// <param name="databaseFile">The database file.</param>
/// <param name="database">The opened database.</param>
/// <param name="outputType">The type of output to create.</param>
/// <param name="exportBasePath">The path where files should be exported.</param>
/// <returns>The output representing the database.</returns>
private Output UnbindDatabase(string databaseFile, Database database, OutputType outputType, string exportBasePath)
{
string modularizationGuid = null;
Output output = new Output(SourceLineNumberCollection.FromFileName(databaseFile));
View validationView = null;
// set the output type
output.Type = outputType;
// get the codepage
database.Export("_ForceCodepage", this.TempFilesLocation, "_ForceCodepage.idt");
using (StreamReader sr = File.OpenText(Path.Combine(this.TempFilesLocation, "_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
using (SummaryInformation summaryInformation = new SummaryInformation(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 (database.TableExists("_Validation"))
{
validationView = database.OpenView("SELECT * FROM `_Validation` WHERE `Table` = ? AND `Column` = ?");
}
// get the normal tables
using (View tablesView = database.OpenExecuteView("SELECT * FROM _Tables"))
{
Record tableRecord;
while (null != (tableRecord = tablesView.Fetch()))
{
string tableName = tableRecord.GetString(1);
using (View tableView = database.OpenExecuteView(String.Format(CultureInfo.InvariantCulture, "SELECT * FROM `{0}`", tableName)))
{
Record rowRecord;
Table table;
TableDefinition tableDefinition;
if (this.tableDefinitions.Contains(tableName))
{
tableDefinition = this.tableDefinitions[tableName];
// TODO: verify table definitions
// - error for different column name or data type
// - warn for additional columns
// - need extra info for new columns in standard tables (MSI 4.0 changes)
}
else // custom table
{
TableDefinition customTableDefinition = new TableDefinition(tableName, false, false);
Hashtable customTablePrimaryKeys = new Hashtable();
Record customColumnNameRecord = tableView.GetColumnInfo(MsiInterop.MSICOLINFONAMES);
Record customColumnTypeRecord = tableView.GetColumnInfo(MsiInterop.MSICOLINFOTYPES);
int customColumnCount = customColumnNameRecord.GetFieldCount();
// index the primary keys
using (Record primaryKeysRecord = database.PrimaryKeys(tableName))
{
int primaryKeysFieldCount = primaryKeysRecord.GetFieldCount();
for (int i = 1; i <= primaryKeysFieldCount; i++)
{
customTablePrimaryKeys[primaryKeysRecord.GetString(i)] = null;
}
}
for (int i = 1; i <= customColumnCount; i++)
{
string columnName = customColumnNameRecord.GetString(i);
string idtType = customColumnTypeRecord.GetString(i);
ColumnType columnType;
int length;
bool nullable;
ColumnCategory columnCategory = ColumnCategory.Unknown;
ColumnModularizeType columnModularizeType = ColumnModularizeType.None;
bool primary = customTablePrimaryKeys.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)
{
Record validationRecord = new Record(2);
validationRecord.SetString(1, tableName);
validationRecord.SetString(2, columnName);
validationView.Execute(validationRecord);
validationRecord.Close();
if (null != (validationRecord = validationView.Fetch()))
{
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;
}
}
validationRecord.Close();
}
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)
{
columnModularizeType = ColumnModularizeType.Property;
}
else if (ColumnCategory.Identifier == columnCategory)
{
columnModularizeType = ColumnModularizeType.Column;
}
customTableDefinition.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 = customTableDefinition;
customColumnNameRecord.Close();
customColumnTypeRecord.Close();
}
table = new Table(null, tableDefinition);
while (null != (rowRecord = tableView.Fetch()))
{
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.IsNullable)
{
// 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:
if (row.Fields[i].Column.IsLocalizable)
{
row[i] = Convert.ToString(rowRecord.GetInteger(i + 1), CultureInfo.InvariantCulture);
}
else
{
row[i] = rowRecord.GetInteger(i + 1);
}
break;
case ColumnType.Object:
string sourceFile = "FILE NOT EXPORTED, USE THE dark.exe -x OPTION TO EXPORT BINARIES";
if (null != exportBasePath)
{
string relativeSourceFile = Path.Combine(tableName, row.GetPrimaryKey('.'));
sourceFile = Path.Combine(exportBasePath, relativeSourceFile);
// ensure the parent directory exists
System.IO.Directory.CreateDirectory(Path.Combine(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;
}
}
}
rowRecord.Close();
}
output.Tables.Add(table);
}
tableRecord.Close();
}
}
}
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;
}
}
}
return(output);
}
