// Copyright (c) 1997-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 <comms-infras/ss_roles.h>

#include <ss_glob.h>

//#include <es_ini.h>

#include <comms-infras/ss_log.h>

#include <ss_protprov.h>

#include <comms-infras/ss_sapshim.h>

#include <ss_sock.h>

#include "SS_rslv.H"

#include "SS_conn.H"

#include "ss_eintsockimpl.h"

#ifdef _DEBUG

// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module

// (if it could happen through user error then you should give it an explicit, documented, category + code)

_LIT(KSpecAssert_ESockSSockS_MAN, "ESockSSockS_MAN.");

#endif

using namespace ESock;

#if defined (_DEBUG)

/** @file

Check that the protocol has filled in the protocol structure

As much as we can anyway.

Note that this function needs to be maintained in parallel with the contents of es_sock.h and es_prot.h

A panic in this function means that the protocol has returned an invalid TServerProtocolDesc

@internalComponent

*/

void CheckProtocolList(TServerProtocolDesc* aProtocolList,TInt aCount)

	{

	for (TInt i=0;i<aCount;i++)

		{

		if ((aProtocolList+i)->iServiceTypeInfo&0xFFFFFF00)

			{

			Panic(EBadProtocolDescription);

			}

		if ((aProtocolList+i)->iNumSockets==(TInt)0xa5a5a5a5)

			{

			Panic(EBadProtocolDescription);

			}

		if ((aProtocolList+i)->iName.Length()==0)

			{

			Panic(EBadProtocolDescription);

			}

		if ((aProtocolList+i)->iAddrFamily==0 || (aProtocolList+i)->iAddrFamily==0xa5a5a5a5)

			{

			Panic(EBadProtocolDescription);

			}

		if ((aProtocolList+i)->iSockType==0xa5a5a5a5)

			{

			Panic(EBadProtocolDescription);

			}

		//If the socket has no support for sockets (NumSockets is 0)

		//then it should be of SockType 0.

		if ((aProtocolList+i)->iSockType==0)

			{

			if ((aProtocolList+i)->iNumSockets!=0)

				{

				Panic(EBadProtocolDescription);

				}

			}

		if ((aProtocolList+i)->iProtocol==0 || (aProtocolList+i)->iProtocol==0xa5a5a5a5)

			{

			Panic(EBadProtocolDescription);

			}

		if ((((aProtocolList+i)->iVersion.iMajor==0)&&((aProtocolList+i)->iVersion.iMinor==0)&&((aProtocolList+i)->iVersion.iBuild==0)))

			{

			Panic(EBadProtocolDescription);

			}

		if (((aProtocolList+i)->iByteOrder!=EBigEndian && (aProtocolList+i)->iByteOrder!=ELittleEndian && (aProtocolList+i)->iByteOrder!=EOtherByteOrder))

			{

			Panic(EBadProtocolDescription);

			}

		if ((aProtocolList+i)->iServiceInfo&0xfffc0000)

			{

			Panic(EBadProtocolDescription);

			}

		if ((aProtocolList+i)->iNamingServices&0xfffffe00)

			{

			Panic(EBadProtocolDescription);

			}

		if ((aProtocolList+i)->iSecurity&0xfffffffe)

			{

			Panic(EBadProtocolDescription);

			}

		if (((aProtocolList+i)->iMessageSize<0 && (aProtocolList+i)->iMessageSize!=KSocketMessageSizeNoLimit))

			{

			Panic(EBadProtocolDescription);

			}

		}

	}

#endif

//

// Protocol manager assumes that there will be an ini file setion called

// [protocols] which will contain a single entry: protocols= the data for

// which is a comma seperated list of further section names.

// Each of these section names should contina a file name of a .PRT

// and index number of the protocol inside this family and an optional

// bindto= entry specifying which lower protocols this should be bound to.

//

// The protocol manager late loads (and binds) all protocols - keeping only CProtocolRef etc.

// classes which contain enough data to reload the protocol when the first socket is

// created. Protocols will the stay loaded unti lthe last client (who made a socket of

// the specified type) closes. I.e. protocols are created for sockets but referenced by

// sessions.

//

/**

@internalComponent

*/

_LIT(KSockManMainSectionName,"sockman");

_LIT(KProtocolListItemName,"protocols");

_LIT(KFilenameItemName,"filename");

_LIT(KIndexTagName,"index");

_LIT(KBindToItemName,"bindto");

_LIT(KBindFromItemName,"bindfrom");

_LIT(KFlowFactoryUid, "flow_factory_uid");

_LIT(KFlowProtocol, "flow_protocol_id");

_LIT(KOpenAngle, "<");

_LIT(KCloseAngle, ">");

_LIT(KComma, ",");

const TInt KDependSize = 32;

void ProtocolManager::AddDependencyL(const TDesC& aDependentsList, const TDesC& aModuleToLoad)

/**

Adds a module to the dependency list. Dependency list is of form <a>b,c<d>e,f

meaning that module "a" is dependant on "b" and "c" and requires module b and c to be loaded.

@param aDependentsList list of dependant components to be loaded

@param aModuleToLoad The module for which the dependency is added

*/

	{

	CSockManData *globals=SockManGlobals::Get();

	if (globals->iDeps == NULL)

		{

		globals->iDeps = HBufC::NewL(KDependSize);

		}

	TLex lex(aDependentsList);

	TChar ch=0;

	do

		{

		lex.Mark();

		do

			{

			ch=lex.Get();

			}

		while (ch!=',' && ch!=0);

		if (ch==',')

			{

			lex.UnGet();

			}

		TPtrC dependent=lex.MarkedToken();

		lex.Get();

		TBuf<50> searchBuf;

		searchBuf.Append(KOpenAngle);

		searchBuf.Append(dependent);

		searchBuf.Append(KCloseAngle);

		TPtr list = globals->iDeps->Des();

		TInt reqLength = list.Length() + searchBuf.Length() + aModuleToLoad.Length();

		if (reqLength >= list.MaxLength())

			{

			globals->iDeps = globals->iDeps->ReAllocL(reqLength);

			list.Set(globals->iDeps->Des());

			}

		TInt pos = list.Find(searchBuf);

		if (pos == KErrNotFound)

			{

			list.Append(searchBuf);

			list.Append(aModuleToLoad);

			}

		else

			{

			pos++;

			TInt endPos = list.Mid(pos).Find(KOpenAngle);

			if (endPos != KErrNotFound)

				{

				endPos += pos;

				list.Insert(endPos, KComma);

				list.Insert(endPos + 1, aModuleToLoad);

				}

			else

				{

				list.Append(KComma);

				list.Append(aModuleToLoad);

				}

			}

		} while (ch != 0);

	}

TBool ProtocolManager::GetDependency(const TDesC& aTag,TPtrC &aList)

/**

Goes through the dependency list and gets the dependant modules for aTag

@param aTag The protocol tag based on which the dependancy list is searched

@param aList A list of components dependant on aTag protocol which are returned

@return ETrue if a dependency for the component aTag is found else EFalse

*/

	{

	CSockManData *globals=SockManGlobals::Get();

	if(globals->iDeps)

		{

		TPtrC list = *globals->iDeps;

	  	TBuf<50> tag(KOpenAngle);

		tag.Append(aTag);

		tag.Append(KCloseAngle);

		TInt offset= list.Find(tag);

		if(offset!=KErrNotFound)

			{

			aList.Set(list.Mid(offset+tag.Length()));

			offset= aList.Find(KOpenAngle);

			if(offset!=KErrNotFound)

				{

				aList.Set(aList.Mid(0,offset));

				}

			return ETrue;

			}

		}

	return EFalse;

	}

void ProtocolManager::InitL()

/**

Init data structures and hunt for protocols.

*/

	{

	LOG( ESockLog::Printf(_L("ProtocolManager: Initialising.")) );

	// Allocate global storage to be held in tls.

	CSockManData *globals=SockManGlobals::Get();

	globals->iProtocols=new(ELeave) TSglQue<CProtocolRef>(_FOFF(CProtocolRef,iLink));

	CleanupStack::PushL(globals->iProtocols);

	globals->iProtocolFamilies=new(ELeave) TSglQue<CProtocolFamilyRef>(_FOFF(CProtocolFamilyRef,iLink));

	CleanupStack::Pop(globals->iProtocols);

	}

void ProtocolManager::ShutDown()

/**

free data structures

*/

	{

	CSockManData* globals=SockManGlobals::Get();

	TSglQueIter<CProtocolRef> i(*globals->iProtocols);

	CProtocolRef* p=NULL;

	while(p=i++,p!=NULL)

		{

		globals->iProtocols->Remove(*p);

		delete p;

		}

	TSglQueIter<CProtocolFamilyRef> j(*globals->iProtocolFamilies);

	CProtocolFamilyRef* f=NULL;

	while(f=j++,f!=NULL)

		{

		globals->iProtocolFamilies->Remove(*f);

		delete f;

		}

	// delete all the containers and lists of protocols etc.

	delete globals->iProtocols;

	delete globals->iProtocolFamilies;

	delete globals->iDeps;

	}

void ProtocolManager::ProcessIniDataL()

	{

	LOG( ESockLog::Printf(_L("ProtocolManager: Retrieve ESock inidata.")) );

	CSockManData *globals=SockManGlobals::Get();

	const CESockIniData* ini=globals->IniData();

	TPtrC protocols;

	if (ini->FindVar(KSockManMainSectionName,KProtocolListItemName,protocols)==EFalse)

		User::Leave(KErrBadName);

	LOG( ESockLog::Printf(_L("ProtocolManager: Protocol list is %S"), &protocols) );

	LOG( ESockLog::Printf(_L("ProtocolManager: Loading PRTs and setting up protocols.")) );

	TLex lex(protocols);

	TChar ch=0;

	do

		{

		lex.Mark();

		do

			{

			ch=lex.Get();

			}

		while (ch!=',' && ch!=0);

		if (ch==',')

			{

			lex.UnGet();

			}

		TPtrC protTag=lex.MarkedToken();

		lex.Get();

		TPtrC fileName(NULL,0);

		// If there is no filename present (legacy PRT based protocols) then we expect instead the uid of a

		// three plane comms based flow factory that can can return a protocol description

		if(ini->FindVar(protTag, KFilenameItemName, fileName) == EFalse)

			{

			// Deal with the flow case

			// Fetch the UID of the flow factory

			TInt flowFactoryUid;

			if(ini->FindVar(protTag, KFlowFactoryUid, flowFactoryUid) == EFalse)

				{

#if defined(_DEBUG)

				LOG(ESockLog::Printf(_L("ProtocolManager: error while parsing 3PC based protocol - no flow factory UID found")));

				Panic(EBadProtocolDescription);

#else

				User::Leave(KErrNotFound);

#endif

				}

			// We need the flow factory container in order to instantiate a flow factory with ECOM

			// Misconfiguration should not kill off c32 in a release build so we simply leave rather than panic

#if defined(_DEBUG)

			if(globals->iSubConnectionFlowFactories == NULL)

				{

				LOG(ESockLog::Printf(_L("ProtocolManager: error while parsing esk files - flow factories not yet initialised")));

				Panic(EBadProtocolDescription);

				}

#else

			User::LeaveIfNull(globals->iSubConnectionFlowFactories);

#endif

			// Fetch the given factory and fetch the protocol description from it

			CSubConnectionFlowFactoryBase* flowFactory =

				static_cast<CSubConnectionFlowFactoryBase*>(globals->iSubConnectionFlowFactories->FindOrCreateFactoryL(TUid::Uid(flowFactoryUid)));

			CleanupStack::PushL(flowFactory);

			// Fetch the id of the protocol itself (as one factory can create flows of more than one type)

			TInt protocol;

			if(ini->FindVar(protTag, KFlowProtocol, protocol) == EFalse)

				{

				LOG(ESockLog::Printf(_L("ProtocolManager: error while parsing esk file - no 3PC protocol found")));

				__ASSERT_DEBUG(0, Panic(EBadProtocolDescription));

				User::Leave(KErrNotFound);

				}

			// Ask for a protocol description from the flow factory and add that description to our globals

#if defined(_DEBUG)

			TServerProtocolDesc* protocolDescription = NULL;

			TRAPD(descriptionError, protocolDescription = flowFactory->CreateFlowDescriptionL(protocol););

			if(descriptionError != KErrNone)

				{

				LOG(ESockLog::Printf(_L("ProtocolManager: error while parsing esk file - no protocol description provided by factory for 3PC based flow type")));

				Panic(EBadProtocolDescription);

				}

#else

			TServerProtocolDesc* protocolDescription = flowFactory->CreateFlowDescriptionL(protocol);

#endif

			CleanupStack::PushL(protocolDescription);

			CProtocolRef::MakeRefL(protTag, protocolDescription);

			globals->iNumProtocols++;

			delete protocolDescription;

			CleanupStack::Pop(2, flowFactory);

			}

		else

			{

			// Deal with the legacy case

			TPtrC bindfrom(NULL, 0);

			if (ini->FindVar(protTag,KBindFromItemName,bindfrom))

				{

				AddDependencyL(bindfrom, protTag);

				}

			CProtocolFamilyRef* protFamily = NULL;

			TInt err;

			TRAP(err, protFamily = CProtocolFamilyRef::GetProtocolFamilyL(fileName));

			if (err != KErrNone)

				{

				continue;

				}

			CleanupStack::PushL(protFamily);

			// Query the protocol family about all the socket types it can produce

			// We'll remember them because we unload the libraries until we actually need them.

			TServerProtocolDesc *protocolList = NULL;

			// Note: some protocols will leave in their ProtocolList() method.  This

			// is handled correctly here, although the naming convention is incorrect.

			TInt numProtocols = 0;

			TRAP(err, numProtocols = protFamily->ProtocolFamilyL(EFalse).ProtocolList(protocolList));

			if (numProtocols == 0 || err != KErrNone)

				{

				LOG( ESockLog::Printf(_L("ProtocolManager: Protocol %S failed to load (error = %d, number of protocols = %d)"),

					&protTag, err, numProtocols) );

				CleanupStack::Pop(protFamily);

				continue;

				}

#if defined (_DEBUG)

			CheckProtocolList(protocolList,numProtocols);

#endif

			CleanupArrayDeletePushL(protocolList);

			TInt num=0;

			if (numProtocols>1)

				{

				if (ini->FindVar(protTag,KIndexTagName,num) == EFalse)

					{

                    LOG(ESockLog::Printf(_L("ProtocolManager: error while parsing esk file - Protocol index missing")));

					User::Leave(KErrNotFound);

					}

				num--;

				}

			if (num>numProtocols)

				{

				CleanupStack::Pop(protocolList);

				CleanupStack::Pop(protFamily);

				continue;

				}

			CProtocolRef *pp=CProtocolRef::MakeRefL(protTag,protFamily,protocolList+num);

			if (pp==NULL)

				{

				User::Leave(KErrNoMemory);

				}

			CleanupStack::Pop(protocolList);

			LOG(ESockLog::Printf(KESockSessDetailTag, _L("ProtocolManager: prot '%S' ref=%08x, famRef=%08x, num=%d"), &protTag, pp, protFamily, num));

			globals->iNumProtocols++;

			delete []protocolList;

			CleanupStack::Pop(protFamily);

			}

		}

	while (ch!=0);	// ch==0 when last token removed from TLex

	// Leave if there's no point in carrying on. - i.e. no protocols.

	if (globals->iNumProtocols==0)

		{

		LOG(ESockLog::Printf(_L("ProtocolManager: No protocols - leaving.")));

		User::Leave(KErrBadDriver);

		}

	// Delete all protocolfamilybase objects, causing DLLs to unload

	LOG(ESockLog::Printf(_L("ProtocolManager: Finished initialising. Unloading all PRTs.")));

	TSglQueIter<CProtocolFamilyRef> familyIter(*globals->iProtocolFamilies);

	CProtocolFamilyRef* family;

	while(family=familyIter++,family!=NULL)

		{

		delete &(family->ProtocolFamilyL(EFalse));

		}

	LOG(ESockLog::Printf(_L("ProtocolManager: Done.")));

	if(globals->iDeps)

		{

		LOG(ESockLog::Printf(_L("Dependencies: %S"), &*(globals->iDeps)));

		}

	}

void ProtocolManager::SafeCleanupProtocol(TAny* aProtocolRef)

/**

Try to clean up a protocol instance

This routine is pushed onto the cleanup stack in order to clean up a protocol instance.

The check against the protocol pointer being non-NULL is a safety check.  This routine was

created because ProtocolManager::CleanupProtocol(protocol) was being called in circumstances

where the protocol had already gone and the pointer to it had become invalid.  This routine

takes as argument a pointer to the CProtocolRef instance of the protocol, so that the protocol

pointer can be checked against NULL.

@param aProtocolRef pointer to the CProtocolRef instance whose protocol needs to be deleted

*/

	{

	CProtocolRef *pRef = reinterpret_cast<CProtocolRef*>(aProtocolRef);

	if (pRef->Protocol())

		{

		pRef->Protocol()->TryDelete();

		}

	}

void ProtocolManager::CleanupProtocol(TAny* aProtocol)

	{

	((CProtocolBase *)aProtocol)->TryDelete();

	}

void ProtocolManager::TransferSocketL(CSocket* aSocket, CPlayer* aPlayer)

/**

Transfer socket from one session to another

*/

	{