--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/smsprotocols/smsstack/smsprot/Test/TE_SMSINTER/actrecv.cpp Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,826 @@
+// 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:
+//
+
+#include <gsmubuf.h>
+#include <gsmuset.h>
+#include <smsustrm.h>
+
+#include "TE_smsinterbase.h"
+
+const TInt KActiveReceiverSocketGranularity = 8;
+const TInt KActiveSocketPriority = CActive::EPriorityIdle;
+
+class CStopIfKeyPressed;
+
+class MStopTest
+ {
+public:
+ virtual void StopTests() = 0;
+ };
+
+//
+//
+// CActiveSocket
+//
+//
+
+class CActiveSocket : public CActive
+ {
+public:
+ enum { EPriority = KActiveSocketPriority };
+public:
+ static CActiveSocket* NewL(const TTestCase& aTest, RSocketServ& aSocketServer, RFs& aFs);
+ ~CActiveSocket();
+ void ReceiveMessage(TRequestStatus* aStatus);
+ void SetIndex(TInt aIndex);
+ void TestResultL();
+ TBool TestComplete();
+ TPtrC Message();
+private:
+ virtual void DoCancel();
+ virtual void RunL();
+ CActiveSocket(RSocketServ& aSocketServer);
+private:
+ void InitRSocketL();
+private:
+ TRequestStatus* iActiveReceiverStatus;
+ RSocket iSocket;
+ TTestCase iTestCase;
+ CSmsMessage* iSmsMessage;
+ TInt iActiveReceiverIndex;
+ TPckgBuf<TUint> iSelectBuf;
+ RSocketServ& iSocketServer;
+ };
+
+//
+//
+// CActiveSenderImp
+//
+//
+
+class CActiveSenderImp : public CActiveSender, MStopTest
+ {
+public:
+ static CActiveSenderImp* NewL(RSocketServ& aSocketServer,
+ RFs& aFs,
+ const TDesC& aTelephoneNumber,
+ const TDesC& aServiceCenterNumber);
+ virtual void StartSendingL();
+ virtual void StopIfKeyPressedL();
+ ~CActiveSenderImp();
+public:
+ void StopTests();
+private:
+ void InitRSocketL();
+ void SendSmsMessageL();
+private:
+ virtual void DoCancel();
+ virtual void RunL();
+private:
+ CActiveSenderImp(RSocketServ& aSocketServer, RFs& aFs);
+ CStopIfKeyPressed* iStopTest;
+ RSocket iSocket;
+ CSmsMessage* iSmsMessage;
+ TPckgBuf<TUint> iIntBuf;
+ TInt iCount;
+ };
+
+//
+//
+// CActiveReceiverImp
+//
+//
+
+class CActiveReceiverImp : public CActiveReceiver, MStopTest
+ {
+public:
+ static CActiveReceiverImp* NewL(RSocketServ& aSocketServer, RFs& aFs);
+ virtual void AddTestL(const TTestCase& aTest);
+ virtual void StartTestsL();
+ virtual void StopIfKeyPressedL();
+ ~CActiveReceiverImp();
+public:
+ void StopTests();
+private:
+ virtual void DoCancel();
+ virtual void RunL();
+private:
+ CActiveReceiverImp(RSocketServ& aSocketServer, RFs& aFs);
+ CArrayPtr<CActiveSocket>* iSockArray;
+ TInt iResultCount;
+ CStopIfKeyPressed* iStopTest;
+ };
+
+//
+//
+// CStopIfKeyPressed
+//
+//
+
+class CStopIfKeyPressed : public CActive
+ {
+public:
+ enum { EPriority = KStopIfKeyPressedPriority };
+public:
+ static CStopIfKeyPressed* NewL(MStopTest* aReceiver);
+ virtual void RunL();
+ virtual void DoCancel();
+public:
+ void StopIfKeyPressed();
+private:
+ CStopIfKeyPressed();
+ MStopTest* iReceiver;
+ };
+
+CStopIfKeyPressed* CStopIfKeyPressed::NewL(MStopTest* aReceiver)
+//
+// Factory
+//
+ {
+
+ CStopIfKeyPressed* stopTest = new(ELeave) CStopIfKeyPressed;
+ stopTest->iReceiver = aReceiver;
+ CActiveScheduler::Add(stopTest);
+ return stopTest;
+ }
+
+void CStopIfKeyPressed::StopIfKeyPressed()
+//
+// Activate
+//
+ {
+
+ if (IsActive())
+ return;
+// CConsoleBase* console = gTest.Console();
+// console->Read(iStatus);
+// SetActive();
+ }
+
+CStopIfKeyPressed::CStopIfKeyPressed()
+//
+// Constructor
+//
+: CActive(EPriority)
+ {}
+
+void CStopIfKeyPressed::RunL()
+//
+// Called if a key has been pressed
+//
+ {
+
+ iReceiver->StopTests();
+ CActiveScheduler::Stop();
+ }
+
+void CStopIfKeyPressed::DoCancel()
+//
+// Cancel has been called
+//
+ {
+
+// CConsoleBase* console = gTest.Console();
+// console->ReadCancel();
+ }
+
+//
+//
+// CActiveSocket
+//
+//
+
+CActiveSocket* CActiveSocket::NewL(const TTestCase& aTest, RSocketServ& aSocketServer, RFs& aFs)
+//
+// Factory
+//
+ {
+
+ CActiveSocket* socket = new(ELeave) CActiveSocket(aSocketServer);
+ CleanupStack::PushL(socket);
+ socket->iTestCase=aTest;
+ socket->InitRSocketL();
+
+ CSmsBuffer* buffer=NULL;
+ buffer=CSmsBuffer::NewL();
+ socket->iSmsMessage=CSmsMessage::NewL(aFs, CSmsPDU::ESmsSubmit,buffer);
+ CleanupStack::Pop();
+
+ CActiveScheduler::Add(socket);
+ return socket;
+ }
+
+CActiveSocket::CActiveSocket(RSocketServ& aSocketServer)
+//
+// Constructor
+//
+: CActive(EPriority),
+ iSocketServer(aSocketServer)
+ {}
+
+CActiveSocket::~CActiveSocket()
+//
+// Destructor
+//
+ {
+
+ delete iSmsMessage;
+ iSocket.Close();
+ }
+
+void CActiveSocket::TestResultL()
+//
+// Test the sms message contains the expected data
+//
+ {
+
+ CSmsBufferBase& smsBuffer=iSmsMessage->Buffer();
+ TInt bufLen=smsBuffer.Length();
+ HBufC* textBuf=HBufC::NewL(bufLen);
+ TPtr textPtr(textBuf->Des());
+ smsBuffer.Extract(textPtr,0,bufLen);
+
+// if (iTestCase.iTestForever)
+// gTest.Printf(_L("RECEIVED: Msg %S\n"),&textPtr);
+// else if (iTestCase.iMatchType==ESmsAddrStatusReport)
+// gTest.Printf(_L("SUCCESS: Status report received for %S\n"),&iTestCase.iMsg);
+// else
+// {
+// TBool ret = (textPtr==iTestCase.iMsg);
+// if (ret>0)
+// gTest.Printf(_L("SUCCESS: Msg %S received\n"),&iTestCase.iMsg);
+// else
+// gTest.Printf(_L("SUCCESS: Msg %S not received\n"),&iTestCase.iMsg);
+// }
+
+ delete textBuf;
+ }
+
+
+void CActiveSocket::SetIndex(TInt aIndex)
+//
+// Set the index ofthe socket within the receiver's iSockArray
+//
+ {
+
+ iActiveReceiverIndex = aIndex;
+ }
+
+TPtrC CActiveSocket::Message()
+//
+// Return the testcase message
+//
+ {
+
+ return iTestCase.iMsg;
+ }
+
+void CActiveSocket::InitRSocketL()
+//
+// Initialise the active socket's connection with the socket server
+//
+ {
+
+ TInt ret=iSocket.Open(iSocketServer,KSMSAddrFamily,KSockDatagram,KSMSDatagramProtocol);
+ User::LeaveIfError(ret);
+ TSmsAddr smsAddr;
+ smsAddr.SetSmsAddrFamily(iTestCase.iMatchType);
+
+ switch(iTestCase.iMatchType)
+ {
+ case ESmsAddrMatchText:
+ {
+ TBuf8<128> match;
+ match.Copy(iTestCase.iMatch);
+ smsAddr.SetTextMatch(match);
+ break;
+ }
+ case ESmsAddrMatchIEI:
+ smsAddr.SetIdentifierMatch(iTestCase.iIdentifierMatch);
+ break;
+ case ESmsAddrMessageIndication:
+ break;
+ default:
+ break;
+ };
+
+ ret=iSocket.Bind(smsAddr);
+ User::LeaveIfError(ret);
+ }
+
+void CActiveSocket::ReceiveMessage(TRequestStatus* aStatus)
+//
+// Receive a message
+//
+ {
+
+ iActiveReceiverStatus = aStatus;
+ iSelectBuf()=KSockSelectRead;
+ iSocket.Ioctl(KIOctlSelect,iStatus,&iSelectBuf,KSOLSocket);
+ SetActive();
+ }
+
+void CActiveSocket::DoCancel()
+//
+// Cancel the select
+//
+ {
+
+ iSocket.CancelAll();
+ }
+
+void CActiveSocket::RunL()
+//
+// Got something to read
+//
+ {
+
+ if (iStatus<0)
+ {
+ User::RequestComplete(iActiveReceiverStatus,iStatus.Int());
+ return;
+ }
+
+ RSmsSocketReadStream readstream(iSocket);
+ TRAPD(ret,readstream >> *iSmsMessage);
+ User::LeaveIfError(ret);
+
+ TPckgBuf<TUint> sbuf;
+ TRequestStatus status;
+ iSocket.Ioctl(KIoctlReadMessageSucceeded,status,&sbuf, KSolSmsProv);
+ User::WaitForRequest(status);
+
+ User::RequestComplete(iActiveReceiverStatus,iActiveReceiverIndex);
+ }
+
+TBool CActiveSocket::TestComplete()
+//
+// Socket has finished performing all tests
+//
+ {
+
+ if (iTestCase.iTestForever)
+ return EFalse;
+ return ETrue;
+ }
+
+//
+//
+// CActiveReceiverImp
+//
+//
+
+CActiveReceiverImp* CActiveReceiverImp::NewL(RSocketServ& aSocketServer, RFs& aFs)
+//
+// Factory
+//
+ {
+
+ CActiveReceiverImp* actRecv = new(ELeave) CActiveReceiverImp(aSocketServer, aFs);
+ CleanupStack::PushL(actRecv);
+ actRecv->iSockArray=new(ELeave) CArrayPtrSeg<CActiveSocket>(KActiveReceiverSocketGranularity);
+ actRecv->iStatus=KRequestPending;
+ CleanupStack::Pop();
+ CActiveScheduler::Add(actRecv);
+ return actRecv;
+ }
+
+CActiveReceiverImp::CActiveReceiverImp(RSocketServ& aSocketServer, RFs& aFs)
+//
+// Constructor
+//
+:CActiveReceiver(aSocketServer, aFs)
+ {}
+
+CActiveReceiverImp::~CActiveReceiverImp()
+//
+// Destructor
+//
+ {
+
+ if (iSockArray)
+ {
+ StopTests();
+ iSockArray->ResetAndDestroy();
+ }
+ delete iStopTest;
+ delete iSockArray;
+ }
+
+void CActiveReceiverImp::AddTestL(const TTestCase& aTest)
+//
+// Add a test case to the receiver
+//
+ {
+
+ CActiveSocket* socket = CActiveSocket::NewL(aTest, iSocketServer, iFs);
+ CleanupStack::PushL(socket);
+ iSockArray->AppendL(socket);
+ socket->SetIndex(iSockArray->Count()-1);
+ socket->ReceiveMessage(&iStatus);
+ CleanupStack::Pop();
+
+ if (aTest.iMatchType==ESmsAddrStatusReport)
+ {
+ // Add a test to match the original message as well as the status report
+ TTestCase srrIdMatch(aTest.iMsg,aTest.iMsg.Left(TSmsAddr::EMaxTextMatchLength));
+ AddTestL(srrIdMatch);
+ }
+ }
+
+void CActiveReceiverImp::StartTestsL()
+//
+// Kick off the tests
+//
+ {
+
+ SetActive();
+ CActiveScheduler::Start();
+ }
+
+void CActiveReceiverImp::StopTests()
+//
+// Cancel all active sockets
+//
+ {
+
+ for (TInt i=0;i<iSockArray->Count();i++)
+ (*iSockArray)[i]->Cancel();
+ if (iStopTest)
+ iStopTest->Cancel();
+ Cancel();
+ }
+
+void CActiveReceiverImp::StopIfKeyPressedL()
+//
+// Stop the active scheduler if a key is pressed
+//
+ {
+
+ if (!iStopTest)
+ iStopTest=CStopIfKeyPressed::NewL(this);
+ iStopTest->StopIfKeyPressed();
+ }
+
+void CActiveReceiverImp::DoCancel()
+ {
+
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete(status,KErrCancel);
+ }
+
+void CActiveReceiverImp::RunL()
+//
+// An active socket has received a message
+//
+ {
+
+ TInt index = iStatus.Int();
+ CActiveSocket* socket = (*iSockArray)[index];
+ socket->TestResultL();
+
+ if (socket->TestComplete())
+ iResultCount++;
+ else
+ socket->ReceiveMessage(&iStatus);
+
+ if (iResultCount == iSockArray->Count())
+ {
+ StopTests();
+ CActiveScheduler::Stop();
+ return;
+ }
+
+ SetActive();
+ iStatus=KRequestPending;
+ }
+
+//
+//
+// TTestCase
+//
+//
+
+TTestCase::TTestCase()
+//
+// Constructor
+//
+ {
+
+ CommonInit();
+ }
+
+TTestCase::TTestCase(const TDesC& aMsg, const TDesC& aMatch)
+//
+// Constructor
+//
+: iMatchType(ESmsAddrMatchText), iMsg(aMsg), iMatch(aMatch)
+ {
+
+ CommonInit();
+ }
+
+void TTestCase::CommonInit()
+//
+// Reset member variables
+//
+ {
+
+ iTestSmsClass = EFalse;
+ iTestValidityPeriod = EFalse;
+ iTestForever=EFalse;
+ iTestIndicators=EFalse;
+ }
+
+TTestCase::TTestCase(const TDesC& aMsg, CSmsInformationElement::TSmsInformationElementIdentifier aIdentifier)
+//
+// Constructor
+//
+: iMatchType(ESmsAddrMatchIEI), iMsg(aMsg), iIdentifierMatch(aIdentifier)
+ {
+
+ CommonInit();
+ }
+
+TTestCase::TTestCase(const TDesC& aMsg, TSmsFirstOctet::TSmsStatusReportRequest /*aSRR*/)
+//
+// Match on status report - ignore actual value of aSRR
+//
+: iMatchType(ESmsAddrStatusReport), iMsg(aMsg)
+ {
+
+ CommonInit();
+ }
+
+TTestCase::TTestCase(const TDesC& aMsg, TSmsDataCodingScheme::TSmsIndicationType aIndicationType,
+ TSmsDataCodingScheme::TSmsDCSBits7To4 aBits7To4,
+ TSmsDataCodingScheme::TSmsIndicationState aIndicationState)
+//
+// Match on a type of message indication
+//
+: iMatchType(ESmsAddrMessageIndication), iMsg(aMsg), iIndicationType(aIndicationType),
+ iBits7To4(aBits7To4), iIndicationState(aIndicationState)
+ {
+
+ __ASSERT_ALWAYS(iBits7To4==TSmsDataCodingScheme::ESmsDCSMessageWaitingIndicationDiscardMessage
+ || iBits7To4==TSmsDataCodingScheme::ESmsDCSMessageWaitingIndication7Bit
+ || iBits7To4==TSmsDataCodingScheme::ESmsDCSMessageWaitingIndicationUCS2,
+ User::Panic(_L("TestCase"), KErrNotSupported));
+
+ CommonInit();
+ iTestIndicators=ETrue;
+
+ }
+
+TTestCase::TTestCase(const TDesC& aMsg)
+//
+// Constructor
+//
+: iMatchType(ESmsAddrRecvAny), iMsg(aMsg)
+ {
+
+ CommonInit();
+ }
+
+const TTestCase& TTestCase::operator=(const TTestCase& aTest)
+//
+// Assignment operator
+//
+ {
+
+ iMatchType = aTest.iMatchType;
+ iMsg.Set(aTest.iMsg);
+ iMatch.Set(aTest.iMatch);
+ iIdentifierMatch = aTest.iIdentifierMatch;
+ iTestForever = aTest.iTestForever;
+ return *this;
+ }
+
+void TTestCase::SetSmsClass(TSmsDataCodingScheme::TSmsClass aClass)
+//
+// Set Sms Class
+//
+ {
+
+ iTestSmsClass = ETrue;
+ iSmsClass = aClass;
+ }
+
+void TTestCase::SetValidityPeriod(const TTimeIntervalMinutes& aTimeInterval)
+//
+// Set the validity period
+//
+ {
+
+ iTestValidityPeriod = ETrue;
+ iValidityPeriod = aTimeInterval;
+ }
+
+void TTestCase::SetRecvForever()
+//
+// Recv all messages forever
+//
+ {
+
+ iTestForever = ETrue;
+ iMatchType = ESmsAddrRecvAny;
+ }
+
+
+//
+//
+// CActiveReceiver
+//
+//
+
+CActiveReceiver* CActiveReceiver::NewL(RSocketServ& aSocketServer, RFs& aFs)
+ { return CActiveReceiverImp::NewL(aSocketServer, aFs); }
+CActiveReceiver::CActiveReceiver(RSocketServ& aSocketServer, RFs& aFs)
+: CActive(EPriority),
+ iSocketServer(aSocketServer),
+ iFs(aFs)
+ {}
+void CActiveReceiver::AddTestL(const TTestCase& /*aTest*/)
+ {}
+void CActiveReceiver::StartTestsL()
+ {}
+void CActiveReceiver::StopIfKeyPressedL()
+ {}
+
+//
+//
+// CActiveSender
+//
+//
+
+CActiveSender* CActiveSender::NewL(RSocketServ& aSocketServer,
+ RFs& aFs,
+ const TDesC& aTelephoneNumber,
+ const TDesC& aServiceCenterNumber)
+ { return CActiveSenderImp::NewL(aSocketServer, aFs, aTelephoneNumber, aServiceCenterNumber); }
+CActiveSender::CActiveSender(RSocketServ& aSocketServer, RFs& aFs)
+: CActive(EPriority),
+ iSocketServer(aSocketServer),
+ iFs(aFs)
+ {}
+void CActiveSender::StartSendingL()
+ {}
+void CActiveSender::StopIfKeyPressedL()
+ {}
+
+
+//
+//
+// CActiveSenderImp
+//
+//
+
+CActiveSenderImp* CActiveSenderImp::NewL(RSocketServ& aSocketServer,
+ RFs& aFs,
+ const TDesC& aTelephoneNumber,
+ const TDesC& aServiceCenterNumber)
+//
+// Factory
+//
+ {
+
+ CActiveSenderImp* actSend = new(ELeave) CActiveSenderImp(aSocketServer, aFs);
+ CleanupStack::PushL(actSend);
+ actSend->iStatus=KRequestPending;
+ actSend->InitRSocketL();
+
+ CSmsBuffer* buffer=NULL;
+ buffer=CSmsBuffer::NewL();
+ actSend->iSmsMessage=CSmsMessage::NewL(aFs, CSmsPDU::ESmsSubmit,buffer);
+
+ TSmsUserDataSettings smsSettings;
+ smsSettings.SetAlphabet(TSmsDataCodingScheme::ESmsAlphabet7Bit);
+ smsSettings.SetTextCompressed(EFalse);
+ actSend->iSmsMessage->SetUserDataSettingsL(smsSettings);
+
+ actSend->iSmsMessage->SetToFromAddressL(aTelephoneNumber);
+ actSend->iSmsMessage->SmsPDU().SetServiceCenterAddressL(aServiceCenterNumber);
+ buffer->InsertL(0,_L("Test Message"));
+
+ CleanupStack::Pop(); // actSend
+ CActiveScheduler::Add(actSend);
+ return actSend;
+ }
+
+CActiveSenderImp::CActiveSenderImp(RSocketServ& aSocketServer, RFs& aFs)
+//
+// Constructor
+//
+:CActiveSender(aSocketServer, aFs)
+ {}
+
+CActiveSenderImp::~CActiveSenderImp()
+//
+// Destructor
+//
+ {
+
+ Cancel();
+ delete iStopTest;
+ delete iSmsMessage;
+ iSocket.Close();
+ }
+
+void CActiveSenderImp::StartSendingL()
+//
+// Kick off the tests
+//
+ {
+
+ SendSmsMessageL();
+ CActiveScheduler::Start();
+ }
+
+void CActiveSenderImp::StopTests()
+//
+// Prepare for active scheduler stop
+//
+ {
+
+ Cancel();
+ }
+
+void CActiveSenderImp::StopIfKeyPressedL()
+//
+// Stop the active scheduler if a key is pressed
+//
+ {
+
+ if (!iStopTest)
+ iStopTest=CStopIfKeyPressed::NewL(this);
+ iStopTest->StopIfKeyPressed();
+ }
+
+void CActiveSenderImp::DoCancel()
+//
+// Cancel the current send
+//
+ {
+
+ iSocket.CancelSend();
+ }
+
+void CActiveSenderImp::SendSmsMessageL()
+//
+// Send an SMS message and wait for complete
+//
+ {
+
+ RSmsSocketWriteStream writestream(iSocket);
+ iSmsMessage->SmsPDU().SetClass(ETrue, TSmsDataCodingScheme::ESmsClass2);
+ TRAPD(ret,writestream << *iSmsMessage);
+ User::LeaveIfError(ret);
+ TRAP(ret,writestream.CommitL());
+ User::LeaveIfError(ret);
+
+ iSocket.Ioctl(KIoctlSendSmsMessage,iStatus,&iIntBuf, KSolSmsProv);
+ SetActive();
+ }
+
+void CActiveSenderImp::RunL()
+//
+// An active socket has received a message
+//
+ {
+
+ if (iStatus.Int()!=KErrNone)
+ {
+ //gTest.Printf(_L("Error: Send completed with %d\n"),iStatus.Int());
+ iStopTest->DoCancel();
+ return;
+ }
+ iCount++;
+ //gTest.Printf(_L("Sent %d messages\n"),iCount);
+ SendSmsMessageL();
+ }
+
+void CActiveSenderImp::InitRSocketL()
+//
+// Initialise the sender's socket
+//
+ {
+
+ TInt ret=iSocket.Open(iSocketServer,KSMSAddrFamily,KSockDatagram,KSMSDatagramProtocol);
+ User::LeaveIfError(ret);
+ TSmsAddr smsAddr;
+ smsAddr.SetSmsAddrFamily(ESmsAddrSendOnly);
+ ret=iSocket.Bind(smsAddr);
+ User::LeaveIfError(ret);
+ }