diff -r 000000000000 -r d0791faffa3f backupandrestore/backupengine/inc/sbedataowner.h
--- /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__