diff -r 9f5ae1728557 -r db3f5fa34ec7 messagingfw/msgtestfw/TestActions/Drm/src/CMtfTestActionSmtpSendEmail.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/messagingfw/msgtestfw/TestActions/Drm/src/CMtfTestActionSmtpSendEmail.cpp Wed Nov 03 22:41:46 2010 +0530 @@ -0,0 +1,419 @@ +// Copyright (c) 2004-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: + +// __ACTION_INFO_BEGIN__ +// [Action Name] +// DrmSendEmail +// [Action Parameters] +// sender input HBufC8, user name of email sender +// recipient input HBufC8, user name of email recipient +// mailFile input HBufC, path and name of the meta data file to check +// serverIP input HBufC, IP address of SMTP server +// [Action Description] +// This test action will send an email from to with the contents +// of as message body using the SMTP server specified by . +// [APIs Used] +// RFile::Open +// RFile::Read +// CImTextServerSession::QueueConnectL +// CImTextServerSession::Send +// CImTextServerSession::QueueReceiveNextTextLine +// CImTextServerSession::GetCurrentTextLine +// CImTextServerSession::Disconnect +// CImIAPPreferences::NewLC +// __ACTION_INFO_END__ +// + +//! @file + +#include "CMtfTestActionSmtpSendEmail.h" + +#include "CMtfTestCase.h" +#include "CMtfTestActionParameters.h" +#include "CMtfTestActionUtilsConfigFileMachineName.h" + +#include + + +_LIT8(KHeloString, "HELO\r\n"); +_LIT8(KMailFrom, "MAIL FROM:"); +_LIT8(KRcptTo, "RCPT TO:"); +_LIT8(KDataString, "DATA\r\n"); +_LIT8(KEndData, "\r\n.\r\n"); +_LIT8(KQuitString, "QUIT\r\n"); +_LIT8(KCrlfString, "\r\n"); + +/** + Function : NewL + Description : + @internalTechnology + @param : aTestCase - CMtfTestCase for the CMtfTestAction base class + @param : aActionParams - CMtfTestActionParameters + @return : CMtfTestAction* - a base class pointer to the newly created CMtfTestActionSmtpSendEmail object + @pre none + @post none +*/ +CMtfTestAction* CMtfTestActionSmtpSendEmail::NewL(CMtfTestCase& aTestCase,CMtfTestActionParameters* aActionParameters) +{ + CMtfTestActionSmtpSendEmail* self = new (ELeave) CMtfTestActionSmtpSendEmail(aTestCase); + CleanupStack::PushL(self); + self->ConstructL(aActionParameters); + CleanupStack::Pop(self); + return self; +} + +/** + Function : CMtfTestActionSmtpSendEmail + Description : Constructor + @internalTechnology + @param : aTestCase - CMtfTestCase for the CMtfTestAction base class + @return : N/A + @pre none + @post none +*/ +CMtfTestActionSmtpSendEmail::CMtfTestActionSmtpSendEmail(CMtfTestCase& aTestCase) + : CMtfTestAction(aTestCase) +{ +} + +/** + Function : ~CMtfTestActionSmtpSendEmail + Description : Destructor + @internalTechnology + @param : + @return : + @pre + @post +*/ +CMtfTestActionSmtpSendEmail::~CMtfTestActionSmtpSendEmail() +{ + iFile.Close(); + iFs.Close(); + delete iImSocket; + delete iIapPrefs; +} + +/** + Function : ExecuteActionL + Description : Entry point for the this test action in the test framework + @internalTechnology + @param : none + @return : void + @pre none + @post none +*/ +void CMtfTestActionSmtpSendEmail::ExecuteActionL() +{ + TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionSmtpSendEmail); + CActiveScheduler::Add(this); + HBufC* serverIP = ObtainParameterReferenceL(TestCase(), ActionParameters().Parameter(3)); + + HBufC* emailAddressExt = ObtainParameterReferenceL(TestCase(), ActionParameters().Parameter(4), (*serverIP).Alloc()); + + CMtfTestActionUtilsConfigFileMachineName* machineNameFile = CMtfTestActionUtilsConfigFileMachineName::NewLC(*emailAddressExt); + + TPtrC machineNameEmail(machineNameFile->MachineNameEmail()); + iSender = ObtainParameterReferenceL(TestCase(), ActionParameters().Parameter(0), machineNameEmail.Alloc()); + iRecipient = ObtainParameterReferenceL(TestCase(), ActionParameters().Parameter(1), machineNameEmail.Alloc()); + + HBufC* mailFile = ObtainParameterReferenceL(TestCase(), ActionParameters().Parameter(2)); + + iFs.Connect(); + iFile.Open(iFs, *mailFile, EFileShareAny|EFileRead); + + iImSocket = CImTextServerSession::NewL(); + iIapPrefs = CImIAPPreferences::NewLC(); + CleanupStack::Pop(); + + iImSocket->QueueConnectL(iStatus, serverIP->Des(), 25, *iIapPrefs, ETrue); + + CleanupStack::PopAndDestroy(machineNameFile); + + iSendState = ESmtpConnecting; + SetActive(); + TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionSmtpSendEmail); +} + +/** + Function : DoCancel + Description : CActive derived function to handle Cancel requests + @internalTechnology + @param : none + @return : void + @pre none + @post none +*/ +void CMtfTestActionSmtpSendEmail::DoCancel() +{ + iImSocket->Cancel(); +} + +/** + Function : RunL + Description : CActive derived function to handle the state machine + @internalTechnology + @param : none + @return : void + @pre none + @post none +*/ +void CMtfTestActionSmtpSendEmail::RunL() +{ + // handle send state + switch (iSendState) + { + case ESmtpNotConnected: + { // ok, we're done. send completed. + TestCase().ActionCompletedL(*this); + break; + } + case ESmtpConnecting: + { // connection attempt completed. + if (iStatus != KErrNone) + { + // error + TestCase().ERR_PRINTF2(_L("CMtfTestActionSmtpSendEmail: failed to connect: [%d]."), iStatus.Int()); + TestCase().SetTestStepResult(EFail); + User::Leave(iStatus.Int()); + } + + // ok successful connect, next send HELO + iSendState = ESmtpSendHELO; + iImSocket->Send(iStatus, KHeloString()); + SetActive(); + break; + } + case ESmtpSendHELO: + { // HELO was sent + if (iStatus != KErrNone) + { + // error + TestCase().ERR_PRINTF2(_L("CMtfTestActionSmtpSendEmail: failed to send HELO: [%d]."), iStatus.Int()); + TestCase().SetTestStepResult(EFail); + User::Leave(iStatus.Int()); + } + + // ok we sent HELO, now receive reply + iSendState = ESmtpReceiveReply; + iRecvState = ESmtpHeloReply; + iImSocket->QueueReceiveNextTextLine(iStatus); + SetActive(); + break; + } + case ESmtpSendMailFrom: + { // MAIL FROM was sent. + if (iStatus != KErrNone) + { + // error + TestCase().ERR_PRINTF2(_L("CMtfTestActionSmtpSendEmail: failed to send MAIL FROM: [%d]."), iStatus.Int()); + TestCase().SetTestStepResult(EFail); + User::Leave(iStatus.Int()); + } + + // ok we sent MAIL FROM, now receive reply + iSendState = ESmtpReceiveReply; + iRecvState = ESmtpFromReply; + iImSocket->QueueReceiveNextTextLine(iStatus); + SetActive(); + break; + } + case ESmtpSendRcptTo: + { // RCPT TO was sent. + if (iStatus != KErrNone) + { + // error + TestCase().ERR_PRINTF2(_L("CMtfTestActionSmtpSendEmail: failed to send RCPT TO: [%d]."), iStatus.Int()); + TestCase().SetTestStepResult(EFail); + User::Leave(iStatus.Int()); + } + + // ok we sent RCPT TO, now receive reply + iSendState = ESmtpReceiveReply; + iRecvState = ESmtpRcptReply; + iImSocket->QueueReceiveNextTextLine(iStatus); + SetActive(); + break; + } + case ESmtpSendData: + { // DATA was sent. + if (iStatus != KErrNone) + { + // error + TestCase().ERR_PRINTF2(_L("CMtfTestActionSmtpSendEmail: failed to send DATA: [%d]."), iStatus.Int()); + TestCase().SetTestStepResult(EFail); + User::Leave(iStatus.Int()); + } + + // ok we sent DATA, now receive reply + iSendState = ESmtpReceiveReply; + iRecvState = ESmtpDataReply; + iImSocket->QueueReceiveNextTextLine(iStatus); + SetActive(); + break; + } + case ESmtpSendContent: + { //content was sent. + // read and send file. send file in chunks of 100 bytes. + TBuf8<100> buffer; + User::LeaveIfError(iFile.Read(buffer, 100)); + if (buffer.Length() == 0) + { + // ok, end of file. send end of email. + iSendState = ESmtpSendEndData; + iImSocket->Send(iStatus, KEndData()); + } + else + { + // we still have data in file. read and send. + iSendState = ESmtpSendContent; + iImSocket->Send(iStatus, buffer); + } + SetActive(); + break; + } + case ESmtpSendEndData: + { // end of data was sent. + if (iStatus != KErrNone) + { + // error + TestCase().ERR_PRINTF2(_L("CMtfTestActionSmtpSendEmail: failed to send end-of-data marker: [%d]."), iStatus.Int()); + TestCase().SetTestStepResult(EFail); + User::Leave(iStatus.Int()); + } + + // ok we sent end-of-data, now receive reply + iSendState = ESmtpReceiveReply; + iRecvState = ESmtpContentReply; + iImSocket->QueueReceiveNextTextLine(iStatus); + SetActive(); + break; + } + case ESmtpSendLogout: + { + iSendState = ESmtpReceiveReply; + iRecvState = ESmtpLogoutReply; + iImSocket->QueueReceiveNextTextLine(iStatus); + SetActive(); + break; + } + case ESmtpReceiveReply: + { + if (iStatus != KErrNone) + { + // error + TestCase().ERR_PRINTF3(_L("CMtfTestActionSmtpSendEmail: failed to receive reply: error [%d] recvstate [%d]."), iStatus.Int(), iRecvState); + TestCase().SetTestStepResult(EFail); + User::Leave(iStatus.Int()); + } + + // ok, read and print out the reply + TBuf8<50> buffer; + TBuf<50> buffer16; + TImLineType replyLine = iImSocket->GetCurrentTextLine(buffer); + buffer16.Copy(buffer); + TestCase().INFO_PRINTF1(buffer16); + + if (replyLine == EBufferTooSmall) + { + while (replyLine != ECRLFTerminated) + { + replyLine = iImSocket->GetCurrentTextLine(buffer); + buffer16.Copy(buffer); + TestCase().INFO_PRINTF1(buffer16); + } + } + + // handle reply state + switch (iRecvState) + { + case ESmtpHeloReply: + { + // send MAIL FROM + iSendState = ESmtpSendMailFrom; + TBuf8<100> from; + from.Append(KMailFrom); + from.Append(*iSender); + from.Append(KCrlfString); + iImSocket->Send(iStatus, from); + break; + } + case ESmtpFromReply: + { + // send RCPT TO + iSendState = ESmtpSendRcptTo; + TBuf8<100> to; + to.Append(KRcptTo); + to.Append(*iRecipient); + to.Append(KCrlfString); + iImSocket->Send(iStatus, to); + break; + } + case ESmtpRcptReply: + { + // send DATA + iSendState = ESmtpSendData; + iImSocket->Send(iStatus, KDataString()); + break; + } + case ESmtpDataReply: + { + // send content + iSendState = ESmtpSendContent; + TBuf8<100> buffer; + User::LeaveIfError(iFile.Read(buffer, 100)); + if (buffer.Length() == 0) + { + // ok, end of file. since this is first read it would mean the file + // is empty! we should maybe leave here or?? + iSendState = ESmtpSendEndData; + iImSocket->Send(iStatus, KEndData()); + } + else + { + // we still have data in file + iSendState = ESmtpSendContent; + iImSocket->Send(iStatus, buffer); + } + break; + } + case ESmtpContentReply: + { + // send QUIT + iSendState = ESmtpSendLogout; + iImSocket->Send(iStatus, KQuitString()); + break; + } + case ESmtpLogoutReply: + { + iSendState = ESmtpNotConnected; + iImSocket->Disconnect(iStatus); + break; + } + default: + { + User::Panic(_L("Unkown receive state!"), iRecvState); + break; + } + } // End switch (iRecvState) + + SetActive(); + break; + } + default: + { + User::Panic(_L("Unkown send state!"), iSendState); + break; + } + } // End switch (iSendState) +}