// 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)+
−
/**+
−
Updates/Creates an attribute in a record on the global database using the packaged +
−
record handle, the packaged attribute id, and the encoded attribute value +
−
sent in message slots 0, 1, and 2. +
−
**/+
−
	{+
−
	LOG_FUNC+
−
	+
−
	TSdpAttributeIDPckgBuf idPckg;+
−
	TSdpServRecordHandlePckgBuf handlePckg;+
−
	+
−
 	aMessage.ReadL(0, handlePckg); //get handle into handle package+
−
 	+
−
	//the service record handle should be non-zero+
−
	__ASSERT_DEBUG(handlePckg() != 0, Panic(ESdpServerUpdateAttributeRecordHandleZero));+
−
	+
−
 	aMessage.ReadL(1, idPckg); //get id into id package+
−
 	TInt bufLen = aMessage.GetDesLengthL(2);+
−
 	HBufC8* buf = HBufC8::NewLC(bufLen);+
−
 	TPtr8 ptr = buf->Des();+
−
 	aMessage.ReadL(2, ptr); //get message data into buf (via ptr)+
−
 	+
−
	CSdpServRecord* record = FindRecordByHandle(handlePckg());+
−
	if(!record)+
−
		{+
−
		PanicClient(aMessage, ESdpNonExistantRecordHandle);+
−
		return;+
−
		}+
−
	+
−
	CheckAllowedL(aMessage, *record);+
−
	+
−
	UpdateOrCreateAtributeL(*record, idPckg(), ptr);+
−
	+
−
	iUuidManager->NotifySdpRecordChange();+
−
	+
−
	CleanupStack::PopAndDestroy(); //buf+
−
	}+
−
+
−
void CSdpServer::UpdateOrCreateAtributeL(CSdpServRecord& aRecord, TSdpAttributeID aAttrId, const TDesC8& aBuf)+
−
	{+
−
	LOG_FUNC+
−
	CSdpAttr* attr = FindAttributeByID(aRecord, aAttrId);+
−
	if(attr)+
−
		{+
−
		//Deletes old attr value, and replaces with encoded value found in 'ptr'.+
−
		attr->BuildEncodedL(aBuf);	+
−
		}+
−
	else+
−
		{+
−
		TPckg<TUint16> idBuf(0);+
−
		BigEndian::Put16(&idBuf[0], aAttrId);+
−
		static_cast<CSdpAttr*>(aRecord.BuildUintL(idBuf))->BuildEncodedL(aBuf);+
−
		}+
−
+
−
	aRecord.RecordStateChange();+
−
	}+
−
+
−
void CSdpServer::DeleteAttribute(const RMessage2& aMessage)+
−
/**+
−
Deletes an attribute on the global database using the packaged record and the packaged +
−
attribute id found in record handle and attribute id sent in message slots 0 and 1. +
−
**/+
−
	{+
−
	LOG_FUNC+
−
	+
−
	TSdpAttributeIDPckgBuf idPckg;+
−
	TSdpServRecordHandlePckgBuf handlePckg;+
−
	+
−
 	TRAPD(err, aMessage.ReadL(0, handlePckg)); //get handle into handle package+
−
	if(err)+
−
		{+
−
		// Client has sent us a dodgy descriptor, punish them!+
−
		PanicClient(aMessage, ESdpBadDescriptor);+
−
		return;+
−
		}+
−
	+
−
	//the service record handle should be non-zero+
−
	__ASSERT_DEBUG(handlePckg() != 0, Panic(ESdpServerDeleteAttributeRecordHandleZero));+
−
	+
−
 	TRAP(err, aMessage.ReadL(1, idPckg)); //get id into id package+
−
	if(err)+
−
		{+
−
		// Client has sent us a dodgy descriptor, punish them!+
−
		PanicClient(aMessage, ESdpBadDescriptor);+
−
		return;+
−
		}+
−
+
−
	CSdpServRecord* record = FindRecordByHandle(handlePckg());+
−
	if(!record)+
−
		{+
−
		PanicClient(aMessage, ESdpNonExistantRecordHandle);+
−
		return;+
−
		}+
−
+
−
	TRAP(err, CheckAllowedL(aMessage, *record));+
−
	if(err)+
−
		{+
−
		// Client has been naughty, trying to delete things they shouldn't!+
−
		PanicClient(aMessage, ESdpBadRequest);+
−
		return;+
−
		}+
−
	+
−
	CSdpAttr* attr = FindAttributeByID(*record, idPckg());+
−
	if(!attr)+
−
		{+
−
		return;+
−
		}+
−
+
−
	delete attr;+
−
+
−
	record->RecordStateChange();+
−
+
−
	return;+
−
	}+
−
+
−
void CSdpServer::DeleteServiceRecord(CSdpServRecord* aServiceRecord)+
−
/**+
−
Deletes a record on the global database using a pointer to the record. This +
−
is used to delete records added to a session when the session is closed if +
−
the records have not been deleted by the client.+
−
**/+
−
	{+
−
	LOG_FUNC+
−
	if (aServiceRecord)+
−
		{+
−
		//Destructor of a record removes/destroys all its +
−
		//attributes and deques it from database list.+
−
		delete aServiceRecord;+
−
		DatabaseStateChange();+
−
		}+
−
	}+
−
+
−
TInt CSdpServer::RunError(TInt aError)+
−
/**+
−
   Handle an error from ServiceL()+
−
   A bad descriptor error implies a badly programmed client, so panic it;+
−
   otherwise report the error to the client+
−
**/+
−
	{+
−
	LOG_FUNC+
−
	LOG1(_L("s\tCSdpServer::RunError(): %d"), aError);+
−
	if (aError==KErrBadDescriptor)+
−
		{+
−
		PanicClient(Message(),ESdpBadDescriptor);+
−
		}+
−
	else+
−
		{+
−
		Message().Complete(aError);+
−
		}+
−
	ReStart();+
−
	return KErrNone;	// handled the error fully+
−
	}+
−
+
−
void PanicClient(const RMessage2& aMessage, TSdpClientPanic aPanic)+
−
/**+
−
   Panic the client and complete the message.+
−
   RMessage2::Panic() also completes the message. This is:+
−
   (a) important for efficient cleanup within the kernel+
−
   (b) a problem if the message is completed a second time+
−
**/+
−
	{+
−
	LOG_STATIC_FUNC+
−
	LOG1(_L("s\tPanicClient: Reason = %d"), aPanic);+
−
	aMessage.Panic(KSdpClientPanic,aPanic);+
−
	}+
−
+
−
void PanicServer(TSdpServerPanic aPanic)+
−
/**+
−
Panic our own thread+
−
**/+
−
	{+
−
	LOG_STATIC_FUNC+
−
	LOG1(_L("s\tPanicServer: Reason = %d"), aPanic);+
−
	User::Panic(KSdpServerPanic, aPanic);+
−
	}+
−
+
−
class CAttrPrintVisitor : public CBase, public MAttributeVisitor+
−
	{+
−
public:+
−
	CAttrPrintVisitor(){}+
−
#ifdef _DEBUG+
−
    void VisitAttributeL(CSdpAttr& aAttribute)+
−
#else+
−
    void VisitAttributeL(CSdpAttr& /*aAttribute*/)+
−
#endif+
−
		{+
−
		Indent();+
−
		LOG1(_L("Attribute ID: 0x%x"), aAttribute.AttributeID());+
−
		}+
−
	void VisitAttributeValueL(CSdpAttrValue & aValue, TSdpElementType aType)+
−
		{+
−
		TBuf16<64> iString;+
−
		switch (aType)+
−
			{+
−
			case ETypeString:+
−
				iString.Copy(aValue.Des());+
−
				LOG1(_L("\"%S\""),&iString);+
−
				break;+
−
			case ETypeDES:+
−
				LOG(_L(" DES"));+
−
				break;+
−
			case ETypeUint:+
−
				LOG1(_L(" UInt:0x%x"), aValue.Uint());+
−
				break;+
−
			case ETypeUUID:+
−
				LOG(_L(" UUID:0x"));+
−
				HexDes(aValue.UUID().ShortestForm());+
−
				break;+
−
			case ETypeEncoded:+
−
				HexDes(aValue.Des());  // simplest+
−
				break;+
−
			default:+
−
				LOG1(_L("type %d"), aType);+
−
			}+
−
		}+
−
    void StartListL(CSdpAttrValueList &/*aList*/)+
−
		{+
−
		++iIndent;+
−
		Indent();+
−
		LOG(_L("{"));+
−
		}+
−
    void EndListL()+
−
		{+
−
		if(iIndent<=0)+
−
			{+
−
			LOG(_L("ERROR! Unmatched EndList!"));+
−
			__DEBUGGER();+
−
			}+
−
		Indent();+
−
		LOG(_L("}"));+
−
		--iIndent;+
−
		}+
−
private:+
−
#ifdef _DEBUG+
−
	void Indent() {for(TInt i=0; i<iIndent;++i)+
−
						LOG(_L("  "));}+
−
+
−
	void HexDes(const TDesC8& aDes)+
−
		{+
−
		for (TInt i = 0; i < aDes.Length(); ++i)+
−
			LOG1(_L("%02x"), aDes[i]);+
−
		};+
−
#else+
−
	void Indent() {}+
−
	void HexDes(const TDesC8&) {}+
−
#endif+
−
	TInt iIndent;+
−
	};+
−
+
−
void FlogDb(CSdpDatabase& aDb)+
−
	{+
−
	LOG_STATIC_FUNC+
−
	LOG(_L("Printing Database..."));+
−
+
−
	for(TServRecordIter recIter(aDb.RecordIter()); recIter; recIter++)+
−
		{// Iterate thru records in Db+
−
		LOG1(_L("...Printing Record 0x%x"), (*recIter).Handle());+
−
		for(TServAttrIter attrIter((*recIter).AttributeIter()); attrIter; attrIter++)+
−
			{// Iterate thru attributes in record+
−
			CAttrPrintVisitor* theVisitor = new CAttrPrintVisitor();+
−
			if (theVisitor)+
−
				{+
−
				TRAP_IGNORE((*attrIter).AcceptVisitorL(*theVisitor));+
−
				delete theVisitor;+
−
				}+
−
			}+
−
		}+
−
	LOG(_L("End Printing Database..."));+
−
	}+
−
+
−
+
−
	+
−
static void RunServerL(/*TSdpServerStart& aStart*/)+
−
+
−
/**+
−
Perform all server initialisation, in particular creation of the+
−
scheduler and server and then run the scheduler+
−
**/+
−
	{+
−
	LOG_STATIC_FUNC+
−
+
−
	CActiveScheduler *scheduler = new (ELeave) CActiveScheduler;+
−
	CleanupStack::PushL(scheduler); //1st Push+
−
	CActiveScheduler::Install(scheduler); +
−
+
−
	// create the server (leave it on the cleanup stack)+
−
	CSdpServer::NewLC();//2nd Push+
−
	//+
−
	+
−
#ifdef __SDPSERVER_NO_PROCESSES__+
−
	RThread::Rendezvous(KErrNone);        // this causes the client's Rendezvous to complete +
−
#else+
−
	// naming the server thread after the server helps to debug panics+
−
	// ignore the error returned here - it's not critcal+
−
	User::RenameThread(KSdpServerName);+
−
+
−
	// Initialisation complete, now signal the client+
−
	RProcess::Rendezvous(KErrNone);        // this causes the client's Rendezvous to complete +
−
#endif+
−
	+
−
	//+
−
	// Ready to run+
−
	CActiveScheduler::Start();+
−
	//+
−
	// Cleanup the server and scheduler+
−
	CleanupStack::PopAndDestroy(2);+
−
	}+
−
+
−
+
−
TInt E32Main()+
−
/**+
−
Server process entry-point+
−
Recover the startup parameters and run the server+
−
**/+
−
	{+
−
+
−
	__UHEAP_MARK;+
−
#ifdef TEST_OOM //define TEST_OOM in preprocessor definitions in project settings+
−
	__UHEAP_SETFAIL(RHeap::ERandom, 100);	//Qualified - this results in a false positive error from leavescan (... may employ a macro), because the macro name ends with an 'L'.+
−
#endif+
−
	CTrapCleanup* cleanup=CTrapCleanup::New();+
−
	TInt r=KErrNoMemory;+
−
	if (cleanup)+
−
		{+
−
		TRAP(r,RunServerL());+
−
		delete cleanup;+
−
		}+
−
	//+
−
	__UHEAP_MARKEND;+
−
	+
−
	return r;+
−
	}+
−
+
−
+
−
//=====================================================================+
−
//CSdpServSession+
−
//=====================================================================+
−
+
−
CSdpServer& CSdpServSession::Server()+
−
	{+
−
	LOG_FUNC+
−
	return *static_cast<CSdpServer*>(const_cast<CServer2*>(CSession2::Server()));+
−
	}+
−
+
−
// constructor - must pass client to CSession2+
−
CSdpServSession::CSdpServSession(const RMessage2& /*aMessage*/)+
−
	{+
−
	LOG_FUNC+
−
	}+
−
+
−
void CSdpServSession::CreateL(const CServer2& /*aServer*/)+
−
	{+
−
	LOG_FUNC+
−
	User::Leave(KErrNotSupported); //FIXME - PRE SECURE_API - NEEDED TO AVOID COMPILER WARNING+
−
	}+
−
+
−
void CSdpServSession::CreateL()+
−
/**+
−
2nd phase construct for sessions - called by the CServer2 framework+
−
**/+
−
	{+
−
	LOG_FUNC+
−
	//CSession2::CreateL();	// private and does nowt so removed+
−
	//Add session to server first. If anything leaves, it will be removed by the destructor+
−
	Server().AddSession();+
−
	ConstructL();+
−
	}+
−
+
−
void CSdpServSession::ConstructL()+
−
	{+
−
	LOG_FUNC+
−
	// try to reopen the acceptor+
−
	Server().Listener().TryRestartL();+
−
	}+
−
+
−
CSdpServSession::~CSdpServSession()+
−
	{+
−
	LOG_FUNC+
−
	Server().DropSession();+
−
	+
−
	//Cleanup any records that have been added during this session but not removed+
−
	RemoveSessionRecords();+
−
	}+
−
+
−
void CSdpServSession::RemoveSessionRecords()+
−
	{+
−
	LOG_FUNC+
−
	for (TInt index = iSessionRecords.Count()-1; index >= 0; index--)+
−
		{+
−
		Server().DeleteServiceRecord(iSessionRecords[index]);+
−
		}+
−
	iSessionRecords.Close();+
−
	}+
−
+
−
void CSdpServSession::ServiceL(const RMessage2& aMessage)+
−
/**+
−
   Handle a client request.+
−
**/+
−
	{+
−
	LOG_FUNC+
−
	switch(aMessage.Function())+
−
		{+
−
	case ESdpCreateAgentSubSession:+
−
		NewSubSessionL(ESdpAgent, aMessage);+
−
		break;+
−
	case ESdpCreateDatabaseSubSession:+
−
		NewSubSessionL(ESdpDatabase, aMessage);+
−
		break;+
−
	case ESdpResourceCountMarkStart:+
−
		ResourceCountMarkStart();+
−
		aMessage.Complete(KErrNone);+
−
		break;+
−
	case ESdpResourceCountMarkEnd:+
−
		ResourceCountMarkEnd(aMessage); //ss//+
−
		aMessage.Complete(KErrNone);+
−
		break;+
−
	case ESdpResourceCount:+
−
		NumResourcesL(aMessage);+
−
		break;+
−
	case ESdpCloseSubSession:+
−
		CloseSubSession(aMessage);+
−
		break;+
−
+
−
	case ESdpDatabaseCreateServiceRecord:+
−
		{+
−
		if (aMessage.Int3() != KSdpDatabaseSubSessionHandle)+
−
			{+
−
			PanicClient(aMessage, ESdpBadSubSessionHandle);+
−
			return;+
−
			}+
−
	+
−
		CSdpServRecord* newRecord = NULL;+
−
		TRAPD(err, newRecord = Server().CreateServiceRecordL(aMessage));+
−
		// Inspect iHandle to see if we panicked the client and already completed +
−
		if (aMessage.Handle())+
−
			{+
−
			if (newRecord)+
−
				{+
−
				// Update our list of records for this session. Ignore error as+
−
				// we wouldn't want to remove the record if an error did occur,+
−
				// which is very unlikely as typically only 1 or 2 records are+
−
				// added per session.+
−
				err = iSessionRecords.Append(newRecord);+
−
				if(err != KErrNone)+
−
				    {+
−
				    //if append fails delete the service record created above and return the error code+
−
				    Server().DeleteServiceRecord(newRecord);+
−
				    }+
−
				}+
−
			aMessage.Complete(err);+
−
			}+
−
		return;+
−
		}+
−
	case ESdpDatabaseDeleteServiceRecord:+
−
		{+
−
		if (aMessage.Int3() != KSdpDatabaseSubSessionHandle)+
−
			{+
−
			PanicClient(aMessage, ESdpBadSubSessionHandle);+
−
			return;+
−
			}+
−
+
−
		CSdpServRecord* recordToBeDeleted = Server().FindAndCheckServiceRecordForDeletion(aMessage);+
−
		+
−
		// If recordToBeDeleted returned is NULL, PanicClient will have been called so aMessage.Handle() +
−
		// is zero and we've already completed - see if this is not the case  +
−
		if (aMessage.Handle())+
−
			{+
−
			TInt index = iSessionRecords.Find(recordToBeDeleted); // Find the index of the record before deleting the record+
−
			// Ignore if the record is not found as it may not have been added+
−
			// in the first place.+
−
			if (index >= 0)+
−
				{+
−
				iSessionRecords.Remove(index);+
−
				}+
−
			Server().DeleteServiceRecord(recordToBeDeleted);+
−
			aMessage.Complete(KErrNone);+
−
			}+
−
		return;+
−
		}+
−
	case ESdpDatabaseUpdateAttribute:+
−
		{+
−
		if (aMessage.Int3() != KSdpDatabaseSubSessionHandle)+
−
			{+
−
			PanicClient(aMessage, ESdpBadSubSessionHandle);+
−
			return;+
−
			}+
−
+
−
		TRAPD(err, Server().UpdateAttributeL(aMessage));+
−
		// Inspect iHandle to see if we panicked the client and already completed +
−
		if (aMessage.Handle())+
−
			{+
−
			aMessage.Complete(err);+
−
			}+
−
		return;+
−
		}+
−
	case ESdpDatabaseDeleteAttribute:+
−
		{+
−
		if (aMessage.Int3() != KSdpDatabaseSubSessionHandle)+
−
			{+
−
			PanicClient(aMessage, ESdpBadSubSessionHandle);+
−
			return;+
−
			}+
−
+
−
		Server().DeleteAttribute(aMessage);+
−
		// Inspect iHandle to see if we panicked the client and already completed +
−
		if (aMessage.Handle())+
−
			{+
−
			aMessage.Complete(KErrNone);+
−
			}+
−
		return;+
−
		}+
−
	case ESdpServerDbgMarkHeap:+
−
		{+
−
#ifdef _DEBUG+
−
		LOG(_L("\tmark sdp server heap"));+
−
		__UHEAP_MARK;+
−
#endif // _DEBUG+
−
		aMessage.Complete(KErrNone);+
−
		break;+
−
		}+
−
	case ESdpServerDbgCheckHeap:+
−
		{+
−
#ifdef _DEBUG+
−
		LOG1(_L("\tcheck sdp server heap (expecting %d cells)"), aMessage.Int0());+
−
		__UHEAP_CHECK(aMessage.Int0());+
−
#endif // _DEBUG+
−
		aMessage.Complete(KErrNone);+
−
		break;+
−
		}+
−
	case ESdpServerDbgMarkEnd:+
−
		{+
−
#ifdef _DEBUG+
−
		LOG1(_L("\tmark end sdp server heap (expecting %d cells)"), aMessage.Int0());+
−
		__UHEAP_MARKENDC(aMessage.Int0());+
−
#endif // _DEBUG+
−
		aMessage.Complete(KErrNone);+
−
		break;+
−
		}+
−
	case ESdpServerDbgFailNext:+
−
		{+
−
#ifdef _DEBUG+
−
		LOG1(_L("\tfail next sdp server alloc (simulating failure after %d allocation(s))"), aMessage.Int0());+
−
		if ( aMessage.Int0() == 0 )+
−
			{+
−
			__UHEAP_RESET;+
−
			}+
−
		else+
−
			{+
−
			__UHEAP_FAILNEXT(aMessage.Int0());+
−
			}+
−
#endif // _DEBUG+
−
		aMessage.Complete(KErrNone);+
−
		break;+
−
		}+
−
	default:+
−
		//not handled here so must be for subsession+
−
		PanicClient(aMessage, ESdpBadRequest);+
−
		}+
−
	}+
−
+
−
void CSdpServSession::NewSubSessionL(TSubSessionType aType, const RMessage2& aMessage)+
−
/**+
−
   Increment our subsession count and send the SDP subsession handle+
−
   back to the client.+
−
   If we succeed, we complete the message.  If we fail, we leave+
−
   and the server sends back the error for us.+
−
**/+
−
	{+
−
	LOG_FUNC+
−
	if (aType!=ESdpDatabase)+
−
		{+
−
		User::Leave(KErrNotSupported);+
−
		}+
−
+
−
	//Write handle to client+
−
	TPckg<TInt> pckg(KSdpDatabaseSubSessionHandle);+
−
	TRAPD(err, aMessage.WriteL(3, pckg)); //ss//+
−
	if(err)+
−
		{+
−
		User::Leave(err);+
−
		}+
−
	iSubSessionCount++;+
−
	aMessage.Complete(KErrNone);+
−
	}+
−
+
−
void CSdpServSession::DeleteSubsession(TUint aHandle, const RMessage2& aMessage)+
−
	{+
−
	LOG_FUNC+
−
	//panic client if bad handle+
−
	if ((aHandle != KSdpDatabaseSubSessionHandle) || (iSubSessionCount == 0))+
−
		{+
−
		PanicClient(aMessage, ESdpBadSubSessionRemove);+
−
		return;+
−
		}+
−
	iSubSessionCount--;+
−
	aMessage.Complete(KErrNone);+
−
	}+
−
+
−
void CSdpServSession::CloseSubSession(const RMessage2& aMessage)+
−
	{+
−
	LOG_FUNC+
−
+
−
	DeleteSubsession((aMessage).Int3(), aMessage); //calls aMessage.Complete(KErrNone)	+
−
	}+
−
+
−
void CSdpServSession::NumResourcesL(const RMessage2& aMessage)+
−
	{+
−
	LOG_FUNC+
−
	TPckgBuf<TInt> pckg(CountResources());+
−
	aMessage.WriteL(0, pckg); //ss//+
−
	aMessage.Complete(KErrNone);+
−
	}+
−
+
−
TInt CSdpServSession::CountResources()+
−
	{+
−
	LOG_FUNC+
−
	return iSubSessionCount;+
−
	}+
−
+
−
+
−
//**********************************+
−
// CEirPublisherSdpUuidBase+
−
//**********************************+
−
/**+
−
CEirPublisherSdpUuidBase provides base class for Sdp Uuid Eir Publisher.+
−
**/+
−
+
−
CEirPublisherSdpUuidBase::~CEirPublisherSdpUuidBase()+
−
	{+
−
	delete iPublisher;+
−
	}+
−
+
−
CEirPublisherSdpUuidBase::CEirPublisherSdpUuidBase(CSdpUuidManager& aSdpUuidManager, TEirTag aTag)+
−
: iParent(aSdpUuidManager), iTag(aTag)+
−
	{+
−
	}+
−
+
−
void CEirPublisherSdpUuidBase::ConstructL()+
−
	{+
−
	iPublisher = CEirPublisher::NewL(iTag, *this);+
−
	}+
−
+
−
void CEirPublisherSdpUuidBase::UpdateUuids(TInt aLength)+
−
	{+
−
	iPublisher->PublishData(aLength);+
−
	}+
−
+
−
//**********************************+
−
// CEirPublisherSdpUuid16+
−
//**********************************+
−
/**+
−
Provides functionality to publish 16 bit UUIDs to EIR.+
−
**/+
−
CEirPublisherSdpUuid16* CEirPublisherSdpUuid16::NewL(CSdpUuidManager& aSdpUuidManager)+
−
	{+
−
	CEirPublisherSdpUuid16* self = new (ELeave) CEirPublisherSdpUuid16(aSdpUuidManager);+
−
	CleanupStack::PushL(self);+
−
	self->ConstructL();+
−
	CleanupStack::Pop();+
−
	return self;+
−
	}+
−
	+
−
CEirPublisherSdpUuid16::CEirPublisherSdpUuid16(CSdpUuidManager& aSdpUuidManager)+
−
:	CEirPublisherSdpUuidBase(aSdpUuidManager, EEirTagSdpUuid16)+
−
	{+
−
	}+
−
+
−
CEirPublisherSdpUuid16::~CEirPublisherSdpUuid16()+
−
	{+
−
	delete iExtracted;+
−
	}+
−
+
−
// From MEirPublisherNotifier+
−
void CEirPublisherSdpUuid16::MepnSpaceAvailable(TUint aBytesAvailable)+
−
	{+
−
	// Ensure previous memory is freed+
−
	delete iExtracted, iExtracted = NULL;+
−
	TBool partial = EFalse;+
−
	+
−
	if (aBytesAvailable > 0)+
−
		{+
−
		iExtracted = iParent.GetAll16BitUUIDs(aBytesAvailable, partial);+
−
		if(!iExtracted)+
−
			{+
−
			// OOM probably+
−
			iPublisher->SetData(KNullDesC8, EEirDataPartial);+
−
			}+
−
		else if(partial)+
−
			{+
−
			iPublisher->SetData(*iExtracted, EEirDataPartial);+
−
			}+
−
		else+
−
			{+
−
			iPublisher->SetData(*iExtracted, EEirDataComplete);+
−
			}+
−
		}+
−
	}+
−
+
−
void CEirPublisherSdpUuid16::MepnSetDataError(TInt /*aResult*/)+
−
	{+
−
	delete iExtracted;+
−
	iExtracted = NULL;+
−
	}+
−
+
−
+
−
//**********************************+
−
// CEirPublisherSdpUuid128+
−
//**********************************+
−
/**+
−
Provides functionality to publish 128 bit UUIDs to EIR.+
−
**/+
−
CEirPublisherSdpUuid128* CEirPublisherSdpUuid128::NewL(CSdpUuidManager& aSdpUuidManager)+
−
	{+
−
	CEirPublisherSdpUuid128* self = new (ELeave) CEirPublisherSdpUuid128(aSdpUuidManager);+
−
	CleanupStack::PushL(self);+
−
	self->ConstructL();+
−
	CleanupStack::Pop();+
−
	return self;+
−
	}+
−
	+
−
CEirPublisherSdpUuid128::CEirPublisherSdpUuid128(CSdpUuidManager& aSdpUuidManager)+
−
:	CEirPublisherSdpUuidBase(aSdpUuidManager, EEirTagSdpUuid128)+
−
	{+
−
	}+
−
+
−
CEirPublisherSdpUuid128::~CEirPublisherSdpUuid128()+
−
	{+
−
	delete iExtracted;+
−
	}+
−
+
−
// From MEirPublisherNotifier+
−
void CEirPublisherSdpUuid128::MepnSpaceAvailable(TUint aBytesAvailable)+
−
	{+
−
	// Ensure previous memory is freed+
−
	delete iExtracted, iExtracted = NULL;+
−
	TBool partial = EFalse;+
−
	+
−
	if (aBytesAvailable > 0)+
−
		{+
−
		iExtracted = iParent.GetAll128BitUUIDs(aBytesAvailable, partial);+
−
		if(!iExtracted)+
−
			{+
−
			// OOM probably+
−
			iPublisher->SetData(KNullDesC8, EEirDataPartial);+
−
			}+
−
		else if(partial)+
−
			{+
−
			iPublisher->SetData(*iExtracted, EEirDataPartial);+
−
			}+
−
		else+
−
			{+
−
			iPublisher->SetData(*iExtracted, EEirDataComplete);+
−
			}+
−
		}+
−
	}+
−
+
−
void CEirPublisherSdpUuid128::MepnSetDataError(TInt /*aResult*/)+
−
	{+
−
	delete iExtracted;+
−
	iExtracted = NULL;+
−
	}+
−
+
−
+
−
CSdpUuidManager* CSdpUuidManager::NewL(CSdpDatabase& aSdpDatabase)+
−
	{+
−
	CSdpUuidManager* self = new (ELeave) CSdpUuidManager(aSdpDatabase);+
−
	CleanupStack::PushL(self);+
−
	self->ConstructL();+
−
	CleanupStack::Pop();+
−
	return self;+
−
	}+
−
	+
−
CSdpUuidManager::~CSdpUuidManager()+
−
	{+
−
	i16BitUUIDs.Close();+
−
	i128BitUUIDs.Close();+
−
	+
−
	delete iEirPublisherSdpUuid16;+
−
	delete iEirPublisherSdpUuid128;+
−
	delete iUuidVisitor;+
−
	}+
−
+
−
void CSdpUuidManager::NotifySdpRecordChange()+
−
	{+
−
	TServRecordIter recIter(iSdpDatabase.RecordIter());+
−
	CSdpServRecord* rec = NULL;+
−
	CSdpAttr* attr = NULL;+
−
	CSdpAttrValue* serviceClassValue = NULL;+
−
	CSdpAttrValue* browseGroupValue = NULL;+
−
	+
−
	ResetUuids();+
−
	while((rec = recIter++) != NULL)+
−
		{// Iterate thru records in Db+
−
		TServAttrIter attrIter(rec->AttributeIter());+
−
		while((attr = attrIter++) != NULL)+
−
			{+
−
			if(attr->AttributeID()==KSdpAttrIdServiceClassIDList)+
−
				{+
−
				// Find the value of ServiceClassIDList attribute+
−
				serviceClassValue = &(attr->Value());+
−
				}+
−
			if(attr->AttributeID()==KSdpAttrIdBrowseGroupList)+
−
				{+
−
				// Find the value of BrowseGroupList attribute+
−
				browseGroupValue = &(attr->Value());+
−
				}+
−
			}+
−
		if(serviceClassValue && browseGroupValue)+
−
			{+
−
			// Both ServiceClassIDList and BrowseGroupList have value+
−
			iUuidVisitor->GetUuids().Reset();+
−
			TRAPD(err, browseGroupValue->AcceptVisitorL(*iUuidVisitor));+
−
			if(err == KErrNone)+
−
				{+
−
				TUUID publicBrowseGroupUUID = TUUID(static_cast<TUint32>(KPublicBrowseGroupUUID));+
−
				if(iUuidVisitor->GetUuids().IsPresent(publicBrowseGroupUUID))+
−
					{+
−
					iUuidVisitor->GetUuids().Reset();+
−
					TRAPD(err, serviceClassValue->AcceptVisitorL(*iUuidVisitor));+
−
					if(err == KErrNone && iUuidVisitor->GetUuids().Count() > 0)+
−
						{+
−
						// In eir, we use the 1st uuid on the list, as it is the most specific one+
−
						AddUuid(iUuidVisitor->GetUuids()[0]);+
−
						}+
−
					}+
−
				}+
−
			}+
−
		// Reset the pointers for these two values+
−
		serviceClassValue = NULL;+
−
		browseGroupValue = NULL;+
−
		}+
−
	// Only publish UUIDs in public browse group+
−
	// 16 bit UUIDs+
−
	TUint8 count = i16BitUUIDs.Count();+
−
	// Skip the 1st 16 bit uuid record, it's a SDP service UUID+
−
	if(count > 0)+
−
		{+
−
		// UpdateUuids expects the length in bytes, so multiply number of uuids by 2+
−
		iEirPublisherSdpUuid16->UpdateUuids(count<<1);+
−
		}+
−
		+
−
	// 128 bit UUIDs+
−
	count = i128BitUUIDs.Count();+
−
	if(count > 0)+
−
		{+
−
		// UpdateUuids expects the length in bytes, so multiply number of uuids by 16+
−
		iEirPublisherSdpUuid128->UpdateUuids(count<<4);+
−
		}+
−
	}+
−
+
−
void CSdpUuidManager::AddUuid(TUUID aUuid)+
−
	{+
−
	TUint8 count = aUuid.MinimumSize();+
−
	if(count == KSizeOf16BitUUID)+
−
		{+
−
		// 16 bit UUID+
−
		i16BitUUIDs.Add(aUuid);+
−
		}+
−
	else if(count == KSizeOf128BitUUID)+
−
		{+
−
		// 128 bit UUID+
−
		i128BitUUIDs.Add(aUuid);+
−
		}+
−
	else+
−
		{+
−
		// 32 bit UUIDs are not supported+
−
		}+
−
	}+
−
+
−
void CSdpUuidManager::ResetUuids()+
−
	{+
−
	i16BitUUIDs.Reset();+
−
	i128BitUUIDs.Reset();+
−
	}+
−
+
−
HBufC8* CSdpUuidManager::GetAll16BitUUIDs(TInt aBytesAvailable, TBool& aPartial)+
−
	{+
−
	// Flatten the UUIDs into a little-endian buffer+
−
	HBufC8* extracted = HBufC8::New(aBytesAvailable);+
−
	if(extracted)+
−
		{+
−
		TPtr8 ptr = extracted->Des();+
−
		TInt i = 0;+
−
		TInt count = i16BitUUIDs.Count();+
−
		// Iterate whilst not exhausted and there's space for a UUID+
−
		while (i < count && ptr.Length() + KSizeOf16BitUUID <= aBytesAvailable)+
−
			{+
−
			// convert to 16 bit Little Endian for EIR+
−
			TPtrC8 p = i16BitUUIDs[i].ShortestForm();+
−
			ptr.Append(p[1]);+
−
			ptr.Append(p[0]);+
−
			i++;+
−
			}+
−
		__ASSERT_DEBUG(extracted->Length() <= aBytesAvailable, Panic(ESdpServerUuidFlattenBroken));+
−
		// Let the caller know if there wasn't enough space for all UUIDs+
−
		aPartial = EFalse;+
−
		if (i < count)+
−
			{+
−
			aPartial = ETrue;+
−
			}+
−
		}+
−
	return extracted;+
−
	}+
−
+
−
HBufC8* CSdpUuidManager::GetAll128BitUUIDs(TInt aBytesAvailable, TBool& aPartial)+
−
	{+
−
	// Flatten the UUIDs into a little-endian buffer+
−
	HBufC8* extracted = HBufC8::New(aBytesAvailable);+
−
	if(extracted)+
−
		{+
−
		TPtr8 ptr = extracted->Des();+
−
		TInt i = 0;+
−
		TInt count = i128BitUUIDs.Count();+
−
		+
−
		// Iterate whilst not exhausted and there's space for a UUID+
−
		while (i < count && ptr.Length() + KSizeOf128BitUUID <= aBytesAvailable)+
−
			{+
−
			// convert to 128 bits Little Endian for EIR+
−
			for (TUint j = 1; j<= KSdpUUIDMaxLength ;j++)+
−
				{+
−
				ptr.Append(i128BitUUIDs[i][KSdpUUIDMaxLength - j]);+
−
				}+
−
			i++;+
−
			}+
−
		__ASSERT_DEBUG(extracted->Length() <= aBytesAvailable, Panic(ESdpServerUuidFlattenBroken));+
−
		// Let the caller know if there wasn't enough space for all UUIDs+
−
		aPartial = EFalse;+
−
		if (i < count)+
−
			{+
−
			aPartial = ETrue;+
−
			}+
−
		}+
−
	return extracted;+
−
	}+
−
+
−
CSdpUuidManager::CSdpUuidManager(CSdpDatabase& aSdpDatabase)+
−
: iSdpDatabase(aSdpDatabase)+
−
	{+
−
	}+
−
	+
−
void CSdpUuidManager::ConstructL()+
−
	{+
−
	iUuidVisitor = CAttrUuidVisitor::NewL();+
−
	iEirPublisherSdpUuid16 = CEirPublisherSdpUuid16::NewL(*this);+
−
	iEirPublisherSdpUuid128 = CEirPublisherSdpUuid128::NewL(*this);+
−
	}+
−
+
−