diff -r 000000000000 -r ba25891c3a9e secureswitools/swisistools/source/sisxlibrary/fieldroot.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/secureswitools/swisistools/source/sisxlibrary/fieldroot.h Thu Dec 17 08:51:10 2009 +0200 @@ -0,0 +1,433 @@ +/* +* Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "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: +* Note: This file may contain code to generate corrupt files for test purposes. +* Such code is excluded from production builds by use of compiler defines; +* it is recommended that such code should be removed if this code is ever published publicly. +* base class for all types found in sis files. Defines all virtual functions. +* fieldroot <- field <- container <- [array, sequence, structure] <- most SIS types +* fieldroot <- field <- [string, compressed, blob] +* fieldroot <- numeric +* fieldroot <- header +* +*/ + + +/** + @file + @internalComponent + @released +*/ + + +#ifndef __FIELDROOT_H__ +#define __FIELDROOT_H__ + +#include +#include "basefile.h" + + +#ifdef GENERATE_ERRORS +#ifndef _DEBUG +#error GENERATE_ERRORS requires _DEBUG + // or change the code to rewrite TLV sizes in array and structure +#endif +#endif + +class CSISFieldRoot + + { +public: + typedef TUint64 TFieldSize; // in BYTES + + typedef enum + { + ESISUndefined, + ESISString, + ESISArray, + ESISCompressed, + ESISVersion, + ESISVersionRange, + ESISDate, + ESISTime, + ESISDateTime, + ESISUid, + ESISUnused1, + ESISLanguage, + ESISContents, + ESISController, + ESISInfo, + ESISSupportedLanguages, + ESISSupportedOptions, + ESISPrerequisites, + ESISDependency, + ESISProperties, + ESISProperty, + ESISSignatures, + ESISCertificateChain, + ESISLogo, + ESISFileDescription, + ESISHash, + ESISIf, + ESISElseIf, + ESISInstallBlock, + ESISExpression, + ESISData, + ESISDataUnit, + ESISFileData, + ESISSupportedOption, + ESISControllerChecksum, + ESISDataChecksum, + ESISSignature, + ESISBlob, + ESISSignatureAlgorithm, + ESISSignatureCertificateChain, + ESISDataIndex, + ESISCapabilities, + // insert new fields here + ESISUnknown + } TFieldType; + + typedef enum + { + EDbgDefault = 0, + EDbgDataChecksum = 0x01, + EDbgControllerChecksum = 0x02, + EDbgCompress = 0x04, + EDbgNoCompress = 0x08, + } TDbgFlag; + +#ifdef GENERATE_ERRORS + typedef enum + { + EBugDefault = 0, + EBugCRCError = 0x0001, + EBugInvalidLength = 0x0002, + EBugMissingField = 0x0004, + EBugUnexpectedField = 0x0008, + EBugBigEndian = 0x0010, + EBugDuffFieldType = 0x0020, + EBugInvalidValues = 0x0040, + EBugHashError = 0x0080, + EBugNegativeLength = 0x0100, + EBugInsaneString = 0x0200, + EBugInsaneBlob = 0x0400, + EBugArrayCount = 0x0800, + EBug32As64 = 0x1000, + EBugUnknownField = 0x2000, + EBugEmptyCaps = 0x4000, + EBugUnknownData = 0x8000, + } TBug; +#endif // GENERATE_ERRORS + + typedef enum + { + EOptDefault = 0, + EOptIsUnicode = 1<<0, + EOptIsDistributable = 1<<1, + EOptIsCompareToMajor = 1<<2, + EOptNoCompress = 1<<3, + EOptShutdownApps = 1<<4, + EOptNonRemovable = 1<<5, + EOptROMUpgrade = 1<<6, + } THeadOpt; + + +public: + CSISFieldRoot (); + virtual ~CSISFieldRoot (); + +public: + /** + * Internalize the class + * @param aFile File stream from where data needs to be read. + * @param aContainerSize size of the content to be read. + * @param aArrayType Type of the array + */ + virtual void Read (TSISStream& aFile, const TFieldSize& aContainerSize, const TFieldType aArrayType = ESISUndefined) = 0; + /** + * Skip the file reading for this field. Read pointer will be moved to the + * next field to be read. + * @param aFile stream for which the data read should be skipped. + * @param aContainerSize size of the data to be skipped. + */ + virtual void Skip (TSISStream& aFile, const TFieldSize& aContainerSize) const = 0; + /** + * Externalize the class + * @param aFile File stream to which the data needs to be written. + * @param aIsArrayElement whether the structure is part of an array or not. + */ + virtual void Write (TSISStream& aFile, const bool aIsArrayElement) const = 0; + + /** + * This function verifies the structure. If verification of object fails, throw an exception + * aLanguages >= 1 + * @param aLanguages - language + */ + virtual void Verify (const TUint32 aLanguages) const; + /** + * if object not acceptable, modify it. Assumes, once modified, will not need modifying again + */ + virtual void MakeNeat (); + /** + * @return if true, don't bother writing this record to disc + * if false, when reading, it'd better be there + */ + virtual bool WasteOfSpace () const; + /** + * Retrieves the size of the structure excluding the header. + * @param aInsideArray - whether the structure is part of an array or not. + * @return byte count. + */ + virtual TFieldSize ByteCount (const bool aInsideArray) const = 0; + /** + * Retrieves the in-stream size of data in BYTES of the structure with the header. + * @param aInsideArray - whether the structure is part of an array or not. + * @return byte count. + */ + virtual TFieldSize ByteCountWithHeader (const bool aInsideArray) const; + /** + * Sets the size of the structure. + * either a) set variable size field, or + * b) ensure fixed size field is expected size + * @param size - size of the structure. + */ + virtual void SetByteCount (const TFieldSize aSize); + /** + * Dump the entire content in hex format into the stream + */ + virtual void Dump (std::ostream& aStream, const int aLevel) const = 0; + /** + * Adds the write the package details into the stream. + * @param aStream - Stream in which the package entries need to be written. + * @param aVerbose - If this option is set then detail description of pkg + * will be written into the stream. + */ + virtual void AddPackageEntry(std::wostream& aStream, bool aVerbose) const; + /** + * Class name + */ + virtual std::string Name () const; + /** + * Calculates CRC of the content + * @param aCRC CRC value of the content + * @param aIsArrayElement whether the structure is part of an array or not. + */ + virtual void CalculateCrc (TCRC& aCRC, const bool aIsArrayElement) const = 0 ; +#ifdef GENERATE_ERRORS + virtual void CreateDefects (); +#endif // GENERATE_ERRORS + virtual void SkipOldWriteNew (TSISStream& aFile) const; + /** + * stream offset before the header + */ + virtual TSISStream::pos_type PreHeaderPos () const; + /** + * stream offset after the header + */ + virtual TSISStream::pos_type PostHeaderPos () const; + /** + * Calculates CRC of the content + * @param aIsArrayElement whether the structure is part of an array or not. + * @return CRC value of the content + */ + TCRC Crc (const bool aIsArrayElement = false) const; + std::string NoteIfOptional () const; + + /** + * Set Debug options + */ + static void SetDebugOption (const TDbgFlag aDbgFlag); + /** + * Check if a particular debug option is set or not. + */ + static bool IsDebugOptionSet (const TDbgFlag aDbgFlag); + /** + * Set file header option + */ + static void SetHeaderOption (const THeadOpt aHeaderOption); + /** + * Check if a particular file header option is set or not. + */ + static bool IsHeaderOptionSet (const THeadOpt aHeaderOption); + +#ifdef GENERATE_ERRORS + static void SetBug (const TBug aBug); + static bool IsBugSet (const TBug aBug); + static bool IsAnyBugSet (); + static void SetBugStart (const unsigned aStart); + static void SetBugRepeat (const unsigned aRepeat); + static bool IsBugToBeCreated (const TBug aBug); + static void AddRawDataValue (TSISStream& aFile,const unsigned aLength); +#endif // GENERATE_ERRORS + + /** + * Initialize the instance. + */ + static void InitInstance (); + +protected: + // calculates the CRC of the given data + static void DoTheCrc (TCRC& aCRC, const TUint8* aData, const unsigned aLen); + + // calculates CRC on the given data and the padding bytes that will be required + static void DoPaddedCrc(TCRC& aCRC, const TUint8* aData, const unsigned aLen); + + // calculate the CRC of just the padding for the given data length + static void PaddingCrc(TCRC& aCRC, const unsigned aLength); + + static unsigned SizeOfFieldType (); + +protected: + static TDbgFlag iDbgFlag; + static THeadOpt iOptions; + +#ifdef GENERATE_ERRORS + static TBug iBug; + static unsigned iBugStart; + static unsigned iBugRepeat; + static unsigned iBugRepeatCountdown; +#endif // GENERATE_ERRORS + }; + + +inline void CSISFieldRoot::AddPackageEntry(std::wostream& aStream, bool aVerbose) const + { + (void)aStream; + (void)aVerbose; + } + +inline void CSISFieldRoot::InitInstance () + { + srand (1); + // Please consult the VC6 documentation to understand the supplied parameter value. + } + + +inline void CSISFieldRoot::SetDebugOption (const TDbgFlag aDbgFlag) + { + iDbgFlag = static_cast (static_cast (iDbgFlag) + static_cast (aDbgFlag)); + } + +inline bool CSISFieldRoot::IsDebugOptionSet (const TDbgFlag aDbgFlag) + { + return (static_cast (iDbgFlag) & static_cast (aDbgFlag)) != 0; + } + +inline void CSISFieldRoot::SetHeaderOption (const THeadOpt aOptions) + { + iOptions = static_cast (static_cast (iOptions) + static_cast (aOptions)); + } + +inline bool CSISFieldRoot::IsHeaderOptionSet (const THeadOpt aOptions) + { + return (static_cast (iOptions) & static_cast (aOptions)) != 0; + } + +#ifdef GENERATE_ERRORS +inline void CSISFieldRoot::SetBug (const TBug aBug) + { + iBug = static_cast (static_cast (iBug) + static_cast (aBug)); + } + +inline bool CSISFieldRoot::IsBugSet (const TBug aBug) + { + return (static_cast (iBug) & static_cast (aBug)) != 0; + } + +inline bool CSISFieldRoot::IsAnyBugSet () + { + return iBug != EBugDefault; + } + +inline void CSISFieldRoot::SetBugStart (const unsigned aStart) + { + iBugStart = aStart; + } + +inline void CSISFieldRoot::SetBugRepeat (const unsigned aRepeat) + { + iBugRepeat = aRepeat; + iBugRepeatCountdown = aRepeat; + } + +inline void CSISFieldRoot::CreateDefects () + { + } +#endif // GENERATE_ERRORS + +inline std::string CSISFieldRoot::NoteIfOptional () const + { + return WasteOfSpace () ? " (Dropped)" : std::string (); + } + + +inline void CSISFieldRoot::Verify (const TUint32 aLanguages) const + { + } + + +inline bool CSISFieldRoot::WasteOfSpace () const + { + return false; + } + + +inline CSISFieldRoot::TFieldSize CSISFieldRoot::ByteCountWithHeader (const bool aInsideArray) const + { + return ByteCount (aInsideArray); + } + + +inline void CSISFieldRoot::SetByteCount (const TFieldSize aSize) + { + assert (aSize == ByteCount (false)); + } + + +inline void CSISFieldRoot::MakeNeat () + { + } + + +inline std::string CSISFieldRoot::Name () const + { + return std::string (); + } + + +inline unsigned CSISFieldRoot::SizeOfFieldType () + { + return sizeof (TUint32); + } + +inline void CSISFieldRoot::SkipOldWriteNew (TSISStream& aFile) const + { + } + +inline TSISStream::pos_type CSISFieldRoot::PreHeaderPos () const + { + return 0; + } + +inline TSISStream::pos_type CSISFieldRoot::PostHeaderPos () const + { + return 0; + } + +TSISStream& operator >> (TSISStream& aFile, CSISFieldRoot::TFieldType& aType); +TSISStream& operator << (TSISStream& aFile, const CSISFieldRoot::TFieldType aType); + +#endif // __FIELDROOT_H__ +