// Copyright (c) 2001-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:

//

#ifdef _DEBUG

#undef _MSG_NO_LOGGING

#endif

#include <csch_cli.h>

#include <msvapi.h>

#include <msvschedulepackage.h>

#include "SchSendExe.h"

#include <msvschedulesend.h>

#include <msvschedulesettings.h>

#include <msvids.h>

#include <msvuids.h>

#include <tmsvschedulesettingsutils.h>

#include <centralrepository.h>

#ifndef _MSG_NO_LOGGING

	#include <flogger.h>

	_LIT(KSchSendExeLogFile, "SchSendExe.txt");

	const TFileLoggingMode KSchSendExeLoggingMode = EFileLoggingModeAppend;

#endif

_LIT_SECURE_ID(KSchSendExeSid, 0x100056A1);

_LIT_SECURE_ID(KTaskSchedulerSid, 0x10005399);

_LIT(KSchSendThreadName, "SchSend");

#include <u32std.h>

#include <miutset.h>

GLDEF_C TInt E32Main()

	{

	if(User::CreatorSecureId() != KTaskSchedulerSid)

		{

		// Not launched by Task Scheduler - exit

		return KErrPermissionDenied;

		}

	TBuf<0x100> fileName;

	RFile taskFile;

 	// Adopt the task file using the RFs handle into environment  slot 

 	// 1 and the RFile handle into slot 2

 	TInt err = taskFile.AdoptFromCreator(1,2);

 	if(KErrNone !=err)

 		{

 		return err;

 		}

 	taskFile.Name(fileName);

 	return Execute(fileName, taskFile);

	}

TInt Execute(const TDesC& aFileName, RFile& aFile )

	{

	__UHEAP_MARK;

	CTrapCleanup* cleanup = CTrapCleanup::New();

	SCHSENDLOG(CMsvSendExe::FLog(aFileName, _L("Processing file %S"), &aFileName));

	TRAPD(leaveValue, DoExecuteL(aFileName, aFile ));

	if (leaveValue != KErrNone)

		{

		// DoExecuteL will only leave in the unlikely event that available memory is too low

		// to create an instance of the active scheduler or the CMsvSendExe object or in the

		// event that we cannot rename the thread. Once the CMsvSendObject has been created

		// leaves are handled cleanly by the object. We could retry the call to DoExecuteL,

		// but it's unlikely to succeed a second time around.

		}

	SCHSENDLOG(CMsvSendExe::FLog(aFileName, _L("DoExecuteL completed with error %d"), leaveValue));

	delete cleanup;

	__UHEAP_MARKEND;

	return leaveValue;

	}

void DoExecuteL(const TDesC& aFileName, RFile& aFile )

	{

	CleanupClosePushL(aFile);

	User::LeaveIfError(User::RenameThread(KSchSendThreadName));

	CActiveScheduler* activeSch = new (ELeave) CActiveScheduler();

	CleanupStack::PushL(activeSch);

	CActiveScheduler::Install(activeSch);

	CMsvSendExe::StartLC(aFileName, aFile );

	CleanupStack::PopAndDestroy(3, &aFile);

	}

//

// CMsvSendExe Implementation

//

/**

The CMsvSendExe Constructor

@return			

@internalAll

@param				 aFile

*/

CMsvSendExe::CMsvSendExe(const TDesC& aFileName, RFile& aFile )

	: CActive(KDefaultPriority), iFileName(aFileName), iTaskFile(aFile )

	{

	//Add this to the Active Scheduler.

	//This is a requirement if a class is derived from CActive

	CActiveScheduler::Add(this);

	iCreated.UniversalTime();

	}

CMsvSendExe::~CMsvSendExe()

/*

	CMsvSendExe Destructor

*/

	{

	Cancel();

	delete iSession;

	iOperations.ResetAndDestroy();

	iPackages.Reset();

	}

/**

The CMsvSendExe::StartLC method

1. Constructs CMsvSendExe

2. Processes the task scheduler file

3. Attempts to send the messages

@return			

@internalAll

@param				 aFile File containing the task information

*/

CMsvSendExe* CMsvSendExe::StartLC(const TDesC& aFileName, RFile& aFile )

	{

	CMsvSendExe* self = new (ELeave) CMsvSendExe(aFileName,aFile );

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void CMsvSendExe::ConstructL()

	{

	TRAPD(err, ProcessFileL());

	if(err == KErrPermissionDenied)

		{

		//security violation

		User::Leave(err);

		}

	if (err != KErrNone)

		RescheduleAllL(err);

	}

void CMsvSendExe::ProcessFileL()

/*

	ProcessFileL

*/

	{

	RetrievePackagesL();

	RetrieveMessagesL();

	if (iOperations.Count())

		{

		CallMtmL();

		iActiveSchedulerWait.Start();

		}

	else

		{

		SCHSENDLOG(FLog(iFileName, _L("\tNO msg to send!")));

		}

	}

void CMsvSendExe::RetrievePackagesL()

	{

	//open the filestore 	

	CFileStore* store = CDirectFileStore::FromLC(iTaskFile);//pushes store

	RStoreReadStream instream;

	instream.OpenLC(*store,store->Root());//pushes instream

	//get task count

	TInt taskCount = instream.ReadInt32L();

	SCHSENDLOG(FLog(iFileName, _L("\tTask Count=%d"), taskCount));

	for (TInt curTask = 0; curTask < taskCount; curTask++)

		{

		CScheduledTask* task = CScheduledTask::NewLC(instream);

		AddPackageL(*task);

		CleanupStack::PopAndDestroy(task);

		}

	CleanupStack::PopAndDestroy(2, store);

	}

#ifndef _MSG_NO_LOGGING

void CMsvSendExe::FLog(const TDesC& aFileName, TRefByValue<const TDesC16> aFmt, ...)

	{

	VA_LIST list;

	VA_START(list, aFmt);

	TParse parse;

	parse.Set(aFileName, NULL, NULL);

	TBuf<256> buf;

	buf.Append(parse.Name());

	buf.Append(_L(": "));

	buf.AppendFormatList(aFmt, list);

	RFileLogger::Write(KSchSendLogDir, KSchSendExeLogFile, KSchSendExeLoggingMode,

				buf);

	}

#endif

/**

The CMsvSendExe::CallMtmL method

Attempts to send the messages in the operation selection

@internalAll

*/

void CMsvSendExe::CallMtmL()

	{

	__ASSERT_DEBUG(iOperations.Count(), gPanic(ENoMessagesInSelection));

	TInt count = iOperations.Count();

	while (count--)

		{

		CMsvSendExeActive& active = *iOperations[count];

		SCHSENDLOG(FLog(iFileName, _L("\tStarting operation for %d msgs (Mtm=%d CommandId=%d)"), active.MsgCount(), active.Mtm().iUid, active.Package().iCommandId));

		active.StartL();

		SCHSENDLOG(FLog(iFileName, _L("\tStarted (Mtm=%d CommandId=%d)"), active.Mtm().iUid, active.Package().iCommandId));

		}

	iStatus = KRequestPending;

	SetActive();

	}

/**

The CMsvSendExe::DoCancel method

Cancels all outstanding operations and stops the active scheduler.

@return			

@internalAll

*/

void CMsvSendExe::DoCancel()

	{

	SCHSENDLOG(FLog(iFileName, _L("\tOperations cancelled"), iStatus.Int()));

	TInt count = iOperations.Count();

	while (count--)

		iOperations[count]->Cancel();

	iActiveSchedulerWait.AsyncStop();

	}

/**

The CMsvSendExe::RunL method

Called when all operations in iOperations have completed.

Stops the active scheduler.

@return			

@internalAll

*/

void CMsvSendExe::RunL()

	{

	SCHSENDLOG(FLog(iFileName, _L("All operations completed")));

	iActiveSchedulerWait.AsyncStop();

	}

void CMsvSendExe::AddPackageL(const CScheduledTask& aTask)

	{

	TMsvSchedulePackage pkg;

	TSecurityInfo securityInfo = aTask.SecurityInfo();

	if( (securityInfo.iSecureId.iId != KSchSendExeSid) && (securityInfo.iSecureId.iId != KMsvServerId) )

		{

		if( PlatSec::ConfigSetting(PlatSec::EPlatSecDiagnotics) )

			{

             _LIT(KMessage,"CMsvSendExe::AddPackageL ERROR %d");

             RDebug::Print(KMessage,  KErrPermissionDenied);

			}

		if( PlatSec::ConfigSetting(PlatSec::EPlatSecEnforcement) )

			{

			//security violation

			User::Leave(KErrPermissionDenied);

			}

		}

	pkg.UnpackL(aTask.Info(), aTask.Data());

	User::LeaveIfError(iPackages.Append(pkg));

	}

/**

The CMsvSendExe::RetrieveMessagesL method

Retrieves the message selection from the task file.

@internalAll

*/

void CMsvSendExe::RetrieveMessagesL()

	{

	iSession = CMsvSession::OpenSyncL(*this);

	TInt count = iPackages.Count();

	while(count--)

		{

		AddTaskL(iPackages[count]);

		iPackages.Remove(count);

		}

	}

void CMsvSendExe::AddTaskL(const TMsvSchedulePackage& aPackage)

	{

	CMsvEntry* cEntry = NULL;

	TRAPD(err, cEntry = iSession->GetEntryL(aPackage.iId));

	if (err != KErrNotFound)

		{

		User::LeaveIfError(err);

		CleanupStack::PushL(cEntry);

		TMsvEntry entry = cEntry->Entry();

		const TInt sendState = entry.SendingState();

		//Only send the message if sending state is Scheduled or Resend.

		if (entry.Scheduled() && (sendState == KMsvSendStateScheduled || sendState == KMsvSendStateResend))

			{

			entry.SetSendingState(KMsvSendStateWaiting);

			// Fix for DEF000924: Need to be able to send/cancel an sms while another is being sent

			if (entry.iServiceId == KMsvLocalServiceIndexEntryId && entry.iRelatedId != KMsvNullIndexEntryId)

				{

				SCHSENDLOG(  FLog(iFileName, _L("Changing service from %x to %x"), entry.iServiceId, entry.iRelatedId));

				entry.iServiceId = entry.iRelatedId;

				}

			else

				{

				SCHSENDLOG(  FLog(iFileName, _L("Not changing service from %x (related=%x)"), entry.iServiceId, entry.iRelatedId));

				}

			// End of fix

 			cEntry->ChangeL(entry);

			AddTaskL(aPackage, entry.iMtm);

			SCHSENDLOG(FLog(iFileName, _L("\t\tMsg=%d [Mtm=%d SendState=%d]"), aPackage.iId, entry.iMtm.iUid, entry.SendingState()));

			}

		else

			{

			SCHSENDLOG(FLog(iFileName, _L("\t\tIGNORING Msg=%d (Mtm=%d SendState=%d Scheduled=%d)"), aPackage.iId, entry.iMtm.iUid, sendState, entry.Scheduled()));

			}

		CleanupStack::PopAndDestroy(cEntry);

		}

	else

		{

		SCHSENDLOG(FLog(iFileName, _L("\t\tIGNORING Msg=%d: NOT FOUND"), aPackage.iId));

		}

	}

/**

The CMsvSendExe::AddTaskL method

Finds a CMsvSendExeActive in iOperations that corresponds to aPackage and aMtm.

If not found, then creates a new CMsvSendExeActive, and appends it to iOperations.

Then the message in aPackage is appended to the CMsvSendExeActive.

@internalAll

@param				aPackage	Information about what operation to start

@param				aMtm		The MTM of the message identified in aPackage

*/

void CMsvSendExe::AddTaskL(const TMsvSchedulePackage& aPackage, const TUid& aMtm)

	{

	//Add the task to an object in iOperations

	CMsvSendExeActive* active = NULL;

	TInt count = iOperations.Count();

	while (active == NULL && count--)

		{

		CMsvSendExeActive* tempActive = iOperations[count];

		if (tempActive->Mtm() == aMtm &&

			tempActive->Package().iCommandId == aPackage.iCommandId &&

			tempActive->Package().iParameter == aPackage.iParameter &&

			tempActive->Package().iPollProgress == aPackage.iPollProgress)

			active = tempActive;

		}

	if (active == NULL)

		{

		active = CMsvSendExeActive::NewLC(*iSession, *this, aPackage, aMtm, Priority());

		User::LeaveIfError(iOperations.Append(active));

		CleanupStack::Pop(active);

		}

	active->AppendL(aPackage.iId);

	}

/**

The CMsvSendExe::OperationComplete method

Called by a CMsvSendExeActive when it completes

If all operations in iOperations are complete, then CMsvSendExe completes itself

@return			

@internalAll

@param				 aActive The operation that has just completed

@param				 aError  

*/

void CMsvSendExe::OperationComplete(const CMsvSendExeActive& aActive, TInt aError)

	{

	SCHSENDLOG(FLog(iFileName, _L("\tOperation Complete (Mtm=%d CommandId=%d Err=%d)"), aActive.Mtm().iUid, aActive.Package().iCommandId, aError));

	if (aError != KErrNone)

		RescheduleOnError(aActive, aError);

#ifdef _DEBUG

	iOperationsComplete++;

#endif

	__ASSERT_DEBUG(!aActive.IsActive(), gPanic(EOperationCompletedTooSoon));

	TInt count = iOperations.Count();

	while (count--)

		{

		if (iOperations[count]->IsActive())

			{

			__ASSERT_DEBUG(iOperationsComplete < iOperations.Count(), gPanic(ETooManyOperationsCompleted));

			return;

			}

		}

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, KErrNone);

	}

_LIT(KSchSendExePanic, "SchSendExe");

GLDEF_C void gPanic(TSchSendExePanic aPanic)

	{

	User::Panic(KSchSendExePanic,aPanic);

	}

GLDEF_C void gPanic(TInt aPanic)

	{

	User::Panic(KSchSendExePanic,aPanic);

	}

void CMsvSendExe::RescheduleOnError(const CMsvSendExeActive& aActive, TInt aError)

	{

	SCHSENDLOG(FLog(iFileName, _L("\tRescheduleOnError (Mtm=%d CommandId=%d InCount=%d)"), aActive.Mtm().iUid, aActive.Package().iCommandId, aActive.Selection().Count()));

	RescheduleOnError(aActive.Selection(), aActive.Package(), aError);

	}

void CMsvSendExe::RescheduleAllL(TInt aError)

	{

	SCHSENDLOG(FLog(iFileName, _L("\tRescheduleAllL [aError=%d]"), aError));

	RScheduler scheduler;

	TSchedulerItemRef ref;

	ref.iHandle = KErrNotFound;

	TInt count = 0;

	TInt err = KErrNone;

	TTime start;

	start.UniversalTime();

	TInt activeCount = iOperations.Count();

	while (activeCount--)

		{

		CMsvSendExeActive& active = *iOperations[activeCount];

		active.Cancel();

		TRAP(err, DoResheduleOnErrorL(scheduler, active.Selection(), active.Package(), aError, ref, count, start)); //ignore error

		FailOnError(active.Selection(), aError);

		}

	activeCount = iPackages.Count();

	CMsvEntrySelection* sel = new (ELeave) CMsvEntrySelection;

	CleanupStack::PushL(sel);

	while (activeCount--)

		{

		const TMsvSchedulePackage& package = iPackages[activeCount];