private async Task readImportTable(Action <DomainLoadProgress> progress)
{
DomainLoadProgress message = new DomainLoadProgress {
Text = "Reading Import Table...", Current = 0, Total = ImportTableCount
};
reader.Seek(ImportTableOffset);
for (int i = 0; i < ImportTableCount; ++i)
{
DomainImportTableEntry import = new DomainImportTableEntry {
TableIndex = -(i + 1)
};
await import.ReadImportTableEntry(reader, this);
ImportTable.Add(import);
message.IncrementCurrent();
if (ImportTableCount > 100)
{
progress?.Invoke(message);
}
}
message.Text = "Expanding References...";
message.Current = 0;
message.Total = 0;
progress?.Invoke(message);
await ImportTable.ForEachAsync(import => Task.Run(() => import.ExpandReferences(this)));
}
public void PropertyCanReadStructVectorValueTest2()
{
var pf1 = new PackageReader();
pf1.Read("D:\\la2\\system\\lineageeffect.u");
var header1 = new Header(pf1.Bytes);
var ExportTable1 = new ExportTable(header1, pf1.Bytes);
var ImportTable1 = new ImportTable(header1, pf1.Bytes);
var NameTable1 = new NameTable(header1, pf1.Bytes);
string name = "MeshEmitter0";
Export Exp = ExportTable1[1939];
int PropertyOffset = 0xA + Exp.SerialOffset + 28;
//Act
Property Prop = new Property(pf1.Bytes, PropertyOffset);
Prop.SetStructType(StructType.Vector);
//Assert
string Str = NameTable1[Prop.NameTableRef];
Assert.AreEqual(Str, "Acceleration");
Assert.IsTrue(Prop.Value is DataStructures.UVector);
Assert.AreEqual(Prop.Size, 15);
DataStructures.UVector uv = Prop.Value as DataStructures.UVector;
Assert.AreEqual(Prop.Type, PropertyType.StructProperty);
Assert.AreEqual(uv.X, -13.00f);
Assert.AreEqual(uv.Y, 0.0f);
Assert.AreEqual(uv.Z, -50.0f);
}
public Package(BinaryReader reader)
: this()
{
header = new PackageHeader(reader);
nameTable = new NameTable(reader);
exportTable = new ExportTable(reader);
importTable = new ImportTable(reader);
}
public void AddModuleImport(ImageModuleImport moduleImport)
{
_imports.Add(moduleImport);
ImportTable.AddModuleImport(moduleImport);
LookupTables.GetModuleLookupTable(moduleImport);
AddressTables.GetModuleLookupTable(moduleImport);
NameTable.GetModuleNameSegment(moduleImport);
}
public ImportSectionNode(string name, CorCompileImportType importType, CorCompileImportFlags flags, byte entrySize, bool emitPrecode, bool emitGCRefMap)
{
_name = name;
_type = importType;
_flags = flags;
_entrySize = entrySize;
_emitPrecode = emitPrecode;
_emitGCRefMap = emitGCRefMap;
_imports = new ImportTable(_name + "_ImportBegin", _name + "_ImportEnd");
_signatures = new ArrayOfEmbeddedPointersNode <Signature>(_name + "_SigBegin", _name + "_SigEnd", new EmbeddedObjectNodeComparer(new CompilerComparer()));
_signatureList = new List <Signature>();
_gcRefMap = _emitGCRefMap ? new GCRefMapNode(this) : null;
}
static void Main(string[] args)
{
//Alloc
pf = new PackageReader();
pf.Read("D:\\la2\\maps\\17_21.unr");
//pf.Read("D:\\la2\\system\\lineageeffect.u");
header = new Header(pf.Bytes);
ExportTable = new ExportTable(header, pf.Bytes);
ImportTable = new ImportTable(header, pf.Bytes);
NameTable = new NameTable(header, pf.Bytes);
Property.Resolve = Resolver;
//GetAllPropertyNames();
Console.ReadKey();
}
public void Initialize()
{
try
{
//Alloc
pf = new PackageReader();
pf.Read("D:\\la2\\maps\\17_21.unr");
header = new Header(pf.Bytes);
ExportTable = new ExportTable(header, pf.Bytes);
ImportTable = new ImportTable(header, pf.Bytes);
NameTable = new NameTable(header, pf.Bytes);
Property.Resolve = Resolver;
}
catch (Exception ex)
{
//Assert (no exceptions reading...)
Assert.Fail(ex.ToString());
}
}
public void PropertyCanReadEntireObject()
{
var pf1 = new PackageReader();
pf1.Read("D:\\la2\\system\\lineageeffect.u");
var header1 = new Header(pf1.Bytes);
var ExportTable1 = new ExportTable(header1, pf1.Bytes);
var ImportTable1 = new ImportTable(header1, pf1.Bytes);
var NameTable1 = new NameTable(header1, pf1.Bytes);
//Property.Resolve = Resolver;
var Exp = ExportTable1[0x793];
Assert.AreEqual("MeshEmitter0", NameTable1[Exp.NameTableRef]);
var list = Property.ReadProperties(pf1.Bytes, Exp.SerialOffset + 28);
Assert.IsNotNull(list);
Assert.AreEqual(31, list.Count);
}
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 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);
}
private void ParseImportTable(BinaryReader reader)
{
//empty import table
if (Is32BitHeader && optionalHeader32.DataDirectory[1].Size == 0 ||
!Is32BitHeader && optionalHeader64.DataDirectory[1].Size == 0)
{
return;
}
long oldPosition = reader.BaseStream.Position;
uint rva = Is32BitHeader ? optionalHeader32.DataDirectory[1].VirtualAddress : optionalHeader64.DataDirectory[1].VirtualAddress;
uint offset = RvaToOffset(rva);
reader.BaseStream.Position = offset;
var desc = FromBinaryReader <IMAGE_IMPORT_DESCRIPTOR>(reader);
while (desc.Name != 0)
{
var libOffset = RvaToOffset(desc.Name);
if (libOffset == 0)
{
break;
}
string name = ReadName(reader, libOffset).ToLower().Trim();
if (!ImportTable.ContainsKey(name))
{
ImportTable.Add(name, new List <string>());
}
var address = Math.Max(desc.ImportLookupTable, desc.Name) - Math.Min(desc.ImportLookupTable, desc.Name) < Math.Max(desc.ImportAddressTable, desc.Name) - Math.Min(desc.ImportAddressTable, desc.Name) ? desc.ImportLookupTable : desc.ImportAddressTable;
List <string> functions = ReadFunctions(reader, RvaToOffset(address));
ImportTable[name].AddRange(functions.ToArray());
ImportTable[name] = ImportTable[name].Distinct().ToList();
desc = FromBinaryReader <IMAGE_IMPORT_DESCRIPTOR>(reader);
}
reader.BaseStream.Position = oldPosition;
}
private bool UpdateCustom(ref ImportTable importTable, ref DataRow dataRow)
{
bool result = false;
if ((importTable != null) && (dataRow != null))
{
int assetId = GetIntValue(ref dataRow, "AssetId");
if (assetId > 0)
{
ImportColumns customColumnList = importTable.GetCustomColumnList();
int customColumnCount = customColumnList.GetColumnCount();
for (int i = 0; i < customColumnCount; i++)
{
ImportColumn customColumn = customColumnList.GetColumn(i);
if (customColumn != null)
{
string customColumnNameId = customColumn.ColumnName + "Id";
int customPropertyId = GetIntValue(ref dataRow, customColumnNameId);
string customValue = GetValue(ref dataRow, customColumn.ColumnName);
if (customPropertyId > 0)
{
AssetTypeProperties.SetValue(_departmentId, assetId, customPropertyId, customValue);
result = true;
}
}
}
}
}
return result;
}
private bool UpdateAsset(ref ImportTable importTable, int? userId, string userName, ref DataRow row)
{
bool result = false;
if (row != null)
{
int AssetCategoryID = GetIntValue(ref row, "AssetCategoryId");
int AssetTypeID = GetIntValue(ref row, "AssetTypeId");
int AssetMakeID = GetIntValue(ref row, "AssetMakeId");
int AssetModelID = GetIntValue(ref row, "AssetModelId");
int DeptID = _departmentId;
int? UserID = userId;
int AssetID = GetIntValue(ref row, "AssetId");
bool updateUniqeFields = GetBoolValue(ref row, "UpdateUniqueFields");
int OldStatusID = GetIntValue(ref row, "StatusId");
DataRow _dr = Asset.GetAsset(_departmentId, AssetID);
if (_dr != null)
{
OldStatusID = GetIntValue(ref _dr, "StatusId");
}
int PurchaseVendorID = GetIntValue(ref row, "VendorId");
int WarrantyVendorID = GetIntValue(ref row, "WarrantyVendorId");
int AccountId = GetIntValue(ref row, "AccountId");
int LocationID = GetIntValue(ref row, "LocationId");
string AssetName = GetValue(ref row, "AssetName");
string AssetDescription = GetValue(ref row, "AssetDescription");
double AssetValue = GetDoubleValue(ref row, "Value");
double ValueCurrent = GetDoubleValue(ref row, "ValueCurrent");
double ValueReplacement = GetDoubleValue(ref row, "ValueReplacement");
double ValueDepreciated = GetDoubleValue(ref row, "ValueDepreciated");
double ValueSalvage = GetDoubleValue(ref row, "ValueSalvage");
double DisposalCost = GetDoubleValue(ref row, "DisposalCost");
int AssetSort = GetIntValue(ref row, "AssetSort");
string FundingSource = GetValue(ref row, "FundingSource");
DateTime? DateAcquired = null;
if (row.Table.Columns.Contains("DateAquired"))
DateAcquired = GetDateTimeValue(ref row, "DateAquired");
else
{
if (row.Table.Columns.Contains("DateAcquired"))
DateAcquired = GetDateTimeValue(ref row, "DateAcquired");
}
DateTime? DatePurchased = GetDateTimeValue(ref row, "DatePurchased");
DateTime? DateDeployed = GetDateTimeValue(ref row, "DateDeployed");
DateTime? DateOutOfService = GetDateTimeValue(ref row, "DateOutOfService");
DateTime? DateEntered = GetDateTimeValue(ref row, "DateEntered");
DateTime? DateReceived = GetDateTimeValue(ref row, "DateReceived");
DateTime? DateDisposed = GetDateTimeValue(ref row, "DateDisposed");
int WarrantyLabor = GetIntValue(ref row, "LaborWarrantyLength");
int WarrantyPart = GetIntValue(ref row, "PartsWarrantyLength");
string PONumber = GetValue(ref row, "PONumber");
string FindingCode = GetValue(ref row, "FundingCode");
string SerialNumber = GetValue(ref row, "SerialNumber");
string Unique1 = GetValue(ref row, "Unique1");
string Unique2 = GetValue(ref row, "Unique2");
string Unique3 = GetValue(ref row, "Unique3");
string Unique4 = GetValue(ref row, "Unique4");
string Unique5 = GetValue(ref row, "Unique5");
string Unique6 = GetValue(ref row, "Unique6");
string Unique7 = GetValue(ref row, "Unique7");
int NewStatusID = GetIntValue(ref row, "StatusId");
bool isValidDateAquired = false;
if (row.Table.Columns.Contains("DateAquired"))
isValidDateAquired = (GetDateTimeValue(ref row, "DateAquired") != DateTime.MinValue);
else if (row.Table.Columns.Contains("DateAcquired"))
isValidDateAquired = (GetDateTimeValue(ref row, "DateAcquired") != DateTime.MinValue);
int updateResult = Asset.UpdateAsset(
DeptID,
UserID,
AssetID,
PurchaseVendorID,
WarrantyVendorID,
AccountId,
LocationID,
AssetName,
AssetDescription,
AssetValue,
ValueCurrent,
ValueReplacement,
ValueDepreciated,
ValueSalvage,
DisposalCost,
AssetSort,
FundingSource,
DateAcquired,
DatePurchased,
DateDeployed,
DateOutOfService,
DateEntered,
DateReceived,
DateDisposed,
WarrantyLabor,
WarrantyPart,
PONumber,
FindingCode,
SerialNumber,
Unique1,
Unique2,
Unique3,
Unique4,
Unique5,
Unique6,
Unique7,
NewStatusID,
OldStatusID,
updateUniqeFields
);
if (updateResult == 0)
{
int oldOwnerId = 0;
int oldCheckoutId = 0;
int ownerId = GetIntValue(ref row, "OwnerId");
int checkoutId = GetIntValue(ref row, "CheckedOutId");
if (_dr != null)
{
oldOwnerId = GetIntValue(ref _dr, "OwnerId");
oldCheckoutId = GetIntValue(ref _dr, "CheckedOutId");
}
if ((ownerId > 0) && (ownerId != oldOwnerId))
Asset.UpdateAssetOwner(_departmentId, ownerId, AssetID, userName);
if ((checkoutId > 0) && (checkoutId != oldCheckoutId))
Asset.UpdateAssetCheckout(_departmentId, checkoutId, AssetID, userName);
if ((AssetID > 0) && (AssetCategoryID > 0) && (AssetTypeID > 0) && (AssetMakeID > 0) && (AssetModelID > 0))
Asset.UpdateAssetTypeMakeModel(_departmentId, AssetID, AssetCategoryID, AssetTypeID, AssetMakeID, AssetModelID);
string notes = GetValue(ref row, "Notes");
Asset.UpdateAssetNotes(_departmentId, AssetID, notes);
UpdateCustom(ref importTable, ref row);
result = true;
}
}
return result;
}
private void ImportData(ref ImportTable importTable, int? userId, string userName, ref DataTable table, ref int newObjectsCount, ref int updatedObjectsCount)
{
if (table != null)
{
for (int i = 0; i < table.Rows.Count; i++)
{
DataRow drAsset = table.Rows[i];
if (drAsset != null)
{
int assetId = 0;
int.TryParse(drAsset["AssetId"].ToString(), out assetId);
if (assetId == -1)
{
if (AddAsset(userId, ref drAsset))
{
newObjectsCount++;
UpdateAsset(ref importTable, userId, userName, ref drAsset);
}
}
else if (assetId > 0)
{
if (UpdateAsset(ref importTable, userId, userName, ref drAsset))
updatedObjectsCount++;
}
}
}
}
}
private DataTable AppendVendorData(ref DataTable _destination, ref DataTable _source, ref ImportTable source)
{
if ((_destination == null) && (source != null))
{
_destination = new DataTable();
if (_destination != null)
{
string _system_type = "System.String";
string _column_name = "AssetVendorName";
DataColumn data_column = new DataColumn();
if (data_column != null)
{
data_column.DataType = System.Type.GetType(_system_type);
data_column.AllowDBNull = false;
data_column.Caption = _column_name;
data_column.ColumnName = _column_name;
data_column.DefaultValue = "";
_destination.Columns.Add(data_column);
}
}
}
if ((source != null) && (_destination != null))
{
if (_source != null)
{
foreach (DataRow _row in _source.Rows)
{
if (_row != null)
{
string _vendor_name = "";
string _warranty_vendor_name = "";
string _vendor_id = _row["VendorId"].ToString();
string _warranty_vendor_id = _row["WarrantyVendorId"].ToString();
if (_row["VendorName"] != null)
_vendor_name = _row["VendorName"].ToString();
if (_row["WarrantyVendorName"] != null)
_warranty_vendor_name = _row["WarrantyVendorName"].ToString();
if ((_vendor_id == "-1") && (_vendor_name.Length > 0))
{
DataRow _new_row = _destination.NewRow();
if (_new_row != null)
{
_new_row["AssetVendorName"] = _vendor_name;
_destination.Rows.Add(_new_row);
}
}
if ((_warranty_vendor_id == "-1") && (_warranty_vendor_name.Length > 0))
{
DataRow _new_row2 = _destination.NewRow();
if (_new_row2 != null)
{
_new_row2["AssetVendorName"] = _warranty_vendor_name;
_destination.Rows.Add(_new_row2);
}
}
}
}
}
}
return _destination;
}
private DataTable AppendData(ref DataTable _destination, ref DataTable _source, ref ImportTable source)
{
if ((_destination == null) && (source != null))
{
_destination = new DataTable();
if (_destination != null)
{
ImportColumns _require_columns = source.GetAllRequiredColumnList();
if (_require_columns != null)
{
int _require_columns_count = _require_columns.GetColumnCount();
for (int index = 0; index < _require_columns_count; index++)
{
ImportColumn _require_column = _require_columns.GetColumn(index);
if (_require_column != null)
{
string _system_type = _require_column.ColumnSystemType;
string _column_name = _require_column.ColumnName;
DataColumn data_column = new DataColumn();
if (data_column != null)
{
data_column.DataType = System.Type.GetType(_system_type);
data_column.AllowDBNull = true;
data_column.Caption = _column_name;
data_column.ColumnName = _column_name;
_destination.Columns.Add(data_column);
}
}
}
}
}
}
if ((source != null) && (_destination != null))
{
ImportColumns _row_require_columns = source.GetRequiredColumnList();
if (_row_require_columns != null)
{
int _row_require_columns_count = _row_require_columns.GetColumnCount();
if (_source != null)
{
foreach (DataRow _row in _source.Rows)
{
DataRow _new_row = _destination.NewRow();
for (int index = 0; index < _row_require_columns_count; index++)
{
ImportColumn _row_require_column = _row_require_columns.GetColumn(index);
if (_row_require_column != null)
_new_row[_row_require_column.ColumnName] = _row[_row_require_column.ColumnName];
}
_destination.Rows.Add(_new_row);
}
}
}
}
return _destination;
}
public virtual void Setup()
{
Imports = IndianCustomsHelper.LoadImports();
Table = new ImportTable(Imports);
}
public ImportTableDataSource(ImportTable importTable, Package pkg)
: base(importTable.items.Count)
{
dataGetters = new PackageTableDataGetter[] {
new PackageTableDataGetter { column = "#",
sort = (i => { return importTable[i].index; }),
data = (i => { return importTable[i].index.ToString(); }),
},
new PackageTableDataGetter { column = "offset",
sort = (i => { return importTable[i].offset; }),
data = (i => { return String.Format("{0:X8}", importTable[i].offset); }),
},
new PackageTableDataGetter { column = "# of",
sort = (i => { return importTable[i].ClassPackage; }),
data = (i => { return importTable[i].ClassPackage.ToString(); }),
},
new PackageTableDataGetter { column = "ClassPackage",
sort = (i => { return pkg.GetName(importTable[i].ClassPackage); }),
data = (i => { return pkg.GetName(importTable[i].ClassPackage); }),
},
new PackageTableDataGetter { column = "# of",
sort = (i => { return importTable[i].ObjectName; }),
data = (i => { return importTable[i].ObjectName.ToString(); }),
},
new PackageTableDataGetter { column = "ObjectName",
sort = (i => { return pkg.GetName(importTable[i].ObjectName); }),
data = (i => { return pkg.GetName(importTable[i].ObjectName); }),
},
new PackageTableDataGetter { column = "# of",
sort = (i => { return importTable[i].Package; }),
data = (i => { return importTable[i].Package.ToString(); }),
},
new PackageTableDataGetter { column = "Package",
sort = (i => { return pkg.GetObjNameRec(importTable[i].Package); }),
data = (i => { return pkg.GetObjNameRec(importTable[i].Package); }),
},
new PackageTableDataGetter { column = "# of",
sort = (i => { return importTable[i].Class; }),
data = (i => { return importTable[i].Class.ToString(); }),
},
new PackageTableDataGetter { column = "Class",
sort = (i => { return pkg.GetName(importTable[i].Class); }),
data = (i => { return pkg.GetName(importTable[i].Class); }),
},
};
}
public virtual void VisitImportTable(ImportTable it)
{
}
private void ReadPEHeaders()
{
int offset = Util.GetInt32(this.data, 0x3c);
offset += 4;
this.pe1 = new PEFileHeader();
this.pe1.ReadData(this.data, offset);
offset += 20;
this.pe2 = new PEHeaderStandardFields();
this.pe2.ReadData(this.data, offset);
this.pe3 = new PEHeaderWindowsNTSpecificFields();
this.pe3.ReadData(this.data, offset);
this.pe4 = new PEHeaderDataDirectories();
this.pe4.ReadData(this.data, offset);
offset += 224;
this.ReadSections(offset);
int addr_it = RVAManager.GetAddress(this.pe4.ImportTable);
if (addr_it == 0) return;
ArrayList list = new ArrayList();
for (int ad = this.rva.ConvertToPhysical(addr_it); !Util.IsZero(this.data, ad, 20); ad += 20)
{
ImportTable it = new ImportTable();
it.ReadData(this.data, ad);
it.AppendTitle(string.Format(" \"{0}\"", Util.EscapeText(Util.GetASCIIString(this.data, this.rva.ConvertToPhysical(it.Name)))));
list.Add(it);
}
this.imptbl = list.ToArray(typeof (ImportTable)) as ImportTable[];
}
public ImportRows(ImportTable import_table)
{
_import_table = import_table;
}
public virtual void VisitImportTable(ImportTable it)
{
}
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;
}
bool InitInstance()
{
if (App.instance == null)
{
Log.LogSystem.LogSystemFlags = LogSystemFlags.UseIp | LogSystemFlags.UseUserId;
Log.LogSystem.AddLogHandlers(new MessageFormLogInformer());
}
using (WaitCursor wc = new WaitCursor())
{
if (App.instance != null)
{
throw new HospitalDepartmentException("Приложение уже инициализировано.");
}
Locale.StringSet.Load();
instance = this;
assemblyInfo = new AssemblyInfo();
appCache = new AppCache();
userInfo = new UserInfo();
// App config
appConfig = AppConfig.Load();
// DB
if (appConfig.dataProvider.Trim().Length == 0 || appConfig.connStr.Trim().Length == 0 || appConfig.debugMode == 2)
{
CreateDbForm form = new CreateDbForm("Data", "HospitalDepartment");
form.DataProviders.Add(SqlServerProvider.name);
if (form.ShowDialog() == DialogResult.OK)
{
connectionFactory = form.DbCreationProperties.CreateDb();
// create database
UpdateScripts.UpdateDb(connectionFactory, null, "HospitalDepartment.Resources.CreationScripts.sql");
appConfig.dataProvider = connectionFactory.ProviderFactory.Name;
appConfig.connStr = connectionFactory.ConnectionString;
appConfig.Save();
// import tables
ImportTable.ImportData(connectionFactory, PathUtils.BaseDirectory + "Import");
}
else
{
return(false);
}
}
else
{
connectionFactory = new ConnectionFactory(appConfig.dataProvider, appConfig.connStr);
}
// Hospital department config
config = Config.Load();
ConfigUpdate.CheckUpdate(config, true);
// Connection test
using (GmConnection conn = App.CreateConnection())
{
conn.DbConnection.Open();
}
Log.LogSystem.AddLogHandlers(new SqlLog(connectionFactory));
Log.LogSystem.OnLogMessage += new EventHandler <LogMessageEventArgs>(LogHandler_OnLogMessage);
Log.Info("AppStart", "Запуск программы.");
// update database
UpdateScripts.UpdateDb(connectionFactory, null, "HospitalDepartment.Resources.UpdateScripts.sql");
// load icon
Assembly assembly = Assembly.GetExecutingAssembly();
using (Stream stream = assembly.GetManifestResourceStream(App.DepartmentConfig.iconName))
{
icon = new Icon(stream);
}
}
// Login
if (App.DebugMode > 0 && System.Diagnostics.Debugger.IsAttached) // autologin
{
Login("1", "1");
}
else
{
LoginForm form = new LoginForm(false);
form.ShowDialog();
}
if (UserId == 0 || Role == null)
{
return(false);
}
Log.Info("Пользователь вошел в систему", "UserId={0} RoleId={1}", UserId, Role.Id);
// App cache
using (WaitCursor wc = new WaitCursor())
{
using (GmConnection conn = App.CreateConnection())
{
appCache.Update(conn, this.Role.watchingGroupId);
}
}
// Check watching
if (userInfo.HasWatching)
{
if (userInfo.Watching.Id == 0)
{
WatchingForm watchingForm = new WatchingForm(this);
if (watchingForm.ShowDialog() != DialogResult.OK)
{
return(false);
}
}
if (userInfo.Watching.Id == 0)
{
return(false);
}
}
taskManager = new TaskManager(userInfo, config, appCache);
return(true);
}
public bool AddTable(Guid organizationId, int departmentId, string tableName, ref ImportLog importLog, ref ImportCustomProperty importCustomProperty, IDataReaderAdapter tableReader)
{
bool result = false;
if (_tables != null)
{
if (!_tables.Contains(tableName))
{
ImportTable _table = new ImportTable(tableName, organizationId, departmentId, ref importLog, ref importCustomProperty, tableReader);
if (_table != null)
{
_tables.Add(tableName, _table);
result = true;
}
}
}
return result;
}
public IReadable Read()
{
var peHeaderReader = (PeHeaderReader) new PeHeaderReader(_filePath).Read();
ImportTableDirectory = peHeaderReader.Is32BitPeHeader
? peHeaderReader.PeHeader32.OptionalHeader.ImportTable
: peHeaderReader.PeHeader64.OptionalHeader.ImportTable;
var address = RvaToRawFormatConverter.RvaToOffset32(ImportTableDirectory.VirtualAddress,
peHeaderReader.SectionHeaders,
peHeaderReader.Is32BitPeHeader
? peHeaderReader.PeHeader32.OptionalHeader.SectionAlignment
: peHeaderReader.PeHeader64.OptionalHeader.SectionAlignment);
using var fs = new FileStream(_filePath, FileMode.Open, FileAccess.Read);
var br = new BinaryReader(fs);
fs.Seek(address, SeekOrigin.Begin);
while (true)
{
var importDescriptor = PeBlockToStructConverter.ConvertTo <ImportDescriptor>(br);
if (importDescriptor.OriginalFirstThunk == 0 &&
importDescriptor.ForwarderChain == 0 &&
importDescriptor.Name == 0 &&
importDescriptor.FirstThunk == 0)
{
break;
}
ImportTable.Add(importDescriptor);
}
for (var i = 0; i < ImportTable.Count; i++)
{
var importFunction = new ImportFunction();
// Getting DLL name
var dllNameAddress = RvaToRawFormatConverter.RvaToOffset32(ImportTable[i].Name,
peHeaderReader.SectionHeaders,
peHeaderReader.Is32BitPeHeader
? peHeaderReader.PeHeader32.OptionalHeader.SectionAlignment
: peHeaderReader.PeHeader64.OptionalHeader.SectionAlignment);
var currentPosition = fs.Position;
importFunction.DllName = ByteArrayToAsciiStringConverter.ConvertToString(fs, dllNameAddress);
fs.Seek(currentPosition, SeekOrigin.Begin);
importFunction.TimeDateStamp = TimeDateStampToDateTimeConverter.ConvertTimeDateStamp(ImportTable[i].TimeDateStamp);
var ilt = RvaToRawFormatConverter.RvaToOffset32(ImportTable[i].OriginalFirstThunk,
peHeaderReader.SectionHeaders,
peHeaderReader.Is32BitPeHeader
? peHeaderReader.PeHeader32.OptionalHeader.SectionAlignment
: peHeaderReader.PeHeader64.OptionalHeader.SectionAlignment);
fs.Seek(ilt, SeekOrigin.Begin);
if (peHeaderReader.Is32BitPeHeader)
{
while (true)
{
var thunkData32 = PeBlockToStructConverter.ConvertTo <ThunkData32>(br);
if (thunkData32.Function == 0)
{
break;
}
var currentPosition2 = fs.Position;
if ((thunkData32.AddressOfData & (UInt32)1 << 31) == 0)
{
var functionAddress = RvaToRawFormatConverter.RvaToOffset32(thunkData32.Function,
peHeaderReader.SectionHeaders, peHeaderReader.PeHeader32.OptionalHeader.SectionAlignment);
fs.Seek(functionAddress, SeekOrigin.Begin);
var hint = br.ReadUInt16();
var byteList = new List <Byte>();
while (true)
{
var b = br.ReadByte();
if (b == 0x00)
{
break;
}
byteList.Add(b);
}
var name = Encoding.ASCII.GetString(byteList.ToArray());
importFunction.Functions.Add(new ImportFunctionInfo()
{
Hint = hint,
Name = name
});
fs.Seek(currentPosition2, SeekOrigin.Begin);
}
else
{
importFunction.Functions.Add(new ImportFunctionInfo()
{
Name = null,
Ordinal64 = null,
Ordinal32 = (thunkData32.Ordinal & (((UInt32)1 << 31) - 1))
});
}
}
}
else
{
while (true)
{
var thunkData64 = PeBlockToStructConverter.ConvertTo <ThunkData64>(br);
if (thunkData64.Function == 0)
{
break;
}
var currentPosition2 = fs.Position;
if ((thunkData64.AddressOfData & ((UInt64)1 << 63)) == 0)
{
var functionAddress = RvaToRawFormatConverter.RvaToOffset64(thunkData64.Function,
peHeaderReader.SectionHeaders, peHeaderReader.PeHeader64.OptionalHeader.SectionAlignment);
fs.Seek(functionAddress, SeekOrigin.Begin);
var hint = br.ReadUInt16();
var byteList = new List <Byte>();
while (true)
{
var b = br.ReadByte();
if (b == 0x00)
{
break;
}
byteList.Add(b);
}
var name = Encoding.ASCII.GetString(byteList.ToArray());
importFunction.Functions.Add(new ImportFunctionInfo()
{
Hint = hint,
Name = name
});
fs.Seek(currentPosition2, SeekOrigin.Begin);
}
else
{
importFunction.Functions.Add(new ImportFunctionInfo()
{
Name = null,
Ordinal32 = null,
Ordinal64 = (thunkData64.Ordinal & (((UInt64)1 << 63) - 1))
});
}
}
}
ImportFunctions.Add(importFunction);
}
return(this);
}
