// 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 <bluetooth/logger.h>

#include <e32svr.h>

#include <e32uid.h>

#include <btsdp.h>

#include "DataEncoder.h"

#include "EncoderVisitor.h"

#include "sdputil.h"

#include "reqhandler.h"

#include "listener.h"

#include "epocsvr.h"

#include "ipcinternals.h"

#include "attrvalueencoded.h"

#include "epocsvr.inl"

#include <f32file.h>	//	For RFs

#ifdef __EPOC32__

#include <c32comm.h>

#endif

#include "SdpServerSecurityPolicy.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_SDP_SERVER);

#endif

#ifdef _DEBUG

PANICCATEGORY("epocsvr");

#endif

GLDEF_D TInt sdp_debug_level = 5;

void Panic(TSdpServerPanics aCode)

	{

	User::Panic(KSdpServerPanicName, aCode);

	}

/**

 The SDP database subsession class has been removed from the SDP server but to 

 maintain BC we still have to deal with subsession requests from the client.

 The constant below is used as the subsession handle for any new subsession

 requests from a client as we no longer maintain a real handle to a subsession.

**/

static const TInt KSdpDatabaseSubSessionHandle = 0x1A2B3C4D;

inline CSdpServerShutdown::CSdpServerShutdown()

	:CTimer(-1)

	{CActiveScheduler::Add(this);}

inline void CSdpServerShutdown::ConstructL()

	{CTimer::ConstructL();}

inline void CSdpServerShutdown::Start()

	{After(KSdpServerShutdownDelay);}

//

void CSdpServerShutdown::RunL()

/**

 Initiate server exit when the timer expires

**/

	{

	LOG_FUNC

	CActiveScheduler::Stop();

	}

CSdpServer::CSdpServer()

	: CPolicyServer(0, KSdpServerPolicy)

	{

	CONNECT_LOGGER

	LOG_FUNC

	}

CSdpServer* CSdpServer::NewLC()

/**

 Create the server object and leave on cleanup stack.

**/

	{

	LOG_STATIC_FUNC

	CSdpServer* self=new(ELeave) CSdpServer();

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void CSdpServer::ConstructL()

	{

	LOG_FUNC

	StartL(KSdpServerName);

	iSdpDatabase = CSdpDatabase::NewL();

	iUuidManager = CSdpUuidManager::NewL(*iSdpDatabase);

	TPckg<TUint> intBuf(0);

	iDbState = CSdpAttrValueUint::NewUintL(intBuf);

	// Create the buffer the correct size for storing a Uint

	TInt encodedSize = TElementEncoder::EncodedSize(iDbState->Type(), iDbState->DataSize());

	iEncodeBuf.CreateL(encodedSize);

	TElementEncoder encoder(iEncodeBuf);

	iEncoderVisitor = CAttrEncoderVisitor::NewL(encoder);

	BuildRecordZeroL(); //Unencoded

	Database()->EncodeDbL(); /*If we get to here, database exists*/

	User::LeaveIfError(iSocketServ.Connect());

	iSdpListener = CSdpListener::NewL(iSocketServ, 4, *(Database()));

	//Ensure that the server will exit even if the 1st client fails to connect

	//Start shutdown timer only after all the heavy duty initialisation has been done. 

	//Otherwise it could fire before any client had a chance to connect to the server

	iShutdown.ConstructL();

	iShutdown.Start();

	}

CSdpServer::~CSdpServer()

	{

	LOG_FUNC

	delete iSdpListener;

	iSocketServ.Close();

	delete iRecZero;

	delete iDbState;

	delete iEncoderVisitor;

	iEncodeBuf.Close();

	delete iUuidManager;

	delete iSdpDatabase;

	CLOSE_LOGGER

	}

CSdpDatabase* CSdpServer::Database()

	{

	LOG_FUNC

	return iSdpDatabase;

	}

void CSdpServer::BuildRecordZeroL()

/**

 Record 0 should be used when a server instance is created.

 note that attributes 2, 5 and 0x201 should be updated.

 also note only English, pas de Francais, keine Deutsch, non Espanol

**/

	{

	LOG_FUNC

	ASSERT_DEBUG(iSdpDatabase);

	TBuf8<2> attrId;

	TBuf8<4> val;

	iRecZero = CSdpServRecord::NewServerSideL(User::Identity());

	// Set Attr 0 (Record handle) to 0

	attrId.FillZ(2);

	val.FillZ(4);

	iRecZero->BuildUintL(attrId)->BuildUintL(val);

	// Set Attr 1 (service class list) to list with UUID = 0x1000

	attrId[0] = 0x00;

	attrId[1] = 0x01;

	iRecZero->BuildUintL(attrId)->BuildDESL()

			->StartListL()

				->BuildUUIDL(TUUID(TUint16(KServiceDiscoveryServerServiceClassUUID)))

			->EndListL();

	// Set Attr 2 (service record state) to 0

	attrId[0] = 0x00;

	attrId[1] = 0x02;

	val.FillZ(4);

	iRecZero->BuildUintL(attrId)->BuildUintL(val);

	// Set attr 4 (protocol list) to L2CAP, no RFCOMM, no OBEX

	attrId[0] = 0x00;

	attrId[1] = 0x04;

	val.FillZ(4);

	val[3] = 1;

	iRecZero->BuildUintL(attrId)->BuildDESL()

			->StartListL()

				->BuildDESL()

				->StartListL()

					->BuildUUIDL(TUUID(TUint16(0x0100))) // L2CAP

					->EndListL()

					->EndListL();

	// Set Attr 5 (browse group list) to list with one UUID

	// 0x1000 (SDP server class)

	// this should be updated with other service classes when other services are added.

	attrId[0] = 0x00;

	attrId[1] = 5;

	iRecZero->BuildUintL(attrId)->BuildDESL()

			->StartListL()

				->BuildUUIDL(TUUID(TUint32(0x1000)))

			->EndListL();

	// Set Attr 0x006 (language base)

	attrId[0] = 0x00;

	attrId[1] = 0x06;

	TUint16 lang = 0x656e;

	TUint16 coding = 0x006a;

	TUint16 base = 0x0100;

	iRecZero->BuildUintL(attrId)->BuildDESL()

			->StartListL()

				->BuildUintL(TSdpIntBuf<TUint16>(lang)) // english

				->BuildUintL(TSdpIntBuf<TUint16>(coding)) // UTF-8

				->BuildUintL(TSdpIntBuf<TUint16>(base)) // language base

			->EndListL();

	// Set Attr 0x007 (time to live) to 1200 (0x4B0) seconds (20 minutes)

	attrId[0] = 0x00;

	attrId[1] = 0x07;

	val.FillZ(4);

	val[2]=4;

	val[3]=0xb0;

	iRecZero->BuildUintL(attrId)->BuildUintL(val);

	// Set Attr 0x008 (availability) to 0xff - fully available - not in use

	attrId[0] = 0x00;

	attrId[1] = 0x08;

	TBuf8<1> val4;

	val4.FillZ(1);

	val4[0]=0xff;

	iRecZero->BuildUintL(attrId)->BuildUintL(val4);

	// Set Attr 0x100 (default Name) to string

	attrId[0] = 0x01;

	attrId[1] = 0;

	iRecZero->BuildUintL(attrId)->BuildStringL(_L8("SDP Server"));

	// Set Attr 0x101 (def. description) to string

	attrId[0] = 0x01;

	attrId[1] = 1;

	iRecZero->BuildUintL(attrId)->BuildStringL(_L8("Provides local service information for remote devices."));

	// Set Attr 0x102 (def. provider) to Symbian

	attrId[0] = 0x01;

	attrId[1] = 2;

	iRecZero->BuildUintL(attrId)->BuildStringL(_L8("Symbian OS"));

	// Set Attr 0x200 (version number support) to list with 1.0 and 1.1

	iRecZero->BuildUintL(TSdpIntBuf<TSdpAttributeID>(0x200))

			->BuildDESL()

			->StartListL()

				->BuildUintL(TSdpIntBuf<TUint16>(0x0100)) // 1.0

				->BuildUintL(TSdpIntBuf<TUint16>(0x0101)) // 1.1

			->EndListL();

	// Set Attr 0x201 (service database state) to 0

	attrId[0] = 0x02;

	attrId[1] = 0x01;

	val.FillZ(4);

	iRecZero->BuildUintL(attrId)->BuildUintL(val);

	// Add the record into the database

	Database()->AddRecord(iRecZero);

	}

CSession2* CSdpServer::NewSessionL(const TVersion& /*aVersion*/) const

	{

	LOG_FUNC

	User::Leave(KErrNotSupported);

	return 0;

	}

CSession2* CSdpServer::NewSessionL(const TVersion& aVersion,const RMessage2& aMessage) const

	{

	LOG_FUNC

	TVersion v(KSdpServerMajorVersionNumber,KSdpServerMinorVersionNumber,KSdpServerBuildVersionNumber);

	if (!User::QueryVersionSupported(v,aVersion))

		{

		User::Leave(KErrNotSupported);

		}

	// make new session

	return new(ELeave) CSdpServSession(aMessage);

	}

void CSdpServer::AddSession()

/**

A new session is being created

Cancel the shutdown timer if it was running

**/

	{

	LOG_FUNC

	++iSessionCount;

	if (iSessionCount > iMaxSessionCount)

		{

		iMaxSessionCount = iSessionCount;

		}

	iShutdown.Cancel();

	}

void CSdpServer::DropSession()

/**

A session is being destroyed

Start the shutdown timer if it is the last session.

**/

	{

	__ASSERT_DEBUG(iSessionCount > 0, PanicServer(ESdpBadState));

	if (--iSessionCount==0)

		{

		iShutdown.Start();

		}

	}

void CSdpServer::CheckAllowedL(const RMessage2& aMessage, const CSdpServRecord& aRecord)

	{

	LOG_FUNC

	if (!Allowed(aMessage, aRecord))

		{

		User::Leave(KErrPermissionDenied);

		}

	}

TBool CSdpServer::Allowed(const RMessage2& aMessage, const CSdpServRecord& aRecord)

	{

	LOG_FUNC

	_LIT_SECURITY_POLICY_S0(KSidPolicy, aRecord.ClientUid().iUid);

	//if the secure id of the record matches the secure id of the message sender

	if (KSidPolicy().CheckPolicy(aMessage))

		{

		//allowed

		return ETrue;

		}

	//not allowed

	return EFalse;

	}

CSdpServRecord* CSdpServer::FindRecordByHandle(const TSdpServRecordHandle aHandle)

/**

Returns a pointer to the first record object found with its 

attribute '0' set to the specified handle.

If no such record object is found, this function return 0 (Null).

**/

	{

	LOG_FUNC

	for(TServRecordIter recIter(Database()->RecordIter()); recIter; recIter++)

		{// Iterate thru records in iDatabase

		if((*recIter).Handle()==aHandle)

			{

			//Destructor of a record removes/destroys all its 

			//attributes and deques it from database list.

			return &(*recIter);

			}

		}

	return 0;

	}

CSdpAttr* CSdpServer::FindAttributeByID(CSdpServRecord& aRecord, const TSdpAttributeID aAttrID)

/**

Returns a pointer to the attribute object found in the 

specified record that has the specified ID.

If no such attribute object is found, this function return 0 (Null).

**/

	{

	LOG_FUNC

	for(TServAttrIter attrIter(aRecord.AttributeIter()); attrIter; attrIter++)

		{// Iterate thru attributes in record

		if((*attrIter).AttributeID()==aAttrID)

			{

			return &(*attrIter);

			}

		}

	return 0;

	}

/**

This function must be called whenever a service record is added or removed.

The SDP server 0 service record has a ServerServiceDatabaseState attribute

which, if present, must be updated when a service record is added or removed.

*/

void CSdpServer::DatabaseStateChange()

	{

	LOG_FUNC

	//increment database state attribute in record zero

	if(iRecZero)

		{

		TUint state = iDbState->Uint();

		TPckg<TUint> stateBuf(0);

		SdpUtil::PutUint(&stateBuf[0], ++state, sizeof(TUint));

		iDbState->SetUintValue(stateBuf);

		// This encodes iDbState into the buffer provided at construction

		iEncodeBuf.SetLength(0);

		TRAPD(err, iEncoderVisitor->EncodeAttributeL(*iDbState));

		// Attribute encoding can only fail if the attribute is of an unknown type 

		// or the supplied buffer is too small.  We have set the length of the

		// buffer to the correct length on creation so that will not fail.

		// We know iDbState is a CSdpAttrValueUint so cannot fail.

		__ASSERT_ALWAYS(!err, PanicServer(ESdpAttributeEncodingFailed));

		CSdpAttr* attr = FindAttributeByID(*iRecZero, KSdpAttrIdSdpServerServiceDatabaseState);

		__ASSERT_ALWAYS(attr->Value().Type() == ETypeEncoded, PanicServer(ESdpStoredAttrValNotEncoded));

		reinterpret_cast<CSdpAttrValueEncoded&>(attr->Value()).SetEncodedValue(iEncodeBuf);

		iRecZero->RecordStateChange();

		iUuidManager->NotifySdpRecordChange();

		}

	}

CSdpServRecord* CSdpServer::CreateServiceRecordL(const RMessage2& aMessage)

/**

Creates a record on the global database. Returns a pointer to the new record.

**/

	{

	LOG_FUNC

	CSdpServRecord* record = CSdpServRecord::NewServerSideL(aMessage.Identity());

	CleanupStack::PushL(record);

	//Build record handle attribute...

	//..NB if we had created the record using iDatabase.NewRecordL we would not

	//     have to add the handle attribute manually..BUT then to encode the 

	//	   the handle attribute would have required us to dig it out of the

	//	   record first which seems less robust than what is below.

	//	   For 1.1 we might create an EncodeRecordL function for a single record

	//	   in the same way we now have an EncodeDbL function for the whole database.

	//	   This would then allow us to call iDatabase>NewRecordL, followed by 

	//	   record.EncodeRecordL.	

	CSdpAttr* handleAttr = CSdpAttr::NewL(0x00, record);

	record->AddAttribute(handleAttr);

	handleAttr->BuildUintL(TSdpIntBuf<TSdpServRecordHandle>(Database()->NextFreeHandle()));

	CSdpAttrValue* handleAttrValue = &(handleAttr->Value());

	TUint size = TElementEncoder::EncodedSize(handleAttrValue->Type(), 

											  handleAttrValue->DataSize());

	HBufC8* bufEncodedHandle = HBufC8::NewL(size);

	CleanupStack::PushL(bufEncodedHandle);

	TPtr8 ptrEncodedHandle = bufEncodedHandle->Des();

	TElementEncoder ee(ptrEncodedHandle);

	CAttrEncoderVisitor::EncodeAttributeL(ee, *handleAttrValue);

	handleAttr->BuildEncodedL(ptrEncodedHandle); 

	CleanupStack::PopAndDestroy(); //bufEncodedHandle

	//Write record handle back to EPOC client (i.e. user)

	TSdpServRecordHandlePckgBuf pckg(record->Handle());

	pckg() = record->Handle();

	aMessage.WriteL(1, pckg); //ss//

	//Build service class attribute...

 	TInt bufServiceClassLen = aMessage.GetDesLengthL(0); //ss//

 	HBufC8* bufServiceClass = HBufC8::NewLC(bufServiceClassLen);

 	TPtr8 ptrServiceClass = bufServiceClass->Des();

 	aMessage.ReadL(0, ptrServiceClass); //get message data into buf (via ptr) //ss//

	TBuf8<2> attrId;

	attrId.FillZ(2); // Order of following lines important to value in attrId!!!

	attrId[0] = 0x00;

	attrId[1] = 0x01;

	CSdpAttr* attr = CSdpAttr::NewL(0x0001, record);

	record->AddAttribute(attr);

	attr->BuildEncodedL(ptrServiceClass);

	//Add record, now with handle and service class attributes, to database

	Database()->AddRecord(record);

	CleanupStack::PopAndDestroy(); //bufServiceClass

 	CleanupStack::Pop(); //record,

	DatabaseStateChange();

	//Return a pointer to the new record

	return record;

	}

CSdpServRecord* CSdpServer::FindAndCheckServiceRecordForDeletion(const RMessage2& aMessage)

/**

Checks it's ok to delete a record on the global database using handle sent in message slot 0.

Returns the pointer of the record that is to be deleted. 

**/

	{

	LOG_FUNC

	TSdpServRecordHandlePckgBuf pckg;

 	TRAPD(err, aMessage.ReadL(0, pckg)); //get message data into buf (via ptr)

	if(err)

		{

		// Client has sent us a dodgy descriptor, punish them!

		PanicClient(aMessage, ESdpBadDescriptor);

		return NULL;

		}

	//the service record handle should be non-zero

	__ASSERT_DEBUG(pckg() != 0, Panic(ESdpServerDeleteServiceRecordHandleZero));

	CSdpServRecord* record = FindRecordByHandle(pckg());

	if(!record)

		{

		PanicClient(aMessage, ESdpNonExistantRecordHandle);

		return NULL;

		}

	TRAP(err, CheckAllowedL(aMessage, *record));

	if(err)

		{

		// Client has been naughty, trying to delete things they shouldn't!

		PanicClient(aMessage, ESdpBadRequest);

		return NULL;

		}

	//Return a pointer to the record to be deleted

	return record;

	}

void CSdpServer::UpdateAttributeL(const RMessage2& aMessage)

/**