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

//

#include <bttypes.h>

#include <bt_sock.h>

/** 

Constructor

Start with no requests to update the required configuration.

*/

EXPORT_C TL2CapConfig::TL2CapConfig()

 : iSpecifiedMask(ENoConfigElementsSpecified)

 	{

 	}

/** 

Request a new preferred Max Transmit Unit size.

The L2CAP channel configuration process will attempt to configure with this MTU

size. The resulting negotiated MTU will be at most this size and at least the

size given by the minimum acceptable MTU option (@see SetMinMTU).

Please note that if the minimum acceptable MTU is not specified along with this

parameter, it is taken to be equal to the preferred value, so a smaller MTU

value will not be accepted from the peer during the negotiation.

@param aSize the MTU size for use in configuration

@return error code, KErrArgument if MTU set too small, otherwise KErrNone

*/

EXPORT_C TInt TL2CapConfig::SetMaxTransmitUnitSize(TUint16 aSize)

	{

	TInt rerr = KErrArgument;

	if(aSize >= KL2MinMTU)

		{		

		iMTUSize = aSize;

		iSpecifiedMask |= EMTUSizeSpecifiedMask;

		rerr = KErrNone;

		}

	return rerr;

	}

/** 

Returns preferred MTU.

Also allows the user to know whether that value has been set, 

or whether it is a random value that will be ignored. 

This is done via the parameter 'aIsSpecified'. 

@param aIsSpecified Used to tell the caller whether the MTU value has been set. 

@return preferred MTU

*/

EXPORT_C TUint16 TL2CapConfig::MaxTransmitUnitSize(TBool& aIsSpecified) const

	{

	aIsSpecified = ((iSpecifiedMask & EMTUSizeSpecifiedMask) != 0);

	return iMTUSize;

	}

/** 

Request a new preferred Max Receive Unit size.

The L2CAP channel configuration process will attempt to configure with this MRU

size.  The resulting negotiated MRU will be at most this size and at least the

size given by the minimum acceptable MRU option (@see SetMinMRU).

Please note that if the minimum acceptable MRU is not specified, it is taken by

APIs using this class to be equal to the protocol minimum (48 bytes). 

@param aSize the MRU size for use in configuration

@return error code, KErrArgument if MRU set too small, otherwise KErrNone

*/

EXPORT_C TInt TL2CapConfig::SetMaxReceiveUnitSize(TUint16 aSize)

	{

	TInt rerr = KErrArgument;

	if(aSize >= KL2MinMTU)

		{		

		iMRUSize = aSize;

		iSpecifiedMask |= EMRUSizeSpecifiedMask;

		rerr = KErrNone;

		}

	return rerr;

	}

/** 

Returns preferred MRU.

Also allows the user to know whether that value has been set, 

or whether it is a random value that will be ignored. 

This is done via the parameter 'aIsSpecified'. 

@param aIsSpecified Used to tell the caller whether the MRU value has been set. 

@return preferred MRU

*/

EXPORT_C TUint16 TL2CapConfig::MaxReceiveUnitSize(TBool& aIsSpecified) const

	{

	aIsSpecified = ((iSpecifiedMask & EMRUSizeSpecifiedMask) != 0);

	return iMRUSize;

	}

/**

Set the minimum MTU acceptable during L2CAP channel configuration.

The configuration process will attempt to configure with the largest possible

MTU that's greater than or equal to this boundary and less than or equal to

the preferred value (@see SetMaxTransmitUnitSize) or the preferred stack

default.

A peer's proposal of any value below the minimum will be rejected and replied to

with a value equal to the acceptable minimum. The peer will then choose to

either close the connection or proceed with the acceptable minimum.

@param aSize the smallest acceptable MTU size

@return error code, KErrArgument if MTU set too small, otherwise KErrNone

*/

EXPORT_C TInt TL2CapConfig::SetMinMTU(TUint16 aSize)

	{

	TInt rerr = KErrArgument;

	if(aSize >= KL2MinMTU)

		{		

		iMinMTUSize = aSize;

		iSpecifiedMask |= EMinMTUSizeSpecifiedMask;

		rerr = KErrNone;

		}

	return rerr;

	}

/** 

Returns the minimum acceptable negotiated MTU.

Also allows the user to know whether that value has been set, 

or whether it is a random value that will be ignored. 

This is done via the parameter 'aIsSpecified'. 

@param aIsSpecified Used to tell the caller whether the smallest acceptable MTU

	value has been set. 

@return Requested smallest acceptable MTU.

*/

EXPORT_C TUint16 TL2CapConfig::MinMTU(TBool& aIsSpecified) const

	{

	aIsSpecified = ((iSpecifiedMask & EMinMTUSizeSpecifiedMask) != 0);

	return iMinMTUSize;

	}

/**

Set the minimum MRU acceptable during L2CAP channel configuration.

The configuration process will attempt to configure with the largest possible

MRU that's greater than or equal to this boundary and less than or equal to

the preferred value (@see SetMaxReceiveUnitSize) or the preferred stack

default.

If the peer proposes an MRU below the minimum the L2CAP channel will be

disconnected, so this option should not be specified unless the application/profile

requires a guarantee of MRU of certain size and can not work with a smaller one.

@param aSize the smallest acceptable MRU size

@return error code, KErrArgument if MRU set too small, otherwise KErrNone

*/

EXPORT_C TInt TL2CapConfig::SetMinMRU(TUint16 aSize)

	{

	TInt rerr = KErrArgument;

	if(aSize >= KL2MinMTU)

		{		

		iMinMRUSize = aSize;

		iSpecifiedMask |= EMinMRUSizeSpecifiedMask;

		rerr = KErrNone;

		}

	return rerr;

	}

/** 

Returns the minimum acceptable negotiated MRU.

Also allows the user to know whether that value has been set, 

or whether it is a random value that will be ignored. 

This is done via the parameter 'aIsSpecified'. 

@param aIsSpecified Used to tell the caller whether the smallest acceptable MRU

	value has been set. 

@return Requested smallest acceptable MRU.

*/

EXPORT_C TUint16 TL2CapConfig::MinMRU(TBool& aIsSpecified) const

	{

	aIsSpecified = ((iSpecifiedMask & EMinMRUSizeSpecifiedMask) != 0);

	return iMinMRUSize;

	}

/** 

Request a reliable channel.

A reliable channel relies on the retransmission by L2Cap of unacknowledged 

L2Cap packets. 

Retransmissions are continued for a specified length of time. 

If this time is exceeded the L2Cap channel is disconnected.

The resulting behaviour depends on the setting of the LegacyModesDisallowed

option (@see SetLegacyModesDisallowed). If that option is disabled (which is the

default setting), then the channel mode attempted in L2CAP configuration process

will be Enhanced Retransmission Mode if the peer supports it, else

Retransmission Mode if the peer supports it, else Basic Mode.

If the LegacyModesDisallowed option is enabled, then the connection will only

be made if the peer supports and accepts the Enhanced Retransmission Mode.

If it doesn't then the connection will not be made.

Note that due to the nature of the negotiation process, it is not guranteed that

a mode will be negotiated even if it's supported by a peer.

The KL2CAPNegotiatedChannelMode socket option can be used to obtain the

negotiated channel mode after a socket has been connected.

@param aRetransmissionTimer The length of time allowed for l2Cap transmissions.

Note that the value of this parameter does not directly drive the L2CAP

retransmission timer. It is instead translated into a corresponding value for

the maximum number of transmissions of a single packet. If that number is

exceeded, then the connection is closed.

@return error code, currently KErrNone

*/

EXPORT_C TInt TL2CapConfig::ConfigureReliableChannel(TUint16 aRetransmissionTimer)

	{

	iChannelReliability = EReliableChannel;

	iChannelReliabilityTimer = aRetransmissionTimer;

	iSpecifiedMask |= EReliabilitySpecifiedMask;

	return KErrNone;

	}

/** 

Request a reliable channel.

This is a deprecated version of the ConfigureReliableChannel method and its

behaviour is exactly the same.

@param aRetransmissionTimer The length of time allowed for l2Cap transmissions

@return error code, currently KErrNone

@deprecated

Use ConfigureReliableChannel(TUint16 aRetransmissionTimer) instead

*/

EXPORT_C TInt TL2CapConfig::SetupReliableChannel(TUint16 aRetransmissionTimer)

	{

	iChannelReliability = EReliableChannel;

	iChannelReliabilityTimer = aRetransmissionTimer;

	iSpecifiedMask |= EReliabilitySpecifiedMask;

	return KErrNone;

	}

/** 

Request an unreliable channel.

An unreliable channel allows L2Cap packets to be dropped by the baseband.

It helps to maintain low latency at the cost of reliability.

The resulting behaviour depends on the setting of the LegacyModesDisallowed

option (@see SetLegacyModesDisallowed). If that option is disabled (which is the

default setting), then the channel mode attempted in L2CAP configuration process

will be Streaming Mode if the peer supports it, else Flow Control Mode if the

peer supports it, else Basic Mode.

If the LegacyModesDisallowed option is enabled, then the connection will only

be made if the peer supports and accepts Streaming Mode. If it doesn't then the

connection will not be made.

Note that due to the nature of the negotiation process, it is not guranteed that

a mode will be negotiated even if it's supported by a peer.

The KL2CAPNegotiatedChannelMode socket option can be used to obtain the

negotiated channel modes after a socket has been connected.

@param aObsolescenceTimer The time after which a packet may be dropped 

or "flushed" by the baseband. Note that outgoing packet flushing may not be

implemented on all Symbian OS platforms.

@return error code, KErrArgument if the obsolescence time is made shorter than is 

physically possible, otherwise KErrNone

*/

EXPORT_C TInt TL2CapConfig::ConfigureUnreliableChannel(TUint16 aObsolescenceTimer)

	{

	TInt rerr = KErrNone;

	// Only flush timers above a certain physical limit are permitted.

	if(aObsolescenceTimer < EMinDataObsolescenceTimeout)

		{

		rerr = KErrArgument;

		}

	else

		{

		iChannelReliability = EUnreliableChannel;

		iChannelReliabilityTimer = aObsolescenceTimer;

		iSpecifiedMask |= EReliabilitySpecifiedMask;

		}

	return rerr;

	}

/** 

Request an unreliable channel.

This is a deprecated version of the ConfigureReliableChannel method and its

behaviour is exactly the same.

@param aObsolescenceTimer The time after which a packet may be dropped 

or "flushed" by the baseband.

@return error code, KErrArgument if the obsolescence time is made shorter than is 

physically possible, otherwise KErrNone

@deprecated

Use ConfigureUnreliableChannel(TUint16 aObsolescenceTimer) instead

*/

EXPORT_C TInt TL2CapConfig::SetupUnreliableChannel(TUint16 aObsolescenceTimer)

	{

	TInt rerr = KErrNone;

	// Only flush timers above a certain physical limit are permitted.

	if(aObsolescenceTimer < EMinDataObsolescenceTimeout)

		{

		rerr = KErrArgument;

		}

	else

		{

		iChannelReliability = EUnreliableChannel;

		iChannelReliabilityTimer = aObsolescenceTimer;

		iSpecifiedMask |= EReliabilitySpecifiedMask;

		}

	return rerr;

	}

/** 

Request an unreliable channel, but allow any channel mode to be negotiated.

This will configure the socket to prefer unreliable modes during L2CAP channel

configuration, but accept any mode proposed by the peer.

The purpose of this interface is to be used with listening sockets which need

to accept both reliable and unreliable mode connections on a single PSM.

The ConfigureReliableChannel and ConfigureUnreliableChannel methods should be

used in preference to this one in normal situations.

The LegacyModesDisallowed option does not influence the behavior of this method.

The KL2CAPNegotiatedChannelMode socket option can be used to obtain the

negotiated channel modes after a socket has been connected.

@param aObsolescenceTimer The time after which a packet may be dropped 

or "flushed" by the baseband if an Unreliable channel is negotiated.

Note that outgoing packet flushing may not be implemented on all Symbian OS

platforms.

@param aRetransmissionTimer The length of time allowed for l2Cap transmissions

if a Reliable channel is negotiated.

Note that the value of this parameter does not directly drive the L2CAP

retransmission timer. It is instead translated into a corresponding value for

the maximum number of transmissions of a single packet. If that number is

exceeded, then the connection is closed.

@return error code, KErrArgument if the obsolescence time is made shorter than is 

physically possible, otherwise KErrNone

*/

EXPORT_C TInt TL2CapConfig::ConfigureUnreliableDesiredChannel(TUint16 aObsolescenceTimer, TUint16 aRetransmissionTimer)

	{

	TInt rerr = KErrNone;

	// Only flush timers above a certain physical limit are permitted.

	if(aObsolescenceTimer < EMinDataObsolescenceTimeout)

		{

		rerr = KErrArgument;

		}

	else

		{

		iChannelReliability = EUnreliableDesiredChannel;

		iChannelReliabilityTimer = aObsolescenceTimer;

		iAdditionalChannelReliabilityTimer = aRetransmissionTimer;

		iSpecifiedMask |= EReliabilitySpecifiedMask;

		}

	return rerr;

	}

/** 

Disallow usage of legacy L2CAP channel modes.

This option influences the behavior of ConfigureReliableChannel and

ConfigureUnreliableChannel. If it's enabled, then only the newest

reliable/unreliable modes will be allowed during L2CAP channel configuration.

The default value is to allow the usage of legacy modes.

@param aDisallowed Whether the usage of legacy modes is disallowed.

*/

EXPORT_C void TL2CapConfig::SetLegacyModesDisallowed(TBool aDisallowed)

	{

	if (aDisallowed)

		{

		iSpecifiedMask |= ELegacyModesDisallowedSpecifiedMask;

		}

	else

		{

		iSpecifiedMask &= ~ELegacyModesDisallowedSpecifiedMask;

		}

	}

/** 

Checks if the usage of legacy L2CAP channel modes is disallowed.

The default value is to allow the usage of legacy modes.

@param aDisallowed Whether the usage of legacy modes is disallowed.

*/

EXPORT_C TBool TL2CapConfig::LegacyModesDisallowed() const

	{

	return iSpecifiedMask & ELegacyModesDisallowedSpecifiedMask;

	}

/** 

Returns the channel reliability and the associated timer.

Also allows the user to know whether reliability has been set up, 

or whether it is a random value that will be ignored. 

This is done via the parameter 'aIsSpecified'. 

The associated timer is the obsolescence timer if the channel is unreliable 

and the retransmission timer if it is reliable.

This is returned via the parameter 'aAssociatedTimer'.

Note that if ConfigureUnreliableDesiredChannel was used then both timer values

have been set and this method will only return the obsolescence timeout.

The overload of this method which doesn't return a timer value together

with the timer value getters can be used instead of this one to uniformly handle

all cases.

@param aIsSpecified Used to tell the caller whether reliability has been set up. 

@param aAssociatedTimer This is a 'return' value. The associated timer is the obsolescence timer if the channel is unreliable 

and the retransmission timer if it is reliable. 

@return the reliability

*/

EXPORT_C TL2CapConfig::TChannelReliability TL2CapConfig::ChannelReliability(TBool& aIsSpecified, TUint16& aAssociatedTimer) const

	{

	aIsSpecified = ((iSpecifiedMask & EReliabilitySpecifiedMask) != 0);

	aAssociatedTimer = iChannelReliabilityTimer;

	return iChannelReliability;

	}

/** 

Returns the channel reliability.

Also allows the user to know whether reliability has been set up, 

or whether it is a random value that will be ignored. 

This is done via the parameter 'aIsSpecified'. 

The associated timer is the obsolescence timer if the channel is unreliable, 

the retransmission timer if it is reliable, and both timers if it's 'unreliable

desired'.

The associated timer values can be obtained with RetransmissionTimer() and

ObsolescenceTimer() methods.

@param aIsSpecified Used to tell the caller whether reliability has been set up. 

@return the reliability

*/

EXPORT_C TL2CapConfig::TChannelReliability TL2CapConfig::ChannelReliability(TBool& aIsSpecified) const

	{

	aIsSpecified = ((iSpecifiedMask & EReliabilitySpecifiedMask) != 0);

	return iChannelReliability;

	}

/** 

Returns the retransmission timer.

@param aIsSpecified Used to tell the caller whether the timer value has been set.

@return The value of the timer.

*/

EXPORT_C TUint16 TL2CapConfig::RetransmissionTimer(TBool& aIsSpecified) const

	{

	TUint16 timer = 0;

	aIsSpecified = EFalse;

	TBool reliabilitySpecified = ((iSpecifiedMask & EReliabilitySpecifiedMask) != 0);

	if (reliabilitySpecified)

		{

		if (iChannelReliability == EReliableChannel)

			{

			aIsSpecified = ETrue;

			// It's the only timer specified, so it's in iChannelReliabilityTimer.

			timer = iChannelReliabilityTimer;

			}

		else if (iChannelReliability == EUnreliableDesiredChannel)

			{

			aIsSpecified = ETrue;

			// We've got 2 timers specified, Retransmission goes in the additional field

			// (see the note accompanying field declarations).

			timer = iAdditionalChannelReliabilityTimer;

			}

		}

	return timer;

	}

/** 

Returns the obsolescence timer.

@param aIsSpecified Used to tell the caller whether the timer value has been set.

@return The value of the timer.

*/

EXPORT_C TUint16 TL2CapConfig::ObsolescenceTimer(TBool& aIsSpecified) const

	{

	TUint16 timer = 0;

	aIsSpecified = EFalse;

	if ((iSpecifiedMask & EReliabilitySpecifiedMask) != 0)

		{

		if (iChannelReliability == EUnreliableChannel || iChannelReliability == EUnreliableDesiredChannel)

			{

			aIsSpecified = ETrue;

			// Flush timeout always goes in iChannelReliabilityTimer

			// (see the note accompanying field declarations).

			timer = iChannelReliabilityTimer;

			}

		}

	return timer;

	}

/** 

Request a new channel priority.

L2Cap channels have three priorities, low, medium, and high. Data on channels with 

higher priority may be sent before data on channels with lower priority.

@param aPriority the priority to be used for this L2Cap channel

@return error code, currently KErrNone

*/

EXPORT_C TInt TL2CapConfig::ConfigureChannelPriority(TL2CapConfig::TChannelPriority aPriority)