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

// BT socket interface types

// 

//

/**

 @file

 @publishedAll

 @released

*/

#ifndef BT_SOCK_H

#define BT_SOCK_H

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <bthci.h>

#include <bluetooth/lmoptions.h>

#endif

#include <bluetooth/btscoparams.h>

#include <bluetooth/btbaseband.h>

#include <btsocketoptionlevels.h>

#include <btdevice.h>

#include <es_sock.h>

#include <bttypes.h>

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

#include <bluetooth/hci/hcierrors.h>

#include <btmanclient.h>

#include <bt_subscribe.h>

#include <btsockaddr.h>

#include <btsecurity.h>

#include <btbasebandpolicy.h>

#include <btsyncbandwidth.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 */

// The Socket Options are now in btsocketoptionlevels.h

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;

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

const static TInt KErrL2CAPPeerDoesNotSupportRequestedChannelMode = KL2CAPErrBase - 22; /*!< L2CAP peer doesn't support channel modes satisfying requested channel configuration. */

const static TInt KErrL2CAPInvalidPacketSequenceNumber = KL2CAPErrBase - 23;	/*!< L2CAP packet with an invalid sequence number was received */

const static TInt KErrL2CAPInvalidAcknowledgementNumber = KL2CAPErrBase - 24;	/*!< L2CAP invalid acknowledgment number was received */

const static TInt KErrL2CAPIllegalRemoteBehavior = KL2CAPErrBase - 25;			/*!< L2CAP remote broke the L2CAP specification */

const static TInt KErrL2CAPNegotiatedDifferentModesForEachDirection = KL2CAPErrBase - 26; /*!< L2CAP different channel modes were negotiated for incoming and outgoing direction */

const static TInt KErrL2CAPIncomingSduSegmentationError = KL2CAPErrBase - 27;	/*!< L2CAP received I-Frame does not match the sequence of start, continuation, end of SDU */

const static TInt KErrL2CAPIncomingSduTooBig = KL2CAPErrBase - 28;		/*!< L2CAP received SDU size is larger than the negotiated MTU */

const static TInt KErrL2CAPIncomingIFrameTooSmall = KL2CAPErrBase - 29;	/*!< L2CAP Incoming I-Frame size is too small */

const static TInt KErrL2CAPIncomingIFrameTooBig = KL2CAPErrBase - 30;	/*!< L2CAP Incoming I-Frame information payload is larger than the negotiated MPS */

const static TInt KErrL2CAPInvalidIncomingSFrameSize = KL2CAPErrBase - 31; /*!< L2CAP Incoming S-Frame size is incorrect */

const static TInt KErrL2CAPAttemptToSetMinMtuGreaterThanMtu = KL2CAPErrBase - 32; /*!< L2CAP An attempt to configure minimal acceptable MTU that's larger than the preferred MTU was made */

const static TInt KErrL2CAPAttemptToSetMinMruGreaterThanMru = KL2CAPErrBase - 33; /*!< L2CAP An attempt to configure minimal acceptable MRU that's larger than the preferred MRU was made */

// 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 configuration parameters Ioctl name */

const static TInt KL2CAPPretendIncomingSduQFull		= 4;	/*!< Pretend incoming SDU Queue is full - internal testing only @internalComponent */

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

// 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,				// not implemented anymore, just a placeholder for BC

	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,

	KL2CAPLocalPSM,					/*!< Return local PSM of the socket (only works before the socket is accepted, stack internal use only) @internalTechnology */

	KL2CAPNegotiatedChannelMode		/*!< Get the negotiated L2CAP channel mode */

	};

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.