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

// Generic functions associated with all Bluetooth socket addresses

// 

//

#include <bluetooth/logger.h>

#include <bt_sock.h>

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_BTLIB);

#endif

#ifdef _DEBUG

PANICCATEGORY("BtLib");

#endif

enum TBTSockPanics

	{

	EUnfinishedBusiness = 0,

	EBadArgument = 1,

	EBadRequest = 2,

	EBTExportedMethodMovedDLL =3,

	};

void Panic(TBTSockPanics aCode)

	{

	_LIT(KPanicName, "BTSock");

	User::Panic(KPanicName, aCode);

	}

EXPORT_C TBTSockAddr::TBTSockAddr()

/**

Constructor

@publishedAll

@released

*/

	{

	SetFamily(KBTAddrFamily);

	SetUserLen(sizeof(SBTAddrSecurity));

	AddressPtr().FillZ();

	// set default security

	TBTServiceSecurity defaultSec;

	defaultSec.SetAuthorisation(EFalse);

	defaultSec.SetAuthentication(EMitmNotRequired);

	defaultSec.SetDenied(EFalse);

	defaultSec.SetEncryption(EFalse);

	defaultSec.SetPasskeyMinLength(0);

	BTAddrSecStruct().iSecurity = defaultSec;

	}

EXPORT_C TBTSockAddr::TBTSockAddr(const TSockAddr &aAddr)

/**

Constructor taking socket address baseclass reference. Rather like a copy constructor

Copies the port number and the entirety of the user data, which conatins	

the Bluetooth Address and Security Settings	

The family type is set to KBTAddrFamily

@param aAddr a previously filled TSockAddr 

@publishedAll

@released

*/

	{

	SetFamily(KBTAddrFamily);

	SetPort(aAddr.Port());

	SetUserLen(sizeof(SBTAddrSecurity));

	// Copy the user data	

	// The strange cast is to get at UserPtr() while ensuring	

	// that the compiler does not try and create a temporary	

	Mem::Copy(UserPtr(), (*static_cast<const TBTSockAddr*>(&aAddr)).UserPtr(), GetUserLen());

	}

EXPORT_C TBTDevAddr TBTSockAddr::BTAddr() const

/**

Getter

@return The device address specified by this Socket address

@publishedAll

@released

*/

	{

	return BTAddrSecStruct().iAddress; 

	}

EXPORT_C void TBTSockAddr::SetBTAddr(const TBTDevAddr& aRemote)

/**

Sets BT address from a TBTDevAddr.

@param aRemote Bluetooth device address of remote device

@publishedAll

@released

*/

	{

	BTAddrSecStruct().iAddress = aRemote;

	}

EXPORT_C void TBTSockAddr::SetSecurity(const TBTServiceSecurity& aSecurity)

/**

Setter

Care needs to be taken when setting outgoing security as if a device in the system

is using pre-Bluetooth v2.1 hardware then connection attempts may fail.

@param aSecurity reference to const TBTServiceSecurity holding security settings

@publishedAll

@released

*/

	{

	BTAddrSecStruct().iSecurity = aSecurity;

	}

EXPORT_C TAny* TBTSockAddr::EndBTSockAddrPtr() const

	{

	return UserPtr()+sizeof(SBTAddrSecurity);

	}

TBTSockAddr::SBTAddrSecurity& TBTSockAddr::BTAddrSecStruct() const

	{

	return *reinterpret_cast<SBTAddrSecurity*>(UserPtr());

	}

TPtr8 TBTSockAddr::AddressPtr() const

	{

	return BTAddrSecStruct().iAddress.Des();

	}

EXPORT_C TBTServiceSecurity TBTSockAddr::BTSecurity() const

/**

Getter

@return Security settings	

*/

	{

	return BTAddrSecStruct().iSecurity;

	}

EXPORT_C TBTSockAddr& TBTSockAddr::Cast(const TSockAddr &aAddr)

/**

Utility function to downcast a TSockAddr to a TBTSockAddr

@return TBTSockAddr reference

*/

	{

	return *((TBTSockAddr*)&aAddr);

	}

/****** Inquiry Socket Addresses *****/

/** Constructor for TInquirySockAddr object

*/

EXPORT_C TInquirySockAddr::TInquirySockAddr()

	{

	SetFamily(KBTAddrFamily);

	SetUserLen(sizeof(SInquiryAddr));

	AddressPtr().FillZ();

	SetVersion(TVersion(1, 1, 0));

	}

/** Constructor taking socket address base class reference. Rather like a copy constructor

Copies the port number and the entirety of the user data, which contains	

the Bluetooth Address

The family type is set to KBTAddrFamily

@param aAddr a previously filled TSockAddr 

*/   

EXPORT_C TInquirySockAddr::TInquirySockAddr(const TSockAddr &aAddr)

	{

	SetFamily(KBTAddrFamily);

	SetUserLen(sizeof(SInquiryAddr));

	AddressPtr().Copy((*static_cast<const TInquirySockAddr*>(&aAddr)).AddressPtr());

	SetPort(aAddr.Port());

	InquiryAddrStruct() = TInquirySockAddr::Cast(aAddr).InquiryAddrStruct();

	SetVersion(TVersion(1, 1, 0));

	}

/** Getter.

@return The device address specified by this Socket address.

*/

EXPORT_C TBTDevAddr TInquirySockAddr::BTAddr() const

	{

	return InquiryAddrStruct().iAddress; 

	}

/** Setter.

@param aRemote is bluetooth device address

*/

EXPORT_C void TInquirySockAddr::SetBTAddr(const TBTDevAddr& aRemote)

	{

	InquiryAddrStruct().iAddress = aRemote;

	}

/** Utility function to downcast a TSockAddr to a TInquirySockAddr

@param aAddr Represents an end point address

@return  Socket address used for inquiries

*/

EXPORT_C TInquirySockAddr& TInquirySockAddr::Cast(const TSockAddr &aAddr)

	{

	return *((TInquirySockAddr *)&aAddr);

	}

/**  Getter for major service class of the device

 @return The major service class of device

*/

EXPORT_C TUint16 TInquirySockAddr::MajorServiceClass() const

	{

	return InquiryAddrStruct().iMajorServiceClass;

	}

/**  Sets major service class of the device

@param aClass is major service class to be assigned 

 */

EXPORT_C void TInquirySockAddr::SetMajorServiceClass(TUint16 aClass)

	{

	InquiryAddrStruct().iMajorServiceClass=aClass;

	}

/**  Getter for major device class

 @return The major class of device

*/

EXPORT_C TUint8 TInquirySockAddr::MajorClassOfDevice() const

	{

	return InquiryAddrStruct().iMajorDeviceClass;

	}

/**  Sets major device class

@param aClass is major class of device to be assigned 

*/

EXPORT_C void TInquirySockAddr::SetMajorClassOfDevice(TUint8 aClass)

	{

	InquiryAddrStruct().iMajorDeviceClass=aClass;

	}

/**  Getter for minor device class

 @return The minor class of device

*/

EXPORT_C TUint8 TInquirySockAddr::MinorClassOfDevice() const

	{

	return InquiryAddrStruct().iMinorDeviceClass;

	}

/**  Sets minor device class

@param aClass is minor device class to be assigned

 */

EXPORT_C void TInquirySockAddr::SetMinorClassOfDevice(TUint8 aClass)

	{

	InquiryAddrStruct().iMinorDeviceClass=aClass;

	}

/** Getter for Inquiry Access Code

 @return Inquiry Access Code 

*/

EXPORT_C TUint TInquirySockAddr::IAC() const

	{

	return InquiryAddrStruct().iIAC;

	}

/** Sets the Inquiry Access Code

@param aIAC is Inquiry Access Code to be assigned

*/

EXPORT_C void TInquirySockAddr::SetIAC(const TUint aIAC)

	{

	InquiryAddrStruct().iIAC=aIAC;

	}

/**  Utility function to get the host resolve action option

 @return action which can be KHostResInquiry and/or KHostResName 

*/

EXPORT_C TUint8 TInquirySockAddr::Action() const

	{

	return InquiryAddrStruct().iActionFlags;

	}

/**  Utility function to set the host resolve action option

@param aFlags can be KHostResInquiry and/or KHostResName 

 */

EXPORT_C void TInquirySockAddr::SetAction(TUint8 aFlags)

	{

	InquiryAddrStruct().iActionFlags=aFlags;

	}

/**  Utility function to get SInquiryAddr

@return SInquiryAddr class contained within the TInquirySockAddr

*/

EXPORT_C TInt8 TInquirySockAddr::Rssi() const

	{

	return InquiryAddrStruct().iRssi;

	}

EXPORT_C void TInquirySockAddr::SetRssi(const TInt8 aRssi)

	{

	InquiryAddrStruct().iRssi=aRssi;

	}

EXPORT_C TUint8 TInquirySockAddr::ResultFlags() const

	{

	return InquiryAddrStruct().iResultFlags;

	}

EXPORT_C void TInquirySockAddr::SetResultFlags(TUint8 aResultFlags)

	{

	InquiryAddrStruct().iResultFlags=aResultFlags;

	}

TInquirySockAddr::SInquiryAddr& TInquirySockAddr::InquiryAddrStruct() const

	{

	return *reinterpret_cast<SInquiryAddr*>(UserPtr());	// this class' data at end of superclass

	}

/**  Getter

@return bluetooth device address 

*/

TPtr8 TInquirySockAddr::AddressPtr() const

	{

	return InquiryAddrStruct().iAddress.Des();

	}

/** Getter

@return version information

*/

EXPORT_C TVersion TInquirySockAddr::Version() const

	{

	TInt major = InquiryAddrStruct().iFormatTypeField >> 6;

	TInt minor = InquiryAddrStruct().iFormatTypeField >> 4;

	minor &= 0x03; // 0011

	return TVersion(major, minor, 0); // build number unused and returned as zero

	}

/**

Sets a version number. Only the major and minor numbers of the TVersion parameter are used. Both these must be <=3.

@param aVersion TVersion specifying version number to be assigned 

@internalComponent 

*/

void TInquirySockAddr::SetVersion(TVersion aVersion)

	{

	// N.B. TVersion's iBuild number is not used

	TInt major = aVersion.iMajor;

	TInt minor = aVersion.iMinor;

	ASSERT_DEBUG(major<=3 && minor<=3); // since we only want to use 2 bits for each major/minor number in iFormatTypeField

	major = major << 6;

	minor = minor << 4;

	TUint8 version = major | minor; // MMmmbb00, where M = major, m = minor, b = build (not used)

	InquiryAddrStruct().iFormatTypeField &= 0x0F; // 0000 1111 - set first 4 bits to 0 (erase)

	InquiryAddrStruct().iFormatTypeField |= version; // set version information from aVersion

	}

/** Getter

@return Format Type Field number

*/

EXPORT_C TUint8 TInquirySockAddr::FormatTypeField() const

	{

	// only the 2 least significant bits of iFormatTypeField are used (the other bits are used for version information)

	return (InquiryAddrStruct().iFormatTypeField & 0x03);

	}

/** Sets the Format Type Field number. This is defined as a 2 bit value and so must be <=3.

@param aType is Format Type Field number to be assigned

@internalComponent 

*/

void TInquirySockAddr::SetFormatTypeField(TUint8 aType)

	{

	InquiryAddrStruct().iFormatTypeField &= 0xFC; // 1111 1100 - set last 2 bits to 0 (erase)

	InquiryAddrStruct().iFormatTypeField |= (aType & 0x03); // 0000 0011 - set last 2 bits of iFormatTypeField to those in aFlags

	}

/************ Service Security ************/

EXPORT_C TBTServiceSecurity::TBTServiceSecurity(const TBTServiceSecurity& aService)

/**

Copy constructor

@publishedAll

@released

*/

	{

	iUid = aService.Uid();

	iSecurityRequirements = aService.iSecurityRequirements;

	}

EXPORT_C TBTServiceSecurity::TBTServiceSecurity()

/**

Default constructor.

Sets all member data to 0.

@publishedAll

@released

*/

	{

	iUid.iUid = 0;

	}

EXPORT_C void TBTServiceSecurity::SetUid(TUid aUid)

/**

Set Uid of the service - used opaquely by Bluetooth system.  

When a security procedure is initiated the Uid may be given to the notifier framework.

The notifier can then use the Uid to produce a displayable string

detailing the service to which the security procudure pertains.

@param aUid 

The uid of the service.  This is not the Bluetooth UUID, 

but is a Symbian-allocated Uid.

@publishedAll

@released

*/

	{

	iUid = aUid;

	}

EXPORT_C void TBTServiceSecurity::SetAuthentication(TBool aPreference)

/**

Sets whether or not any connections to this service need to be authenticated.

Authentication involves the comparison of a stored link key.  If no link key

has been generated and stored (e.g. the remote device has never been authenticated before)

then the user will be asked to enter a pin code (a process known as pairing).

If authentication fails, the connection will not be permitted.

For Bluetooth v2.1 and onward this has slightly changed in that pin code entry is not neccessary 

to generate a link key.  Because of this, this API has been deprecated, users of this API are

encouraged to migrate to the alterative SetAuthentication method which specifies the level of

Man-in-the-Middle protection required for the service.

@see TBTServiceSecurity::SetAuthentication(TBluetoothMitmProtection aPreference)

@param aPreference if aPreference = EFalse then the Bluetooth stack will not perform pairing on Bluetooth v2.0

and earlier connections.

@publishedAll

@deprecated The TBTServiceSecurity::SetAuthentication(TBluetoothMitmProtection)

			function should be used instead.

*/

	{

	iSecurityRequirements.SetAuthentication(aPreference);

	}

EXPORT_C void TBTServiceSecurity::SetAuthorisation(TBool aPreference)

/**

Sets whether or not any connections to this service need to be authorised.

A dialog will be presented to the user alerting them of the connection.  This will

occur for every connection to this service unless the user has explicitly expressed

their trust for the remote device during a previous connection.

Note: it should not be assumed that the UI will support the setting up of trust for remote devices.

@param aPreference.  

if aPreference = ETrue then the Bluetooth stack will perform authorisation

@publishedAll

@released

*/

	{

	iSecurityRequirements.SetAuthorisation(aPreference);

	}

EXPORT_C void TBTServiceSecurity::SetEncryption(TBool aPreference)

/**

Sets whether or not any connections to this service need to be encrypted.

Authentication must precede encryption, therefore it is recommended that SetAuthentication(ETrue)

is also called.

If encryption fails, the connection will not be permitted.

@param aPreference.  

if aPreference = ETrue then the Bluetooth stack will perform encryption

@publishedAll

@released

*/

	{

	iSecurityRequirements.SetEncryption(aPreference);

	}

EXPORT_C void TBTServiceSecurity::SetDenied(TBool aPreference)

/**

Sets whether or not connections to this service are being denied to all but specified devices.

@param aPreference.  if aPreference = ETrue then the Bluetooth stack will deny the connection

@see per device overrides - service can be reached by only selected devices using this method

@publishedAll

@released

*/

	{

	iSecurityRequirements.SetDenied(aPreference);

	}

EXPORT_C TInt TBTServiceSecurity::SetPasskeyMinLength(TUint aPasskeyMinLength)

/**

Sets the minimum of passkey length for connection.

@param aPasskeyMinLength.  if aPreference = 0, no minimal length requirement.

According to BT spec aPasskeyMinLength <= 16

@publishedAll

@released

*/

	{

	return iSecurityRequirements.SetPasskeyMinLength(aPasskeyMinLength);

	}

/**

Sets the level of authentication needed for any connections to this service.

Authentication involves the comparison of a stored link key.  If no link key

has been generated and stored or one has been stored but is of an insufficient

level of authentication then pairing will be performed.

For Bluetooth v2.0 and earlier pairing involves the user entering the same pin code

for both devices involved in the connection to this service.

For Bluetooth v2.1 and onward pairing can be performed in one of four ways.  Some of which

involve the user of the Symbian OS device, some of which do not.  The pairing performed

is dependant on a number of factors including the input and output capabilities of the devices

and the level of authentication (Man-in-the-Middle protection) required.

If authentication fails, or succeeds but with an insufficient level of Man-in-the-Middle

protection, the connection will not be permitted.

@param aPreference The level of Man-in-the-Middle protection required for authentication.

@publishedAll

@released

*/

EXPORT_C void TBTServiceSecurity::SetAuthentication(TBluetoothMitmProtection aPreference)

	{

	iSecurityRequirements.SetAuthentication(aPreference);

	}