// 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:
//

#ifndef L2CAPSIGPACKETCONFIGURE_H
#define L2CAPSIGPACKETCONFIGURE_H

#include "l2capCommand.h"

class CL2CapChannelConfig;
class TL2CapConfigParamOptions;

NONSHARABLE_CLASS(HConfigureRequest) : public HL2CapCommand
	{
public:	
	static HConfigureRequest* New(TL2CAPPort aRemotePort, CL2CapChannelConfig& aConfig,
                 				  TUint8 aRTXTimerDuration = KDefaultRTXTimerDuration,
	             				  TUint16 aERTXTimerDuration = KDefaultERTXTimerDuration);
	static TInt NewCommandIfValid(RMBufChain& aBuffer, HL2CapCommand*& aCommand);
	
	TBool ProcessCommand(CL2CapSignalHandler& aSignalHandler);

	inline TL2CAPPort DestinationCID() const;
	inline TConfigFlags Flags() const;
	inline void SetDestinationCID(TL2CAPPort aPort);
	inline void SetFlags(TConfigFlags aFlags);

	TInt ParseOptions(TL2CapConfigParamOptions& aConfigOptions, RMBufChain& aUnknownOptions) const;
	TInt AddOptionsToCommand(CL2CapChannelConfig& aConfig);

private:
	HConfigureRequest(RMBufChain& aCommand,
                 	  TUint8 aRTXTimerDuration = KDefaultRTXTimerDuration,
	                  TUint16 aERTXTimerDuration = KDefaultERTXTimerDuration);

private:
	const static TUint8 KConfigRequestEmptyLength	= 8;
	
	const static TUint8 KDestinationCIDOffset		= 4;
	const static TUint8 KFlagsOffset				= 6;
	const static TUint8 KOptionsOffset				= 8;
	
	const static TUint8 KNoConfigurationFlags		= 0;
	};

inline TL2CAPPort HConfigureRequest::DestinationCID() const
	{
	return GetLittleEndian16(KDestinationCIDOffset, iCommand);
	}

inline TConfigFlags HConfigureRequest::Flags() const
	{
	return GetLittleEndian16(KFlagsOffset, iCommand);
	}

inline void HConfigureRequest::SetDestinationCID(TL2CAPPort aPort)
	{
	PutLittleEndian16(aPort, KDestinationCIDOffset, iCommand);
	}

inline void HConfigureRequest::SetFlags(TConfigFlags aFlags)
	{
	PutLittleEndian16(aFlags, KFlagsOffset, iCommand);
	}


NONSHARABLE_CLASS(HConfigureResponse) :public HL2CapCommand
	{
public:
	static HConfigureResponse* New(TUint8 aId, TL2CAPPort aRemotePort, TConfigFlags aFlags, TConfigResponseResult aResult);
	static TInt NewCommandIfValid(RMBufChain& aBuffer, HL2CapCommand*& aCommand);
	
	TBool ProcessCommand(CL2CapSignalHandler& aSignalHandler);

	inline TL2CAPPort SourceCID() const;
	inline TConfigFlags Flags() const;
	inline TConfigResponseResult Results() const;
	inline void SetSourceCID(TL2CAPPort aPort);
	inline void SetFlags(TConfigFlags aFlags);
	inline void SetResults(TConfigResponseResult aResult);

	TInt ParseOptions(TL2CapConfigParamOptions& aConfigOptions, RMBufChain& aUnknownOptions) const;
	TInt AddOptionsToCommand(CL2CapChannelConfig& aConfig, TConfigResponseResult aResult);
	void AddUnknownOptionsToCommand(RMBufChain& aUnknownOptions);

public:
	// Used on creation to specify that no flags
	// (i.e., the continuation flag) are set.
	const static TUint8 KNoConfigurationFlags		= 0;

private:
	HConfigureResponse(RMBufChain& aCommand);
		
private:
	const static TUint8 KConfigResponseEmptyLength	= 10;
	
	const static TUint8 KSourceCIDOffset			= 4;
	const static TUint8 KFlagsOffset				= 6;
	const static TUint8 KResultOffset				= 8;
	const static TUint8 KOptionsOffset				= 10;
	};

inline TL2CAPPort HConfigureResponse::SourceCID() const
	{
	return GetLittleEndian16(KSourceCIDOffset, iCommand);
	}

inline TConfigFlags HConfigureResponse::Flags() const
	{
	return GetLittleEndian16(KFlagsOffset, iCommand);
	}

inline TConfigResponseResult HConfigureResponse::Results() const
	{
	return static_cast<TConfigResponseResult>(GetLittleEndian16(KResultOffset, iCommand));
	}

inline void HConfigureResponse::SetSourceCID(TL2CAPPort aPort)
	{
	PutLittleEndian16(aPort, KSourceCIDOffset, iCommand);
	}

inline void HConfigureResponse::SetFlags(TConfigFlags aFlags)
	{
	PutLittleEndian16(aFlags, KFlagsOffset, iCommand);
	}

inline void HConfigureResponse::SetResults(TConfigResponseResult aResult)
	{
	PutLittleEndian16(static_cast<TUint16>(aResult), KResultOffset, iCommand);
	}

NONSHARABLE_CLASS(TL2CapConfigParamOptions)
	{
public:
	TL2CapConfigParamOptions();

	inline void SetMtu(const TMTUOption& aMtu);
	inline TBool IsMtuSet() const;
	inline const TMTUOption& Mtu() const;

	inline void SetFlushTimeout(const TFlushTimeoutDurationOption& aFlushTimeout);
	inline TBool IsFlushTimeoutSet() const;
	inline const TFlushTimeoutDurationOption& FlushTimeout() const;
	
	inline void SetFec(const TRetransmissionAndFlowControlOption& aFec);
	inline TBool IsFecSet() const;
	inline const TRetransmissionAndFlowControlOption& Fec() const;

	inline void SetQos(const TQualityOfServiceOption& aQos);
	inline TBool IsQosSet() const;
	inline const TQualityOfServiceOption& Qos() const;

	TBool operator==(const TL2CapConfigParamOptions& aThat);

	TInt ParseOptions(TUint8 aOptionOffset, const RMBufChain& aCommand, RMBufChain& aUnknownOptions);
	
	static TInt AddConfigRequestOptions(CL2CapChannelConfig& aConfig, TUint8 aOptionOffset, RMBufChain& aOptions);
	static TInt AddConfigResponseOptions(CL2CapChannelConfig& aConfig, TUint8 aOptionOffset, RMBufChain& aOptions, TConfigResponseResult aResult);
	static TInt AddMtuOptionL(TInt16 aMtu, TUint8 aOptionOffset, RMBufChain& aOptions);
	static TInt AddFlushOptionL(TInt16 aFlushTimeout, TUint8 aOptionOffset, RMBufChain& aOptions);
	static TInt AddQosOptionL(const TQualityOfServiceOption& aQosOption, TUint8 aOptionOffset, RMBufChain& aOptions);
	static TInt AddFecOptionL(const TRetransmissionAndFlowControlOption& aFecOption, TUint8 aOptionOffset, RMBufChain& aOptions);
	static TBool VerifyOptionsStructure(TUint8 aOptionOffset, const RMBufChain& aCommand);
private:
	// Options Constants
	const static TUint8 KTypeOffset   			= 0;
	const static TUint8 KLengthOffset 			= 1;
	const static TUint8 KDataOffset   			= 2;
	const static TUint8 KOptionHeaderLength		= 2;

	const static TUint8 KMTUOptionDataLen 		= 2;
	const static TUint8 KFlushOptionDataLen		= 2;
	const static TUint8 KQOSOptionDataLen 		= 22;
	const static TUint8 KFECOptionDataLen		= 9;
	const static TUint8 KFcsOptionDataLen		= 1;
	
	//QOS Options Offsets
	const static TUint8 KQOSServiceTypeOffset 	= 1;
	const static TUint8 KTokenRateOffset 		= 2;
	const static TUint8 KTokenBucketSizeOffset 	= 6;
	const static TUint8 KPeakBandwidthOffset 	= 10;
	const static TUint8 KLatencyOffset 			= 14;
	const static TUint8 KDelayVariationOffset 	= 18;

	// FEC Options Offsets
	const static TUint8 KLinkModeOffset					= 0;
	const static TUint8 KTxWindowSizeOffset 			= 1;
	const static TUint8 KMaxTransmitOffset 				= 2;
	const static TUint8 KRetransmissionTimeoutOffset 	= 3;
	const static TUint8 KMonitorTimeoutOffset 			= 5;
	const static TUint8 KMaximumPDUSizeOffset 			= 7;

private:
	TBool								iMtuSet;
	TMTUOption							iMtu;

	TBool								iFlushTimeoutSet;
	TFlushTimeoutDurationOption			iFlushTimeout;

	TBool								iFecSet;
	TRetransmissionAndFlowControlOption iFec;

	TBool								iQosSet;
	TQualityOfServiceOption				iQos;
	};


inline void TL2CapConfigParamOptions::SetMtu(const TMTUOption& aMtu)
	{
	iMtu = aMtu;
	iMtuSet = ETrue;
	}

inline TBool TL2CapConfigParamOptions::IsMtuSet() const
	{ return iMtuSet; }

inline const TMTUOption& TL2CapConfigParamOptions::Mtu() const
	{ return iMtu; }

inline void TL2CapConfigParamOptions::SetFlushTimeout(const TFlushTimeoutDurationOption& aFlushTimeout)
	{
	iFlushTimeout = aFlushTimeout;
	iFlushTimeoutSet = ETrue;
	}

inline TBool TL2CapConfigParamOptions::IsFlushTimeoutSet() const
	{ return iFlushTimeoutSet; }

inline const TFlushTimeoutDurationOption& TL2CapConfigParamOptions::FlushTimeout() const
	{ return iFlushTimeout; }

inline void TL2CapConfigParamOptions::SetFec(const TRetransmissionAndFlowControlOption& aFec)
	{
	iFec = aFec;
	iFecSet = ETrue;
	}

inline TBool TL2CapConfigParamOptions::IsFecSet() const
	{ return iFecSet; }

inline const TRetransmissionAndFlowControlOption& TL2CapConfigParamOptions::Fec() const
	{ return iFec; }

inline void TL2CapConfigParamOptions::SetQos(const TQualityOfServiceOption& aQos)
	{
	iQos = aQos;
	iQosSet = ETrue;
	}

inline TBool TL2CapConfigParamOptions::IsQosSet() const
	{ return iQosSet; }

inline const TQualityOfServiceOption& TL2CapConfigParamOptions::Qos() const
	{ return iQos; }

#endif