diff -r 000000000000 -r e4d67989cc36 genericservices/taskscheduler/Test/PlatSec/TC_TSCH_PLATSEC.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/genericservices/taskscheduler/Test/PlatSec/TC_TSCH_PLATSEC.cpp Tue Feb 02 02:01:42 2010 +0200 @@ -0,0 +1,403 @@ +// 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: +// + +#include +#include "Thelpers.h" + +#include +#include +#include + +#include "TestUtils.h" +#include "platsectaskcommon.h" + +_LIT(KTestName, "Task Scheduler platform security Test"); + +_LIT(KProcess1, "tschsvrclient1"); +_LIT(KProcess2, "tschsvrclient2"); +_LIT(KProcess3, "tschsvrclient3"); + +RTest TheTest(KTestName); + +typedef CArrayFixFlat CSchEntryInfoArray; +typedef CArrayFixFlat CTaskInfoArray; +typedef CArrayFixFlat CSchItemRefArray; + +static RScheduler TheScheduler; +static CTrapCleanup* TheCleanup; +static RFs TheFsSession; + +//creates a daily schedule with StartTime of aStartTime +static TInt CreateScheduleL(TSchedulerItemRef& aRef, + RScheduler& aScheduler, + const TTime& aStartTime) + { + CSchEntryInfoArray* entryList + = new (ELeave) CSchEntryInfoArray(1); + CleanupStack::PushL(entryList); + + TScheduleEntryInfo entry1; + entry1.iStartTime = aStartTime; + entry1.iInterval = 1; // TTimeIntervalDays + entry1.iIntervalType = EDaily; + entry1.iValidityPeriod = 30; // minutes + entryList->AppendL(entry1); + TInt res = aScheduler.CreatePersistentSchedule(aRef, *entryList); + CleanupStack::PopAndDestroy(); // entryList + return res; + } + +static void LaunchClient(TInt aScheduleHandle, + TInt aTaskHandle, + const TDesC& aClient, + TInt aErrorCondition, + TInt aScheduleCount, + TInt aTaskCount) + { + // now launch process to try and access schedule + TRequestStatus stat; + RProcess client; + + TBuf<30> id; + id.Append(':'); + id.AppendNum(aScheduleHandle); + id.Append(':'); + id.AppendNum(aTaskHandle); + id.Append(':'); + id.AppendNum(aErrorCondition); + id.Append(':'); + id.AppendNum(aScheduleCount); + id.Append(':'); + id.AppendNum(aTaskCount); + id.Append(':'); + + TInt res = client.Create(aClient, id); + TEST2(res, KErrNone); + // Asynchronous logon: completes when process terminates with process exit code + client.Logon(stat); + client.Resume(); + + User::WaitForRequest(stat); + + TInt exitReason = client.ExitReason(); + TEST2(exitReason, KErrNone); + client.Close(); + } + +/** +@SYMTestCaseID SYSLIB-SCHSVR-CT-0025 +@SYMTestCaseDesc Check that schedules/tasks cannot be manipulated by unauthorised clients +@SYMTestPriority High +@SYMTestActions Ensure permission denied for client with the wrong SID and without WriteDeviceData + Ensure permission granted for client with the wrong SID but with WriteDeviceData +@SYMTestExpectedResults Only the schedule creator or clients with WriteDeviceData can manipulate schedules/tasks. +@SYMPREQ 277 Ensure integrity of Symbian OS handsets +*/ +static void DoTest1L() + { + + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-0025 platformsec - API policing ")); + + TheTest.Next(_L("Connect to Scheduler")); + TInt res = TheScheduler.Connect(); + TEST2(res, KErrNone); + + TheTest.Next(_L("Registering Client")); + TEST2(SchSvrHelpers::RegisterClientL(TheScheduler), KErrNone); + + // Create a schedule + TheTest.Next(_L("Creating schedule")); + TSchedulerItemRef scheduleHandle; + TTime time; + time.HomeTime(); + time += TTimeIntervalHours(1); //Task to go off one hour from now (ie we dont + //want it going off for the purposes of this test) + User::LeaveIfError(CreateScheduleL(scheduleHandle, TheScheduler, time)); + + // Add a task to the schedule + TheTest.Next(_L("Creating task for schedule")); + TTaskInfo taskInfo; + taskInfo.iName = _L("MyTaskName"); + taskInfo.iPriority = 2; + taskInfo.iTaskId = 0; + taskInfo.iRepeat = 1; + HBufC* data = _L("Tasks Data").AllocLC(); + res = TheScheduler.ScheduleTask(taskInfo, *data, scheduleHandle.iHandle); + CleanupStack::PopAndDestroy(); // data + TEST2(res, KErrNone); + + // Now launch client process with a different SID to ours + // and all capabilities excluding WriteDeviceData (and TCB) + // Client operations should fail with KErrPermissionDenied + TheTest.Next(_L("Launch Client1")); + LaunchClient(scheduleHandle.iHandle, + taskInfo.iTaskId, + KProcess1, + KErrPermissionDenied, + 0, + 0); + + TheScheduler.Close(); + // Now shut down the server and restart. + TheTest.Next(_L("shuting down and restarting server")); + CleanupHelpers::TestCleanupL(); + res = TheScheduler.Connect(); + TEST2(res, KErrNone); + TEST2(SchSvrHelpers::RegisterClientL(TheScheduler), KErrNone); + + //Check we still have 1 schedule and 1 task. + TheTest.Next(_L("Checking schedule info and launching client")); + CSchItemRefArray* refs = new (ELeave) CSchItemRefArray(3); + CleanupStack::PushL(refs); + res = TheScheduler.GetScheduleRefsL(*refs, EAllSchedules); + TEST2(res, KErrNone); + TInt count = refs->Count(); + TEST2(count, 1); + scheduleHandle.iHandle = refs->At(0).iHandle; + + res = TheScheduler.GetTaskRefsL(*refs, EAllSchedules, EAllTasks); + TEST2(res, KErrNone); + count = refs->Count(); + TEST2(count, 1); + taskInfo.iTaskId = refs->At(0).iHandle; + + CleanupStack::PopAndDestroy(refs); + + // Client operations should fail with KErrPermissionDenied + TheTest.Next(_L("Launch client1 again")); + LaunchClient(scheduleHandle.iHandle, + taskInfo.iTaskId, + KProcess1, + KErrPermissionDenied, + 0, + 0); + + // Try with client with no 3rd UID. + // Client operations should fail with KErrPermissionDenied + TheTest.Next(_L("Launch client3")); + LaunchClient(scheduleHandle.iHandle, + taskInfo.iTaskId, + KProcess3, + KErrPermissionDenied, + 0, + 0); + + // Now try with a client with WriteDeviceData. + // All operations should succeed + TheTest.Next(_L("Launch client2")); + LaunchClient(scheduleHandle.iHandle, + taskInfo.iTaskId, + KProcess2, + KErrNone, + 1, + 1); + + TheScheduler.Close(); + + SchSvrHelpers::Pause(TheTest); + } + +/** +@SYMTestCaseID SYSLIB-SCHSVR-CT-0026 +@SYMTestCaseDesc Check that the scheduled exe receives the security info of the schedule creator. +@SYMTestPriority High +@SYMTestActions Check that the scheduled exe receives the security info of the schedule creator. +@SYMTestExpectedResults The scheduled exe receives the security info of the schedule creator. +@SYMPREQ 277 Ensure integrity of Symbian OS handsets +*/ +static void DoTest2L() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-0026 platformsec - TSecurityInfo validity ")); + TheTest.Next(_L("Connect to Scheduler")); + TInt res = TheScheduler.Connect(); + TEST2(res, KErrNone); + + TheTest.Next(_L("Registering Client")); + TFileName filename; + filename = _L("PlatSecTaskHandler"); + TEST2(TheScheduler.Register(filename, 27), KErrNone); + + // Create a schedule + TheTest.Next(_L("Creating schedule")); + TSchedulerItemRef scheduleHandle; + TTime time; + time.HomeTime(); + time += TTimeIntervalSeconds(2); + User::LeaveIfError(CreateScheduleL(scheduleHandle, TheScheduler, time)); + + // Add a task to the schedule + TheTest.Next(_L("Creating task for schedule")); + TTaskInfo taskInfo; + taskInfo.iName = KPlatSecTaskName(); + taskInfo.iPriority = 2; + taskInfo.iTaskId = 0; + taskInfo.iRepeat = 1; + HBufC* data = KPlatSecTaskData().AllocLC(); + res = TheScheduler.ScheduleTask(taskInfo, *data, scheduleHandle.iHandle); + CleanupStack::PopAndDestroy(); // data + TEST2(res, KErrNone); + + TheTest.Next(_L("Wait for task to fire")); + TEST2(STaskSemaphore::WaitL(KDefaultTimeout), KErrNone); + + SchSvrHelpers::Pause(TheTest); + } + +/** +@SYMTestCaseID SYSLIB-SCHSVR-CT-1885 +@SYMTestCaseDesc Check that TTaskInfo states correctly persisted +@SYMTestPriority High +@SYMTestActions Setup a schedule and task and then close the server, reconnect and check that the schedule and task + info has been persisted correctly. +@SYMTestExpectedResults The test must not panic or fail. +@SYMDEF INC093573 +*/ +static void DoTest3L() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-1885 INC093573: Symbian provided task scheduler (RScheduler) loses parts of pending schedule inf ")); + TheTest.Next(_L("Connect to Scheduler")); + TInt res = TheScheduler.Connect(); + TEST2(res, KErrNone); + + TheTest.Next(_L("Registering Client")); + TEST2(SchSvrHelpers::RegisterClientL(TheScheduler), KErrNone); + + // Create a schedule + TheTest.Next(_L("Creating schedule")); + TSchedulerItemRef scheduleHandle; + TTime time; + time.HomeTime(); + time += TTimeIntervalHours(1); //Task to go off one hour from now (ie we dont + //want it going off for the purposes of this test) + User::LeaveIfError(CreateScheduleL(scheduleHandle, TheScheduler, time)); + + // Add a task to the schedule + TheTest.Next(_L("Creating task for schedule")); + TTaskInfo taskInfo; + taskInfo.iName = _L("INC093573"); + taskInfo.iPriority = 2; + taskInfo.iTaskId = 0; + taskInfo.iRepeat = -1; + HBufC* data = _L("Tasks Data").AllocLC(); + res = TheScheduler.ScheduleTask(taskInfo, *data, scheduleHandle.iHandle); + CleanupStack::PopAndDestroy(); // data + TEST2(res, KErrNone); + + TheScheduler.Close(); + + // Now shut down the server and restart. + TheTest.Next(_L("shuting down and restarting server")); + CleanupHelpers::TestCleanupL(); + res = TheScheduler.Connect(); + TEST2(res, KErrNone); + TEST2(SchSvrHelpers::RegisterClientL(TheScheduler), KErrNone); + + //Check that the task is still there with all the correct settings + TheTest.Next(_L("Checking schedule info and launching client")); + TTaskInfo returnedInfo; + TSchedulerItemRef returnedItemRef; + TTsTime returnedTsTime; + TInt size=0; + res=TheScheduler.GetTaskDataSize(0,size); + TEST2(res,KErrNone); + HBufC* buffer=HBufC::NewL(size); + TPtr modifiableBuffer=buffer->Des(); + + //now get the task info and compare to the original submitted to ensure that it is properly + //externalized when server shut down. + res=TheScheduler.GetTaskInfoL(0,returnedInfo,modifiableBuffer,returnedItemRef,returnedTsTime); + TEST2(res,KErrNone); + TEST2(returnedInfo.iPriority,taskInfo.iPriority); + TEST2(returnedInfo.iRepeat,taskInfo.iRepeat); + TEST2(returnedInfo.iTaskId,taskInfo.iTaskId); + TEST2(returnedInfo.iName.Compare(taskInfo.iName),0); + + //now clear the buffer + delete buffer; + } + +static TInt RunTestsL() + { + TheTest.Next(_L("Delete old files")); + SchSvrHelpers::DeleteScheduleFilesL(); + + TheTest.Next(_L("Create Task notification semaphore")); + //initialise task notification semaphore + STaskSemaphore sem; + sem.CreateL(); + + // Connect to the server + TheTest.Next(_L("===== Connect to Scheduler =====")); + TInt res = TheScheduler.Connect(); + TEST2(res, KErrNone); + + // Register a client with the server + TheTest.Next(_L("===== Registering Client =====")); + res = SchSvrHelpers::RegisterClientL(TheScheduler); + TEST2(res, KErrNone); + + CActiveScheduler* scheduler = new (ELeave) CActiveScheduler(); + CleanupStack::PushL(scheduler); + CActiveScheduler::Install(scheduler); + + TheTest.Next(_L("Start tests")); + + if(PlatSec::IsCapabilityEnforced(ECapabilityWriteDeviceData)) + DoTest1L(); + DoTest2L(); + DoTest3L(); + TheTest.Next(_L("Tidying up")); + CleanupStack::PopAndDestroy(scheduler); + //close handle to semaphore + sem.Close(); + + //Tidying up so next test will be clear. + TheTest.Next(_L("Delete all schedules")); + SchSvrHelpers::DeleteAllSchedulesL(TheScheduler); + SchSvrHelpers::Pause(TheTest, 2); + TheTest.Next(_L("Delete old files\n")); + SchSvrHelpers::DeleteScheduleFilesL(); + + TheScheduler.Close(); + return KErrNone; + } + +GLDEF_C TInt E32Main() + { + __UHEAP_MARK; + TheTest.Start(_L("TC_TSCH_PLATSEC")); + TheTest.Title(); + + TheCleanup = CTrapCleanup::New(); + //If the previous test fails, SCHSVR.exe may stay in memory. + TRAPD(error, CleanupHelpers::TestCleanupL()); + TEST2(error, KErrNone); + + TheTest(TheFsSession.Connect() == KErrNone); + + TRAP(error, RunTestsL()); + TEST2(error,KErrNone); + + TRAP(error,CleanupHelpers::TestCleanupL()); + TEST2(error, KErrNone); + delete TheCleanup; + + TheFsSession.Close(); + TheTest.End(); + TheTest.Close(); + __UHEAP_MARKEND; + + return KErrNone; + }