// Copyright (c) 2003-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:

//

/**

 @file

 @publishedAll

 @released

*/

#ifndef __OBEXBASE_H

#define __OBEXBASE_H

#include <obextypes.h>

#include <mobexnotify.h>

class CObexTransportControllerBase;

class TObexTransportInfo;

class CObexPacket;

class CObexNotifyHandlerBase;

/**

@publishedAll

@released

This class is the common base class for any object which wishes

to use the Obex Server or Client.

The class which owns a CObexClient or CObexServer must be provide an object

derived from this class to handle the call from the Server/Client for a request

for a Password.

@see CObex::SetCallBack

*/

class MObexAuthChallengeHandler

	{

public:

	/**

	Indicates that the server/client has received an Authentication challenge. The challenge

	can only be responded to once a password has been retrieved by some means and passed

	back to the calling class. The password is passed back via CObex::UserPasswordL

	@param aRealm This will contain the Realm specified by the unit forcing the

	Authentication, if no UserID was supplied then this parameter will be of zero length. 

	*/

	virtual void GetUserPasswordL(const TDesC& aRealm) = 0;

	/**

 	Returns a null aObject if the extension is not implemented, or a pointer to another interface if it is.

	@param aInterface UID of the interface to return

	@param aObject the container for another interface as specified by aInterface

	*/

	IMPORT_C virtual void MOACH_ExtensionInterfaceL(TUid aInterface, void*& aObject);

	};

/**

This class is the common base class for CObexClient and CObexServer. It is 

an abstract class and cannot be instantiated in itself. However, it does 

contain user functionality common to both client and server connections.

Provides the basic OBEX transport functionality (sending and receiving 

files)

Client and server provide the more specialied APIs for

- initiation or response to puts & gets

- (possible) handling of more generalised 'objects' (prob. with data buffered through a file).

This class is not designed for user derivation

@publishedAll

@released

*/

NONSHARABLE_CLASS(CObex) : public CBase, protected MObexNotify

	{

public:

	/**

	Describes the information set or received in a SETPATH command.

	The first bit of iFlags, 0, can be set to indicate to the receiver of SETPATH to backup a level before applying the path name.

	The second bit of iFlags, 1, can be set to indicate to the receiver of SETPATH to NOT create the directory if it doesn't exist.

	The iConstants variable is always set to zero as it is reserved. 

	The iName variable indicates the directory to create or go to, and does not include the root directory of the receiver (i.e. 

	if the directory to be set is C:\notes then iName is set to "notes").

	 If  a name is not set then set CObex::TSetPathInfo::iNamePresent to false. 

	*/

	NONSHARABLE_CLASS(TSetPathInfo)

		{

	public:

		IMPORT_C TSetPathInfo();

		TSetPathInfo(const TObexSetPathData& aData);

		IMPORT_C TBool Parent() const;

		TUint8 iFlags;

		TUint8 iConstants;

		TBuf<KObexObjectDescriptionSize> iName;

		/** Whether iName is present in this SETPATH info */	

		TBool iNamePresent;	

	private:

		// This data padding has been added to help prevent future binary compatibility breaks	

		// Neither iPadding1 nor iPadding2 have been zero'd because they are currently not used

		TUint32     iPadding1; 

		TUint32     iPadding2; 				

		};

	/**

	Current obex connection state

	In general, the further through the enum the values are,

	the further through the connection process the state machine

	will be.

	*/

	enum TConnectState 

		{ 

		EConnIdle,					/** Nothing is happening */

		EConnTransport,				/** Transport Link connected not yet established true Link */

		EConnObex,					/** full connection established */

		ESimpleConnRequest,			/** Connect without Auth has been sent by ClientReceived by Server */

		EConnChallRxed,				/**  Server has issued a challenge, to a Client cionnect */

		ESimpleConnChallIssued,		/** Server, received Simple Connect but Server Challenge issued */

		EChallConnRequested,		/** Connect with Auth has been sent by Client/Received by Server */

		EChallConnChallIssued,		/** Server has sent a Challenge & Resp to a Client EChallConnRequest */

		EWaitForFinalResponse,		/** Client, waiting for final success/fail not chall-response expected

									    Server, Waiting for final Resp fromm Client to Challenge */

		EFinalResponseReceived,		/** Server, the final response has been received */

		EFinalChallRxed,			/** Server, Client connect with challenge, Server responds with challenge, Client re-issued original/new challenge */

		EWaitForUserInput,			/** waiting for the user */

		EDropLink					/** drop the link */

		};

	/**

	The Obex operation currently being performed.

	*/

	enum TOperation 

		{ 

		EOpConnect		= 0x00, /** Connect */

		EOpDisconnect	= 0x01, /** Disconnect */

		EOpPut			= 0x02, /** Put */

		EOpGet			= 0x03, /** Get */

		EOpSetPath		= 0x05, /** SetPath */

		EOpAbort		= 0xFF,	/** Abort - must fit in one pkt so final bit is always set */

		EOpAbortNoFBit	= 0x7F, /** Abort (internal, never transmitted) */

		EOpGetResponse  = 0xFD,	/** Internal - not actually an obex operation. */

		EOpIdle			= 0xFE,	/** Internal - not actually an obex operation. */

		};

	/**

	Flags to suppress the authentication elements of the authentication challenge header.

	*/

	enum TObexSuppressedAuthElements

		{

		EObexNoSuppressedAuthElements				= 0x00,

		EObexSuppressChallengeOptionsAuthElement	= 0x01,

		EObexSuppressRealmAuthElement				= 0x02,

		EObexSuppressAllAuthElements				= EObexSuppressChallengeOptionsAuthElement | EObexSuppressRealmAuthElement // Must be last

		};

	virtual ~CObex();

	IMPORT_C void SetCallBack(MObexAuthChallengeHandler& aCallBack);

	IMPORT_C TBool IsConnected() const;

	IMPORT_C TBool IsStrictPeer() const;

	IMPORT_C const TObexConnectInfo& LocalInfo() const;

	IMPORT_C TInt SetLocalWho(const TDesC8& aInfo); 

    IMPORT_C const TObexConnectInfo& RemoteInfo() const;

   	IMPORT_C void SuppressAuthenticationHeaderElements(TObexSuppressedAuthElements aSuppressedObexAuthElements);

	virtual void UserPasswordL( const TDesC& aPassword) = 0; 

	IMPORT_C void RemoteAddr(TSockAddr& anAddr); 

	TConnectState GetConnectState() const;

	IMPORT_C TBool IsAuthenticating() const;

	// Handling notified events.

	void NotifyProcess(CObexPacket& aPacket);

	void NotifyError(TInt aError);

	void NotifyTransportUp();

	void NotifyTransportDown(TBool);

public: // Implementation of MObexNotify Interface (No longer used)

	virtual void Process(CObexPacket& aPacket);

	virtual void Error(TInt aError) ;

	virtual void TransportUp();

	virtual void TransportDown(TBool aForceTransportDeletion);

protected:

	CObex();

	virtual void ConstructL(TObexTransportInfo& aObexTransportInfo);

	virtual TInt ParseConnectPacket(CObexPacket& aPacket) = 0;	

	void SetConnectState(TConnectState aNewState);

	IMPORT_C TConnectState ConnectState() const;	// same as GetConnectState - has to be maintained here for BC

	virtual void OnPacketReceive(CObexPacket& aPacket) =0;

	virtual void OnError(TInt aError) =0;

	virtual void OnTransportUp() =0;

	virtual void OnTransportDown() =0;

	void ProcessChallengeL(const TObexInternalHeader& hdr);			//process the received challenge

	void ProcessChallResponseL(const TObexInternalHeader& hdr);		//process the response to challenge

	TInt GenerateChallenge(CObexPacket& aPacket);					//generate a challenge 

	void PrepareChallResponseL(const TDesC& aPassword);				//generate a response to challenge

																		//after user Password input

	void ForcedTransportDown();

	void ControlledTransportDown();

	void RemoteInfoCleanup();

	void CancelObexConnection();

protected:

	TConnectState iConnectState;

	CObexTransportControllerBase* iTransportController;

	TObexConnectInfo iLocalInfo;

	TObexConnectInfo iRemoteInfo;

	MObexAuthChallengeHandler* iCallBack;

	TNonce iOutgoingNonce; //nonce used when challenging

	TNonce iIncomingNonce; //nonce used when receiving a challenge

	HBufC8* iChallPassword; //password used when challenging

	HBufC8* iRespPassword; //password used when responding to a challenge

	HBufC8* iRxChallenge;

	TBuf8<KChallResponseSize> iOutgoingChallResp;//response to the previously issued challenge

								//16 nonce, 16 digest resp, 20 UserID, 3*(tag+size)

	TBuf8<KChallResponseSize> iIncomingChallResp;//response received from previous challenge

	TBuf8<KObexRespSize> iIncomingRequestDigest;

	HBufC* iRemoteUID; //UID of remote device

	HBufC* iRemoteRealm;//Realm of remote device

	CObexAuthenticator* iAuthEngine;

	TBool iChallenge; //to challenge or not to challenge?

	TBool iUserIDRequested; //does the challenge insist that a UserID is returned

	TBool iReserved; //released boolean now available for future use

	TOperation iCurrentOperation;

	CObexNotifyHandlerBase* iNotifyHandler;

	TUint iSuppressedObexAuthElements;

	};

#endif // __OBEXBASE_H