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

// NBSocketWatcher.cpp

// 

//

#include "NBSSocketWatcher.h"

#include "SmsSocketWatcher.h"

#include <smuthdr.h>

#include <msventry.h>

#include <msvstd.h>

#include <msvuids.h>

#include <smut.h>

#include <watcher.h>

#include <smsuaddr.h>

#include <gsmuelem.h>

#include <gsmunonieoperations.h>

#include <s32strm.h>

#include <s32mem.h>

#include <gsmubuf.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS  

#include <tmsvsmsentry.h>

#include "cwatcher.h"			

#endif

const TInt KSmsWRetryTimer = 1000000 * 15; // 15 Secs

/*

 * CNbsSocketWatcher

 */

CNbsSmsSocketWatcher::CNbsSmsSocketWatcher(CWatcherLog& aWatcherLog, TInt aPriority, TUid aBioID, RFs& aFs, const TDesC& aNbsPattern, TSmsAddrFamily aAddrFamily)

:	CBaseSmsActiveSocketWatcher(aWatcherLog, aPriority, aBioID, aFs),

	iAddrFamily(aAddrFamily),

	iNbsPattern(aNbsPattern)

	{

	}

CNbsSmsSocketWatcher::~CNbsSmsSocketWatcher()

	{

	Cancel();

	if (iSocket.SubSessionHandle())

		iSocket.Close();

	if (iSocketServer.Handle())

		iSocketServer.Close();

	//destroying class 0 SMS E-Com pluin implementation 

	if (iSmsClass0 != NULL)

		{

		REComSession::DestroyedImplementation(iDtor_ID_Key);

		REComSession::FinalClose();

		delete iSmsClass0;

		}

	RProperty::Delete(KUidSystemCategory, KUidPSDiskSpaceMonitorKeyType);

	}

CNbsSmsSocketWatcher* CNbsSmsSocketWatcher::NewLC(TMsvId aBioServiceId, 

									   			  TMsvId aSmsServiceId, 

									   			  CBIODatabase& aBioDb, 

									   			  CWatcherLog& aWatcherLog, 

									   			  TInt aPriority, 

									   			  TUid aBioID, 

									   			  RFs& aFs, 

									   			  const TDesC& aNbsPattern, 

									   			  TSmsAddrFamily aAddrFamily /*= ESmsAddrMatchText*/)

	{

	CNbsSmsSocketWatcher* self = new(ELeave) CNbsSmsSocketWatcher(aWatcherLog, aPriority, aBioID, aFs, aNbsPattern, aAddrFamily);

	CleanupStack::PushL(self);

	self->ConstructL(aBioServiceId, aSmsServiceId, aBioDb);

	return self;	

	}

void CNbsSmsSocketWatcher::ConstructL(TMsvId aBioServiceId, TMsvId aSmsServiceId, CBIODatabase& aBioDb)

	{

	CBaseSmsActiveSocketWatcher::ConstructL(aBioDb, aBioServiceId, aSmsServiceId);

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

	TSecurityPolicy  readPolicy(ECapabilityReadDeviceData);

	TSecurityPolicy  writePolicy(ECapabilityWriteDeviceData);

	TInt ret = RProperty::Define(KUidSystemCategory, KUidPSDiskSpaceMonitorKeyType,

  	  	 				  RProperty::EInt, readPolicy, writePolicy);

	BIOWATCHERLOG(iWatcherLog.Printf(_L(" Define return value %d"), ret));

	if (ret != KErrNone  &&  ret != KErrAlreadyExists)

  		{

  		User::Leave(ret);

  		}   

	TInt setRet = RProperty::Set(KUidSystemCategory, KUidPSDiskSpaceMonitorKeyType, ESmsDiskSpaceAvailable);

	BIOWATCHERLOG(iWatcherLog.Printf(_L(" Set value %d"), setRet));

	if (setRet != KErrNone)

  		{

  		User::Leave(setRet);

  		}

	}

void CNbsSmsSocketWatcher::DoCancel()

	{

	BIOWATCHERLOG(iWatcherLog.Printf(_L("BioNbs: DoCancel")));

	if (iIoCtlActive)

		{

		iSocket.CancelIoctl();

		}

	if(iTimer.Handle() != NULL)

		iTimer.Cancel();

	Complete(KErrCancel);

	}

void CNbsSmsSocketWatcher::DoRunL()

	{

	iIoCtlActive = EFalse;

	switch(iState)

		{

		case ESmsWWaitForMsg:

			iState = ESmsWReadMsg;

			WaitForMessageL();

			break;

		case ESmsWReadMsg:

			iState = ESmsWWaitForMsg;

			ReceiveL();

			break;

		case ESmsWRetryError:

			if (!iTimer.Handle())

				{

				User::LeaveIfError(iTimer.CreateLocal());

				}

			iState=ESmsWWaitForMsg;

			iTimer.After(iStatus, KSmsWRetryTimer);

			break;

		case ESmsIsClass0Msg:

			iState = ESmsSupportClass0Msg;

			CheckForClass0SmsSupport();

			break;

		case ESmsSupportClass0Msg:

			iState = ESmsWWaitForMsg;

			SupportForClass0SmsL();

			break;

		}

	SetActive();

	}

void CNbsSmsSocketWatcher::DoSetupL()

	{

	BIOWATCHERLOG(iWatcherLog.Printf(_L("BioNbs: DoSetupL: %S"), &iBioMsgText));

	// Set up the Socket to watch the port

	// test if it's there... 

	TProtocolDesc protoInfo;

	TProtocolName protocolname;

	BIOWATCHERLOG(iWatcherLog.Printf(_L8("BioNbs: DoSetupL: Finding protocol")));

	protocolname.Copy(KSmsDatagram);

	User::LeaveIfError(iSocketServer.FindProtocol(protocolname,protoInfo));

	BIOWATCHERLOG(iWatcherLog.Printf(_L8("BioNbs: DoSetupL: Opening socket")));

	// Create the RSocket

	User::LeaveIfError(iSocket.Open(iSocketServer,

										protoInfo.iAddrFamily,

										protoInfo.iSockType, 

										protoInfo.iProtocol));

	// Set up the Socket to watch the pattern

	if (iBioMsgUID != KNullUid && iAddrFamily == ESmsAddrMatchText)

	{

		// need an 8 bit pattern

		TBuf8<KMaxBioIdText> pattern; 

		pattern.Copy(iNbsPattern);

		iSmsAddr.SetSmsAddrFamily(ESmsAddrMatchText);

		iSmsAddr.SetTextMatch(pattern);

	}

	else

	{

		// Binding to a non-patter address family

		// like StatusReports, Special Messages, and RecieveAny

		iSmsAddr.SetSmsAddrFamily(iAddrFamily);

	}

	BIOWATCHERLOG(iWatcherLog.Printf(_L8("BioNbs: DoSetupL: Binding socket")));

	User::LeaveIfError(iSocket.Bind(iSmsAddr));

	}

void CNbsSmsSocketWatcher::DoComplete(TInt& rStatus)

	{	

	BIOWATCHERLOG(iWatcherLog.Printf(_L("BioNbs: DoComplete: %S, status %d"), &iBioMsgText, rStatus));

	if (iSocket.SubSessionHandle())

		{

		iSocket.Close();

		}

	}

void CNbsSmsSocketWatcher::WaitForMessageL()

	{

	BIOWATCHERLOG(iWatcherLog.Printf(_L("BioNbs: WaitForMessageL: %S"), &iBioMsgText));

	iOctlRes()= KSockSelectRead;

	iIoCtlActive = ETrue;

	iSocket.Ioctl(KIOctlSelect, iStatus, &iOctlRes, KSOLSocket);

	}

// CNbsSmsSocketWatcher::CheckForClass0SmsSupport to find out whether SMS stack is 

// configured for this new behaviour of class 0 message or not.

void CNbsSmsSocketWatcher::CheckForClass0SmsSupport()

	{

	// Need verify SMS stack configuration, if type of socket address is ESmsAddrRecvAny only

	if (iAddrFamily == ESmsAddrRecvAny)

		{

		BIOWATCHERLOG(iWatcherLog.Printf(_L("BioNbs: CheckForClass0SmsSupport")));

		iOctlRes()= KSockSelectRead;

		iIoCtlActive = ETrue;

		//iStatus will return KErrNone if stack supports new way of handling class 0 messages. 

		//Otherwise it will return KErrNotSupported.

		iSocket.Ioctl(KIoctlSupportOODClass0SmsMessages, iStatus, NULL, KSolSmsProv);

		}

	else

		{

		//Change state to Wait For Message

		iState = ESmsWWaitForMsg;

		//Complete self to enter state machine

		TRequestStatus* status = &iStatus;

		iStatus=KRequestPending;

		User::RequestComplete(status, KErrNone);

		}

	}

void CNbsSmsSocketWatcher::DoReceiveL()

 	{

 	// Get the Message

 	CSmsMessage* smsmessage = CSmsMessage::NewL(iFs, CSmsPDU::ESmsDeliver, CSmsBuffer::NewL());

 	CleanupStack::PushL(smsmessage);

 	RSmsSocketReadStream readstream(iSocket);

 	readstream >> *smsmessage; //can leave

 	CleanupStack::Pop(smsmessage);

 	//get the class type here

	TSmsDataCodingScheme::TSmsClass classType(TSmsDataCodingScheme::ESmsClass2);

	const CSmsDeliver& deliver = static_cast<const CSmsDeliver&>(smsmessage->SmsPDU());

    TBool classDefined = deliver.Class(classType);

    //handling class 0 sms message 

 	if(iSmsClass0 != NULL && classType == TSmsDataCodingScheme::ESmsClass0)

 		{

 		//destroy the CSmsMessage, once passed succesfully to Class0SMS plugin

 		CleanupStack::PushL(smsmessage);

		//Externalize CSmsMessage into a TDesC8

		CSmsBufferBase& convSmsMsg = smsmessage->Buffer();

		TInt len = convSmsMsg.Length() ;

		//for sending Incomplete MessageInfo to UI.

		TInt startPos = 0;

		TInt endPos = 0;

		TBool isLastMessage = EFalse;

		HBufC *buffer = HBufC::NewLC(len);

		TPtr temp = buffer->Des();

		convSmsMsg.Extract(temp, 0, len);

		//allocate memory for CBufFlat, length sholud be: length of Class0SMS data + 2*(size of TInt)+(size of TBool)

		CBufFlat* flat = CBufFlat::NewL(len + (3 * sizeof(TInt)));

		CleanupStack::PushL(flat);

		flat->ExpandL(0, len);

		RBufWriteStream writeStream(*flat);

		CleanupClosePushL (writeStream);

		if (smsmessage->IsComplete())

			{

			//if it's complete class 0 SMS message

			//passing startPos, endPos and isLastMessage value to 0

			ExternalizeL(writeStream, startPos, endPos, isLastMessage, temp);

			TPtr8 smsMsg(flat->Ptr(0));

			iSmsClass0->DisplayMessageHandler(smsMsg, ETrue);

			}

		else

			{

			//handling incomplete SMS Message

			CIncompleteClass0MessageInfo  &incompleteMessageInfo = (CIncompleteClass0MessageInfo&)smsmessage->GetOperationsForNonIEL(ESmsIncompleteClass0MessageParameter);

			TInt msgRefNo = smsmessage->SmsPDU().ConcatenatedMessageReference();

			//get the information about the messsage & externalize it..	

			incompleteMessageInfo.GetIncompleteMessageInfoL(startPos, endPos, isLastMessage);

			ExternalizeL(writeStream, startPos, endPos, isLastMessage, temp);

			TPtr8 smsMsg(flat->Ptr(0));

			if (iMsgRefNumber == -1 || iMsgRefNumber == msgRefNo)

				{

				//if it's 1st part of the Message, assign msgRefNo to iMsgRefNumber  

				if (iMsgRefNumber == -1)

					{

					iMsgRefNumber = msgRefNo;

					}

				iSmsClass0->DisplayMessageHandler(smsMsg, EFalse);

				//if it's last part of the Message, assign iMsgRefNumber to -1  							

				if (isLastMessage)

					{

					iMsgRefNumber = -1;	

					}

				}

			}

			//delete smsmessage, as owned by header

			CleanupStack::PopAndDestroy(4, smsmessage);

 		} //handling class 0 sms message

 	// If the message is delivered to an unknown port (as opposed to no port at all)

 	// then we should only store the message if it is a "TextMessage".

 	// Otherwise the message should be silently consumed without being delivered.

 	// This is a requirement of the Java "Mobile Service Architecture", JSR 248, section 6.11.3.2 	

 	else if (	iAddrFamily == ESmsAddrRecvAny 			// << This watcher is listening on an unknown port

 			&& MessageHasPort(*smsmessage)			// << The message is addressed to a specific port

 			&& ! IsJavaTextMessage(*smsmessage) )	// << The message is defined by JSR 205 as NOT a TextMessage object

 		{

 		BIOWATCHERLOG(iWatcherLog.Printf(_L8("BioNbs: Non-text message delivered to unknown port - deleting message")));

 		}

 	else

 		{

 		StoreMsgL(smsmessage, ETrue); // Store the messaage and check for SID entry for ownership

 		}

 	}

void CNbsSmsSocketWatcher::ReceiveL()

	{

	BIOWATCHERLOG(iWatcherLog.Printf(_L("BioNbs: ReceiveL: %S"), &iBioMsgText));

	TInt error;

	switch (iStatus.Int())

		{

		case KErrNone:

			{

			TRAP(error, DoReceiveL());

			// Tell the socket if we handled the message or not

			if (error == KErrNone)

				{

				iIoCtlActive = ETrue;

				iSocket.Ioctl(KIoctlReadMessageSucceeded, iStatus, NULL, KSolSmsProv);

				}

			else

				{

				BIOWATCHERLOG(iWatcherLog.Printf(_L("BioNbs: Recv fail %d: %S"), error, &iBioMsgText));

 				iState = ESmsWRetryError;

				iIoCtlActive = ETrue;

				iSocket.Ioctl(KIoctlReadMessageFailed, iStatus, NULL, KSolSmsProv);

				}

			}

			break;

		case KIoctlSelectModemPresent:

			// Enumerate to see it there are any messages when the phone's hooked up

			// Only enumerate with default recievAny watcher

			// this pattern watcher should do nothing

			// SMS Prot should get the phone memory's SMS messages here

		case KIoctlSelectModemNotPresent:

			{

			// Phone's disconnected ... wait in Ioctl again

			// base class does this ... we're okay

			TRequestStatus* pS=&iStatus;

			User::RequestComplete(pS,0);

			}			

			break;

		default:

			User::Leave(iStatus.Int());

		}

	}

/**

Returns whether the message contains optional port addressing information.

@return ETrue if message contains port addressing information, otherwise EFalse.

*/

TBool CNbsSmsSocketWatcher::MessageHasPort(const CSmsMessage& aSmsMessage)

	{

	// Declare variables that will receive their values in ApplicationPortAddressing()

 	TInt destinationPort=0;

 	TInt originatorPort=0;

 	TBool is16bit=EFalse;

 	TBool hasPortAddressing = aSmsMessage.SmsPDU().ApplicationPortAddressing(destinationPort, originatorPort, &is16bit);

 	BIOWATCHERLOG(iWatcherLog.Printf(_L("BioNbs: MessageHasPort()"))); 	

 	BIOWATCHERLOG(iWatcherLog.Printf(_L("BioNbs:  > has:%d, dest:%d, orig:%d, 16bit:%d)"), hasPortAddressing, destinationPort, originatorPort, is16bit));

 	return hasPortAddressing;

	}

/**

Check whether Discard Unknown Port message flag is set, if not check for Java wireless messaging.

Returns whether the message is considered a TextMessage, according to Java wireless messaging

specifications - JSR 205 "Wireless Messaging API" Appendix A.5.0 - which associates the TextMessage

object with the 7-bit and 16-bit UCS-2 alphabets, and BinaryMessage with the 8-bit alphabet.

@param aSmsMessage the message whose alphabet we are testing.

@return ETrue if the alphabet is 7-bit or 16-bit UCS-2, otherwise EFalse.

*/

TBool CNbsSmsSocketWatcher::IsJavaTextMessage(const CSmsMessage& aSmsMessage)

	{

	TBool isTextMessage = EFalse;

	if(!iSettings->DiscardUnknownPortMessage())

		{

		TSmsDataCodingScheme::TSmsAlphabet alphabet = aSmsMessage.SmsPDU().Alphabet();

		if (alphabet == TSmsDataCodingScheme::ESmsAlphabet7Bit || alphabet == TSmsDataCodingScheme::ESmsAlphabetUCS2)

			{

			isTextMessage = ETrue;

			}

			BIOWATCHERLOG(iWatcherLog.Printf(_L("BioNbs: IsJavaTextMessage()")));

	 		BIOWATCHERLOG(iWatcherLog.Printf(_L("BioNbs:  > isTextMessage:%d, alphabet:%d)"), isTextMessage, alphabet));

		}

	return isTextMessage;

	}	

/*

 *	CSpecialNbsSmsSocketWatcher Implementation

 */

CSpecialNbsSmsSocketWatcher* CSpecialNbsSmsSocketWatcher::NewLC(

															TMsvId 			aBioServiceId, 

															TMsvId 			aSmsServiceId, 

															CBIODatabase&	aBioDb, 

															CWatcherLog&	aWatcherLog,

															TInt			aPriority,

															TUid			aBioID,

															RFs&			aFs,

															const TDesC&	aNbsPattern, 

															TSmsAddrFamily	aAddrFamily)

	{

	CSpecialNbsSmsSocketWatcher* self = new (ELeave) CSpecialNbsSmsSocketWatcher(aWatcherLog, aPriority, aBioID, aFs, aNbsPattern, aAddrFamily);

	CleanupStack::PushL(self);

	self->ConstructL(aBioServiceId, aSmsServiceId, aBioDb);

	return self;

	}

CSpecialNbsSmsSocketWatcher* CSpecialNbsSmsSocketWatcher::NewL(

															TMsvId 			aBioServiceId, 

															TMsvId 			aSmsServiceId, 

															CBIODatabase&	aBioDb, 

															CWatcherLog&	aWatcherLog, 

															TInt			aPriority, 

															TUid			aBioID, 

															RFs&			aFs,

															const TDesC&	aNbsPattern, 

															TSmsAddrFamily	aAddrFamily)

	{

	CSpecialNbsSmsSocketWatcher* self = NewLC(aBioServiceId, aSmsServiceId, aBioDb, aWatcherLog, aPriority, aBioID, aFs, aNbsPattern, aAddrFamily);

	CleanupStack::Pop(self);

	return self;

	}

CSpecialNbsSmsSocketWatcher::CSpecialNbsSmsSocketWatcher(CWatcherLog& aWatcherLog, TInt aPriority, TUid aBioID, RFs& aFs, const TBioMsgIdText& aNbsPattern, TSmsAddrFamily aAddrFamily)

: CNbsSmsSocketWatcher(aWatcherLog, aPriority, aBioID, aFs, aNbsPattern, aAddrFamily)

	{

	}

void CSpecialNbsSmsSocketWatcher::RestoreSettingsL(CMsvSession& aSession)

	{

	CBaseSmsActiveSocketWatcher::RestoreSettingsL(aSession);

	switch(iAddrFamily)

		{

	case ESmsAddrMessageIndication:

		iReportHandling = iSettings->SpecialMessageHandling();

		break;

	case ESmsAddrStatusReport:

		iReportHandling = iSettings->StatusReportHandling();

		break;

	default:

		PanicWatcher(EAddrFamilyNotSupported1);

		break;

		}

	}

void CSpecialNbsSmsSocketWatcher::RestoreSettingsL(TMsvId aBioServiceId, TMsvId aSmsServiceId)

	{

	CBaseSmsActiveSocketWatcher::RestoreSettingsL(aBioServiceId, aSmsServiceId);

	switch(iAddrFamily)

		{

	case ESmsAddrMessageIndication:

		iReportHandling = iSettings->SpecialMessageHandling();

		break;

	case ESmsAddrStatusReport:

		iReportHandling = iSettings->StatusReportHandling();

		break;

	default:

		PanicWatcher(EAddrFamilyNotSupported2);

		break;

		}

	}

void CSpecialNbsSmsSocketWatcher::ConstructL(TMsvId aBioServiceId, TMsvId aSmsServiceId, CBIODatabase& aBioDb)