--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/backupandrestore/backupengine/inc/sbedataowner.h Tue Feb 02 01:11:40 2010 +0200
@@ -0,0 +1,476 @@
+/**
+* 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 "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:
+* Declaration of CDataOwner
+*
+*
+*/
+
+
+
+/**
+ @file
+*/
+#ifndef __DATAOWNER_H__
+#define __DATAOWNER_H__
+
+/// System
+#include <e32base.h>
+#include <connect/sbtypes.h>
+#include <f32file.h>
+#include <xml/contenthandler.h> // MContentHandler mix in class
+
+// Other
+#include "sbeparserproxy.h"
+#include "sbebufferhandler.h"
+#include "sbedataownermanager.h"
+
+using namespace Xml;
+
+namespace conn
+ {
+
+ void CleanupRPointerArray(TAny* aPtr);
+
+ /** Name of Central Repository Server
+ @internalTechnology
+ */
+
+ _LIT(KCentRepProcessName, "centralrepositorysrv.exe");
+ _LIT8(KYes, "yes");
+
+ // Forwards
+ class CABServer;
+ class CDataOwnerManager;
+ class CBufferFileWriter;
+ class CBufferFileReader;
+ class CBufferSnapshotWriter;
+ class CBufferSnapshotReader;
+
+ /** Enumeration to specify if a selection should be included or excluded
+ @internalComponent
+ */
+ enum TSelectionType
+ {
+ EInclude, /*<!< Is included */
+ EExclude /*!< Is excluded */
+ };
+
+
+ /** Simple class to store registraion file selections
+ @internalComponent
+ */
+ class CSelection : public CBase
+ {
+ public:
+ static CSelection* NewLC(TSelectionType aType, const TDesC& aSelection);
+ ~CSelection();
+ TSelectionType SelectionType() const;
+ const TDesC& SelectionName() const;
+
+ private:
+ CSelection(TSelectionType aType);
+ void ConstructL(const TDesC& aSelection);
+
+ private:
+ TSelectionType iType; /*<! The type of the selection */
+ HBufC* iSelection; /*<! The actual selection */
+ };
+
+ /** An RArray of selections
+ @internalComponent
+ */
+ typedef RPointerArray<CSelection> RSelections;
+
+ /** Simple class to store passive information
+ @internalComponent
+ */
+ class TPassiveInformation
+ {
+ public:
+ TPassiveInformation() :
+ iSupported(EFalse),
+ iSupportsSelective(EFalse),
+ iDeleteBeforeRestore(EFalse),
+ iBaseBackupOnly(EFalse)
+ /** C++ Constructor
+ */
+ {}
+ public:
+ TUint8 iSupported; /*<! supported */
+ TUint8 iSupportsSelective; /*<! Supports selective */
+ TUint8 iDeleteBeforeRestore; /*<! Delete before restore */
+ TUint8 iBaseBackupOnly; /*<! Base backup */
+ };
+
+ /** Simple class to store public backup information
+ @internalComponent
+ */
+ class TPublicInformation
+ {
+ public:
+ TPublicInformation() :
+ iSupported(EFalse), iDeleteBeforeRestore(EFalse)
+ /** C++ Constructor
+ */
+ {}
+ public:
+ TUint8 iSupported; /*<! supported */
+ TUint8 iDeleteBeforeRestore; /*<! Delete before restore */
+ };
+
+ /** Simple class to store system backup information
+ @internalComponent
+ */
+ class TSystemInformation
+ {
+ public:
+ TSystemInformation() :
+ iSupported(EFalse)
+ /** C++ Constructor
+ */
+ {}
+ public:
+ TUint8 iSupported; /*!< backup system files */
+ };
+
+ /** Information about proxy data owners (i.e. CentRep etc.)
+ @internalComponent
+ */
+ class TProxyInformation
+ {
+ public:
+ /** C++ Constructor
+ */
+ TProxyInformation() : iDataRequested(EFalse), iDataSupplied(EFalse), iOpInProgress(EFalse)
+ {}
+ public:
+ TSecureId iSecureId; /*!< The secure ID of the proxy data manager */
+ TInt iDataRequested; /*!< Data has already been requested from this data owner. While restoring it is used for Proxy data length*/
+ TInt iDataSupplied; /*!< Data has already been supplied to this data owner. While restoring it is used for consumed/restored data length. */
+ TBool iOpInProgress; /*!< The proxy hasn't yet completed the op and is waiting a further call. While restoring it is used for proxy finished flag and 1 means proxy data finished 0 means has more data to store */
+ };
+
+ /** Simple class to store restore information
+ @internalComponent
+ */
+ class TRestoreInformation
+ {
+ public:
+ /** C++ Constructor
+ */
+ TRestoreInformation() :
+ iSupported(EFalse), iRequiresReboot(EFalse)
+ {};
+ public:
+ TUint8 iSupported; /*<! supported */
+ TUint8 iRequiresReboot; /*<! requires reboot */
+ };
+
+ /** enum representing TActiveType */
+ enum TActiveType
+ {
+ EActiveOnly = 0, /*<! Data Owner have Active Implementaion only */
+ EActiveAndProxyImpl = 1, /*<! Data Owner have Active and Proxy Implementation */
+ EProxyImpOnly = 2, /*<! Data Owner have only Proxy Implementation */
+ };
+
+ /** Simple class to store active information
+ @internalComponent
+ */
+ class TActiveInformation
+ {
+ public:
+ /** C++ Constructor
+ */
+ TActiveInformation() :
+ iSupported(EFalse), iRequiresDelayToPrepareData(EFalse),
+ iSupportsSelective(EFalse), iSupportsIncremental(ETrue), iActiveDataOwner(EFalse), iActiveType(EActiveOnly)
+ {
+ }
+ public:
+ TUint8 iSupported; /*<! supported? */
+ TName iProcessName; /*<! Active process name */
+ TUint8 iRequiresDelayToPrepareData; /*<! Requires delay to prepare data */
+ TUint8 iSupportsSelective; /*<! Supports selective */
+ TUint8 iSupportsIncremental; /*<! Supports Incremental */
+ TUint8 iActiveDataOwner; /*<! Although we say we're active, we're not really */
+ TActiveType iActiveType; /*<! Type of the Active DO */
+ };
+
+ /** Data Owner support classes and enums */
+
+ /**
+ This class holds the state of the data owner by the drive
+ @internalComponent
+ */
+ class TDataOwnerStateByDrive
+ {
+ public:
+ TDataOwnerStateByDrive(TDriveNumber aDrive) : iDrive(aDrive), iPassiveSnapshotReceived(EFalse),
+ iPassiveBaseDataReceived(EFalse), iPassiveIncDataReceived(EFalse),
+ iPassiveSnapshotRequested(EFalse), iPassiveBaseDataRequested(EFalse),
+ iPassiveIncDataRequested(EFalse), iActiveSnapshotReceived(EFalse),
+ iActiveBaseDataReceived(EFalse), iActiveIncDataReceived(EFalse),
+ iActiveSnapshotRequested(EFalse), iActiveBaseDataRequested(EFalse),
+ iActiveIncDataRequested(EFalse), iFirstActiveTransaction(ETrue),
+ iDeleteBeforeRestorePerformed(EFalse), iOpInProgress(EFalse)
+ {}
+
+ public:
+ TDriveNumber iDrive; /*!< Record whether any snapshot data has been received */
+ TUint8 iPassiveSnapshotReceived; /*!< Record whether any snapshot data has been received */
+ TUint8 iPassiveBaseDataReceived; /*!< Record whether or not any data has been received */
+ TUint8 iPassiveIncDataReceived; /*!< Record whether or not any data has been received */
+ TUint8 iPassiveSnapshotRequested; /*!< Record whether any snapshot data has been requested */
+ TUint8 iPassiveBaseDataRequested; /*!< Record whether or not any data has been requested */
+ TUint8 iPassiveIncDataRequested; /*!< Record whether or not any data has been requested */
+ TUint8 iActiveSnapshotReceived; /*!< Record whether any snapshot data has been received */
+ TUint8 iActiveBaseDataReceived; /*!< Record whether or not any data has been received */
+ TUint8 iActiveIncDataReceived; /*!< Record whether or not any data has been received */
+ TUint8 iActiveSnapshotRequested; /*!< Record whether any snapshot data has been requested */
+ TUint8 iActiveBaseDataRequested; /*!< Record whether or not any data has been requested */
+ TUint8 iActiveIncDataRequested; /*!< Record whether or not any data has been requested */
+ TUint8 iFirstActiveTransaction; /*!< Is this the first of an active transaction sequence */
+ TUint8 iDeleteBeforeRestorePerformed; /*!< Have we performed the delete before restore */
+ TUint8 iOpInProgress; /*!< The active data owner hasn't yet completed the op and is waiting a further call */
+ };
+
+
+ /**
+ This class holds the state of each proxy for a particular drive
+ @internalComponent
+ */
+ class TProxyStateByDrive
+ {
+ public:
+ TProxyStateByDrive(TDriveNumber aDrive, TInt aProxy) : iDrive(aDrive), iProxy(aProxy),
+ iDataRequested(EFalse), iDataSupplied(EFalse), iOpInProgress(EFalse)
+ {}
+
+ public:
+ TDriveNumber iDrive; /*!< The drive that this state relates to */
+ TInt iProxy; /*!< The proxy that this state relates to */
+ TUint8 iDataRequested; /*!< Data has already been requested from this data owner */
+ TUint8 iDataSupplied; /*!< Data has already been supplied to this data owner */
+ TUint8 iOpInProgress; /*!< The proxy hasn't yet completed the op and is waiting a further call */
+ };
+
+
+ /** Class to store the state of the data owner
+ @internalComponent
+ */
+ class TDOState
+ {
+ public:
+ TState iState; /*<! The current state of the DOM */
+ TDriveNumber iDriveNumber; /*<! The drive number for the current request */
+ TTransferDataType iTransferType; /*<! The transfer type of the current request */
+ };
+
+
+ /** Class representing the snapshot
+ @internalComponent
+ */
+ class CSnapshotHolder : public CBase
+ {
+ public:
+ // Constructors
+ static CSnapshotHolder* NewL();
+ static CSnapshotHolder* NewLC();
+ ~CSnapshotHolder();
+
+ // Members
+ TDriveNumber iDriveNumber;
+ RSnapshots iSnapshots;
+ private:
+ CSnapshotHolder();
+ };
+
+ /** A data owner
+
+ @internalTechnology
+ */
+ class CDataOwner : public CBase, public MContentHandler, public MValidationHandler
+ {
+ public:
+ static CDataOwner* NewL(TSecureId aSID, CDataOwnerManager* apDataOwnerManager);
+ static CDataOwner* NewLC(TSecureId aSID, CDataOwnerManager* pDataOwnerManager);
+ ~CDataOwner();
+
+
+ // Methods
+ void AddRegistrationFilesL(const TDesC& aFileName);
+ void ParseFilesL();
+ void GetExpectedDataSizeL(TTransferDataType aTransferType, TDriveNumber aDriveNumber, TUint& aSize);
+ void GetPublicFileListL(TDriveNumber aDriveNumber, RFileArray& aFiles);
+ void GetRawPublicFileListL(TDriveNumber aDriveNumber, RRestoreFileFilterArray& aRestoreFileFilter);
+ void SupplyDataL(TDriveNumber aDriveNumber, TTransferDataType aTransferType, TDesC8& aBuffer,
+ TBool aLastSection);
+ void RequestDataL(TDriveNumber aDriveNumber, TTransferDataType aTransferType, TPtr8& aBuffer,
+ TBool& aLastSection);
+ void RestoreCompleteL();
+ void GetNextPublicFileL(TBool aReset, TDriveNumber aDriveNumber, TEntry& aEntry);
+
+ // Accessors
+ TSecureId SecureId() const;
+ TDataOwnerStatus ReadyState();
+ void SetReadyState(TDataOwnerStatus aDataOwnerStatus);
+ TCommonBURSettings CommonSettingsL();
+ TPassiveBURSettings PassiveSettingsL();
+ TActiveBURSettings ActiveSettingsL();
+ void GetDriveListL(TDriveList& aDriveList);
+ void SetBackedUpAsPartial(TBool aPartial);
+ TBool PartialAffectsMe() const;
+ void StartProcessIfNecessaryL();
+ void BuildDriveStateArrayL();
+ void DisableSystemData();
+ TActiveInformation ActiveInformation();
+ TBool ValidFileL(const TDesC& aFileName);
+
+ // MContentHandler
+ void OnStartDocumentL(const RDocumentParameters& aDocParam, TInt aErrorCode);
+ void OnEndDocumentL(TInt aErrorCode);
+ void OnStartElementL(const RTagInfo& aElement, const RAttributeArray& aAttributes, TInt aErrorCode);
+ void OnEndElementL(const RTagInfo& aElement, TInt aErrorCode);
+ void OnContentL(const TDesC8& aBytes, TInt aErrorCode);
+ void OnStartPrefixMappingL(const RString& aPrefix, const RString& aUri, TInt aErrorCode);
+ void OnEndPrefixMappingL(const RString& aPrefix, TInt aErrorCode);
+ void OnIgnorableWhiteSpaceL(const TDesC8& aBytes, TInt aErrorCode);
+ void OnSkippedEntityL(const RString& aName, TInt aErrorCode);
+ void OnProcessingInstructionL(const TDesC8& aTarget, const TDesC8& aData, TInt aErrorCode);
+ void OnError(TInt aErrorCode);
+ TAny* GetExtendedInterface(const TInt32 aUid);
+ // MContentHandler
+
+ private:
+ // Constructors
+ CDataOwner(TSecureId aSID, CDataOwnerManager* apDataOwnerManager);
+ void ConstructL();
+
+ // Methods
+ void PrivatePathL(const TDesC& aFileName);
+ void ParseFileL(const TDesC& aFileName);
+ TInt GetDrive(const TDesC& aPath) const;
+ void BuildFileListL(const RSelections& aFileSelection,
+ const TDriveNumber aDriveNumber,
+ const TTransferDataType aTransferType,
+ const TBool aIsPublic,
+ RSnapshots* apSnapshot,
+ RFileArray* apFileEntries,
+ CDesCArray* apFileNames);
+ void AddDBMSFilesL(TDriveNumber aDriveNumber,
+ CDesCArray* apFileNames,
+ RFileArray* apEntries);
+ void ParseDirL(const TDesC& aDirName,
+ const RArray<TPtrC>& aExclude,
+ const TTransferDataType aTransferType,
+ const TBool aIsPublic,
+ RSnapshots* apSnapshots,
+ RFileArray* apFileEntries,
+ CDesCArray* apFileNames);
+ TBool IsExcluded(const TBool aIsPublic, const TDesC& aFileName, const RArray<TPtrC>& aExclude);
+ void IsNewerL(const TDesC& aFileName, const TEntry& aFile, const RSnapshots* aSnapshots, TBool& aNewer);
+ RSnapshots* FindSnapshot(TDriveNumber aDriveNumber);
+ void ResetState();
+ TDataOwnerStateByDrive& StateByDriveL(TDriveNumber& aDrive);
+ TProxyStateByDrive& ProxyStateByDriveL(TDriveNumber& aDrive, TInt aProxy);
+ void CleanupBeforeRestoreL(TDriveNumber& aDriveNumber);
+
+ // Supply
+ void SupplyPassiveSnapshotDataL(TDriveNumber aDriveNumber, TDesC8& aBuffer, TBool aLastSection);
+ void SupplyPassiveBaseDataL(TDriveNumber aDriveNumber, TDesC8& aBuffer, TBool aLastSection);
+
+ // Request
+ void RequestPassiveSnapshotDataL(TDriveNumber aDriveNumber, TPtr8& aBuffer, TBool& aLastSection);
+ void RequestPassiveDataL(TTransferDataType aTransferType, TDriveNumber aDriveNumber, TPtr8& aBuffer, TBool& aLastSection);
+ void ProcessRequestDataL(TDriveNumber aDriveNumber, TTransferDataType aTransferType,
+ TPtr8& aBuffer, TBool& aLastSection);
+ void ProcessSupplyDataL(TDriveNumber aDriveNumber, TTransferDataType aTransferType,
+ TDesC8& aBuffer, TBool aLastSection);
+ TInt AddProxyToList(TProxyInformation aProxy);
+
+
+ // private methods for parsing
+ private:
+ // Element handlers
+ void HandleBackupRegistrationL(const RAttributeArray& aAttributes);
+ void HandlePathL(const TSelectionType aType, const RAttributeArray& aAttributes, const TBool aDir);
+ TInt HandlePassiveBackup(const RAttributeArray& aAttributes);
+ TInt HandlePublicBackup(const RAttributeArray& aAttributes);
+ TInt HandleSystemBackup(const RAttributeArray& aAttributes);
+ TInt HandleCenrepBackup(const RAttributeArray& aAttributes);
+ TInt HandleProxyDataManager(const RAttributeArray& aAttributes);
+ TInt HandleDBMSBackupL(const RAttributeArray& aAttributes);
+ TInt HandleActiveBackupL(const RAttributeArray& aAttributes);
+ TInt HandleRestore(const RAttributeArray& aAttributes);
+ private:
+ // Internal
+ TDOState iState; /*<! The state of the data owner */
+ TDataOwnerStatus iStatus; /*!< Is the DO ready for operations - only relevant for active */
+ CDesCArray* iRegistrationFiles; /*<! A list of registration files for this data owner */
+ TUint8 iFilesParsed; /*<! Have we parsed the registration files */
+ TUint8 iPrimaryFile; /*<! Have we found a primary file */
+ TUint8 iBackupAsPartial; /*!< Will this DO be backed up as partial */
+
+ // Options
+ TSecureId iSecureId; /*<! The data owners SID */
+ TPassiveInformation iPassiveInformation; /*<! Passive backup information */
+ TPublicInformation iPublicInformation; /*<! Public backup information */
+ TSystemInformation iSystemInformation; /*<! System backup information */
+ TActiveInformation iActiveInformation; /*<! Active information */
+ TRestoreInformation iRestoreInformation; /*<! restore information */
+ RArray<TProxyInformation> iProxyInformationArray; /*!< The various proxies that we support */
+ TBufC<KMaxPackageNameLength> iName; /*<! The data owners nice name */
+ RArray<TDataOwnerStateByDrive> iStateByDrive; /*<! Array storing the state of the DO's by drive */
+ RArray<TProxyStateByDrive> iProxyStateByDrive; /*<! Array storing the state of the proxies for each drive */
+ RArray<TUid> iDBMSSelections; /*<! Array storing the list of DBMS selections */
+
+ // Reader\Writer handlers
+ CBufferFileWriter* iBufferFileWriter; /*<! Handles writing files to the buffer */
+ CBufferFileReader* iBufferFileReader; /*<! Handles reading files from the buffer */
+ CBufferSnapshotWriter* iBufferSnapshotWriter; /*<! Handles writing snapshots to the buffer */
+ CBufferSnapshotReader* iBufferSnapshotReader; /*<! Handles reading snapshots from the buffer */
+
+ // Selections
+ RSelections iPassiveSelections; /*<! Passive selections */
+ RSelections iPublicSelections; /*<! Public selections */
+
+ // Snapshots
+ CSnapshotHolder* iTempSnapshotHolder; /*<! Hold a temporary snapshot */
+ RPointerArray<CSnapshotHolder> iSnapshots; /*<! Stores the snapshots we have been sent */
+
+ // Resources
+ CDataOwnerManager* ipDataOwnerManager; /*<! To access resources */
+ HBufC* iPrivatePath; /*<! The path to the private directory */
+
+ /* Simple enumeration: What is our current element?
+ */
+ enum TCurrentElement {ENoElement = 0, // No element
+ EPassive = 1, // Passive element
+ EPublic = 2 // Public element
+ };
+
+ TCurrentElement iCurrentElement; /*<! Current element */
+
+ RArray<RDir> iPublicDirStack; /*<! Stack of public directories for enumerating public files */
+ RPointerArray<HBufC> iPublicDirNameStack; /*<! Directory names corresponding to entries in the above stack */
+ RArray<TPtrC> iPublicExcludes; /*<! Stores list of excludes while enumerating public files */
+ TInt iPublicFileIndex; /*<! Index of current element being enumerated in public file list */
+ TInt iCurrentProxy; // Used to restore the proxy data
+
+ };
+
+ }
+#endif // __DATAOWNER_H__