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

// Implements CWapSmsProvider and CWapSmsProviderWrite

// 

//

/**

 @file

*/

#include <e32std.h>

#include <wap_sock.h>

#include "ws_main.h"

#include "es_wsms.h"

#include "WAPDGRM.H"

#include "ws_obsvr.h"

#include "smsprot.h"

#include <es_mbuf.h>

//

// implementation of CWapSmsProvider

//

	// CWapSmsProvider policies

	static _LIT_SECURITY_POLICY_C1(wapSmsProviderSetLocalNamePolicy, ECapabilityNetworkServices );

	static _LIT_SECURITY_POLICY_C1(wapSmsProviderSetOptionPolicy, ECapability_None);

	static _LIT_SECURITY_POLICY_C1(wapSmsProviderGetLengthIoctlPolicy,ECapability_None);

	static _LIT_SECURITY_POLICY_C1(wapSmsProviderGetMessageParamLengthIoctlPolicy,ECapability_None);

	static _LIT_SECURITY_POLICY_C1(wapSmsProviderGetMessageParametersIoctlPolicy,ECapabilityReadDeviceData);

	static _LIT_SECURITY_POLICY_C1(wapSmsProviderWritePolicy,ECapabilityNetworkServices);

/**

 *  Factory

 */

CWapSmsProvider* CWapSmsProvider::NewL(CWapSmsProtocol* aProtocol)

	{

	LOGWAPPROT1("CWapSmsProvider::NewL()");

	CWapSmsProvider* provider=new(ELeave) CWapSmsProvider(aProtocol);

	CleanupStack::PushL(provider);

	provider->iWapSmsProviderWrite = CWapSmsProviderWrite::NewL(*provider);

	CleanupStack::Pop();

	return provider;

	} // CWapSmsProvider::NewL

/**

 *  Constructor

 */

CWapSmsProvider::CWapSmsProvider(CWapSmsProtocol* aProtocol)

    :iMessageType(ESmartMessage)

    ,iProtocol(aProtocol)

    ,iSendPending(EFalse)

	,iIoctlOutstanding(EFalse)

	,iIsNewStyleClient(EFalse)

	,iStatusReportScheme(EWapSmsDefault)

    {

    iRecvdMsgQueue.SetOffset(CWapDatagram::LinkOffset());

    } // CWapSmsProvider::CWapSmsProvider

/**

 *  Destructor

 */

CWapSmsProvider::~CWapSmsProvider()

    {

    iSAPLink.Deque();

    while(!iRecvdMsgQueue.IsEmpty())

        {

        CWapDatagram* msg = iRecvdMsgQueue.First();

        iRecvdMsgQueue.Remove(*msg);

        delete msg;

        }

    delete iWapSmsProviderWrite;

    } // CWapSmsProvider::~CWapSmsProvider

/**

 *  Return WAPSMS options

 */

TInt CWapSmsProvider::GetOption(TUint aLevel,TUint aName, TDes8& aOption)const

	{

	LOGWAPPROT1("CWapSmsProvider::GetOption");

	TInt ret=KErrNone;

	if (TInt(aLevel)==KWapSmsOptionLevel && TInt(aName)==KWapSmsOptionNameDCS)

		aOption = TPtrC8((TText8*)&iDataCodingScheme,sizeof(TWapSmsDataCodingScheme));

	else

		ret=iProtocol->GetOption(aLevel,aName,aOption,NULL);

	return ret;

	} // CWapSmsProvider::GetOption

/**

 *  Set WAPSMS options

 *  

 *  @capability None

 *  

 */

TInt CWapSmsProvider::SetOption(TUint aLevel, TUint aName, const TDesC8& aOption)

	{

	LOGWAPPROT1("CWapSmsProvider::SetOption");

	if(!iSecurityChecker || (iSecurityChecker->CheckPolicy(wapSmsProviderSetOptionPolicy,"CWapSmsProvider SetOption policy check") != KErrNone))

		{

		return KErrPermissionDenied;

		}

	TInt ret=KErrNone;

	if (TInt(aLevel)==KWapSmsOptionLevel)

	{

		switch(TInt(aName))

		{

		case KWapSmsOptionNameDCS:

			{

			iDataCodingScheme = static_cast<TWapSmsDataCodingScheme>(*aOption.Ptr());

			break;

			}

		case KWapSmsOptionWapDatagram:

			{

			iMessageType=EWapDatagram;

			break;

			}

		case KWapSmsStatusReportScheme:

			{

			iStatusReportScheme = static_cast<TWapSmsStatusReportScheme>(*aOption.Ptr());

			break;				

			}

		case KWapSmsOptionNewStyleClient:

			{

			iIsNewStyleClient = ETrue;

			break;

			}

		case KWapSmsOptionOKToDeleteMessage:

			{

			//Get the first message from the queue

			CWapDatagram* msg = iRecvdMsgQueue.First();

			//Find and delete from SAR

			TBool found=iProtocol->FindAndDeleteMsg(*msg);

			if(!found)

				{

				LOGWAPPROT1("CWapSmsProvider::SetOption: Error. Couldn't find the message in the SAR for deletion");

				break;

				}

			//Remove from the queue

			iRecvdMsgQueue.Remove(*msg);

			delete msg;

			break;

			}

		default:

			ret=KErrNotSupported;

		}

	}

	else

	{

		ret=iProtocol->SetOption(aLevel,aName,aOption,NULL);

	}

	return ret;

	} // CWapSmsProvider::SetOption

/**

 *  Shutdown the SAP

 */

void CWapSmsProvider::Shutdown(TCloseType aType)

	{

	LOGWAPPROT1("CWapSmsProvider::Shutdown");

	if (aType!=CServProviderBase::EImmediate)

		iSocket->CanClose();

	} // CWapSmsProvider::Shutdown

/**

 *  Setup datagram with socket specific options and forward to protocol

 *  Return zero to block the send - will be completed by CWapSapMessageSender

 *  

 *  @capability NetworkServices

 */

TInt CWapSmsProvider::Write(RMBufChain& aBufChain, TUint /*options*/, TSockAddr* aAddr)

	{

	LOGWAPPROT1("CWapSmsProvider::Write()");

		if(!iSecurityChecker || (iSecurityChecker->CheckPolicy(wapSmsProviderWritePolicy,"CWapSmsProvider Write policy check") != KErrNone))

		{

		return KErrPermissionDenied;

		}

	// @note: LOGIFH2A2 macro for logging esock write

#ifdef SMSLOGGERIF

	TInt length = aBufChain.Length();

	LOGWAPPROT2("CWapSmsProvider::Write [%d bytes]", length);

	TBuf8<0x100> dumpBuf;

	if(length > 0x100)

		{

		TInt parts=0;

		TInt offset = 0;

 		while (offset < length)

 			{

			aBufChain.CopyOut(dumpBuf, offset);

			offset += length;

 			LOGIF2(_L8("ESock WAP concantonated part: %d"),parts++);

 			LOGIF2(_L8("ESOCK WRITE: %S"),&dumpBuf);

 			LOGIFH2A2(_L8("ESOCK WRITE: "),dumpBuf);

 			}

 	}

 	else

 	{

		aBufChain.CopyOut(dumpBuf, 0);

 		LOGIF2(_L8("ESOCK WRITE: %S"),&dumpBuf);

 		LOGIFH2A2(_L8("ESOCK WRITE: "),dumpBuf);

	}

#endif

	// Note that if this fails somehow it still frees the buf chain and sets itself active - it's

	// not clear to me whether this is good behaviour but it's the pre-mbuf behaviour too

	iWapSmsProviderWrite->Start(aBufChain, *aAddr);

	return KErrNone;

	} // CWapSmsProvider::Write

/**

 *  Read a datagram off the queue

 */

TInt CWapSmsProvider::GetData(RMBufChain& aBufChain, TUint aLength, TUint /*options*/,TSockAddr* aAddr)

	{

	LOGWAPPROT1("CWapSmsProvider::GetData()");

	CWapDatagram* msg = iRecvdMsgQueue.First();

	if(!iIsNewStyleClient)

		{

		iRecvdMsgQueue.Remove(*msg);

		}

	TInt err = msg->WapDatagram(aBufChain, aLength);

	//@note: LOGIFH2A2 macro for logging esock getdata

	LOGWAPPROT1("CWapSmsProvider::GetData");

	// Logging migrated to WapDatagram() for ease of descriptor ref

	if (err > 0 && aAddr)

		{

		TWapAddr* wapAddr = reinterpret_cast<TWapAddr*>(aAddr);

		TInt toPort,fromPort;

		msg->Ports(fromPort,toPort);

		wapAddr->SetWapPort(static_cast<TWapPortNumber>(fromPort));

		TBuf8<KMaxSockAddrSize> addrBuf;

		addrBuf.Copy(msg->FromAddress());

		wapAddr->SetWapAddress(addrBuf);

		}

	if(!iIsNewStyleClient)

		{

		delete msg;

		}

	return err > 0? 1: err;		// datagrams are atoms not byte counts

	} // CWapSmsProvider::GetData

/**

 *  New data has arrived notify ESOCK.

 */

void CWapSmsProvider::NewData(CWapDatagram* aMsg)

	{

	TBool notifyEsock = EFalse;

	LOGWAPPROT1("CWapSmsProvider::NewData");

	if(iIoctlOutstanding && iName==KSOGetLength && iIsNewStyleClient)

		{

		TPckgBuf<TInt> buf= aMsg->WapDatagramLength();

		iSocket->IoctlComplete(&buf);

		iIoctlOutstanding= EFalse;

		iName= NULL;

		notifyEsock = ETrue;

		}

	else if(iIoctlOutstanding && iName==KSOGetMessageParametersLength && iIsNewStyleClient)

		{

		CBufFlat* buffer = aMsg->SmsExternalisedStream();

		TPckgBuf<TInt> buf = buffer->Size();

		iSocket->IoctlComplete(&buf);

		iIoctlOutstanding= EFalse;

		iName= NULL;

		notifyEsock = ETrue;

		}

	else if(iIoctlOutstanding && iName==KSOGetMessageParameters && iIsNewStyleClient)

		{

		CBufFlat* buffer = aMsg->SmsExternalisedStream();

		TPtr8 buf = buffer->Ptr(0);

		iSocket->IoctlComplete(&buf);

		iIoctlOutstanding= EFalse;

		iName= NULL;

		notifyEsock = ETrue;

		}

	else if(iName!=KSOGetLength && iName!=KSOGetMessageParametersLength && iName!=KSOGetMessageParameters && iIsNewStyleClient)

		{

		notifyEsock= EFalse;

		}

	if(!iIsNewStyleClient || notifyEsock)

		iSocket->NewData(1);

	//else we notify ESock in IOCTL for new client

	} // CWapSmsProvider::NewData

/**

 *  Error happened, notify ESOCK

 */

void CWapSmsProvider::Error(TInt aError, TUint aOperationMask)

	{

	LOGWAPPROT3("CWapSmsProvider::Error [aError=%d, mask=%d] ", aError, aOperationMask);

	iSocket->Error(aError, aOperationMask);

	} // CWapSmsProvider::Error

/**

 *  Return the offset to the dblquelink

 */

TInt CWapSmsProvider::LinkOffset()

	{

	LOGWAPPROT1("CWapSmsProvider::LinkOffset");

	return _FOFF(CWapSmsProvider,iSAPLink);

	} // CWapSmsProvider::LinkOffset

/**

 *  Return the address associated with the sap

 */

void CWapSmsProvider::LocalName(TSockAddr& aAddr) const

	{

	LOGWAPPROT1("CWapSmsProvider::LocalName");

	Mem::Copy(&aAddr,&iLocalAddress,sizeof(TSockAddr));

	} // CWapSmsProvider::LocalName

/**

 *  Set the local address of the sap - called by RSocket::Bind

 *  

 *  @capability NetworkServices

 */

TInt CWapSmsProvider::SetLocalName(TSockAddr& aAddr)

	{

	LOGWAPPROT1("CWapSmsProvider::SetLocalName()");

		if(!iSecurityChecker || (iSecurityChecker->CheckPolicy(wapSmsProviderSetLocalNamePolicy,"CWapSmsProvider SetLocalName policy check") != KErrNone))

		{

		return KErrPermissionDenied;

		}

	TWapAddr* wapAddr = reinterpret_cast<TWapAddr*>(&aAddr);

	LOGWAPPROT2("CWapSmsProvider::SetLocalName %d",wapAddr->WapPort());

	// Due ESOCK interface port EWapPortUnspecified value (-1)  can be transferred as a maximum unsigned 16 int

	if (wapAddr->WapPort()==EWapPortUnspecified || wapAddr->WapPort()==static_cast<TUint16>(EWapPortUnspecified))

		{

		if(!iProtocol->AllocateLocalAddress(iLocalAddress))

			return KErrInUse;

		else return KErrNone;

		}

	TInt ret=iProtocol->AddrAlreadyUsedByWAP(*wapAddr,this);

	if(ret == KErrInUse) return ret;

	else if(ret == KErrAlreadyExists) return KErrNone;

	TSmsAddr addr;

	if(wapAddr->Port() <=255)

		addr.SetSmsAddrFamily(ESmsAddrApplication8BitPort);

	else

		addr.SetSmsAddrFamily(ESmsAddrApplication16BitPort);

	addr.SetPort(wapAddr->Port());

	if((iProtocol->SmsProtocol()->SmsAddrIsAlreadyUsed(NULL,addr)))

		return KErrInUse;

	Mem::Copy(&iLocalAddress,&aAddr,sizeof(TSockAddr));

	TInt err;

	TRAP(err,ret = iProtocol->CheckSarL(*wapAddr,this));

	if(err!=KErrNone)

			return err;

	if(ret!=KErrNone)

		{

		Error(ret,MSocketNotify::EErrorAllOperations);

		}

	return KErrNone;

	} // RSocket::Bind

/**

 *  Returns true if aAddr matches the local address of the sap

 */

TBool CWapSmsProvider::MatchesLocalAddress(const TWapAddr& aAddr)

	{

	LOGWAPPROT1("CWapSmsProvider::MatchesLocalAddress");

	return (iLocalAddress == aAddr);

	} // CWapSmsProvider::MatchesLocalAddress

//

/**

 *  Called to perform specific IO control by the client (i.e. Wap Messaging API).The client is able

 *  to get the size of the datagram once it has been received or confirm the receipt

 *  of the message.

 *  

 *  Only one ioctl request may be outstanding at any one time.

 *  

 *  Implementation of pure virtual CServProviderBase::Ioctl().

 *  

 *  @param aLevel the IOCTL level. // Can be only KSolWapProv

 *  @param aName the IOCTL name.

 *  @param aOption the IOCTL option.

 *  

 */

void CWapSmsProvider::Ioctl(TUint aLevel,TUint aName,TDes8 * /*aOption*/)

	{

	LOGWAPPROT3("CWapSmsProvider::Ioctl [aLevel=%d, aName=%d]", aLevel, aName);

	LOGWAPPROT2("CWapSmsProtocol::Ioctl [provider=0x%08x]",this);

	iName=aName;

	switch (aLevel)

		{

		case KSolWapProv:

			{

		    if(iIoctlOutstanding || !iIsNewStyleClient)

				{

				Error(KErrInUse,MSocketNotify::EErrorIoctl);

				break;

				}

			switch (iName)

				{

				case KSOGetLength:

				//

				// Get the length

				//

					{

					if(!iSecurityChecker || (iSecurityChecker->CheckPolicy(wapSmsProviderGetLengthIoctlPolicy,"CWapSmsProvider GetLength Ioctl policy check") != KErrNone))

        				{

        				Error(KErrPermissionDenied,MSocketNotify::EErrorIoctl);

        				return;

        				}

					iIoctlOutstanding = ETrue;

					//check the queue for any other message for this client and call new data if any exist

					if(!iRecvdMsgQueue.IsEmpty())

						{

						CWapDatagram* msg = iRecvdMsgQueue.First();

						//check the datagram.

						if(msg->IsComplete())

							{

							NewData(msg);

							}

						else

							{

							//	else notify the client with error.

							//	Note:this can happen if client uses 8-Bit port number for 7-Bit datagram

							Error(KErrGeneral,MSocketNotify::EErrorIoctl);

							iIoctlOutstanding = EFalse;

							}

						}

					break;

					}

				case KSOGetMessageParametersLength:

				//

				// Get the Message Parameters Length

				//

					{

					if(!iSecurityChecker || (iSecurityChecker->CheckPolicy(wapSmsProviderGetMessageParamLengthIoctlPolicy,"CWapSmsProvider KSOGetMessageParametersLength Ioctl policy check") != KErrNone))

        				{

        				Error(KErrPermissionDenied,MSocketNotify::EErrorIoctl);

        				return;

        				}

					iIoctlOutstanding = ETrue;

					//check the queue for any other message for this client and call new data if any exist

					if(!iRecvdMsgQueue.IsEmpty())

						{

						CWapDatagram* msg = iRecvdMsgQueue.First();

						//check the datagram.

						if(msg->IsComplete())

							{