crashanalysercmd/PerfToolsSharedLibraries/Engine/SymbianImageLib/E32Image/Header/SIHeaderE32Image.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/crashanalysercmd/PerfToolsSharedLibraries/Engine/SymbianImageLib/E32Image/Header/SIHeaderE32Image.cs Thu Feb 11 15:50:58 2010 +0200
@@ -0,0 +1,244 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using SymbianUtils.Tracer;
+using SymbianUtils.Streams;
+using SymbianUtils.Strings;
+using SymbianStructuresLib.Version;
+using SymbianStructuresLib.Uids;
+using SymbianStructuresLib.Security;
+using SymbianStructuresLib.Compression.Common;
+using SymbianImageLib.Common.Header;
+using SymbianImageLib.Common.Image;
+using SymbianImageLib.E32Image.Exceptions;
+
+namespace SymbianImageLib.E32Image.Header
+{
+ public class SIHeaderE32Image : SIHeader
+ {
+ #region Constructors
+ internal SIHeaderE32Image( SIImage aImage, SymbianStreamReaderLE aReader )
+ : base( aImage )
+ {
+ long startPos = aReader.Position;
+ //
+ iUids = new TCheckedUid( aReader );
+ iSignature = aReader.ReadUInt32();
+ //
+ if ( iSignature != KExpectedSignatureUInt32 ) // 'EPOC'
+ {
+ throw new E32ImageNotSupportedException( "Invalid signature" );
+ }
+ //
+ iHeaderCrc = aReader.ReadUInt32();
+ iModuleVersion = aReader.ReadUInt32();
+ iCompressionType = SIHeaderE32Image.ReadCompressionType( aReader );
+ iToolsVersion = new TVersion( aReader );
+ iTimeLo = aReader.ReadUInt32();
+ iTimeHi = aReader.ReadUInt32();
+ iFlags = aReader.ReadUInt32();
+ //
+ iCodeSize = aReader.ReadInt32();
+ iDataSize = aReader.ReadInt32();
+ iHeapSizeMin = aReader.ReadInt32();
+ iHeapSizeMax = aReader.ReadInt32();
+ iStackSize = aReader.ReadInt32();
+ iBssSize = aReader.ReadInt32();
+ //
+ iEntryPoint = aReader.ReadUInt32();
+ iCodeBase = aReader.ReadUInt32();
+ iDataBase = aReader.ReadUInt32();
+ //
+ iDllRefTableCount = aReader.ReadInt32();
+ iExportDirOffset = aReader.ReadUInt32();
+ iExportDirCount = aReader.ReadInt32();
+ //
+ iTextSize = aReader.ReadInt32();
+ iCodeOffset = aReader.ReadUInt32();
+ iDataOffset = aReader.ReadUInt32();
+ iImportOffset = aReader.ReadUInt32();
+ iCodeRelocOffset = aReader.ReadUInt32();
+ iDataRelocOffset = aReader.ReadUInt32();
+ //
+ iProcessPriority = aReader.ReadInt16();
+ //
+ iCpuIdentifier = aReader.ReadUInt16();
+ //
+ iUncompressedSize = aReader.ReadUInt32();
+ //
+ iS = new SSecurityInfo( aReader );
+ iExceptionDescriptor = aReader.ReadUInt32();
+ iSpare2 = aReader.ReadUInt16();
+ iExportDescSize = aReader.ReadUInt16();
+ iExportDescType = aReader.ReadUInt8();
+ //
+ iHeaderSize = (uint) ( aReader.Position - startPos );
+ }
+ #endregion
+
+ #region Constants
+ public const int KMinimumSize = 16 + 4; // Enough to read UIDs + signature
+ #endregion
+
+ #region API
+ public static bool IsSymbianImageHeader( byte[] aHeader )
+ {
+ // We expect to see 16 bytes (3 x UID, 1 x UID checksum) and then
+ // the magic word EPOC
+ bool ret = false;
+ //
+ if ( aHeader.Length >= KMinimumSize )
+ {
+ // We expect 16 bytes are the UID + checksum. Next should be the signature.
+ string sig = StringParsingUtils.BytesToString( aHeader, 16, 20 );
+ ret = ( sig == KExpectedSignature );
+ }
+ //
+ return ret;
+ }
+ #endregion
+
+ #region Constants
+ public const uint KExpectedSignatureUInt32 = 0x434f5045;
+ public const string KExpectedSignature = "EPOC";
+ #endregion
+
+ #region Properties
+ public TCheckedUid Uid
+ {
+ get
+ {
+ return iUids;
+ }
+ }
+
+ public int CodeSize
+ {
+ get { return iCodeSize; }
+ }
+
+ public int DataSize
+ {
+ get { return iDataSize; }
+ }
+
+ public uint CodeOffset
+ {
+ get { return iCodeOffset; }
+ }
+
+ public uint UncompressedSize
+ {
+ get { return iUncompressedSize; }
+ }
+
+ public uint TotalSize
+ {
+ // Just like in E32ImageHeader
+ get { return CodeOffset; }
+ }
+ #endregion
+
+ #region From SymbianImageHeader
+ public override uint HeaderSize
+ {
+ get { return iHeaderSize; }
+ }
+
+ public override TSymbianCompressionType CompressionType
+ {
+ get { return iCompressionType; }
+ }
+ #endregion
+
+ #region Internal methods
+ private static TSymbianCompressionType ReadCompressionType( SymbianStreamReaderLE aReader )
+ {
+ TSymbianCompressionType ret = TSymbianCompressionType.ENone;
+ //
+ uint type = aReader.ReadUInt32();
+ if ( type == (uint) TSymbianCompressionType.EBytePair )
+ {
+ ret = TSymbianCompressionType.EBytePair;
+ }
+ else if ( type == (uint) TSymbianCompressionType.EDeflate )
+ {
+ ret = TSymbianCompressionType.EDeflate;
+ }
+ else
+ {
+ throw new E32ImageNotSupportedException( "Unsupported compression type" );
+ }
+ //
+ return ret;
+ }
+ #endregion
+
+ #region Data members
+ private readonly TCheckedUid iUids;
+ //
+ private readonly uint iSignature; // Contains 'EPOC'.
+ private readonly uint iHeaderCrc; // CRC-32 of entire header. @see #KImageCrcInitialiser.
+ private readonly uint iModuleVersion; // Version number for this executable (used in link resolution).
+ private readonly TSymbianCompressionType iCompressionType; // Type of compression used for file contents located after the header. (UID or 0 for none).
+ //
+ private readonly TVersion iToolsVersion; // Version number of tools which generated this file.
+ //
+ private readonly uint iTimeLo; // Least significant 32 bits of the time of image creation, in milliseconds since since midnight Jan 1st, 2000.
+ private readonly uint iTimeHi; // Most significant 32 bits of the time of image creation, in milliseconds since since midnight Jan 1st, 2000.
+ private readonly uint iFlags; // Contains various bit-fields of attributes for the image.
+ //
+ private readonly int iCodeSize; // Size of executables code. Includes import address table, constant data and export directory.
+ private readonly int iDataSize; // Size of executables initialised data.
+ private readonly int iHeapSizeMin; // Minimum size for an EXEs runtime heap memory.
+ private readonly int iHeapSizeMax; // Maximum size for an EXEs runtime heap memory.
+ private readonly int iStackSize; // Size for stack required by an EXEs initial thread.
+ private readonly int iBssSize; // Size of executables uninitialised data.
+ //
+ private readonly uint iEntryPoint; // Offset into code of the entry point.
+ private readonly uint iCodeBase; // Virtual address that the executables code is linked for.
+ private readonly uint iDataBase; // Virtual address that the executables data is linked for.
+ //
+ private readonly int iDllRefTableCount; // Number of executable against which this executable is linked. The number of files mention in the import section at iImportOffset.
+ private readonly uint iExportDirOffset; // Byte offset into file of the export directory.
+ private readonly int iExportDirCount; // Number of entries in the export directory.
+ //
+ private readonly int iTextSize; // Size of just the text section, also doubles as the offset for the Import Address Table w.r.t. the code section.
+ private readonly uint iCodeOffset; // Offset into file of the code section. Also doubles the as header size.
+ private readonly uint iDataOffset; // Offset into file of the data section.
+ private readonly uint iImportOffset; // Offset into file of the import section (E32ImportSection).
+ private readonly uint iCodeRelocOffset; // Offset into file of the code relocation section (E32RelocSection).
+ private readonly uint iDataRelocOffset; // Offset into file of the data relocation section (E32RelocSection).
+ private readonly short iProcessPriority; // Initial runtime process priorty for an EXE. (Value from enum TProcessPriority.)
+ private readonly ushort iCpuIdentifier; // Value from enum TCpu which indicates the CPU architecture for which the image was created
+ //
+ private readonly uint iUncompressedSize; // Uncompressed size of file data after the header, or zero if file not compressed.
+ //
+ private readonly SSecurityInfo iS; // Platform Security information of executable.
+ private readonly uint iExceptionDescriptor; // Offset in bytes from start of code section to Exception Descriptor, bit 0 set if valid.
+ private readonly ushort iSpare2; // Reserved for future use. Set to zero.
+ private readonly ushort iExportDescSize; // Size of export description stored in iExportDesc.
+ private readonly byte iExportDescType; // Type of description of holes in export table
+
+ // Not part of header
+ private readonly uint iHeaderSize;
+ #endregion
+ }
+}