public Package(BinaryReader reader)
: this()
{
header = new PackageHeader(reader);
nameTable = new NameTable(reader);
exportTable = new ExportTable(reader);
importTable = new ImportTable(reader);
}
public void PropertyCanReadStructRotatorValueTest()
{
string name = "StaticMeshActor2";
Export Exp = ExportTable.FindAll(n => n.NameTableRef == NameTable.IndexOf(name))?.First();
int PropertyOffset = 0x42 + Exp.SerialOffset + 28;
//Act
Property Prop = new Property(pf.Bytes, PropertyOffset);
Prop.SetStructType(StructType.Rotator);
//Assert
string Str = NameTable[Prop.NameTableRef];
Assert.AreEqual(Str, "Rotation");
Assert.IsTrue(Prop.Value is DataStructures.URotator);
Assert.AreEqual(Prop.Size, 15);
DataStructures.URotator ur = Prop.Value as DataStructures.URotator;
Assert.AreEqual(ur.Pitch, 0);
Assert.AreEqual(ur.Yaw, 2048);
Assert.AreEqual(ur.Roll, 0);
}
public void ExportTableIndexOperatorTest()
{
//Alloc
Export str;
ExportTable nt = new ExportTable(header, pf.Bytes);
//Act
try
{
for (int i = 0; i < nt.Count; i++)
{
str = nt[i];
}
}
//Assert
catch (Exception ex)
{
Assert.Fail(ex.ToString());
}
}
public void PropertyCanReadStructColorValueTest()
{
string name = "SpriteEmitter544";
Export Exp = ExportTable.FindAll(n => n.NameTableRef == NameTable.IndexOf(name))?.First();
int PropertyOffset = 0x0B + Exp.SerialOffset + 28;
//Act
Property Prop = new Property(pf.Bytes, PropertyOffset);
Prop.SetStructType(StructType.Color);
UColor Col = Prop.Value as UColor;
//Assert
Assert.IsTrue(Prop.Value is UColor);
Assert.AreEqual(Prop.Size, 7);
Assert.AreEqual(Prop.NameTableRef.Value, NameTable.IndexOf("Color"));
Assert.AreEqual((byte)255, Col.a);
Assert.AreEqual((byte)255, Col.b);
Assert.AreEqual((byte)255, Col.g);
Assert.AreEqual((byte)255, Col.r);
}
public void PropertyCanReadStructPointRegionValueTest()
{
string name = "StaticMeshActor1";
Export Exp = ExportTable.FindAll(n => n.NameTableRef == NameTable.IndexOf(name))?.First();
int PropertyOffset = 0x19 + Exp.SerialOffset + 28;
//Act
Property Prop = new Property(pf.Bytes, PropertyOffset);
Prop.SetStructType(StructType.PointRegion);
//Assert
string Str = NameTable[Prop.NameTableRef];
Assert.AreEqual(Str, "Region");
Assert.IsTrue(Prop.Value is DataStructures.UPointRegion);
Assert.AreEqual(Prop.Size, 17);
DataStructures.UPointRegion ur = Prop.Value as DataStructures.UPointRegion;
Assert.AreEqual(ur.iLeaf, 725);
Assert.AreEqual(ur.ZoneNumber, (byte)1);
Assert.AreEqual(ur.Zone.Value, 0x04);
}
private void btnSave_Click(object sender, EventArgs e)
{
//判斷勾選個數
if (GetSelectedFields().Count == 0)
{
FISCA.Presentation.Controls.MsgBox.Show("必須至少選擇一項匯出欄位!", "欄位空白", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
saveFileDialog1.Filter = "Excel (*.xls)|*.xls|所有檔案 (*.*)|*.*";
saveFileDialog1.FileName = "匯出班級基本資料";
if (saveFileDialog1.ShowDialog() == DialogResult.OK)
{
//??
IExportConnector ec = new ExportClassConnector();
foreach (ClassRecord info in Class.Instance.SelectedList)
{
ec.AddCondition(info.ID);
}
ec.SetSelectedFields(GetSelectedFields());
ExportTable table = ec.Export();
ExportOutput output = new ExportOutput();
output.SetSource(table);
output.Save(saveFileDialog1.FileName);
if (FISCA.Presentation.Controls.MsgBox.Show("檔案存檔完成，是否開啟該檔案", "是否開啟", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
try
{
Process.Start(saveFileDialog1.FileName);
}
catch (Exception ex)
{
FISCA.Presentation.Controls.MsgBox.Show("開啟檔案發生失敗:" + ex.Message, "錯誤", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
this.Close();
}
}
public void PropertyCanReadStructVectorValueTest()
{
string name = "SpriteEmitter544";
Export Exp = ExportTable.FindAll(n => n.NameTableRef == NameTable.IndexOf(name))?.First();
int PropertyOffset = 0x97 + Exp.SerialOffset + 28;
//Act
Property Prop = new Property(pf.Bytes, PropertyOffset);
Prop.SetStructType(StructType.Vector);
//Assert
string Str = NameTable[Prop.NameTableRef];
Assert.AreEqual(Str, "SpinCCWorCW");
Assert.IsTrue(Prop.Value is DataStructures.UVector);
Assert.AreEqual(Prop.Size, 16);
DataStructures.UVector uv = Prop.Value as DataStructures.UVector;
Assert.AreEqual(Prop.Type, PropertyType.StructProperty);
Assert.AreEqual(uv.X, 1.00f);
Assert.AreEqual(uv.Y, 0.50f);
Assert.AreEqual(uv.Z, 0.50f);
}
private void Import()
{
try
{
ExportTable et = SelectedExportTable;
if (et != null)
{
if (dlgOpenFile.ShowDialog() == DialogResult.OK)
{
using (WaitCursor wc = new WaitCursor())
{
Import(et, dlgOpenFile.FileName);
}
}
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
public void PropertyCanReadArrayValueTest()
{
string name = "SpriteEmitter544";
Export Exp = ExportTable.FindAll(n => n.NameTableRef == NameTable.IndexOf(name))?.First();
int PropertyOffset = 0 + Exp.SerialOffset + 28;
List <Property> Val;
//Act
Property Prop = new Property(pf.Bytes, PropertyOffset);
//Assert
string Str = NameTable[Prop.NameTableRef];
Assert.AreEqual(Str, "ColorScale");
Assert.IsTrue(Prop.Value is List <Property>);
Assert.AreEqual(Prop.Size, 33);
Assert.AreEqual(Prop.Type, PropertyType.ArrayProperty);
//Act more
Val = Prop.Value as List <Property>;
//Assert more
Assert.AreEqual(6, Val.Count());
}
public override ExportTable GetExportedTable(ExportMode mode)
{
var table = new ExportTable("Земельные участки")
{
Headers = new List <Header>
{
new Header("Район"),
new Header("Адрес"),
new Header("Площадь"),
new Header("Собств."),
new Header("Комментарий"),
new Header("Вариант"),
new Header("Цена т.р."),
new Header("В.", 100),
new Header("Риэлтор"),
}
};
var collection = GetCollectionForExport(mode);
foreach (var item in collection)
{
var plot = item as PlotViewModel;
var row = new List <string>
{
GetBaseDictionaryName(plot.District),
plot.Address,
plot.PlotSquareString,
GetBaseDictionaryName(plot.Ownership),
plot.Description,
GetBaseDictionaryName(plot.DealVariant),
plot.PriceString,
plot.HasVideo ? "В" : "",
plot.Realtor == null ? "" : plot.Realtor.Phone,
};
table.Data.Add(row);
}
return(table);
}
public static void Invoke(string exportedFunctionName, params object[] values)
{
var assembly = Assembly.GetCallingAssembly();
var exports = ExportTable.GetExports(assembly);
var export = exports[exportedFunctionName];
var result = export.Invoke(null, values);
if (QuietMode && (export.ReturnType.FullName == "System.Void"))
{
return;
}
PrintHeader(assembly);
Console.WriteLine(
"(invoke \"{1}\" {2}){0}" +
"-> {3}",
Environment.NewLine,
exportedFunctionName,
string.Join(" ", values),
result
);
}
public static void Invoke(string exportedFunctionName, params object[] values)
{
var assembly = Assembly.GetCallingAssembly();
var exports = ExportTable.GetExports(assembly);
var export = exports[exportedFunctionName];
object result;
try {
result = export.Invoke(null, values);
} catch (Exception exc) {
throw new Exception(string.Format("Invoke('{0}', ...) failed ", exportedFunctionName), exc);
}
if (QuietMode && (export.ReturnType.FullName == "System.Void"))
{
return;
}
PrintHeader(assembly);
if (export.ReturnType.Name != "Void")
{
Console.WriteLine(
"(invoke \"{1}\" {2}){0}" +
"-> {3}",
Environment.NewLine,
exportedFunctionName,
string.Join(" ", values),
result
);
}
else
{
Console.WriteLine(
"(invoke \"{0}\" {1})",
exportedFunctionName,
string.Join(" ", values)
);
}
}
public void MoveExportTableEnumeratorTest()
{
//Alloc
Export exp;
ExportTable et = new ExportTable(header, pf.Bytes);
try
{
//Act
ExportTableEnumerator <Export> ete = (ExportTableEnumerator <Export>)et.GetEnumerator();
while (ete.MoveNext())
{
exp = ((IEnumerator <Export>)ete).Current;
}
}
catch (Exception)
{
//Assert
Assert.Fail();
}
}
private void btnSave_Click(object sender, EventArgs e)
{
if (GetSelectedFields().Count == 0)
{
FISCA.Presentation.Controls.MsgBox.Show("必須至少選擇一項匯出欄位!", "欄位空白", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
// 2017/8/22 穎驊依據高雄小組專案 [03-05][04+] EXCEL匯入格式可否修正為xlsx也可匯入？ 更改為新版 Aspose.Cells_201402 寫法，支援.xlsx 匯出
saveFileDialog1.Filter = "Excel (*.xlsx)|*.xlsx|Excel (*.xls)|*.xls|所有檔案 (*.*)|*.*";
saveFileDialog1.FileName = "匯出課程基本資料";
if (saveFileDialog1.ShowDialog() == DialogResult.OK)
{
IExportConnector ec = new ExportCourseConnector();
foreach (CourseRecord course in Course.Instance.SelectedList)
{
ec.AddCondition(course.ID);
}
ec.SetSelectedFields(GetSelectedFields());
ExportTable table = ec.Export();
ExportOutput output = new ExportOutput();
output.SetSource(table);
output.Save(saveFileDialog1.FileName);
if (FISCA.Presentation.Controls.MsgBox.Show("檔案存檔完成，是否開啟該檔案", "是否開啟", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
try
{
Process.Start(saveFileDialog1.FileName);
}
catch (Exception ex)
{
FISCA.Presentation.Controls.MsgBox.Show("開啟檔案發生失敗:" + ex.Message, "錯誤", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
this.Close();
}
}
public override int GetBuilderSize()
{
if (CompressedChunks.Any())
{
throw new NotSupportedException("Cannot rebuild compressed files. Yet.");
}
if (Signature == Signatures.EncryptedSignature)
{
throw new NotSupportedException("Cannot rebuild fully encrypted files. Yet.");
}
BuilderSize = sizeof(uint) * 7
+ sizeof(ushort) * 2
+ sizeof(int) * 10
+ Group.GetBuilderSize()
+ Guid.Length
+ GenerationTable.Sum(gen => gen.GetBuilderSize());
BuilderNameTableOffset = BuilderSize;
BuilderSize += NameTable.Sum(name => name.GetBuilderSize());
BuilderImportTableOffset = BuilderSize;
BuilderSize += ImportTable.Sum(import => import.GetBuilderSize());
BuilderExportTableOffset = BuilderSize;
BuilderSize += ExportTable.Sum(export => export.GetBuilderSize());
BuilderDependsTableOffset = BuilderSize;
BuilderSize += DependsTable.Length;
ExportTable.Aggregate(BuilderSize, (current, export) => current + export.GetObjectSize(current));
return(BuilderSize);
}
public void PropertyCanReadStructScaleValueTest()
{
string name = "Brush192";
Export Exp = ExportTable.FindAll(n => n.NameTableRef == NameTable.IndexOf(name))?.First();
int PropertyOffset = 0x13 + Exp.SerialOffset + 28;
//Act
Property Prop = new Property(pf.Bytes, PropertyOffset);
Prop.SetStructType(StructType.Scale);
//Assert
string Str = NameTable[Prop.NameTableRef];
Assert.AreEqual(Str, "MainScale");
Assert.IsTrue(Prop.Value is DataStructures.UScale);
Assert.AreEqual(Prop.Size, 30);
DataStructures.UScale us = Prop.Value as DataStructures.UScale;
Assert.AreEqual(us.x, 1.0f);
Assert.AreEqual(us.y, 1.0f);
Assert.AreEqual(us.z, 1.0f);
Assert.AreEqual(us.sheerrate, 0.0f);
Assert.AreEqual(us.sheeraxis, 5);
}
static IntPtr CorBindToRuntimeExAddress()
{
ProcModule.ModuleInfo targetmscoree = null;
ProcModule.ModuleInfo[] modules = ProcModule.GetModuleInfos((int)processid);
if (modules != null && modules.Length > 0)
{
for (int i = 0; i < modules.Length; i++)
{
if (modules[i].baseName.ToLower().Contains("mscoree.dll"))
{
targetmscoree = modules[i];
break;
}
}
}
if (targetmscoree == null || targetmscoree.baseOfDll == IntPtr.Zero)
{
return(IntPtr.Zero);
}
IntPtr CLRCreateInstanceAddress = IntPtr.Zero;
if (hprocess != IntPtr.Zero)
{
int CLRCreateInstancerva = ExportTable.ProcGetExpAddress
(hprocess, targetmscoree.baseOfDll, "CorBindToRuntimeEx");
if (CLRCreateInstancerva == 0)
{
return(IntPtr.Zero);
}
return((IntPtr)((long)targetmscoree.baseOfDll + (long)CLRCreateInstancerva));
}
return(IntPtr.Zero);
}
public void ResetExportTableEnumeratorTest()
{
//Alloc
ExportTable et = new ExportTable(header, pf.Bytes);
try
{
//Act
ExportTableEnumerator <Export> ete = (ExportTableEnumerator <Export>)et.GetEnumerator();
ete.MoveNext();;
Export First = (Export)ete.Current;
ete.MoveNext();
Export Second = (Export)ete.Current;
Assert.IsTrue(First.SerialOffset.Value != Second.SerialOffset.Value);
}
catch (Exception)
{
//Assert
Assert.Fail();
}
}
public void SetSource(ExportTable dataSource)
{
XmlDocument doc = new XmlDocument();
XmlElement root = doc.CreateElement("Root");
doc.AppendChild(root);
foreach (ExportRow row in dataSource.Rows)
{
XmlElement rowElement = doc.CreateElement("Row");
rowElement.SetAttribute("RowIndex", row.Index.ToString());
root.AppendChild(rowElement);
foreach (ExportField field in dataSource.Columns)
{
XmlElement column = doc.CreateElement("Column");
rowElement.AppendChild(column);
column.SetAttribute("DisplayName", field.DisplayText);
column.InnerText = row.Cells[field.ColumnIndex].Value;
}
}
_doc = doc;
}
private static void RE_GetExportByNameAndGroup()
{
Index NameRef1 = NameTable.IndexOf("MeshEmitter0");
Export GroupRef1 = ExportTable
.Where(E => E.NameTableRef == NameTable.IndexOf("ab_bleeding"))
?.First();
int Ind = ExportTable.IndexOf(GroupRef1);
var Exp1 = ExportTable
.Where(E => E.NameTableRef == NameRef1)
?.Where(E => E.Group == Ind)
.ToArray();
//?.First();
;
/*int RealOffset1 = 0x044C32;
* Console.WriteLine("{0:X} - {1:X} = {2:X}",
* RealOffset1,
* (int)Exp1.SerialOffset,
* RealOffset1 - Exp1.SerialOffset);*/
}
public void Deserialize(FArchive reader)
{
reader.Read(out _summary);
if (!IsValid)
{
return;
}
reader.Seek(_summary.NameOffset);
_nameMap = new NameTable(_summary.NameCount);
_nameMap.Deserialize(reader);
reader.Seek(_summary.ImportOffset);
_imports = new ImportTable(_summary.ImportCount);
_imports.Deserialize(reader);
reader.Seek(_summary.ExportOffset);
_exports = new ExportTable(_summary.ExportCount);
_exports.Deserialize(reader);
reader.Seek(_summary.SoftPackageReferencesOffset);
reader.Read(out _stringAssetReferences, _summary.SoftPackageReferencesCount);
reader.Seek(_summary.GatherableTextDataOffset);
reader.Read(out _gatherableTextDataMap, _summary.GatherableTextDataCount);
foreach (var imp in _imports.Items)
{
imp.Fix(reader);
}
foreach (var exp in _exports.Items)
{
exp.Fix(reader);
}
return;
}
public FArchive Serialize(FArchive archive)
{
archive.Read(ref _summary);
if (!IsValid)
{
return(archive);
}
archive.Seek(_summary.NameOffset);
_nameMap = new NameTable(_summary.NameCount);
_nameMap.Serialize(archive);
archive.Seek(_summary.ImportOffset);
_imports = new ImportTable(_summary.ImportCount);
_imports.Serialize(archive);
archive.Seek(_summary.ExportOffset);
_exports = new ExportTable(_summary.ExportCount);
_exports.Serialize(archive);
archive.Seek(_summary.SoftPackageReferencesOffset);
archive.Read(ref _stringAssetReferences, _summary.SoftPackageReferencesCount);
archive.Seek(_summary.GatherableTextDataOffset);
archive.Read(ref _gatherableTextDataMap, _summary.GatherableTextDataCount);
foreach (var imp in _imports.Items)
{
imp.Fix(archive);
}
foreach (var exp in _exports.Items)
{
exp.Fix(archive);
}
return(archive);
}
public void _0003_DataGrid_To_ExportTable()
{
var dgv = TestDataGridView();
var table = new ExportTable();
foreach (DataGridViewColumn dgvColumn in dgv.Columns)
{
var exportColumn = new ExportColumnItem()
{
Name = dgv.Name,
HeaderText = dgvColumn.HeaderText,
DisplayIndex = dgvColumn.DisplayIndex,
Visible = dgvColumn.Visible,
};
table.Columns.Add(exportColumn);
}
foreach (DataGridViewRow dgvRow in dgv.Rows)
{
var newRow = new ExportRowItem();
table.Rows.Add(newRow);
for (var i = 0; i < dgvRow.Cells.Count; i++)
{
newRow.Cells[i].Value = dgvRow.Cells[i].Value.ToString();
}
}
foreach (var item in table.Rows)
{
Debug.WriteLine(item);
}
Assert.AreEqual(3, table.Columns.Count);
Assert.AreEqual(4, table.Rows.Count);
}
private void CreateKepwareCSVFromDataTable(ExportTable.KepwareExportTableDataTable exportTable)
{
StringBuilder sb = new StringBuilder();
IEnumerable<string> columnNames = exportTable.Columns.Cast<DataColumn>().
Select(column => column.ColumnName.Replace("_", " "));
sb.AppendLine(string.Join(",", columnNames));
foreach (DataRow row in exportTable.Rows)
{
IEnumerable<string> fields = row.ItemArray.Select(field => field.ToString());
sb.AppendLine(string.Join(",", fields));
}
File.WriteAllText(KepwareExportFilePath, sb.ToString());
}
private void CreateExportAllBlocksCSVFromDataTable(ExportTable.AllBlocksExportTableDataTable exportTable)
{
StringBuilder sb = new StringBuilder();
IEnumerable<string> columnNames = exportTable.Columns.Cast<DataColumn>().
Select(column => column.ColumnName.Replace("_", " "));
sb.AppendLine(string.Join("\t", columnNames));
// Append all rows
var rows = from ds in exportTable orderby ds.Path select ds;
foreach (var row in rows)
{
IEnumerable<string> fields = row.ItemArray.Select(field => field.ToString());
sb.AppendLine(string.Join("\t", fields));
}
byte[] bom = new byte[3];
bom[0] = 0xEF;
bom[1] = 0xBB;
bom[2] = 0xBF;
File.WriteAllBytes(AllBlocksExportFilePath, bom);
File.WriteAllText(AllBlocksExportFilePath, sb.ToString());
}
private void AddSymbolsToKepwareExportTable(ExportTable.KepwareExportTableDataTable exportTable)
{
foreach (KeyValuePair<String, Tag> child in Symbols)
{
if (!child.Value.Address.StartsWith("M"))
continue;
ExportTable.KepwareExportTableRow newRow = exportTable.NewKepwareExportTableRow();
newRow.Respect_Data_Type = "1";
newRow.Client_Access = "R/W";
newRow.Scan_Rate = "100";
newRow.Address = child.Value.Address;
newRow.Tag_Name = child.Key;
newRow.Description = child.Value.Name;
//newRow.Tag_Name = ParentPath + "." + child.Name;
//newRow.Description = child.Comment;
//int BitAddress = child.BlockAddress.BitAddress;
//int ByteAddress = child.BlockAddress.ByteAddress + ByteAdder;
switch (child.Value.Address.Substring(0, 2).ToUpper())
{
case "M ":
newRow.Data_Type = "Boolean";
exportTable.AddKepwareExportTableRow(newRow);
break;
case "MB":
newRow.Data_Type = "Byte";
exportTable.AddKepwareExportTableRow(newRow);
break;
case "MD":
newRow.Data_Type = "FLOAT";
exportTable.AddKepwareExportTableRow(newRow);
break;
case "MW":
newRow.Data_Type = "Short";
exportTable.AddKepwareExportTableRow(newRow);
break;
default:
break;
}
}
}
/* method that get the tables from ExportTable */
private void GetTables(ExportTable table, int index)
{
dt[index] = table.GetTable();
}
public ExportTableDataSource(ExportTable exportTable, Package pkg)
: base(exportTable.items.Count)
{
dataGetters = new PackageTableDataGetter[] {
new PackageTableDataGetter { column = "#",
sort = (i => { return exportTable[i].index; }),
data = (i => { return exportTable[i].index.ToString(); }),
},
new PackageTableDataGetter { column = "offset",
sort = (i => { return exportTable[i].offset; }),
data = (i => { return String.Format("{0:X8}", exportTable[i].offset); }),
},
new PackageTableDataGetter { column = "# of",
sort = (i => { return exportTable[i].ObjectName; }),
data = (i => { return exportTable[i].ObjectName.ToString(); }),
},
new PackageTableDataGetter { column = "ObjectName",
sort = (i => { return pkg.GetName(exportTable[i].ObjectName); }),
data = (i => { return pkg.GetName(exportTable[i].ObjectName); })
},
new PackageTableDataGetter { column = "# of",
sort = (i => { return exportTable[i].Class; }),
data = (i => { return exportTable[i].Class.ToString(); }),
},
new PackageTableDataGetter { column = "Class",
sort = (i => { return pkg.GetObjNameRec(exportTable[i].Class); }),
data = (i => { return pkg.GetObjNameRec(exportTable[i].Class); }),
},
new PackageTableDataGetter { column = "# of",
sort = (i => { return exportTable[i].Super; }),
data = (i => { return exportTable[i].Super.ToString(); }),
},
new PackageTableDataGetter { column = "Super",
sort = (i => { return pkg.GetObjNameRec(exportTable[i].Super); }),
data = (i => { return pkg.GetObjNameRec(exportTable[i].Super); })
},
new PackageTableDataGetter { column = "# of",
sort = (i => { return exportTable[i].Package; }),
data = (i => { return exportTable[i].Package.ToString(); }),
},
new PackageTableDataGetter { column = "Package",
sort = (i => { return pkg.GetObjNameRec(exportTable[i].Package); }),
data = (i => { return pkg.GetObjNameRec(exportTable[i].Package); }),
},
new PackageTableDataGetter { column = "SerialSize",
sort = (i => { return exportTable[i].SerialSize; }),
data = (i => { return exportTable[i].SerialSize.ToString(); }),
},
new PackageTableDataGetter { column = "SerialOffset",
sort = (i => { return exportTable[i].SerialOffset; }),
data = (i => { return String.Format("{0:X8}", exportTable[i].SerialOffset); }),
},
new PackageTableDataGetter { column = "ObjectFlags",
sort = (i => { return exportTable[i].ObjectFlags; }),
data = (i => { return exportTable[i].ObjectFlags.ToString(); }),
},
};
}
public virtual void VisitExportTable(ExportTable et)
{
}
//
// Someone must arrange to call this from *within* the
// Protection Domain for us to have an opportunity to finish
// initializing.
//
internal unsafe void InitHook()
{
// If paging is disabled then just return immediately
if (!MemoryManager.UseAddressTranslation)
{
return;
}
DebugStub.Assert(AddressSpace.CurrentAddressSpace == this.AddressSpace);
if (this.initialized)
{
// Someone else has already set up the space
return;
}
bool iflag = initSpin.Lock();
try {
if (this.initialized)
{
// Someone else snuck in and initialized
return;
}
//
// We're first into this space, so set it up.
//
#if VERBOSE
DebugStub.WriteLine("Setting up protection domain \"{0}\"",
__arglist(this.name));
#endif
userRange = new VirtualMemoryRange(VMManager.UserHeapBase,
VMManager.UserHeapLimit,
this);
#if PAGING
if (kernelMode)
{
// This will be a ring-0, trusted domain, so just
// point the userSharedHeap at the kernel's comm heap.
userSharedHeap = SharedHeap.KernelSharedHeap;
this.initialized = true;
}
else
{
// Create a new shared heap that lives in
// user-land.
userSharedHeap = new SharedHeap(this, userRange);
#if VERBOSE
DebugStub.WriteLine(" ...Created a shared heap");
#endif
//
// N.B.: this is kind of tricky. Loading an
// executable image involves allocating memory,
// which goes through this object. So, before
// attempting the load, mark ourselves as initialized.
//
// ---- DON'T PUT GENUINE INITIALIZATION
// CODE BELOW HERE! ---------
this.initialized = true;
// Load our own, protection-domain-private copy of the
// ABI stubs. These will get shared by all apps in
// this domain.
IoMemory syscallsMemory = Binder.LoadRawImage("/init", "syscalls.dll");
IoMemory loadedMemory;
// Load the stubs library into the user range, but make
// the kernel process the logical owner. This seems like
// the only sensible approach since the stubs do not
// belong to any particular process but must be in the
// user range of memory.
// N.B.: RE-ENTERS this object!
ring3AbiImage = PEImage.Load(Process.kernelProcess, syscallsMemory,
out loadedMemory,
false, // isForMp
false // inKernelSpace
);
ring3AbiExports = ring3AbiImage.GetExportTable(loadedMemory);
#if VERBOSE
DebugStub.WriteLine(" ...Loaded ring-3 ABI stubs");
#endif
}
#else // PAGING
this.initialized = true;
#endif // PAGING
}
finally {
DebugStub.Assert(this.initialized);
initSpin.Unlock(iflag);
}
}
public virtual void VisitExportTable (ExportTable et)
{
}
/// <summary>
/// Export data from source DataSet to browser's response.
/// </summary>
/// <param name="datasetToExport">Source DataSet to export data from.</param>
/// <param name="tablesToExport">List of DataTables inside of DataSet to export data from.</param>
/// <param name="outputFormat">Output export format.</param>
/// <param name="exportHeaders">Specifies if we need to export column names.</param>
/// <param name="exportIntoStream">Specifies if we want to export data into some stream first.</param>
/// <param name="xportToolsDemo">Exporter class instance.</param>
/// <remarks></remarks>
private static void ExportDataSetIntoResponse(DataSet datasetToExport, ExportTable[] tablesToExport,
xpOutputFormat outputFormat, bool exportHeaders, bool exportIntoStream, DS2XL xportToolsDemo, string strFileName)
{
//string tempExportFileName;
//System.IO.FileInfo outputFile = null;
//MemoryStream exportStream = null;
/*
//Generate temporary file name.
tempExportFileName = xPortDemoHelper.GenerateTempFileName(outputFormat);
if (outputFormat == xpOutputFormat.HTML)
{
Response.ContentType = @"text/html";
}
else
{
Response.ContentType = @"application/vnd.ms-excel";
}
Response.AddHeader("Content-Disposition", "attachment; filename=" + tempExportFileName);
*/
//If you need to export data from all DataTables then use overloaded Export/ExportToStream
//method that does not require tablesToExport parameter. For example,
//xportTools.Export(products, "Products", outputFormat, True, chkHeaders.Checked)
/*
if (exportIntoStream)
{
//For the demo purposes we export into memory stream, but it could be any type of stream.
//When Export method executed, make sure that DataTable's TableName property is not blank
//and set to any valid DataTable name. If DataTable does not have name, 'Incorrect table name'
//exception will be thrown
exportStream = (MemoryStream)xportToolsDemo.ExportToStream(datasetToExport,
tablesToExport, outputFormat, exportHeaders);
//Do something with stream here. For the demo purposes we store stream content into the response output
Response.OutputStream.Write(exportStream.ToArray(), 0, (int)exportStream.Length);
exportStream.Close();
exportStream = null;
}
else
{
*/
//Export data into temporary file
xportToolsDemo.Export(datasetToExport, tablesToExport, strFileName, outputFormat, true, exportHeaders);
//Output file into client's response
//outputFile = new System.IO.FileInfo(strFileName);
/*
if (outputFile.Exists && Response.IsClientConnected)
{
Response.WriteFile(tempExportFileName);
}
*/
//outputFile = null;
//}
//Response.Flush();
//We need to close response to make sure that generated HTML markup from our
//aspx page does not attach to output Excel file.
//Response.Close();
}
public Win32Exe() : base()
{
filename = null;
dosHeader = null;
//optional header fields
magicNum = 0;
majorLinkerVersion = 0;
minorLinkerVersion = 0;
sizeOfCode = 0;
sizeOfInitializedData = 0;
sizeOfUninitializedData = 0;
addressOfEntryPoint = 0;
baseOfCode = 0;
baseOfData = 0;
imageBase = 0;
sectionAlignment = 0;
fileAlignment = 0;
majorOSVersion = 0;
minorOSVersion = 0;
majorImageVersion = 0;
minorImageVersion = 0;
majorSubsystemVersion = 0;
minorSubsystemVersion = 0;
win32VersionValue = 0;
sizeOfImage = 0;
sizeOfHeaders = 0;
checksum = 0;
subsystem = 0;
dLLCharacteristics = 0;
sizeOfStackReserve = 0;
sizeOfStackCommit = 0;
sizeOfHeapReserve = 0;
sizeOfHeapCommit = 0;
loaderFlags = 0;
numberOfRvaAndSizes = 0;
//data directory
dExportTable = null;
dImportTable = null;
dResourceTable = null;
exceptionTable = null;
certificatesTable = null;
baseRelocationTable = null;
debugTable = null;
architecture = null;
globalPtr = null;
threadLocalStorageTable = null;
loadConfigurationTable = null;
boundImportTable = null;
importAddressTable = null;
delayImportDescriptor = null;
CLRRuntimeHeader = null;
reserved = null;
//standard sections
exportTable = null;
importTable = null;
resourceTable = null;
}
private void ExportToExcelInner(List <Header> headers, List <List <string> > data)
{
var table = new ExportTable("", headers, data);
ExcelProvider.Generate(table);
}
private void CreateWinCCFlexDigitalAlarmsCSVFromDataTable(ExportTable.WinCCFlexDigitalAlarmsExportTableDataTable exportTable)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine(@"// WinCC flexible 2008 SP3 Advanced V 1.4.0.0 (1.16.16)");
sb.AppendLine(@"// Automatically generated alarm export file.");
sb.AppendLine(@"// " + DateTime.Now.ToString("M/d/yyyy h:m:s tt"));
sb.AppendLine(@"// @V1.0.0");
sb.AppendLine(@"");
//sb.AppendLine(@"//Alarm type,Alarm number,Alarm class,Trigger tag,Trigger bit number,Acknowledgment HMI tag,Acknowledgment HMI tag bit number,Acknowledgment PLC tag,Acknowledgment PLC tag bit number,Alarm group,Reported,Text[en-US],Field info[01],Infotext[en-US]");
IEnumerable<string> columnNames = exportTable.Columns.Cast<DataColumn>().
Select(column => column.ColumnName.Replace("_", " "));
sb.AppendLine(@"//" + string.Join("\t", columnNames));
sb.AppendLine(@"");
// Append all rows
foreach (DataRow row in exportTable.Rows)
{
IEnumerable<string> fields = row.ItemArray.Select(field => field.ToString());
sb.AppendLine(string.Join("\t", fields));
}
File.WriteAllText(WinCCFlexDigitalAlarmsExportFilePath, sb.ToString());
}
public static ExportTable GetExports(Assembly assembly)
{
ExportTable result;
if (!Cache.TryGetValue(assembly, out result))
Cache.Add(assembly, result = new ExportTable(assembly));
return result;
}
private void AddChildrenExportAllBlocksExportTable(ExportTable.AllBlocksExportTableDataTable exportTable, Dictionary<String, Block> AllBlocks)
{
foreach (string key in AllBlocks.Keys)
{
Block blk = AllBlocks[key];
// Fill block parameters
if (blk.Name.ToLower().StartsWith("db"))
{
S7DataBlock lblk = (S7DataBlock)blk.BlockContents;
ExportTable.AllBlocksExportTableRow newRow = exportTable.NewAllBlocksExportTableRow();
newRow.Number = "\"" + blk.Name + "\"";
newRow.Name = "\"" + blk.SymbolicName + "\"";
newRow.Path = "\"" + key + "\"";
newRow.Type = "\"" + "DB" + "\"";
newRow.Language = "\"" + "STL" + "\"";
newRow.Comment = "\"";
if (lblk.Title != null && lblk.Title != "")
{
newRow.Comment = "\"" + ClearString(lblk.Title) + "\"";
}
newRow.Comment = newRow.Comment + "\"";
newRow.Size = "\"" + blk.Size.ToString() + "\"";
if (lblk.Version != null)
{
newRow.Version = "\"" + lblk.Version + "\"";
}
else
{
newRow.Version = "\"0.0\"";
}
newRow.LastModified = "\"" + blk.Modified.ToString("yyyy-MM-dd HH:mm:ss") + "\"";
exportTable.AddAllBlocksExportTableRow(newRow);
}
else if ( blk.Name.ToLower().StartsWith("fb") || blk.Name.ToLower().StartsWith("fc") || blk.Name.ToLower().StartsWith("ob") )
{
S7FunctionBlock lblk = (S7FunctionBlock)blk.BlockContents;
ExportTable.AllBlocksExportTableRow newRow = exportTable.NewAllBlocksExportTableRow();
newRow.Number = "\"" + blk.Name + "\"";
newRow.Name = "\"" + blk.SymbolicName + "\"";
newRow.Path = "\"" + key + "\"";
newRow.Type = "\"" + lblk.BlockType.ToString() + "\"";
newRow.Language = "\"" + lblk.BlockLanguage.ToString() + "\"";
newRow.Comment = "\"";
if (lblk.Title != null && lblk.Title != "")
{
newRow.Comment = newRow.Comment + ClearString(lblk.Title);
}
if (lblk.Description != null && lblk.Description != "")
{
newRow.Comment = newRow.Comment + ". " + ClearString(lblk.Description);
}
newRow.Comment = newRow.Comment + "\"";
newRow.Size = "\"" + blk.Size + "\"";
if (lblk.Version != null)
{
newRow.Version = "\"" + lblk.Version + "\"";
}
else
{
newRow.Version = "\"0.0\"";
}
newRow.LastModified = "\"" + blk.Modified.ToString("yyyy-MM-dd HH:mm:ss") + "\"";
exportTable.AddAllBlocksExportTableRow(newRow);
}
}
}
public void SetSource(ExportTable source)
{
Workbook book = new Workbook();
Worksheet sheet = book.Worksheets[0];
foreach (ExportField field in source.Columns)
{
Cell wcell = sheet.Cells[0, field.ColumnIndex];
wcell.PutValue(field.DisplayText);
}
foreach (ExportRow row in source.Rows)
{
foreach (ExportField field in source.Columns)
{
Cell wcell = sheet.Cells[row.Index + 1, field.ColumnIndex];
ExportCell ecell = row.Cells[field.ColumnIndex];
string value = ecell.Value;
IConverter converter = ConverterFactory.GetInstance(field.Converter);
value = converter.Convert(value);
IDataType dataType = DataTypeFactory.GetInstance(field.DataType);
dataType.SetValue(value);
if (!dataType.IsValidDataType)
{
wcell.PutValue(value, false);
}
else
{
switch (field.DataType.ToLower())
{
case "integer":
//wcell.PutValue(int.Parse(value));
wcell.PutValue(value, true);
break;
case "double":
//wcell.PutValue(double.Parse(value));
wcell.PutValue(value, true);
break;
case "datetime":
//int styleIndex = book.Styles.Add();
//Style style = book.Styles[styleIndex];
//style.Number = 14;
//style.Custom = "yyyy/MM/dd;@";
//wcell.Style.Copy(style);
DateTime dt = Convert.ToDateTime(dataType.GetTypeValue());
wcell.PutValue(dt.ToShortDateString(), false);
//wcell.PutValue(DateTime.Parse(value));
break;
case "object":
wcell.PutValue((object)value);
break;
default:
wcell.PutValue(value, false);
break;
}
}
}
}
_book = book;
}
private void AddChildrenToAlarmworxExportTable(ExportTable.AlarmWorxExportTableDataTable exportTable, List<S7DataRow> Children, string strCommentPath)
{
foreach (S7DataRow child in Children)
{
if (!child.IsArray)
{
ExportTable.AlarmWorxExportTableRow newRow = exportTable.NewAlarmWorxExportTableRow();
switch (child.DataType)
{
case S7DataRowType.BOOL:
newRow.LocationPath = "\"" + @"\\Alarm Configurations\" + SelectedAlarmFolder + "\"";
newRow.Name = "\"" + SelectedAlarmFolder + "." + child.StructuredName + "\"";
newRow.Description = "\"" + child.Comment + "\"";
newRow.LastModified = DateTime.Now;
newRow.Input1 = "\"" + SelectedOPCServer + "." + CurrentBlock.Value.SymbolicName + "." + child.StructuredName + "\"";
newRow.BaseText = "\"" + strCommentPath.Trim() + " " + child.Comment.Trim() + "\""; // Message text
newRow.DIG_MsgText = " "; // Prevents 'Digital Alarm' text at the end of each message
exportTable.AddAlarmWorxExportTableRow(newRow);
break;
case S7DataRowType.UDT:
case S7DataRowType.STRUCT:
// Build comments path string, separate each level by the space
AddChildrenToAlarmworxExportTable(exportTable, child.Children, strCommentPath.Trim() + " " + child.Comment.Trim());
break;
default:
break;
}
}
}
}
private void AddChildrenToKepwareExportTable(ExportTable.KepwareExportTableDataTable exportTable, List<S7DataRow> Children, String ParentPath, Block blk, int ByteAdder = 0)
{
foreach (S7DataRow child in Children)
{
if (!child.IsArray)
{
ExportTable.KepwareExportTableRow newRow = exportTable.NewKepwareExportTableRow();
newRow.Respect_Data_Type = "1";
newRow.Client_Access = "R/W";
newRow.Scan_Rate = "100";
newRow.Address = child.BlockAddress.ToString();
newRow.Tag_Name = ParentPath + "." + child.Name;
newRow.Description = child.Comment;
int BitAddress = child.BlockAddress.BitAddress;
int ByteAddress = child.BlockAddress.ByteAddress + ByteAdder;
switch (child.DataType)
{
case S7DataRowType.BOOL:
newRow.Data_Type = "Boolean";
newRow.Address = "DB" + blk.BlockContents.BlockNumber + ".DBX" + ByteAddress + "." + BitAddress;
exportTable.AddKepwareExportTableRow(newRow);
break;
case S7DataRowType.BYTE:
newRow.Data_Type = "Byte";
newRow.Address = "DB" + blk.BlockContents.BlockNumber + ".DBB" + ByteAddress;
exportTable.AddKepwareExportTableRow(newRow);
break;
case S7DataRowType.DINT:
case S7DataRowType.DWORD:
case S7DataRowType.TIME:
newRow.Data_Type = "DWord";
newRow.Address = "DB" + blk.BlockContents.BlockNumber + ".DBD" + ByteAddress;
exportTable.AddKepwareExportTableRow(newRow);
break;
case S7DataRowType.WORD:
newRow.Data_Type = "Word";
newRow.Address = "DB" + blk.BlockContents.BlockNumber + ".DBW" + ByteAddress;
exportTable.AddKepwareExportTableRow(newRow);
break;
case S7DataRowType.INT:
newRow.Data_Type = "Short";
newRow.Address = "DB" + blk.BlockContents.BlockNumber + ".DBW" + ByteAddress;
exportTable.AddKepwareExportTableRow(newRow);
break;
case S7DataRowType.REAL:
newRow.Data_Type = "FLOAT";
newRow.Address = "DB" + blk.BlockContents.BlockNumber + ".DBD" + ByteAddress;
exportTable.AddKepwareExportTableRow(newRow);
break;
case S7DataRowType.STRING:
newRow.Data_Type = "String";
newRow.Address = "DB" + blk.BlockContents.BlockNumber + ".String" + ByteAddress + "." + (child.ByteLength - 2);
exportTable.AddKepwareExportTableRow(newRow);
break;
case S7DataRowType.FB:
case S7DataRowType.BLOCK_FB:
AddChildrenToKepwareExportTable(exportTable, child.Children, newRow.Tag_Name, blk, ByteAdder);
break;
case S7DataRowType.UDT:
case S7DataRowType.STRUCT:
AddChildrenToKepwareExportTable(exportTable, child.Children, newRow.Tag_Name, blk, ByteAdder);
break;
}
}
else //IsArray = true
{
List<S7DataRow> arrayList = new List<S7DataRow>();
int ArrayBitAdder = 0;
int ArrayByteAdder = 0;
for (int i=child.ArrayStart.First();i <= child.ArrayStop.Last();i++)
{
ExportTable.KepwareExportTableRow newRow = exportTable.NewKepwareExportTableRow();
newRow.Respect_Data_Type = "1";
newRow.Client_Access = "R/W";
newRow.Scan_Rate = "100";
newRow.Address = child.BlockAddress.ToString();
newRow.Tag_Name = ParentPath + "." + child.Name + "[" + i + "]";
newRow.Description = child.Comment;
int BitAddress = child.BlockAddress.BitAddress + ArrayBitAdder;
int ByteAddress = child.BlockAddress.ByteAddress + ByteAdder + ArrayByteAdder + (i - child.ArrayStart.First()) * (child.ByteLength / (child.ArrayStop.First() - child.ArrayStart.First() + 1));
switch (child.DataType)
{
case S7DataRowType.BOOL:
newRow.Data_Type = "Boolean";
newRow.Address = "DB" + blk.BlockContents.BlockNumber + ".DBX" + ByteAddress + "." + BitAddress;
exportTable.AddKepwareExportTableRow(newRow);
ArrayBitAdder++;
if (ArrayBitAdder == 8)
{
ArrayBitAdder = 0;
ArrayByteAdder++;
}
break;
case S7DataRowType.BYTE:
newRow.Data_Type = "Byte";
newRow.Address = "DB" + blk.BlockContents.BlockNumber + ".DBB" + ByteAddress;
exportTable.AddKepwareExportTableRow(newRow);
break;
case S7DataRowType.DINT:
case S7DataRowType.DWORD:
case S7DataRowType.TIME:
newRow.Data_Type = "DWord";
newRow.Address = "DB" + blk.BlockContents.BlockNumber + ".DBD" + ByteAddress;
exportTable.AddKepwareExportTableRow(newRow);
break;
case S7DataRowType.WORD:
newRow.Data_Type = "Word";
newRow.Address = "DB" + blk.BlockContents.BlockNumber + ".DBW" + ByteAddress;
exportTable.AddKepwareExportTableRow(newRow);
break;
case S7DataRowType.INT:
newRow.Data_Type = "Short";
newRow.Address = "DB" + blk.BlockContents.BlockNumber + ".DBW" + ByteAddress;
exportTable.AddKepwareExportTableRow(newRow);
break;
case S7DataRowType.REAL:
newRow.Data_Type = "FLOAT";
newRow.Address = "DB" + blk.BlockContents.BlockNumber + ".DBD" + ByteAddress;
exportTable.AddKepwareExportTableRow(newRow);
break;
case S7DataRowType.STRING:
newRow.Data_Type = "String";
newRow.Address = "DB" + blk.BlockContents.BlockNumber + ".String" + ByteAddress + "." + (child.ByteLength - 2);
exportTable.AddKepwareExportTableRow(newRow);
break;
case S7DataRowType.UDT:
case S7DataRowType.FB:
case S7DataRowType.BLOCK_FB:
case S7DataRowType.STRUCT:
AddChildrenToKepwareExportTable(exportTable, child.Children, ParentPath + "." + child.Name + "[" + i + "]", blk, (i - child.ArrayStart.First()) * (child.ByteLength / (child.ArrayStop.First() - child.ArrayStart.First() + 1)) + ByteAdder);
break;
}
}
}
}
}
private void AddChildrenWinCCFlexDigitalAlarmsExportTable(ExportTable.WinCCFlexDigitalAlarmsExportTableDataTable exportTable, List<S7DataRow> Children, string strCommentPath)
{
foreach (S7DataRow child in Children)
{
if (!child.IsArray)
{
ExportTable.WinCCFlexDigitalAlarmsExportTableRow newRow = exportTable.NewWinCCFlexDigitalAlarmsExportTableRow();
// Alarm type,Alarm number,Alarm class,Trigger tag,Trigger bit number,Acknowledgment HMI tag,Acknowledgment HMI tag bit number,Acknowledgment PLC tag,Acknowledgment PLC tag bit number,Alarm group,Reported,Text[en-US],Field info[01],Infotext[en-US]
// D,8,Alarms,dbErrors,8,,,,,,0,en-US= Global Sheeting E-Stop button #01 (HW reset required),,en-US= Global Sheeting E-Stop button #01 (HW reset required)
switch (child.DataType)
{
case S7DataRowType.BOOL:
newRow.AlarmType = "\"" + "D" + "\"";
// Calculate trigger bit/alarm number
int iWinCC_BitNumber;
if (child.BlockAddress.ByteAddress % 2 == 0)
{
iWinCC_BitNumber = (child.BlockAddress.ByteAddress + 1) * 8 + child.BlockAddress.BitAddress;
}
else
{
iWinCC_BitNumber = (child.BlockAddress.ByteAddress - 1) * 8 + child.BlockAddress.BitAddress;
}
newRow.TriggerBitNumber = "\"" + iWinCC_BitNumber.ToString() + "\"";
newRow.AlarmNumber = "\"" + (child.BlockAddress.ByteAddress * 16 + child.BlockAddress.BitAddress + 1).ToString() + "\"";
newRow.AlarmClass = "\"" + "Alarms" + "\"";
newRow.TriggerTag = "\"" + CurrentBlock.Value.SymbolicName + "\"";
newRow.Text = "\"" + "en-US=" + strCommentPath.Trim() + " " + child.Comment.Trim() + "\""; // Message text
newRow.Infotext = "\"" + "en-US=" + strCommentPath.Trim() + " " + child.Comment.Trim() + "\"";
exportTable.AddWinCCFlexDigitalAlarmsExportTableRow(newRow);
break;
case S7DataRowType.UDT:
case S7DataRowType.STRUCT:
AddChildrenWinCCFlexDigitalAlarmsExportTable(exportTable, child.Children, strCommentPath.Trim() + " " + child.Comment.Trim());
break;
default:
break;
}
}
}
}
void HoockDetect()
{
textBox1.Text = "Detecting hooks for process whit the name " + ProcessName + " and PID=" + procid.ToString() + "\r\n";
byte[] Forread = new byte[0x500];
uint BytesRead = 0;
int CompileAddress = 0;
IntPtr processHandle = IntPtr.Zero;
try
{
processHandle = OpenProcess(ProcessAccess.QueryInformation | ProcessAccess.VMRead, false, (uint)procid);
}
catch
{
}
if (processHandle != IntPtr.Zero)
{
ProcModule.ModuleInfo targetmscorjit = null;
ProcModule.ModuleInfo[] modules = ProcModule.GetModuleInfos(procid);
if (modules != null && modules.Length > 0)
{
for (int i = 0; i < modules.Length; i++)
{
if (modules[i].baseName.ToLower().Contains("mscorjit"))
{
targetmscorjit = modules[i];
break;
}
}
}
if (targetmscorjit == null)
{
textBox1.Text = textBox1.Text + "Seems that the target process is not a .NET process!" + "\r\n";
}
else
{
int getJitrva = ExportTable.ProcGetExpAddress(processHandle, targetmscorjit.baseOfDll, "getJit");
bool isok = false;
isok = ReadProcessMemory(processHandle,
(IntPtr)((long)targetmscorjit.baseOfDll + (long)getJitrva), Forread, (uint)Forread.Length, ref BytesRead);
if (isok)
{
int count = 0;
while (Forread[count] != 0x0C3)
{
count++;
}
long cmpointer = (long)targetmscorjit.baseOfDll + getJitrva + count + 1;
textBox1.Text = textBox1.Text + "Pointer of compile method : " + cmpointer.ToString("X8") + "\r\n";
CompileAddress = BitConverter.ToInt32(Forread, count + 1);
textBox1.Text = textBox1.Text + "Address of compile method is : " + CompileAddress.ToString("X8") + "\r\n";
if ((CompileAddress < (int)targetmscorjit.baseOfDll) || (CompileAddress > (int)targetmscorjit.baseOfDll + targetmscorjit.sizeOfImage))
{
textBox1.Text = textBox1.Text + "Address of compile method changed!!!" + "\r\n";
}
else
{
textBox1.Text = textBox1.Text +
"Address of compile method seems to be the original one!" + "\r\n";
}
}
else
{
textBox1.Text = textBox1.Text + "Failed to read from selected process!" + "\r\n";
}
ProcModule.CloseHandle(processHandle);
} // end if is not .NET
}
else
{
textBox1.Text = textBox1.Text + "Failed to open selected process!" + "\r\n";
}
}
public async Task ReadHeaderAsync(Action <DomainLoadProgress> progress)
{
DomainLoadProgress message = new DomainLoadProgress {
Text = "Parsing Header..."
};
progress?.Invoke(message);
await readUpkHeader();
const CompressionTypes validCompression = CompressionTypes.LZO | CompressionTypes.LZO_ENC;
if (((CompressionTypes)CompressionFlags & validCompression) > 0)
{
message.Text = "Decompressing...";
progress?.Invoke(message);
reader = await decompressChunks();
}
else if (CompressionFlags > 0)
{
throw new Exception($"Unsupported compression type 0x{CompressionFlags:X8}.");
}
await readNameTable(progress);
await readImportTable(progress);
await readExportTable(progress);
message.Text = "Slicing and Dicing...";
progress?.Invoke(message);
await readDependsTable();
await decodePointers();
message.Text = "Reading Objects...";
message.Total = ExportTableCount;
progress?.Invoke(message);
await ExportTable.ForEachAsync(export =>
{
return(export.ReadDomainObject(reader).ContinueWith(t =>
{
message.IncrementCurrent();
if (ExportTableCount > 100)
{
progress?.Invoke(message);
}
}));
});
message.IsComplete = true;
progress?.Invoke(message);
}
