// 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 the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members

// which accompanies this distribution, and is available

// at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// BT socket interface types

// 

//

/**

 @file

 @publishedAll

 @released

*/

#ifndef BT_SOCK_H

#define BT_SOCK_H

#include <es_sock.h>

#include <bttypes.h>

#include <d32comm.h>	// for RS232 signal names for RFCOMM

#include <bluetooth/hci/hcierrors.h>

#include <btsecmanclient.h>

#include <bt_subscribe.h>

_LIT(KRFCOMMDesC,"RFCOMM");	/*!< Descriptor name for RFCOMM */

_LIT(KL2CAPDesC,"L2CAP"); 	/*!< Descriptor name for L2CAP */

//

// BT Protocol Family

//

const TUint KBTAddrFamily = 0x101; 		/*!< BT Address Family */

const TUint KBTLinkManager = 0x0099; 	/*!< Protocol Number for Link Manager */

const TUint KL2CAP = 0x0100;			/*!< Protocol Number for L2CAP */

const TUint KRFCOMM = 0x0003;			/*!< Protocol Number for RFCOMM */

const TUint KSDP = 0x0001;				/*!< Protocol Number for SDP */

const TUint	KAVCTP = 0x0017;			/*!< Protocol Number for AVCTP */

const TInt KTCIL2CAP = 0xF100;			/*!< Protocol Number for TCI L2CAP */

const TInt KBTMajor = 0;				/*!< BT version number for major version */

const TInt KBTMinor = 1;				/*!< BT version number for minor version */

const TInt KBTBuild = 1;				/*!< BT version number for build version */

// Socket Options

const TUint	KSolBtBlog  =0x1000;		/*!< Logging socket option */

const TUint KSolBtHCI   =0x1010;		/*!< HCI socket option */

const TUint KSolBtLM    =0x1011;		/*!< Link Manager socket option */

const TUint KSolBtL2CAP =0x1012;		/*!< L2CAP socket option */

const TUint KSolBtRFCOMM=0x1013;		/*!< RFCOMM socket option */

const TUint KSolBtAVCTP	=0x1014;		/*!< AVCTP socket option */

const TUint KSolBtACL	=0x1015;		/*!< ACL socket option */

/**

Decimal Value: 4118.

*/

const TUint	KSolBtAVDTPSignalling	=0x1016;

/**

Decimal Value: 4119.

*/

const TUint	KSolBtAVDTPMedia		=0x1017;

/**

Decimal Value: 4120.

*/

const TUint	KSolBtAVDTPReporting	=0x1018;

/**

Decimal Value: 4121.

*/

const TUint	KSolBtAVDTPRecovery		=0x1019;

/**

Decimal Value: 4128.

*/

const TUint KSolBtAVDTPInternal		=0x1020;

const TUint KSolBtLMProxy = 0x2011;		/*!< Link Manager Proxy socket option */

const TUint KSolBtSAPBase  = 0x2020;	/*!< CBluetoothSAP handles SetOpt first */

const static TUint8 KSCOListenQueSize = 1; /*!< Length of SCO listening queue */

const static TUint16 KL2MinMTU = 48; 			/*!< BT Spec defined min. supported MTU size */

// All PSM values must be ODD, that is, the least significant bit of the least significant

// octet must be '1'. Also, all PSM values must be assigned such that the

// least significant bit of the most significant octet equals '0'.

const static TUint16 KMaxPSM = 0xFEFF;	/*!< Max L2CAP PSM value */

/**

 * This is the minimum user PSM. Smaller PSM values are possible but are reserved for use by the 

 * Bluetooth stack only.

 */

const static TUint16 KMinUserPSM = 0x1001;

/**

 * This constant has been deprecated since its name is misleading becasue it doesn't represent the 

 * absolute minimum PSM but the minimum user PSM instead. 

 * Use KMinUserPSM instead of this constant.

 * @deprecated

 */

const static TUint16 KMinPSM = 0x1001;

/**

An enumeration to represent the possible levels of Man-in-the-Middle protection

that a Bluetooth service may specify.

*/

enum TBluetoothMitmProtection

	{

	EMitmNotRequired	= 0x0, /*!< No Man-in-the-Middle protection is required. */

	EMitmDesired		= 0x1, /*!< Man-in-the-Middle protection should be used where possible. */

	EMitmRequired		= 0x2  /*!< Man-in-the-Middle protection is required. */

	};

NONSHARABLE_CLASS(TBTAccessRequirements)

/** The access requirements set up by a bluetooth service.

An incoming connection must satisfy these criteria before the connection may proceed.

Not spectacularly useful for applications; mainly used by other Bluetooth libraries

@publishedAll

@released

*/

	{

public:

	IMPORT_C TBTAccessRequirements();

	IMPORT_C void SetAuthentication(TBool aPreference);

	IMPORT_C void SetAuthorisation(TBool aPreference);

	IMPORT_C void SetEncryption(TBool aPreference);

	IMPORT_C void SetDenied(TBool aPreference);

	IMPORT_C void SetAuthentication(TBluetoothMitmProtection aPreference);

	IMPORT_C TInt SetPasskeyMinLength(TUint aPasskeyMinLength);	

	IMPORT_C TBool AuthenticationRequired() const;

	IMPORT_C TBool AuthorisationRequired() const;

	IMPORT_C TBool EncryptionRequired() const;

	IMPORT_C TBool Denied() const;

	IMPORT_C TUint PasskeyMinLength() const;

	IMPORT_C TBool operator==(const TBTAccessRequirements& aRequirements) const;

	IMPORT_C TBluetoothMitmProtection MitmProtection() const;

private:

	TUint8 iRequirements;

	TUint  iPasskeyMinLength;

private:

	enum TBTServiceSecuritySettings

		{

		EAuthenticate = 0x01,

		EAuthorise = 0x02,

		EEncrypt = 0x04,

		EDenied = 0x08,

		EMitm = 0x30, // 2 bit field for MITM

		};

	enum TBTAccessRequirementsMitmProtection

		{

		EAccessRequirementsMitmUndefined = 0x00,

		EAccessRequirementsMitmNotRequired = 0x10,

		EAccessRequirementsMitmDesired = 0x20,

		EAccessRequirementsMitmRequired = 0x30

		};

	};

NONSHARABLE_CLASS(TBTServiceSecurity)

/** The security settings of a bluetooth service.

Contains information regarding the service UID and the access requirements.

@publishedAll

@released

*/

	{

public:

	IMPORT_C TBTServiceSecurity(const TBTServiceSecurity& aService);

	IMPORT_C TBTServiceSecurity();

	IMPORT_C void SetUid(TUid aUid);

	IMPORT_C void SetAuthentication(TBool aPreference);

	IMPORT_C void SetAuthorisation(TBool aPreference);

	IMPORT_C void SetEncryption(TBool aPreference);

	IMPORT_C void SetDenied(TBool aPreference);

	IMPORT_C void SetAuthentication(TBluetoothMitmProtection aPreference);

	IMPORT_C TInt SetPasskeyMinLength(TUint aPasskeyMinLength);	

	IMPORT_C TBool AuthorisationRequired() const;

	IMPORT_C TBool EncryptionRequired() const;

	IMPORT_C TBool AuthenticationRequired() const;

	IMPORT_C TBool Denied() const;

	IMPORT_C TUint PasskeyMinLength() const;

	IMPORT_C TUid Uid() const;

	IMPORT_C TBluetoothMitmProtection MitmProtection() const;

private:

	TUid iUid;	///<The UID of the service.  Will be used by the UI to work out the name of the service when prompting the user.

	TBTAccessRequirements iSecurityRequirements;	///<Whether the service requires authentication, authorisation, encryption or min passkey len.

	};

typedef TPckgBuf<TBTServiceSecurity> TBTServiceSecurityPckg;	/*!< Package definition for securty settings */

NONSHARABLE_CLASS(TBTSockAddr) : public TSockAddr

/** Bluetooth socket address

Stores bluetooth device address, and security - these are common to all Bluetooth addresses

@publishedAll

@released

*/

	{

struct SBTAddrSecurity

	{		

	TBTDevAddr iAddress;

	TBTServiceSecurity iSecurity;

	};

public:

	IMPORT_C TBTSockAddr();

	IMPORT_C TBTSockAddr(const TSockAddr& aAddr);

	IMPORT_C TBTDevAddr BTAddr() const;

	IMPORT_C void SetBTAddr(const TBTDevAddr& aRemote);

	IMPORT_C void SetSecurity(const TBTServiceSecurity& aSecurity);

	IMPORT_C TBTServiceSecurity BTSecurity() const;

	IMPORT_C static TBTSockAddr& Cast(const TSockAddr& aAddr);

protected:

	IMPORT_C TAny* EndBTSockAddrPtr() const;

private:

	SBTAddrSecurity& BTAddrSecStruct() const;

	TPtr8 AddressPtr() const;

	};

const static TInt KErrBtEskError = -6999;	/*!< BT ESK error code */

// Options available for all Bluetooth protocols

/** BT options. */

enum TBTOptions

	{

	/** Override device security */

	KBTRegisterCodService = 0x998,		/*!< Set a CoD Service bit(s) */

	KBTSecurityDeviceOverride = 0x999,

	};

typedef TPckgBuf<TBTServiceSecurityPerDevice> TBTServiceSecurityPerDeviceBuf;	/*!< Package definition for securty settings */

// Link manager error codes.

const static TInt KLinkManagerErrBase = -6450;								/*!< Link manager base error value */

const static TInt KErrInsufficientBasebandResources = KLinkManagerErrBase;	/*!< Insufficient baseband resources error value */

const static TInt KErrProxyWriteNotAvailable = KLinkManagerErrBase-1;		/*!< Proxy write not available error value */

const static TInt KErrReflexiveBluetoothLink = KLinkManagerErrBase-2;		/*!< Reflexive BT link error value */

const static TInt KErrPendingPhysicalLink = KLinkManagerErrBase-3;			/*!< Physical link connection already pending when trying to connect the physical link */

const static TInt KErrRemoteDeviceIndicatedNoBonding = KLinkManagerErrBase-4; /*!< Dedicated bonding attempt failure when the remote device responds with No-Bonding */

//

// L2CAP

//

const static TInt KL2CAPErrBase = -6300;								/*!< Base error value for L2CAP error codes */

const static TInt KErrBadAddress = KL2CAPErrBase;						/*!< L2CAP Bad address error code */

const static TInt KErrSAPUnexpectedEvent = KL2CAPErrBase - 1;			/*!< L2CAP unexpected SAP event error code */

const static TInt KErrBadPacketReceived = KL2CAPErrBase - 2;			/*!< L2CAP bad packet received error code */

const static TInt KErrL2CAPBadResponse = KL2CAPErrBase - 3;				/*!< L2CAP bad response error code */

const static TInt KErrHCIConnectFailed = KL2CAPErrBase - 4;				/*!< L2CAP HCI connection failed error code */

const static TInt KErrHCILinkDisconnection = KL2CAPErrBase - 5;			/*!< L2CAP HCI link disconnection error code */

const static TInt KErrSAPNotConnected = KL2CAPErrBase - 6;				/*!< L2CAP SAP not connected error code */

const static TInt KErrConfigBadParams = KL2CAPErrBase - 7;				/*!< L2CAP bad configuration parameters error code */

const static TInt KErrConfigRejected = KL2CAPErrBase - 8;				/*!< L2CAP configuration rejected error code */

const static TInt KErrConfigUnknownOptions = KL2CAPErrBase - 9;			/*!< L2CAP unknown configuration options error code */

const static TInt KErrL2PeerDisconnected = KL2CAPErrBase - 10;			/*!< L2CAP peer disconnected error code */

const static TInt KErrL2CAPAccessRequestDenied = KL2CAPErrBase - 11;	/*!< L2CAP access request denied error code */

const static TInt KErrL2CAPRequestTimeout = KL2CAPErrBase - 12;			/*!< L2CAP request timeout error code */

const static TInt KErrL2PeerRejectedCommand = KL2CAPErrBase - 13;		/*!< L2CAP peer rejected command error code */

const static TInt KErrHostResNameTooLong = KL2CAPErrBase - 14;			/*!< L2CAP host resolver name too long error code */

const static TInt KErrL2CAPNoMorePSMs = KL2CAPErrBase - 15;				/*!< L2CAP no more PSMs error code */

const static TInt KErrL2CAPMaxTransmitExceeded = KL2CAPErrBase - 16;	/*!< L2CAP in reliable mode: the maximum L2Cap retransmissions have been made and channel will disconnect error code*/

const static TInt KErrL2CAPDataControllerDetached = KL2CAPErrBase - 17;	/*!< L2CAP problems (e.g. no memory) whilst sending data error code*/

const static TInt KErrL2CAPConfigPending = KL2CAPErrBase - 18;			/*!< L2CAP configuration is in progress error code 

																			 @internalComponent*/

const static TInt KErrL2CAPConfigAlreadyInProgress = KL2CAPErrBase - 19;/*!< L2CAP attempt to alter config whilst configuration is in progress error code*/

const static TInt KErrL2CAPNoFreeCID = KL2CAPErrBase - 21;				/*!< L2CAP no more channel IDs available error code*/

// Host Resolver

const static TInt KErrHostResNoMoreResults = KErrEof;  					/*!< Host resolver has no more results error code */

const static TUint KHostResInquiry = 1;			/*!< Host resolver inquiry option */ 

const static TUint KHostResName = 2;			/*!< Host resolver name option. This is mutually exclusive with KHostResEir */ 

const static TUint KHostResIgnoreCache = 16; 	/*!< A way of ignoring the cache */ 

const static TUint KHostResCache = 32; 			/*!< A way to get CoD from cache */

const static TUint KHostResEir = 64; 			/*!< Host resolver Eir option. This is mutually exclusive with KHostResName  */

// L2CAP Ioctls

const static TInt KL2CAPEchoRequestIoctl	= 0;		/*!< Echo Request Ioctl name */

const static TInt KL2CAPIncomingMTUIoctl	= 1;		/*!< Change incoming MTU Ioctl name */

const static TInt KL2CAPOutgoingMTUIoctl    = 2;		/*!< Change outgoing MTU Ioctl name */

const static TInt KL2CAPUpdateChannelConfigIoctl	= 3;/*!< Change conguration parameters Ioctl name */

// Link Manager Ioctls

/** Link manager Ioctl codes.*/

enum TBTLMIoctls

	{

	/** Disconnect ACL Ioctl code

	@deprecated

	*/

	KLMDisconnectACLIoctl,

	/** Set Packet type Ioctl code

	@deprecated

	*/

	KLMSetPacketTypeIoctl,

	/** Wait for SCO notification Ioctl code

	@internalComponent

	*/

	KLMWaitForSCONotificationIoctl,

	/** One-shot baseband notification Ioctl code

	@internalComponent

	*/	

	KLMBasebandEventOneShotNotificationIoctl,

	/** Baseband event notification Ioctl code

	@internalComponent

	*/	

	KLMBasebandEventNotificationIoctl,

	/** Read Failed Contact Counter Ioctl

	@internalComponent

	*/	

	KLMReadFailedContactCounterIoctl,

	/** Read Link Quality Ioctl

	@internalComponent

	*/	

	KLMReadLinkQualityIoctl,

	/** Read RSSI Ioctl

	@internalComponent

	*/	

	KLMReadRssiIoctl,

	/** Read Current Transmit Power Level Ioctl

	@internalComponent

	*/	

	KLMReadCurrentTransmitPowerLevelIoctl,

	};

/** Paging policy for baseband.*/

enum TBasebandPageTimePolicy

    {

	EPagingDontCare,	/*!< Don't care setting */

    EPagingNormal,		/*!< Normal setting */

    EPagingBestEffort,	/*!< Best effort setting */

    EPagingQuick,		/*!< Quick paging setting */

    };

struct TBasebandPolicyParams

/** Baseband policy parameters.*/

	{

	TBasebandPageTimePolicy		iPageTimePolicy;	/*!< Page time policy */

	};

struct TSetBasebandPolicy

/** Set baseband policy.

@deprecated

@see RBTBaseband, TPhysicalLinkQuickConnectionToken

*/

	{

	TBTDevAddr				iDevAddr;	/*!< Device Address */

	TBasebandPolicyParams	iPolicy;	/*!< Policy parameters */

	};

/** Package for SetBasebandPolicy structure

@deprecated

*/

typedef TPckgBuf<TSetBasebandPolicy> TSetBasebandPolicyBuf;	

struct TPhysicalLinkQuickConnectionToken

/** Specifies details for faster connection.*/

	{

	TBTNamelessDevice		iDevice;	/*!< Nameless device */

	TBasebandPolicyParams	iPolicy;	/*!< New policy */

	};

typedef TPckgBuf<TPhysicalLinkQuickConnectionToken> TPhysicalLinkQuickConnectionTokenBuf;	/*!< Package for TPhysicalLinkQuickConnectionToken structure */

#define KBasebandSlotTime 0.000625	/*!< Baseband timeslot duration (0.000625 seconds) */

static const TUint KDefaultBasebandConnectionTimeout = 10;  /*!< Default baseband connection timeout (10 seconds) */

struct TLMDisconnectACLIoctl

/**

Structure to specify the remote ACL connection to disconnect.

The reason passed in iReason will be sent to the remote device.

Use with KLMDisconnectACLIoctl.

@deprecated

*/

	{

	TBTDevAddr	iDevAddr;	/*!< Device address */

	TUint8		iReason;	/*!< Reason code */

	};

typedef TPckgBuf<TLMDisconnectACLIoctl> TLMDisconnectACLBuf;	/*!< Package for TLMDisconnectACLIoctl structure */

// private tokens for use by RBTBaseband facade and stack

_LIT8(KDisconnectOnePhysicalLink, "1");		/*!< Specifes one physical link should be disconnected */

_LIT8(KDisconnectAllPhysicalLinks, "A");	/*!< Specifes all physical links should be disconnected */

/** Link manager options.

@internalComponent

*/

enum TBTLMOptions

	{

	ELMOutboundACLSize,						/*!< Outbound ACL size option */

	ELMInboundACLSize,						/*!< Inbound ACL size option */

	KLMGetACLHandle,						/*!< Get ACL Handle option */

	KLMGetACLLinkCount,						/*!< Get ACL link count option */

	KLMGetACLLinkArray,						/*!< Get ACL link array option */

	KLMSetBasebandConnectionPolicy,			/*!< Set baseband connection policy option */

	KLMGetBasebandHandle,					/*!< Get baseband handle option */

	EBBSubscribePhysicalLink,				/*!< Subscribe physical link option */

	EBBBeginRaw,							/*!< Enable raw broadcast option */

	EBBRequestRoleMaster,					/*!< Request switch to master option */

	EBBRequestRoleSlave,					/*!< Request switch to slave option */

	EBBCancelModeRequest,					/*!< Cancel mode request option */

	EBBRequestSniff,						/*!< Request sniff mode option */

	EBBRequestPark,							/*!< Request park mode option */

	EBBRequestPreventRoleChange,			/*!< Request to prevent a role (master / slave) switch option */

	EBBRequestAllowRoleChange,				/*!< Request to allow a role (master / slave) switchoption */

	EBBRequestChangeSupportedPacketTypes,	/*!< Request to cange the current supported packet types option */

	EBBEnumeratePhysicalLinks,				/*!< Enumerate physical links option */

	EBBGetPhysicalLinkState,				/*!< Get the physical link state option */

	EBBGetSniffInterval,					/*!< Get Sniff Interval option */

	EBBRequestLinkAuthentication,			/*!< Request authentication on the link */

	EBBRequestExplicitActiveMode,			/*!< Explicitly request the link to go into active mode */

	//Allow combination of options below...

	EBBRequestPreventSniff = 0x100,			/*!< Request to prevent entering sniff mode option */

	EBBRequestPreventHold = 0x200,			/*!< Request to prevent entering hold mode option */

	EBBRequestPreventPark = 0x400,			/*!< Request to prevent entering park mode option */

	EBBRequestPreventAllLowPowerModes = 

		(EBBRequestPreventSniff | 

		 EBBRequestPreventHold | 

		 EBBRequestPreventPark),			/*!< Request to prevent entering all modes option */

	EBBRequestAllowSniff = 0x800,			/*!< Request to allow entering sniff mode option */

	EBBRequestAllowHold = 0x1000,			/*!< Request to allow entering hold mode option */

	EBBRequestAllowPark = 0x2000,			/*!< Request to allow entering park mode option */

	EBBRequestAllowAllLowPowerModes = 

		(EBBRequestAllowSniff | 

		 EBBRequestAllowHold | 

		 EBBRequestAllowPark),				/*!< Request to allow entering-all-modes option. */

	};

// HCI Ioctls

/** Add SCO connnection Ioctl

@deprecated

*/

static const TUint KLMAddSCOConnIoctl			=0;

/** Remove SCO connection Ioctl

@deprecated

*/

static const TUint KHCIRemoveSCOConnIoctl		=1;

/** Change packet types allowed Ioctl

@deprecated

*/

static const TUint KHCIChangePacketTypeIoctl	=2;

/** Request authorisation Ioctl 

@deprecated

*/

static const TUint KHCIAuthRequestIoctl			=3;

/** Request encryption Ioctl

@deprecated

*/

static const TUint KHCIEncryptIoctl				=4;

/** Change link key Ioctl

@deprecated

*/

static const TUint KHCIChangeLinkKeyIoctl		=5;

/** Master link key Ioctl

@deprecated

*/

static const TUint KHCIMasterLinkKeyIoctl		=6;

/** Enable hold mode Ioctl

@deprecated

*/

static const TUint KHCIHoldModeIoctl			=7;

/** Enable sniff mode Ioctl

@deprecated

*/

static const TUint KHCISniffModeIoctl			=8;

/** Exit sniff mode Ioctl

@deprecated

*/

static const TUint KHCIExitSniffModeIoctl		=9;

/** Enable park mode Ioctl

@deprecated

*/

static const TUint KHCIParkModeIoctl			=10;

/** Exit park mode Ioctl

@deprecated

*/

static const TUint KHCIExitParkModeIoctl		=11;

/** Read page timeout Ioctl

@deprecated

*/

static const TUint KHCIReadPageTimeoutIoctl		=12;

/** Write page timeout Ioctl

@deprecated

*/

static const TUint KHCIWritePageTimeoutIoctl	=13;

/** Read scan enable Ioctl

@deprecated

@see bt_subscribe.h

*/

static const TUint KHCIReadScanEnableIoctl		=14;

/** Write scan enable Ioctl

@deprecated

@see bt_subscribe.h

*/

static const TUint KHCIWriteScanEnableIoctl		=15;

/** Read device class Ioctl

@deprecated

@see bt_subscribe.h

*/

static const TUint KHCIReadDeviceClassIoctl		=16;

/** Write device class Ioctl

@deprecated

@see bt_subscribe.h

*/

static const TUint KHCIWriteDeviceClassIoctl	=17;

/** Read voice settings Ioctl

@deprecated

*/

static const TUint KHCIReadVoiceSettingIoctl	=18;

/** Write voice settings Ioctl

@deprecated

*/

static const TUint KHCIWriteVoiceSettingIoctl	=19;

/** Read hold mode activity Ioctl

@deprecated

*/

static const TUint KHCIReadHoldModeActivityIoctl=20;

/** Write hold mode activity Ioctl

@deprecated

*/

static const TUint KHCIWriteHoldModeActivityIoctl=21;

/** Local version Ioctl

@deprecated

*/

static const TUint KHCILocalVersionIoctl		=22;

/** Local features Ioctl

@deprecated

*/

static const TUint KHCILocalFeaturesIoctl		=23;

/** Country code Ioctl

@deprecated

*/

static const TUint KHCICountryCodeIoctl			=24;

/** Local address Ioctl

@deprecated

@see bt_subscribe.h

*/

static const TUint KHCILocalAddressIoctl		=25;

/** Write discoverability Ioctl

@deprecated

@see bt_subscribe.h

*/

static const TUint KHCIWriteDiscoverabilityIoctl=26;

/** Read discoverability Ioctl

@deprecated

@see bt_subscribe.h

*/

static const TUint KHCIReadDiscoverabilityIoctl	=27;

/** Read authentification enabled Ioctl

@deprecated

*/

static const TUint KHCIReadAuthenticationEnableIoctl=33;

/** Write authentification enabled Ioctl

@deprecated

*/

static const TUint KHCIWriteAuthenticationEnableIoctl=34;

// Structs for ioctl parameters

/**

Enumerations for the four possible scan enable modes.

Use Inquiry scan for discoverability and Page scan for

connectability.

Use with KHCIReadScanEnableIoctl and KHCIWriteScanEnableIoctl.

@deprecated

@see bt_subscribe.h

*/

enum THCIScanEnableIoctl 

    {

     EHCINoScansEnabled=0x00,          /*!< No scans enabled. */

     EHCIInquiryScanOnly,              /*!< Inquiry scan only. */

     EHCIPageScanOnly,                 /*!< Page scan only. */

     EHCIInquiryAndPageScan            /*!< Both inquiry and page scan enabled. */

    };

/**

Package for THCIScanEnableIoctl structure 

@deprecated

*/

typedef TPckgBuf<THCIScanEnableIoctl> THCIScanEnableBuf;	

struct TLMAddSCOConnectionIoctl

/**

Structure for specifying SCO type to add to a connected socket.

The connection handle for the SCO link is returned in iConnH when

the Ioctl completes.

Use with KHCIAddSCOConnIoctl.

@deprecated

*/

	{

	TUint16        iPktType;	/*!< Packet type */

	};

/**

Package for TLMAddSCOConnectionIoctl structure

@deprecated

*/

typedef TPckgBuf<TLMAddSCOConnectionIoctl> TLMAddSCOConnectionBuf;	

struct THCISetEncryptionIoctl

/**

Request to change the encryption state of a connection.

iEncrypt specifies whether to turn encryption on or off.

Use with KHCIEncryptIoctl.

@deprecated

*/

	{

	TBool             iEncrypt;		/*!< Encryption enabled / disabled */

	};

/**

Package for THCISetEncryptionIoctl structure 

@deprecated

*/

typedef TPckgBuf<THCISetEncryptionIoctl> THCISetEncryptionBuf;

struct THCIDeviceClassIoctl

/**

Structure to specify the class of device when getting or setting

the local device class.

Use with KHCIReadDeviceClassIoctl and KHCIWriteDeviceClassIoctl.

@deprecated

@see bt_subscribe.h

*/

	{

	TUint16    iMajorServiceClass;		/*!< Major Service class */

	TUint8     iMajorDeviceClass;		/*!< Major Device class */

	TUint8     iMinorDeviceClass;		/*!< Minor Device class */

	};

/**

Package for THCIDeviceClassIoctl structure 

@deprecated

*/

typedef TPckgBuf<THCIDeviceClassIoctl> THCIDeviceClassBuf;

struct THCILocalVersionIoctl

/**

Structure describing the local Bluetooth hardware version.

Use with KHCILocalVersionIoctl.

@deprecated

*/

	{

	TUint8   iHCIVersion;			/*!< HCI version */

	TUint16  iHCIRevision;			/*!< HCI Revision */

	TUint8   iLMPVersion;			/*!< LMP version */

	TUint16  iLMPSubversion;		/*!< LMP subversion */

	TUint16  iManufacturerName;		/*!< Manufacturer name */

	};

/**

Package for THCILocalVersionIoctl structure 

@deprecated

*/

typedef TPckgBuf<THCILocalVersionIoctl> THCILocalVersionBuf;	

/** L2CAP Get / Set Options. */

enum TBTL2CAPOptions

	{

	/** 

	Get the outbound MTU size taking into account both the negotiated MTU size 

    and best use of underlying packet sizes.

	For example: If the default outgoing MTU of 672 has been negotiated for a L2CAP channel

	that is in Retransmission or Flow control mode then this GetOpt will return an

	outgoing MTU of 668 bytes. This allows a maximally sized SDU 

	(which due to this adjustment will be 668 bytes) to be sent in two DH5 packets.

	KL2CAPOutboundMTUForBestPerformance may also be used to set the current negotiated 

	(or to be negotiated) outbound MTU size.

	Note that the outbound MTU size returned when using KL2CAPOutboundMTUForBestPerformance 

	with a GetOpt may not be the same as the outbound MTU size previously set 

	when using KL2CAPOutboundMTUForBestPerformance with a SetOpt.

	*/ 

	KL2CAPOutboundMTUForBestPerformance,	

	/** 

	This is the legacy value for setting getting \ setting the outbound MTU size and behaves

	in the same way as KL2CAPOutboundMTUForBestPerformance.

	@see KL2CAPOutboundMTUForBestPerformance

	*/ 

	KL2CAPGetOutboundMTU = KL2CAPOutboundMTUForBestPerformance,

	KL2CAPGetDebug1,				/*!< Debug Command */

	KL2CAPInboundMTU,				/*!< Get / Set the current inbound MTU size */

	KL2CAPRTXTimer,					/*!< Change the extended L2CAP command retransmission timeout */

	KL2CAPERTXTimer,				/*!< Change the L2CAP command retransmission timeout */

	KL2CAPGetMaxOutboundMTU,		/*!< Get the max outbound MTU supported by the stack */

	KL2CAPGetMaxInboundMTU,			/*!< Get the max inbound MTU supported by the stack */

	KL2CAPUpdateChannelConfig,		/*!< Get and Set the current configuration parameters */

	/** Get / Set the current negotiated (or to be negotiated) outbound MTU size */

	KL2CAPNegotiatedOutboundMTU,    

	KL2CAPTestConfigure,	

	KL2CAPDebugFlush,

	KL2CAPVersion1_2,

	KL2CAPHeapAlloc,

	KL2CAPDataPlaneConfig,

	/**

	This is similar to KL2CAPOutboundMTUForBestPerformance except that the caller can specify

	a restriction that the returned MTU shall not exceed. This is useful for layers above L2CAP

	that still want an optimal MTU but have their own restrictions on packet size.

	*/

	KL2CAPOutboundMTUForBestPerformanceWithRestriction,

	};

typedef TUint16 TL2CAPPort;			/*!< Definition of a L2CAP port number type */

const static TL2CAPPort KL2CAPPassiveAutoBind = KMaxTUint16;  /*!< PSM out of the valid range used for passive auto bind operation */

NONSHARABLE_CLASS(TL2CAPSockAddr) : public TBTSockAddr

/** L2CAP Socket Address.

Use this class to specify a local or remote L2CAP connection end-point,

that is Device Address and PSM/CID.

When unconnected, the Port() specifies the PSM, once connected it refers to

the CID.

@see TBTSockAddr

@publishedAll

@released

*/

	{

public:

	IMPORT_C TL2CAPSockAddr();

	IMPORT_C TL2CAPSockAddr(const TSockAddr& aSockAddr);

	IMPORT_C static TL2CAPSockAddr& Cast(const TSockAddr& aSockAddr);

	IMPORT_C TL2CAPPort Port() const;

	IMPORT_C void SetPort(const TL2CAPPort aHomePort);

	};

NONSHARABLE_CLASS(TInquirySockAddr) : public TSockAddr

/** Socket address class used for inquiries.

Used to specify the inquiry request, and then filled with information

about remote devices discovered through the inquiry process.

Use the BTAddr() method to extract the device address to connect to.

Note: Usage of RHostResolver class for Bluetooth protocol.

The RHostResolver class is a generic interface to host name 

resolution services, such as DNS, that may be provided 

by particular protocol modules.

The points to remember when using RHostResolver::GetByAddress(), 

RHostResolver::GetByName(), or RHostResolver::Next() 

with Bluetooth protocol are:

1)  If you operate on one instance of RHostResolver you can perform 

	only one request by calling either RHostResolver::GetByAddress() 

	or  RHostResolver::GetByName(). If these functions are called again 

	and if there is more than one possible response	for a given host name

	then that will be returned (The host resolving process will

	not start from the beginning). It is exactly as if the RHostResolve::Next() 

	method was called.

2)  In order to start resolving new hosts from the beginning using the same 

	instance of RHostResolver, the instance must be closed and reopened again.

3)  In order to perform several RHostResolver requests they	should be issued on 

	separate instances of RHostResolver (many RHostResolver instances might 

	exist and perform requests at the same time).

4)  The KHostResIgnoreCache flag is only valid when issuing RHostResolver::GetByAddress() 

	or RHostResolver::GetByName() request for the first time.

5)  As an RHostResolver is only intended to be used once, it is recommended that it 

	be closed as soon as it is finished with as the semantics of Cancel merely

	indicates that one client server request should be cancelled.

@publishedAll

@released

*/

	{

// Max size for this structure is 24 bytes (32 - 8, see TSockAddr). However, due to padding and to prevent BC breaks, 

// only up to 3 TUint8(s) may be added after iFlags

	struct SInquiryAddr

		{

		TBTDevAddr iAddress;

		TUint8 iFormatTypeField; // since 'Format Type' only occupies 2 bits (least significant), we use 4 bits (most significant) for version information (and leave 2 bits unused)

		TUint16 iMajorServiceClass;

		TUint8 iMajorDeviceClass;

		TUint8 iMinorDeviceClass;

		TUint iIAC;

		TUint8 iActionFlags;

		TUint8 iResultFlags;

		TInt8 iRssi;

		};

public:

	// This defines all the bit masks for the inquiry result

	enum TResolverResultFlags

		{

		ERssiValid = 0x1,

		};

public:

	IMPORT_C TInquirySockAddr();

	IMPORT_C TInquirySockAddr(const TSockAddr& aSockAddr);

	IMPORT_C TBTDevAddr BTAddr() const;

	IMPORT_C void SetBTAddr(const TBTDevAddr& aRemote);

	IMPORT_C static TInquirySockAddr& Cast(const TSockAddr& aSockAddr);

	IMPORT_C TUint16 MajorServiceClass() const;

	IMPORT_C void SetMajorServiceClass(TUint16 aClass);

	IMPORT_C TUint8 MajorClassOfDevice() const;

	IMPORT_C void SetMajorClassOfDevice(TUint8 aMajorClassOfDevice);

	IMPORT_C TUint8 MinorClassOfDevice() const;

	IMPORT_C void SetMinorClassOfDevice(TUint8 aMinorClassOfDevice);

	IMPORT_C TUint IAC() const;

	IMPORT_C void SetIAC(const TUint aIAC);

	IMPORT_C TUint8 Action() const;

	IMPORT_C void SetAction(TUint8 aFlags);

	IMPORT_C TVersion Version() const;	

	IMPORT_C TInt8 Rssi() const;	

	IMPORT_C void SetRssi(const TInt8 aRssi);

	IMPORT_C TUint8 ResultFlags() const;

	IMPORT_C void SetResultFlags(TUint8 aResultFlags);

protected:

	void SetVersion(TVersion aVersion);

	IMPORT_C TUint8 FormatTypeField() const;

	void SetFormatTypeField(TUint8 aType);

private:

	SInquiryAddr& InquiryAddrStruct() const;

	TPtr8 AddressPtr() const;

	};

enum TACLPort

/** ACL port types.

@internalComponent

*/

	{

	EACLPortRaw		= 0x00,		/*!< Raw port type */

	EACLPortL2CAP	= 0x01,		/*!< L2CAP port type */

	EACLPortUnset	= 0xFF,		/*!< Unspecified ACL port type */

	};

// SAP types for baseband

/** ACL socket type

@internalTechnology

*/

static const TUint KSockBluetoothTypeACL = KMaxTUint;

/** Raw broadcast socket type

@internalTechnology

*/

static const TUint KSockBluetoothTypeRawBroadcast = KMaxTUint-2;

NONSHARABLE_CLASS(TACLSockAddr) : public TBTSockAddr

/** ACL Socket Address.

Use this class to specify a local or remote baseband connection end-point,

This is tied to the flags field in ACL data packets

@internalComponent

*/

	{

public:

	IMPORT_C TACLSockAddr();

	IMPORT_C TACLSockAddr(const TSockAddr& aSockAddr);

	IMPORT_C static TACLSockAddr& Cast(const TSockAddr& aSockAddr);

	//

	IMPORT_C TACLPort Port() const;

	IMPORT_C void SetPort(TACLPort aPort);

	};

//

// RFCOMM

//

const static TInt KRFErrorBase = -6350;										/*!< RFCOMM base error code. */

const static TInt KErrRfcommSAPUnexpectedEvent = KRFErrorBase;				/*!< RFCOMM unexpected event error code. */

const static TInt KErrRfcommAlreadyBound = KRFErrorBase-1;					/*!< RFCOMM SAP already bound error code. */

const static TInt KErrRfcommBadAddress = KRFErrorBase-2;					/*!< RFCOMM bad address error code. */

const static TInt KErrRfcommMTUSize = KRFErrorBase-3;						/*!< RFCOMM MTU size exceeded error code. */

const static TInt KErrRfcommFrameResponseTimeout = KRFErrorBase-4;			/*!< RFCOMM frame response timeout error code. */

const static TInt KErrRfcommMuxRemoteDisconnect = KRFErrorBase-5;			/*!< RFCOMM remote end disconnected error code. */

const static TInt KErrRfcommNotBound = KRFErrorBase-6;						/*!< RFCOMM SAP not bound error code. */

const static TInt KErrRfcommParameterNegotiationFailure = KRFErrorBase-7;	/*!< RFCOMM parameter negotiation failure error code. */

const static TInt KErrRfcommNotListening = KRFErrorBase-8;					/*!< RFCOMM not listening error code. */

const static TInt KErrRfcommNoMoreServerChannels = KRFErrorBase-9;			/*!< RFCOMM no more server channels available error code. */

//RFCOMMIoctls

const static TInt KRFCOMMModemStatusCmdIoctl =0;		/*!< RFCOMM status command Ioctl */

const static TInt KRFCOMMRemoteLineStatusCmdIoctl = 1;	/*!< RFCOMM remote line status command Ioctl */

const static TInt KRFCOMMRemotePortNegCmdIoctl = 2;		/*!< RFCOMM remote port negotiation command Ioctl */

const static TInt KRFCOMMRemotePortNegRequestIoctl = 3;	/*!< RFCOMM remote port negotiation request Ioctl */

const static TInt KRFCOMMConfigChangeIndicationIoctl = 4;	/*!< RFCOMM MSC activity Ioctl */

// RFCOMM Options

const static TInt KRFCOMMLocalPortParameter = 0;	/*!< RFCOMM local port parameter option (Get + Set) */

/** RFCOMM Get Available server channel option (Get only)

@deprecated

*/

const static TInt KRFCOMMGetAvailableServerChannel = 1;

const static TInt KRFCOMMMaximumSupportedMTU = 2; 	/*!< RFCOMM maximum supported option (Get + Set) */

const static TInt KRFCOMMGetDebug1 = 3;   			/*!< RFCOMM debug option (Get only) */

const static TInt KRFCOMMGetRemoteModemStatus = 4; 	/*!< RFCOMM remote modem status option (Get + Set) */

const static TInt KRFCOMMGetTransmitCredit = 5;		/*!< RFCOMM get transmit credits option */

const static TInt KRFCOMMGetReceiveCredit = 6;		/*!< RFCOMM get receive credits option */

const static TInt KRFCOMMGetReUsedCount = 7;		/*!< RFCOMM get number of remote used credits option */

const static TInt KRFCOMMFlowTypeCBFC = 8; 			/*!< RFCOMM Credit based flow control option (Get + Set) */

const static TInt KRFCOMMErrOnMSC = 9;				/*!< RFCOMM set the value of MSC signals that will cause a disconnect error to be generated */

const static TUint KRFCOMMLocalModemStatus = 10;   	/*!< RFCOMM local modem status option (Get + Set) */

const static TUint KRFCOMMForgiveCBFCOverflow = 11;   	/*!< RFCOMM only when credit-based flow control is used. When unset (default), the remote overflowing us will cause us to disconnect. When set, we keep the connection up and process as much of the data as we can (i.e. RFCOMM becomes unreliable). (Set only) */

const static TInt KRFCOMMMaximumMTU = 12; 	/*!< RFCOMM maximum optimal MTU (Get only) */

// Masks for interpreting signalling commands

const static TUint8 KModemSignalFC  = 0x01;			/*!< RFCOMM FC signalling command mask */

const static TUint8 KModemSignalRTC = 0x02;			/*!< RFCOMM RTC signalling command mask */

const static TUint8 KModemSignalRTR = 0x04;			/*!< RFCOMM RTR signalling command mask */

const static TUint8 KModemSignalIC  = 0x20;			/*!< RFCOMM IC signalling command mask */

const static TUint8 KModemSignalDV  = 0x40;			/*!< RFCOMM DV signalling command mask */

enum TRPNParameterMask

/** Remote port negotiation parameter masks

*/

	{

	EPMBitRate		= 0x0001,		/*!< Remote port negotiation parameter masks for bit rate */

	EPMDataBits		= 0x0002,		/*!< Remote port negotiation parameter masks for data bits */

	EPMStopBit		= 0x0004,		/*!< Remote port negotiation parameter masks for stop bit */

	EPMParity		= 0x0008,		/*!< Remote port negotiation parameter masks for parity */

	EPMParityType	= 0x0010,		/*!< Remote port negotiation parameter masks for parity type */

	EPMXOnChar		= 0x0020,		/*!< Remote port negotiation parameter masks for on character */

	EPMXOffChar		= 0x0040,		/*!< Remote port negotiation parameter masks for off character */

	// RESERVED		= 0x0080		

	EPMXOnOffInput	= 0x0100,		/*!< Remote port negotiation parameter masks for XOn/Off input */

	EPMXOnOffOutput	= 0x0200,		/*!< Remote port negotiation parameter masks for XOn/Off output */

	EPMRTRInput		= 0x0400,		/*!< Remote port negotiation parameter masks for read to receive input */

	EPMRTROutput	= 0x0800,		/*!< Remote port negotiation parameter masks for read to receive output */

	EPMRTCInput		= 0x1000,		/*!< Remote port negotiation parameter masks for RTC input */

	EPMRTCOutput	= 0x2000		/*!< Remote port negotiation parameter masks for RTC output */

	// RESERVED		= 0x4000

	// RESERVED		= 0x8000

	};

enum TRPNFlowCtrlMask

/** Remote port negotiation flow control masks

*/

	{

	EFCXOnOffInput	=0x01,	/*!< Remote port negotiation flow control masks for XOn/Off input */

	EFCXOnOffOutput =0x02,	/*!< Remote port negotiation flow control masks for XOn/Off output */

	EFCRTRInput		=0x04,	/*!< Remote port negotiation flow control masks for ready to receive input */

	EFCRTROutput	=0x08,	/*!< Remote port negotiation flow control masks for ready to receive output */

	EFCRTCInput		=0x10,	/*!< Remote port negotiation flow control masks for RTC input */

	EFCRTCOutput	=0x20	/*!< Remote port negotiation flow control masks for RTC output */

	};

enum TRPNValidityMask

/** Remote port negotiation validity masks

*/

	{