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

//

/**

 @file SS_PROT.CPP

*/

#include <ss_std.h>

#include <ss_glob.h>

#include <comms-infras/ss_roles.h>

#include <comms-infras/ss_log.h>

#include <ss_protprov.h>

#include <ss_sock.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_PROT, "ESockSSockS_PROT");

#endif

using namespace ESock;

NONSHARABLE_CLASS(CLibUnloader) : public CAsyncOneShot

/**

@internalComponent

*/

	{

public:

	static CLibUnloader* NewL(RLibrary &aLibrary);

	inline void Unload();

protected:

	CLibUnloader();

	~CLibUnloader();

	virtual void RunL();

private:

	RLibrary iLib;

	};

CLibUnloader::CLibUnloader()

/**

Constructor

*/

	:CAsyncOneShot(ECAsyncDeferredPriority)

	{

	__DECLARE_NAME(_S("CLibUnloader"));

	}

CLibUnloader* CLibUnloader::NewL(RLibrary &aLibrary)

	{

	CLibUnloader* u=new(ELeave)CLibUnloader;

	u->iLib=aLibrary;

	return u;

	}

inline void CLibUnloader::Unload()

	{

	Call();

	}

CLibUnloader::~CLibUnloader()

	{

	Cancel();

	iLib.Close();

	}

void CLibUnloader::RunL()

	{

	delete this;

	}

EXPORT_C CServProviderBase::CServProviderBase()

	{

	}

EXPORT_C CServProviderBase::~CServProviderBase()

	{

	delete iV1ShimDataOut;

	delete iV1ShimDataIn;

	}

EXPORT_C void CServProviderBase::SetNotify(MSocketNotify* aSocket)

/**

Set notification for transport services to a single protocol

@param aSocket, notify the socket server that various events have occurred

*/

	{

	iSocket = aSocket;

	}

EXPORT_C void CServProviderBase::SetSockType(TUint aSockType)

	{

	iSockType = aSockType;

	}

EXPORT_C TUint CServProviderBase::SockType() const

	{

	return iSockType;

	}

EXPORT_C void CServProviderBase::JoinSubConnectionL(CSubConnectionProviderBase& /*aSubConnProvider*/)

	{

	User::Leave(KErrNotSupported);

	}

EXPORT_C void CServProviderBase::LeaveSubConnection(CSubConnectionProviderBase& /*aSubConnProvider*/)

	{

	__ASSERT_DEBUG(EFalse, User::Panic(KSpecAssert_ESockSSockS_PROT, 1));

	}

EXPORT_C TUint CServProviderBase::Write(const TDesC8& /*aDesc*/, TUint /*options*/, TSockAddr* /*anAddr*/)

	{

	Panic(EProviderIncomplete);

	return 0;

	}

EXPORT_C void CServProviderBase::GetData(TDes8& /*aDesc*/, TUint /*options*/, TSockAddr* /*anAddr*/)

	{

	Panic(EProviderIncomplete);

	}

EXPORT_C TInt CServProviderBase::Write(RMBufChain& aData, TUint aOptions, TSockAddr* anAddr)

	{

	// This version only gets called when the provider neglects to provide a better v1.5

	// implementation; efficiency is not paramount

	if(!iV1ShimDataOut)

		{

		iV1ShimDataOut = HBufC8::New(aData.Length());

		if(!iV1ShimDataOut)

			{

			return KErrNoMemory;

			}

		}

	else if(iV1ShimDataOut->Size() < aData.Length())

		{

		// We need extra room for data. As ReAlloc returns NULL if fails, we

		// need to temporary save the previous storage in order to clear it

		// in the case of ReAlloc failure.

		HBufC8* aTempPtr = iV1ShimDataOut;

		iV1ShimDataOut = iV1ShimDataOut->ReAlloc(aData.Length());

		if(!iV1ShimDataOut)

			{

			delete aTempPtr;

			return KErrNoMemory;

			}

		}

	TPtr8 des = iV1ShimDataOut->Des();

	des.SetLength(aData.Length());

	aData.CopyOut(des, 0);

	TInt ret = Write(des, aOptions, anAddr);

	if(ret > 0)

		{

		if(iSockType == KSockStream)

			{

			aData.TrimStart(ret);

			}

		else

			{

			aData.Free();

			}

		}

	return ret;

	}

EXPORT_C TInt CServProviderBase::GetData(RMBufChain& aData, TUint aLength, TUint aOptions, TSockAddr* anAddr)

	{

	// This version only gets called when the provider neglects to provide a better v1.5

	// implementation; efficiency is not paramount

	// With datagram continuation reads it is important that the provider returns the whole datagram even when

	// the client's transfer buffer is too small for this to be done as a single read. Because legacy protocols

	// may respect the length field ESOCK sets a high-order bit to make it look like a large buffer. Continuation

	// reads aren't supported with this descriptor interface (due to the need to allocate an arbitarily large

	// buffer) so here the bit is reset

	aLength &= ~KGetDataWholeDatagram;

	if(!iV1ShimDataIn)

		{

		iV1ShimDataIn = HBufC8::New(aLength);

		if(!iV1ShimDataIn)

			{

			return KErrNoMemory;

			}

		}

	else if(iV1ShimDataIn->Size() < TInt(aLength))

		{

		// We need extra room for data. As ReAlloc returns NULL if fails, we

		// need to temporary save the previous storage in order to clear it

		// in the case of ReAlloc failure.

		HBufC8* aTempPtr = iV1ShimDataIn;

		iV1ShimDataIn = iV1ShimDataIn->ReAlloc(aLength);

		if(!iV1ShimDataIn)

			{

			delete aTempPtr;

			return KErrNoMemory;

			}

		}

	TInt extraNeeded = aLength - aData.Length();

	if(extraNeeded > 0)

		{

		TInt err = aData.Append(extraNeeded);

		if(err != KErrNone)

			{

			return KErrNoMBufs;

			}

		}

	TPtr8 des = iV1ShimDataIn->Des();

	des.SetLength(aLength);

	GetData(des, aOptions, anAddr);

	aData.CopyIn(des, 0);

	// Handle protocol reneging (eg when read being cancelled)

	if(des.Length() < TInt(aLength))

		{

		aData.TrimEnd(des.Length());

		}

	if(iSockType == KSockStream)

		{

		return des.Length();

		}

	else

		{

		return 1;	// datagrams are counted as "atoms" not bytes

		}

	}

EXPORT_C CServProviderBase * CProtocolBase::NewSAPL(TUint /*aProtocol*/)

//

// Default socket creation

//

/** Creates a new service access point.

If the protocol cannot create the CServProviderBase for any reason, it should leave.

@param aProtocol Protocol.

*/

	{

	Fault(EOddSock);

	return (CServProviderBase*)NULL; //lint !e527	// unreachable

	}

EXPORT_C TInt CHostResolvProvdBase::SetOption(TUint /*level*/, TUint /*name*/, const TDesC8& /*anOption*/)

/**

Default Set Option for Host Resolver

Sets options for the protocol on behalf of socket server clients

@param level, The level in the stack the option request is ‘aimed’ at

@param name, The name of the option

@param anOption, Descriptor to hold the option data

@return KErrNotSupported if the option is not supported.

*/

	{

	return KErrNotSupported;

	}

EXPORT_C void CHostResolvProvdBase::Query(const TDesC8& /*aQryBuf*/, TDes8& /*aResBuf*/, TInt /*aCounter*/)

/**

* Make a query to the protocol.

* @param    aQryBuf  descriptor representing query data.

* @param    aResBuf  descriptor representing query response data.

* @param    aCounter query sequential number counter. From the client's point of view it will be 0 for "Query" call

*           and increased by 1 for each "QueryGetNext" call.

* @note     for aCounter > 0 data in aQryBuf are not supposed to be used.

*/

	{

    if(iNotify)

    	{

        iNotify->QueryComplete(KErrNotSupported);

    	}

	}

EXPORT_C TInt CServProviderBase::SecurityCheck(MProvdSecurityChecker* /*aChecker*/)

/**

Ask the socket provider to perform a security policy check on the originating process

(default implementation).

Called when a socket is opened or transferred, and after the PRT presents a new accepting

socket to ESOCK.

@param aChecker class instance that socket provider can use to check capabilities of originating

process.

@return KErrNone if check passes, KErrPermissionDenied if check fails, else a system-wide error code.

*/

	{

	// ********************************************************************

	// NOTE: KErrNone for now, but this should be changed to KErrNotSupported to

	// turn on strict checking and fail PRTs that have not been secured.

	// ********************************************************************

	return KErrNone;

	}

EXPORT_C TInt CResolverProvdBase::SecurityCheck(MProvdSecurityChecker* /*aChecker*/)

/**

Ask the resolver provider to perform a security policy check on the originating process

(default implementation).

Called when a resolver is opened.

@param aChecker class instance that resolver can use to check capabilities of originating process.

@return KErrNone if check passes, KErrPermissionDenied if check fails, else a system-wide error code.

*/

	{

	// ********************************************************************

	// NOTE: KErrNone for now, but this should be changed to KErrNotSupported to

	// turn on strict checking and fail PRTs that have not been secured.

	// ********************************************************************

	return KErrNone;

	}

EXPORT_C void CProtocolBase::StartSending(CProtocolBase* /*aProtocol*/)

//

// Default StartSending - ignored

//

/** Indicates that data can now be sent. Implementations can call bound higher-level

protocols and service access points in turn.

With Send(), this function forms a flow control pair. A zero return from a

Send() should flow control off the calling protocol. StartSending() acts as

a flow control on.

@note This implementation does nothing.

@param aProtocol The calling protocol */

	{

	}

EXPORT_C void CProtocolBase::InitL(TDesC &/*aTag*/)

//

// Default InitL - ignored

//

/** Initialises a protocol before any binding is performed. A protocol can override

it to create any further resources it may require - this might include allocating

buffers, opening devices or reading more configuration information.

If the protocol encounters any errors it should leave.

@note This implementation does nothing.

@param aTag The string identifier for the protocol as given by its section

header in esock.ini */

	{

	}

EXPORT_C void CProtocolBase::StartL(void)

//

// Default StartL - ignored

//

/** Indicates to a protocol that all binding has completed successfully and it

can start processing datagrams. This is mainly of interest to the lowest levels

of a protocol stack which would queue a read on the network media device driver

in response to this call.

If a protocol cannot start to process data (for example it may not have bound

correctly) it should leave.

@note This implementation does nothing.

 */

	{

	}

EXPORT_C void CProtocolBase::BindL(CProtocolBase* /*protocol*/, TUint /*id*/)

//

// Default BindL - Panic

//

/** This function panics with a panic number of EDoesNotBindBelow.

@param protocol The higher level protocol requesting to bind

@param id The ID number of the protocol requesting to bind */

	{

	Panic(EDoesNotBindBelow);

	}

EXPORT_C void CProtocolBase::BindToL(CProtocolBase* /*protocol*/)

//

// Default BindToL - Panic

//

/** This function panics with a panic number of EDoesNotBindAbove.

@param protocol The lower level protocol whose bind function must be called.

*/

	{

	Panic(EDoesNotBindAbove);

	}

EXPORT_C TInt CProtocolBase::Send(RMBufChain& /*aPDU*/,CProtocolBase* /*aSourceProtocol=NULL*/)

/**

This function panics with a panic number of ECantSendMBufs.

@param aPDU, MBuf chain

@param aSourceProtocol, The protocol from which the data has been sent

*/

	{

	Panic(ECantSendMBufs);

	return 0;

	}

EXPORT_C TInt CProtocolBase::Send(TDes8& /*aPDU*/,TSockAddr* /*to*/,TSockAddr* /*from=NULL*/,CProtocolBase* /*aSourceProtocol=NULL*/)

/** 

This function panics with a panic number of ECantSendDescriptors.

@param aPDU The datagram to be sent.

@param aTo  The address to send the datagram to.

@param aFrom The address originating the send.

@param aSourceProtocol The protocol from which the data has been sent.

@return KErrNone or another of the system wide error codes.

*/

	{

	Panic(ECantSendDescriptors);

	return 0;

	}

EXPORT_C void CProtocolBase::Process(RMBufChain &,CProtocolBase* /*aSourceProtocol=NULL*/)

/**

This function panics with a panic number of ECantProcessMbufs.

@param MBuf Chain

@param aSourceProtocol, The datagram to be sent

*/

	{

	Panic(ECantProcessMbufs);

	}

EXPORT_C void CProtocolBase::Process(TDes8& /*aPDU*/,TSockAddr* /*from*/,TSockAddr* /*to=NULL*/,CProtocolBase* /*aSourceProtocol=NULL*/)

/** 

This function panics with a panic number of ECantProcessDescriptors.

@param aPDU The datagram to process.

@param aFrom The address the datagram is from.

@param aTo The address the datagram is to.

@param aSourceProtocol The higher level protocol which we want to

process our incoming datagram.

*/

	{

	Panic(ECantProcessDescriptors);

	}

EXPORT_C TInt CProtocolBase::GetOption(TUint /*level*/,TUint /*name*/,TDes8& /*option*/,CProtocolBase* /*aSourceProtocol=NULL*/)

//

// default Getoption - return KErrNotSupported

//

/** Gets options for the protocol on behalf of socket server clients.

The option parameter is protocol-defined - this is a generic API.

The protocol is passed in because you might get GetOption() calls from

multiple bindees - this is actually more meaningful for SetOption().

@param aLevel  The level in the stack the option request is aimed at.

@param aName  The name of the option.

@param anOption Descriptor to hold the option data.

@param aSourceProtocol The protocol making the request.

@return  KErrNone or another of the system wide error codes; this version returns KErrNotSupported.

*/

	{

	return KErrNotSupported;

	}

EXPORT_C TInt CProtocolBase::SetOption(TUint /*level*/,TUint /*name*/,const TDesC8& /*option*/,CProtocolBase* /*aSourceProtocol=NULL*/)

//

// default SetOption - return KErrNotSupported

//

/** Sets options for the protocol on behalf of socket server clients.

The option parameter is protocol-defined - this is a generic API.

The protocol is passed in because you might get SetOption() calls from

multiple bindees and need to distinguish who is setting what.

@param aLevel  The level in the stack the option request is aimed at.

@param aName  The name of the option.

@param anOption Descriptor to hold the option data.

@param aSourceProtocol The protocol making the request.

@return  KErrNone or another of the system wide error codes; this version returns KErrNotSupported.

*/

	{

	return KErrNotSupported;

	}

EXPORT_C void CProtocolBase::Error(TInt anError,CProtocolBase* aSourceProtocol)

/** 

This function panics with a panic number of EErrorCallNotHandled unless the error is KErrCancel

which is simply ignored.

@param anError The error code

@param aSourceProtocol The protocol raising the error */

	{

	#ifdef ESOCK_LOGGING_ACTIVE

		_LIT(KUnknownProtocolTag, "unknown");

		TPtrC tagPtr(KUnknownProtocolTag);

		if (iManagerRef)

			{

			tagPtr.Set(iManagerRef->Tag());

			}

		TPtrC srcTagPtr(KUnknownProtocolTag);

		if (aSourceProtocol && aSourceProtocol->iManagerRef)

			{

			srcTagPtr.Set(aSourceProtocol->iManagerRef->Tag());

			}

		TPtrC panicCatPtr(KESockProtocolPanic);

		if(anError == KErrCancel)

			{

			LOG( ESockLog::Printf(KESockErrorTag, _L("CProtocolBase %08x:\tError() - error: KErrCancel, protocol: %S, source protocol: %S (%08X)"), this, &srcTagPtr, &tagPtr, aSourceProtocol ) );