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

// Types that are needed across L2CAP source

// 

//

#ifndef L2TYPES_H

#define L2TYPES_H

#include <e32std.h>

#include <e32cons.h>

#include <e32base.h>

#include <bttypes.h>

#include <bt_sock.h>

#include "l2constants.h"

#include "l2util.h"

enum TSignallingCommand

	{

	ECommandReject        = 0x01,

	EConnectionRequest    = 0x02,

	EConnectionResponse   = 0x03,

	EConfigureRequest     = 0x04,

	EConfigureResponse    = 0x05,

	EDisconnectionRequest = 0x06,

	EDisconnectionResponse= 0x07,

	EEchoRequest          = 0x08,

	EEchoResponse         = 0x09,

	EInformationRequest   = 0x0A,

	EInformationResponse  = 0x0B

	};

enum TL2CAPCommandRejectReason

	{

	ECommandNotUnderstood = 0x00,

	EMTUExceeded          = 0x01,

	EInvalidCID           = 0x02

	};

struct TL2CAPCommandRejectData

	{

	TL2CAPCommandRejectReason iReason;

	TUint16 iMTUExceeded;

	TUint16 iLocalEndpoint;

	TUint16 iRemoteEndpoint;

	};

enum TConnectResponseResult

	{

	EConnectSuccess           = 0x0000,

	EConnectPending           = 0x0001,

	EConnectPSMNotSupported   = 0x0002,

	EConnectSecurityBlock     = 0x0003,

	EConnectNoResources       = 0x0004

	};

enum TConnectResponseStatus

	{

	EConnectPendNoFurtherInfo  = 0x0000,

	EConnectPendAuthentication = 0x0001,

	EConnectPendAuthorization  = 0x0002

	};

// L2Cap Entity Supported Features

enum TInfoType

	{

	EConnectionlessMTU 			= 0x0001,

	EExtendedFeaturesSupported 	= 0x0002

	};

enum TInfoReqResult

	{

	ESuccess 				= 0x0000,

	ENotsupported			= 0x0001

	};

enum TExtendedFeaturesType

	{

	ENoExtendedFeatures				= 0x00,

	EFlowControlMode 				= 0x01,	

	ERetransmissionMode				= 0x02,

	EBiDirectionalQOS				= 0x04,

	EEnhancedRetransmissionMode		= 0x08,

	EStreamingMode					= 0x10,

	EFCSOption						= 0x20,

	};

enum TL2CapEntityInfoState

	{

	EL2CapEntityInfoRequested	=0x00,

	EL2CapEntityInfoUndef		=0x01,

	EL2CapEntityInfoDefined 	=0x02

	};

NONSHARABLE_CLASS(TL2CapEntityInfo)

	{

public:

	TL2CapEntityInfo();

	TL2CapEntityInfo(TUint8 aExtendedFeatures);

	TL2CapEntityInfoState LinkInfoState() const;

	inline void SetLinkInfoState(TL2CapEntityInfoState aLinkInfoState);

	inline void  SetSupportFlowControl();

	inline void  SetSupportRetranmission();

	inline void  SetSupportBiDirectionalQos();

	inline void  SetSupportEnhancedRetransmissionMode();

	inline void  SetSupportStreamingMode();

	inline void  SetSupportFCSOption();

	inline TBool SupportsFlowControl() const;

	inline TBool SupportsRetranmission() const;

	inline TBool SupportsBiDirectionalQOS() const;

	inline TBool SupportsEnhancedRetransmissionMode() const;

	inline TBool SupportsStreamingMode() const;

	inline TBool SupportsFCSOption() const;

	TUint8 ExtendedFeatures() const;

private:

	TUint8 iExtendedFeatures;

	TL2CapEntityInfoState	iLinkInfoState;

	};

inline TL2CapEntityInfoState TL2CapEntityInfo::LinkInfoState() const

	{

	return (iLinkInfoState);

	}

inline void TL2CapEntityInfo::SetLinkInfoState(TL2CapEntityInfoState aLinkInfoState)

	{

	iLinkInfoState  = aLinkInfoState;

	}

inline TBool TL2CapEntityInfo::SupportsFlowControl() const

	{

	return (iExtendedFeatures & EFlowControlMode);

	}

inline TBool TL2CapEntityInfo::SupportsRetranmission() const

	{

	return (iExtendedFeatures & ERetransmissionMode);

	}

inline TBool TL2CapEntityInfo::SupportsBiDirectionalQOS() const

	{

	return (iExtendedFeatures & EBiDirectionalQOS);

	}

inline TBool TL2CapEntityInfo::SupportsEnhancedRetransmissionMode() const

	{

	return (iExtendedFeatures & EEnhancedRetransmissionMode);

	}

inline TBool TL2CapEntityInfo::SupportsStreamingMode() const

	{

	return (iExtendedFeatures & EStreamingMode);

	}

inline TBool TL2CapEntityInfo::SupportsFCSOption() const

	{

	return (iExtendedFeatures & EFCSOption);

	}

inline void TL2CapEntityInfo::SetSupportFlowControl()

	{

	iExtendedFeatures |=  EFlowControlMode;

	}

inline void TL2CapEntityInfo::SetSupportRetranmission()

	{

	iExtendedFeatures |= ERetransmissionMode;

	}

inline void TL2CapEntityInfo::SetSupportBiDirectionalQos()

	{

	iExtendedFeatures |= EBiDirectionalQOS;

	}

inline void TL2CapEntityInfo::SetSupportEnhancedRetransmissionMode()

	{

	iExtendedFeatures |= EEnhancedRetransmissionMode;

	}

inline void TL2CapEntityInfo::SetSupportStreamingMode()

	{

	iExtendedFeatures |= EStreamingMode;

	}

inline void TL2CapEntityInfo::SetSupportFCSOption()

	{

	iExtendedFeatures |= EFCSOption;

	}

inline TUint8 TL2CapEntityInfo::ExtendedFeatures() const

	{

	return iExtendedFeatures;

	}

// ****************************************************************

// *** L2Cap Config Types

// ****************************************************************

enum TConfigOptionType

	{

	// NB: Maximum number is 0x7F as anything higher will set hint bit

	EConfigOptionTypeMTU					= 0x01,

	EConfigOptionTypeFlushTimeoutDuration	= 0x02,

	EConfigOptionTypeQOS					= 0x03,

	EConfigOptionTypeRTxAndFEC 				= 0x04,

	EConfigOptionTypeFcs					= 0x05,

	};

enum TQOSServiceType

	{

	ENoTraffic  = 0x00,

	EBestEffort = 0x01,

	EGuaranteed = 0x02

	};

// All configuration options should be derived from this interface class.

// The interface specifies the mandatory operations for a config option class.

class ML2CapConfigurationOption

	{

public:

	enum TStandardOptionValue

		{

		EAbsoluteMinimumValue,

		ESpecMinimumValue,

		ESpecDefaultValue,

		EMaximumValue,

		EPreferredValue,

		};

	virtual TConfigOptionType OptionType() const = 0;

	// Option operators - these must be implemented by any new options.

	virtual void operator=(const ML2CapConfigurationOption& aOption) = 0;

	virtual TBool operator<=(const ML2CapConfigurationOption& aOption) const = 0;

	virtual TBool operator==(const ML2CapConfigurationOption& aOption) const = 0;

	};

NONSHARABLE_CLASS(TMTUOption) : public ML2CapConfigurationOption

	{

public:

	TMTUOption(TUint16 aMTU);

	TMTUOption(ML2CapConfigurationOption::TStandardOptionValue aStandardOption);

	// Accessor methods.

	inline TUint16 MTU() const;

	// Option operators

	void operator=(const ML2CapConfigurationOption& aOption);

	TBool operator<=(const ML2CapConfigurationOption& aOption) const;

	TBool operator==(const ML2CapConfigurationOption& aOption) const;

	TBool operator>(const ML2CapConfigurationOption& aOption) const;

	void operator=(const TMTUOption& aOption);

	TBool operator<=(const TMTUOption& aOption) const;

	TBool operator==(const TMTUOption& aOption) const;

	TBool operator>(const TMTUOption& aOption) const;

private:

	TConfigOptionType OptionType() const;

	// Option constants.

	const static TUint16 KAbsMinMTU		= 1;

	const static TUint16 KSpecMinMTU 	= KL2MinMTU;

	const static TUint16 KMaxMTU 		= KL2CapMaxMTUSize;

	const static TUint16 KDefaultMTU 	= KL2CapDefaultMTUSize;

	const static TUint16 KPreferredMTU 	= KL2CapPreferredMTUSize;

	TUint16 iMTU;

	};

// Accessor methods.

inline TUint16 TMTUOption::MTU() const

	{

	return iMTU;

	}

NONSHARABLE_CLASS(TFlushTimeoutDurationOption) : public ML2CapConfigurationOption

	{

public:

	TFlushTimeoutDurationOption(TUint16 aFlushTimeoutDuration);

	TFlushTimeoutDurationOption(ML2CapConfigurationOption::TStandardOptionValue aStandardOption);

	// Accessor methods.

	inline TUint16 FlushTimeoutDuration() const;

	// Option operators

	void operator=(const ML2CapConfigurationOption& aOption);

	TBool operator<=(const ML2CapConfigurationOption& aOption) const;

	TBool operator==(const ML2CapConfigurationOption& aOption) const;

	void operator=(const TFlushTimeoutDurationOption& aOption);

	TBool operator<=(const TFlushTimeoutDurationOption& aOption) const;

	TBool operator==(const TFlushTimeoutDurationOption& aOption) const;

private:

	TConfigOptionType OptionType() const;

	// Option constants.

	const static TUint16 KMinFlush 	= 0x0001;  // 1 ms

	const static TUint16 KMaxFlush 	= 0xffff;

	const static TUint16 KDefaultFlush = KMaxFlush;

	TUint16 iFlushTimeoutDuration;

	};

// Accessor methods.

inline TUint16 TFlushTimeoutDurationOption::FlushTimeoutDuration() const

	{

	return iFlushTimeoutDuration;

	}

NONSHARABLE_CLASS(TQualityOfServiceOption) : public ML2CapConfigurationOption

	{

public:

	TQualityOfServiceOption(TQOSServiceType aServiceType,

							TUint32 aTokenRate,

							TUint32 aTokenBucketSize,

							TUint32 aPeakBandwidth,

							TUint32 aLatency,

							TUint32 aDelayVariation);

	TQualityOfServiceOption(ML2CapConfigurationOption::TStandardOptionValue aStandardOption);

	// Accessor Methods

	inline TQOSServiceType ServiceType() const;

	inline TUint32 TokenRate() const;

	inline TUint32 TokenBucketSize() const;

	inline TUint32 PeakBandwidth() const;

	inline TUint32 Latency() const;

	inline TUint32 DelayVariation() const;

	// Option operators

	void operator=(const ML2CapConfigurationOption& aOption);

	TBool operator<=(const ML2CapConfigurationOption& aOption) const;

	TBool operator==(const ML2CapConfigurationOption& aOption) const;

	void operator=(const TQualityOfServiceOption& aOption);

	TBool operator<=(const TQualityOfServiceOption& aOption) const;

	TBool operator==(const TQualityOfServiceOption& aOption) const;

private:

	TConfigOptionType OptionType() const;

	// Option constants.

	const static TUint32 KMinTokenRate 				= 0x00000000;

	const static TUint32 KMinTokenBucketSize 		= 0x00000000;

	const static TUint32 KMinPeakBandwidth 			= 0x00000000;

	const static TUint32 KMinLatency 				= 0x00000000;

	const static TUint32 KMinDelayVariation 		= 0x00000000;

	const static TUint32 KMaxTokenRate 				= 0xffffffff;

	const static TUint32 KMaxTokenBucketSize 		= 0xffffffff;

	const static TUint32 KMaxPeakBandwidth 			= 0xffffffff;

	const static TUint32 KMaxLatency 				= 0xffffffff;

	const static TUint32 KMaxDelayVariation 		= 0xffffffff;

	const static TUint32 KDefaultTokenRate 			= 0x00000000;

	const static TUint32 KDefaultTokenBucketSize 	= 0x00000000;

	const static TUint32 KDefaultPeakBandwidth 		= 0x00000000;

	const static TUint32 KDefaultLatency 			= 0xffffffff;

	const static TUint32 KDefaultDelayVariation		= 0xffffffff;

	TQOSServiceType iServiceType;

	TUint32 iTokenRate;

	TUint32 iTokenBucketSize;

	TUint32 iPeakBandwidth;

	TUint32 iLatency;

	TUint32 iDelayVariation;

	};

inline TQOSServiceType TQualityOfServiceOption::ServiceType() const

	{

	return iServiceType;

	}

inline TUint32 TQualityOfServiceOption::TokenRate() const

	{

	return iTokenRate;

	}

inline TUint32 TQualityOfServiceOption::TokenBucketSize() const

	{

	return iTokenBucketSize;

	}

inline TUint32 TQualityOfServiceOption::PeakBandwidth() const

	{

	return iPeakBandwidth;

	}

inline TUint32 TQualityOfServiceOption::Latency() const

	{

	return iLatency;

	}

inline TUint32 TQualityOfServiceOption::DelayVariation() const

	{

	return iDelayVariation;

	}

// Note that this class does _not_ inherit from ML2CapConfigurationOption,

// as the implementation of comparison operations is not trivial and done outside

// of the class.

NONSHARABLE_CLASS(TRetransmissionAndFlowControlOption)

	{

public:

	TRetransmissionAndFlowControlOption(TL2CapChannelMode aLinkMode,

										TUint8 aTxWindowSize,

										TUint8 aMaxTransmit,

										TUint16 aRetransmissionTimeout,

										TUint16 aMonitorTimeout,

										TUint16 aMaximumPDUSize);

	TRetransmissionAndFlowControlOption(TL2CapChannelMode aMode, TBool aFillWithPreferredValues);

	inline TRetransmissionAndFlowControlOption();

	// Accessor methods.

	inline TL2CapChannelMode LinkMode() const;

	inline TUint8 LinkModeAsUnsignedByte() const;

	inline TUint8 TxWindowSize() const;

	inline TUint8 MaxTransmit() const;

	inline TUint16 RetransmissionTimeout() const;

	inline TUint16 MonitorTimeout() const;

	inline TUint16 MaximumPDUSize() const;

	inline void SetLinkMode(TL2CapChannelMode aLinkMode);

	inline void SetTxWindowSize(TUint8 aTxWindowSize);

	inline void SetMaxTransmit(TUint8 aMaxTransmit);

	inline void SetRetransmissionTimeout(TUint16 aRetransmissionTimeout);

	inline void SetMonitorTimeout(TUint16 aMonitorTimeout);

	inline void SetMaximumPDUSize(TUint16 aPDUSize);

	TBool operator==(const TRetransmissionAndFlowControlOption& aOption) const;

	static TBool EnhancedMaxTransmitLessOrEqual(TUint aLeft, TUint aRight);

	static TBool IsModeReliable(TL2CapChannelMode aMode);

    static TBool IsModeValid(TL2CapChannelMode aMode);

#ifdef __FLOG_ACTIVE

	// Required free buffer space is specified in KReadableDesSpaceRequired.

	void GetReadable(TDes& aBuf) const;

#endif

private:

	void Initialize(TBool aIsEnhanced, ML2CapConfigurationOption::TStandardOptionValue aStandardOption);

	TConfigOptionType OptionType() const;

public:

	// Note: 'Valid' means 'sensible for parsing at all', 'Acceptable' means valid AND

	// something we can agree to use (e.g. 10ms is a 'valid' retransmission time out, but

	// not something we should accept).

	// Option constants.

	const static TUint8  KMinValidTxWindowSize 		= 0x01;

	const static TUint8  KMinValidNumberTransmit 	= 0x01;

	// 100ms.  There could be a risk of denial of service if retransmissions / monitor

	// timers were permitted at a frequency greater than this.

	const static TUint16 KMinAcceptableRetransmissionTimeout	= 100;

	const static TUint16 KMinAcceptableMonitorTimeout 			= 100;

	const static TUint16 KMaxAcceptableRetransmissionTimeout	= 0xffff;

	const static TUint16 KMaxAcceptableMonitorTimeout 			= 0xffff;

	const static TUint16 KMinValidMaximumPDUSize 			= 0x01;

	const static TUint16 KMaxAcceptableMaximumPDUSize		= 0xffff;

	const static TUint8  KMaxValidLegacyTxWindowSize 		= 32;

	const static TUint8  KMaxValidEnhancedTxWindowSize 		= 63;

	const static TUint8  KMaxValidLegacyNumberTransmit		= 0xff;

	const static TUint8  KMaxValidEnhancedNumberTransmit	= 0x0;	// 0 stands for infinity

	const static TUint8  KDefaultLegacyTxWindowSize 	= 32;

	const static TUint8  KDefaultEnhancedTxWindowSize 	= 16;

	const static TUint8  KDefaultNumberTransmit 		= 10;

	// Note: due to differences in the negotiation process, this default retransmission

	// timeout value is used in outgoing direction for ERTM and in incoming direction for

	// RTM (i.e. with RTM we'll actually use peer-proposed value for our retransmission

	// timer and the remote will use this one). 

	const static TUint16 KDefaultRetransmissionTimeout	= 2000;

	const static TUint16 KDefaultMonitorTimeout 		= 12000;

	const static TUint16 KDefaultMaximumPDUSize 		= 0xffff;

	const static TInt KReadableDesSpaceRequired = 128;

private:

	TL2CapChannelMode iLinkMode;

	TUint8 iTxWindowSize;

	TUint8 iMaxTransmit;

	TUint16 iRetransmissionTimeout;

	TUint16 iMonitorTimeout;

	TUint16 iMaximumPDUSize;

	};

inline TRetransmissionAndFlowControlOption::TRetransmissionAndFlowControlOption()

 :	iLinkMode(EL2CAPBasicMode),

 	iTxWindowSize(0),

 	iMaxTransmit(0),

 	iRetransmissionTimeout(0),

	iMonitorTimeout(0),

	iMaximumPDUSize(0)

	{}

// Accessor methods.

inline TL2CapChannelMode TRetransmissionAndFlowControlOption::LinkMode() const