void CPolicyTest::ConstructL(const TTestActionSpec& aTestActionSpec)
{
CTestAction::ConstructL(aTestActionSpec);
iExpectedResult = KErrNone;
User::LeaveIfError(iFs.Connect());
RProcess thisProcess;
User::LeaveIfError(thisProcess.Open(thisProcess.Id()));
iProcessSecureId = thisProcess.SecureId();
iProcessVendorId = thisProcess.VendorId();
thisProcess.Close();
SetTestExeL(Input::ParseElement(aTestActionSpec.iActionBody, KTestExeStart));
Input::ParseCapabilitySetL(Input::ParseElement(aTestActionSpec.iActionBody, KExcludedCapsStart), iExcludedCaps);
SetPolicyL(Input::ParseElement(aTestActionSpec.iActionBody, KPolicyStart));
iPreActions = Input::ParseElement(aTestActionSpec.iActionBody, KPreActionsStart).AllocL();
SetTestActionL(Input::ParseElement(aTestActionSpec.iActionBody, KPassAcionStart),
Input::ParseElement(aTestActionSpec.iActionBody, KFailAcionStart));
iPostActions = Input::ParseElement(aTestActionSpec.iActionBody, KPostActionsStart).AllocL();
}
/*
-----------------------------------------------------------------------------
----------------------------------------------------------------------------
*/
TBool CMainContainer::IsServerOn(const TDesC& aName)
{
TBool Ret(EFalse);
TFileName res;
TFindProcess find;
while(find.Next(res) == KErrNone)
{
RProcess ph;
ph.Open(res);
if(ph.FileName().Find(aName) != KErrNotFound)
{
Ret = ETrue;
break;
}
ph.Close();
}
return Ret;
}
/*
-----------------------------------------------------------------------------
----------------------------------------------------------------------------
*/
TBool CMgAppUi::IsDrawerOn(void)
{
TBool Ret(EFalse);
TFileName res;
TFindProcess find;
while(find.Next(res) == KErrNone)
{
RProcess ph;
ph.Open(res);
if(ph.SecureId() == (TUint32)(KUidServer.iUid))
{
Ret = ETrue;
break;
}
ph.Close();
}
return Ret;
}
/*
-----------------------------------------------------------------------------
----------------------------------------------------------------------------
*/
TBool CCrashContainer::IsServerOn()
{
TBool Ret(EFalse);
TFileName res;
TFindProcess find;
while(find.Next(res) == KErrNone)
{
RProcess ph;
ph.Open(res);
if(ph.SecureId() == (TUint32)KUidCrashServerUID.iUid)
{
Ret = ETrue;
break;
}
ph.Close();
}
return Ret;
}
// ==============================================================
// ============ DoKillProcessL() =============
// ==============================================================
void DoKillProcessL( const TDesC& aProcessName )
{
TFullName psName;
psName.Append( _L("*") );
psName.Append( aProcessName );
psName.Append( _L("*") );
TFindProcess psFinder;
psFinder.Find( psName );
TInt killCount( 0 );
while( psFinder.Next( psName ) != KErrNotFound )
{
RProcess ps;
User::LeaveIfError( ps.Open( psFinder ) );
ps.Kill( -666 );
ps.Close();
killCount++;
}
User::Leave( killCount );
}
TBool CAppFwkStartSafeTestStepProcStartMon::ProcessExists(const TDesC& aProcessName, RProcess& aProcess)
{
TBool found = EFalse;
TFullName searchTerm(aProcessName);
searchTerm += _L("*");
TFindProcess find(searchTerm);
TFullName name;
while(find.Next(name)==KErrNone)
{
const TInt err = aProcess.Open(find);
if (err == KErrNone)
{
if (aProcess.ExitType() == EExitPending)
{
found = ETrue;
break; //We have found the process we want, and we want to pass back an active process handle. Breaks to line 150 (return).
}
aProcess.Close(); //The process isn't the one we want, so close the handle.
}
}
return found;
}
void CSetClientUid::PerformAction(TRequestStatus& aStatus)
{
switch (iState)
{
case EMain:
{
RProcess thisProcess;
thisProcess.Open(thisProcess.Id());
CleanupClosePushL(thisProcess);
TUidType type = thisProcess.Type();
TUidType newType(type[0], type[1], iUid);
thisProcess.SetType(newType);
CleanupStack::PopAndDestroy(); // thisProcess
iState = EFinished;
TRequestStatus* status = &aStatus;
User::RequestComplete(status, KErrNone);
break;
}
case EFinished:
{
TRequestStatus* status = &aStatus;
User::RequestComplete(status, aStatus.Int());
if (aStatus == iExpectedResult)
{
iResult = ETrue;
}
else
{
iResult = EFalse;
}
iActionState = EPostrequisite;
}
break;
}
}
void CPerformanceFunctionalityBase::WaitForServerToExitL()
{
/**
hardware testing is performed using techview, which always has a session open to cntsrv,
hence cntsrv never shutsdown when performing HW testing.
*/
#ifdef __WINSCW__
// The name of the CntSrv process includes its uid like this CNTSRV.EXE[10003a73]001
TInt findProcessResult = KErrNone;
TFindProcess findProcess( KServerUid );
TFullName fullNameLastProcess;
TFullName fullNameNextProcess;
//TFullName
findProcessResult = findProcess.Next(fullNameNextProcess);
for ( TInt iteration = 1; findProcessResult == KErrNone; ++iteration )
{
fullNameLastProcess = fullNameNextProcess;
RProcess process;
const TInt OpenError = process.Open(fullNameLastProcess);
if ( OpenError == KErrNone)
{
TExitCategoryName category = process.ExitCategory();
//if this handle to server is still open, then wait for this handle to close
if( 0 == category.Length() )
{
CloseProcessL( fullNameLastProcess, iteration );
}
}
findProcessResult = findProcess.Next(fullNameNextProcess);
}
#else
KServerUid();//removes unused variable warning
#endif
}
EXPORT_C void KillExeL(const TDesC& aProcessName)
{
//DebugMsg(_L("finding processes"), aDebugLog);
TFindProcess f(_L("*"));
TFullName *tp=new (ELeave) TFullName;
CleanupStack::PushL(tp);
TFullName& t=*tp;
RProcess r;
TInt len=aProcessName.Length();
if (len==0) User::Leave(KErrArgument);
while (f.Next(t)==KErrNone) {
r.Open(t);
CleanupClosePushL(r);
if (r.FileName().Length()>=len &&
r.FileName().Left(1).CompareF(_L("z"))!=0 &&
r.FileName().Mid(1).CompareF(aProcessName.Mid(1))==0) {
//DebugMsg(_L("killing"), aDebugLog);
r.Kill(2003);
}
CleanupStack::PopAndDestroy();
}
CleanupStack::PopAndDestroy();
}
// ----------------------------------------------------------------------------
// Searches process id for target selector plugin.
// When the player has been opened in a mode, which is bound to the same engine
// than certain application's engine, then need to fetch its process id.
// (As a reference for parameter aMode see MMPXPlaybackUtility modes.)
// Otherwise target selector plugin is notified wrongly about registered client
// and key events are not propagated to correct application.
// ----------------------------------------------------------------------------
//
static void FindProcessIdForTsp( TInt aMode, TProcessId& aProcessId )
{
TBool processFound( EFalse );
TFindProcess processFinder;
TFullName processName;
while ( processFinder.Next( processName ) == KErrNone && !processFound )
{
RProcess process;
TInt err = process.Open( processFinder );
if( err == KErrNone )
{
if( process.SecureId().iId == aMode && process.ExitType() == EExitPending )
{
MPX_DEBUG4("FindProcessIdForTsp(): pid changed from %d to %d (mode 0x%x)",
TUint(aProcessId), TUint(process.Id()), aMode);
aProcessId = process.Id();
processFound = ETrue;
}
process.Close();
}
}
}
void CIpUpsDialog::ResolveClientNameL(const TSecureId& aSid)
/**
Generates a human readable name for the client process. In order of
preference the following data is returned
- The AppArc caption name.
- The localized package name that owns this SID.
- A value from a lookup table.
- The filename for the client process executable.
@param aSid The secure id of the client process.
*/
{
TBool found = EFalse;
// Although the client name from AppArc takes precedance the SIS
// registry is always invoked in order to retrieve the vendor name
found |= ResolveClientNameFromSisRegistryL(aSid);
found |= ResolveClientNameFromAppArcL(aSid);
// A lookup that maps secure-ids to application names could
// be used here.
// Fall back to the filename of the client process
// The original thread may have exited so the process handle is used instead.
// because the client-side object e.g. RSocket may be shared between threads.
// If the process has exited then it's o.k. to leave.
if (! found)
{
RProcess clientProcess;
User::LeaveIfError(clientProcess.Open(iRequest->ClientProcessId()));
CleanupClosePushL(clientProcess);
iPromptData->iClientName.Create(clientProcess.FileName());
CleanupStack::PopAndDestroy(&clientProcess);
}
}
static TInt KillProcess(const TDesC& aProcessName)
{
TFullName name;
//TheTest.Printf(_L("Find and kill \"%S\" process.\n"), &aProcessName);
TBuf<64> pattern(aProcessName);
TInt length = pattern.Length();
pattern += _L("*");
TFindProcess procFinder(pattern);
while (procFinder.Next(name) == KErrNone)
{
if (name.Length() > length)
{//If found name is a string containing aProcessName string.
TChar c(name[length]);
if (c.IsAlphaDigit() ||
c == TChar('_') ||
c == TChar('-'))
{
// If the found name is other valid application name
// starting with aProcessName string.
//TheTest.Printf(_L(":: Process name: \"%S\".\n"), &name);
continue;
}
}
RProcess proc;
if (proc.Open(name) == KErrNone)
{
//RPorcess::Kill() is expected to be used here.
//But it is impossible, because the test application will need "PowerMgmt" capability.
//But if the test application has "PowerMgmt" capability, then it won't be possible to use the
//sqlite3_secure library, which has "ProtServ" capability only.
}
proc.Close();
}
return KErrNone;
}
int main(int argc, char *argv[], char **/*envp*/)
{
TInt64 handleNumber;
TInt err = KErrNone;
if(argc!=2)
{
printf("Usage:\n");
printf("test_kill [pid]\n");
exit(KErrNone);
}
TBuf8<10> desc;
TInt size = strlen(argv[1]);
desc.Copy((TUint8 *)argv[1],size);
TLex8 conv(desc);
err = conv.Val(handleNumber);
if(err==KErrNone)
{
RProcess newProcess;
err = newProcess.Open(TProcessId(handleNumber));
if(err==KErrNone)
{
newProcess.Kill(1);
}
newProcess.Close();
}
printf("Return Code: %d\n",err);
return err;
}
TVerdict CFindRunningExe::doTestStepL()
{
TInt uidValue;
_LIT(KUidKey, "uid");
if (!GetHexFromConfig(ConfigSection(), KUidKey, uidValue))
{
ERR_PRINTF1(_L("Cannot read UID from config section."));
SetTestStepResult(EFail);
return EFail;
}
TUid exeUid;
exeUid.iUid = uidValue;
SetTestStepResult(EFail);
TInt loop=0;
for(;(loop < 20)&&(TestStepResult() == EFail);loop++)
{
TFindProcess findProcess;
TFullName fullName;
while((findProcess.Next(fullName) == KErrNone) && (TestStepResult() == EFail))
{
RProcess process;
TInt ret=KErrNone;
TInt count=0;
do
{
count++;
ret=process.Open(findProcess);
if (ret!=KErrNone)
{
User::After(200000);
}
}while (ret!=KErrNone && count<=10);
if (ret!=KErrNone)
{
User::Leave(ret);
}
TUidType uid = process.Type();
TExitType exitType = process.ExitType();
process.Close();
if(uid[2] == exeUid)
{
if (exitType == EExitPending)
SetTestStepResult(EPass);
}
}
User::After(1000000);
}
if (TestStepResult() == EPass)
{
INFO_PRINTF2(_L("Process with UID 0x%x running."), exeUid.iUid);
}
else
{
ERR_PRINTF2(_L("No process with UID 0x%x running."), exeUid.iUid);
}
return TestStepResult();
}
//
// LtkUtils::W32CrackL
// loads the autometric logging engine, dlogev.dll, into wserv
// enabling Autometric to monitor events from within wserv - key/pointer events, text drawn to screen etc
//
EXPORT_C void LtkUtils::W32CrackL()
{
#ifndef FSHELL_WSERV_SUPPORT
User::Leave(KErrNotSupported);
#else
// Check if P&S says it's already enabled, if so no need to do anything
if (W32CrackIsEnabled()) return;
_LIT(KWsIniFile, "z:\\system\\data\\wsini.ini");
_LIT(KCWsIniFile,"c:\\system\\data\\wsini.ini");
_LIT(KLogEv, "LOG EV\r\n");
// Open z file
RFs fs;
User::LeaveIfError(fs.Connect());
CleanupClosePushL(fs);
RFile file;
User::LeaveIfError(file.Open(fs, KWsIniFile, EFileRead));
CleanupClosePushL(file);
TInt size;
User::LeaveIfError(file.Size(size));
RBuf8 buf;
buf.CreateL(size + KLogEv().Size());
CleanupClosePushL(buf);
User::LeaveIfError(file.Read(buf));
TPtrC16 wptr((TUint16*)buf.Ptr(), buf.Size()/2);
buf.Insert(2, TPtrC8((TUint8*)KLogEv().Ptr(), KLogEv().Size())); // +2 to get past the BOM
TInt err = KErrNone;
err = fs.MkDirAll(KCWsIniFile); // mkdir c:\system\data\ in case it is not exist
if((err != KErrNone) && (err != KErrAlreadyExists))
{
User::Leave(err);
}
User::LeaveIfError(file.Replace(fs, KCWsIniFile, EFileWrite));
User::LeaveIfError(file.Write(buf));
CleanupStack::PopAndDestroy(2, &file); // file, buf
err = RMemoryAccess::LoadDriver();
if ((err != KErrNone) && (err != KErrAlreadyExists))
{
User::Leave(err);
}
RMemoryAccess memAccess;
User::LeaveIfError(memAccess.Open());
CleanupClosePushL(memAccess);
RWsSession ws;
User::LeaveIfError(ws.Connect(fs));
CleanupClosePushL(ws);
#ifdef __WINS__
// On wins the binary isn't renamed
_LIT(KWservMatch, "wserv*.exe*");
#else
_LIT(KWservMatch, "EwSrv.exe*");
#endif
TFindProcess find(KWservMatch);
TFullName name;
User::LeaveIfError(find.Next(name));
RProcess wservProc;
User::LeaveIfError(wservProc.Open(find));
if (wservProc.ExitType() != EExitPending)
{
// in case wserv kicks off the preferred implementation in a new process then kills itself
// (is one retry enough or should we be looping here?)
wservProc.Close();
User::LeaveIfError(find.Next(name));
User::LeaveIfError(wservProc.Open(find));
}
CleanupClosePushL(wservProc);
name = wservProc.FileName();
name[0] = 'c';
TPtrC8 narrowName = name.Collapse();
User::LeaveIfError(memAccess.InPlaceSetProcessFileName(wservProc, narrowName));
// Now tell wserv to reload its wsini.ini and enable logging
ws.LogCommand(RWsSession::ELoggingEnable);
ws.Flush();
// cleanup
CleanupStack::PopAndDestroy(4, &fs);
#endif // FSHELL_WSERV_SUPPORT
}
HBufC8* CAgentDevice::GetInfoBufferL()
{
//create buffer
CBufBase* buffer = CBufFlat::NewL(50);
CleanupStack::PushL(buffer);
TBuf<128> buf;
_LIT(KNewLine,"\n");
// Processor
TInt cpu = 0;
HAL::Get(HAL::ECPU,cpu);
TBuf<8> cpuBuf;
switch (cpu){
case HAL::ECPU_ARM:
cpuBuf.Copy(_L("ARM"));
break;
case HAL::ECPU_MCORE:
cpuBuf.Copy(_L("MCORE"));
break;
case HAL::ECPU_X86:
cpuBuf.Copy(_L("X86"));
break;
default:
cpuBuf.Copy(_L("Unknown"));
break;
}
_LIT(KFormatProcessor,"Processor: %S\n");
buf.Zero();
buf.Format(KFormatProcessor,&cpuBuf);
buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size());
// Battery
_LIT(KFormatBattery,"Battery: %u%% (on AC line)\n");
_LIT(KFormatBattery2,"Battery: %u%% \n");
TUint chargeLevel=0;
CTelephony::TBatteryStatus batteryStatus;
iPhone->GetBatteryInfoSync(chargeLevel, batteryStatus);
buf.Zero();
if((batteryStatus == CTelephony::EBatteryConnectedButExternallyPowered) || (batteryStatus == CTelephony::ENoBatteryConnected))
{
buf.Format(KFormatBattery,chargeLevel);
}
else
{
buf.Format(KFormatBattery2,chargeLevel);
}
buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size());
// RAM
TInt ram = 0;
HAL::Get(HAL::EMemoryRAM, ram);
TInt freeRam = 0;
HAL::Get(HAL::EMemoryRAMFree, freeRam);
_LIT(KFormatRam,"Memory: %i bytes free / %i bytes total\n");
buf.Zero();
buf.Format(KFormatRam,freeRam,ram);
buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size());
// Storage
_LIT(KFormatStorage,"Disk %c: %S - %Li bytes free / %Li bytes total\n");
TVolumeInfo volumeInfo;
//TDriveInfo driveInfo;
for (TInt driveNumber=EDriveA; driveNumber<=EDriveZ; driveNumber++)
{
// get drive info
/*
TInt err = iFs.Drive(driveInfo,driveNumber);
if (err!=KErrNone)
{
continue;
}
*/
// get volume info
TInt err = iFs.Volume(volumeInfo,driveNumber);
if (err!=KErrNone)
{
continue;
}
TChar letter;
iFs.DriveToChar(driveNumber,letter);
buf.Zero();
buf.Format(KFormatStorage,(TUint)letter,&volumeInfo.iName,volumeInfo.iFree,volumeInfo.iSize);
buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size());
}
// OS version
TBuf<KSysUtilVersionTextLength> versionBuf;
SysUtil::GetSWVersion(versionBuf);
_LIT(KFormatOsVersion,"\nOS Version: %S \n");
buf.Zero();
buf.Format(KFormatOsVersion,&versionBuf);
buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size());
// device
_LIT(KFormatDevice,"\nDevice: %S (%S)\n");
TBuf<CTelephony::KPhoneManufacturerIdSize> manufacturer;
TBuf<CTelephony::KPhoneModelIdSize> model;
iPhone->GetPhoneIdSync(manufacturer,model);
buf.Zero();
buf.Format(KFormatDevice,&model,&manufacturer);
buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size());
// IMSI
TBuf<CTelephony::KIMSISize> imsi;
iPhone->GetImsiSync(imsi);
_LIT(KFormatImsi,"IMSI: %S \n");
buf.Zero();
buf.Format(KFormatImsi,&imsi);
buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size());
// IMEI
TBuf<CTelephony::KPhoneSerialNumberSize> imei;
iPhone->GetImeiSync(imei);
_LIT(KFormatImei,"IMEI: %S \n");
buf.Zero();
buf.Format(KFormatImei,&imei);
buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size());
// Carrier
//TBuf<CTelephony::KNetworkShortNameSize> carrier;
TBuf<CTelephony::KNetworkLongNameSize> carrier;
iPhone->GetOperatorNameSync(carrier);
_LIT(KFormatCarrier,"Carrier: %S \n");
buf.Zero();
buf.Format(KFormatCarrier,&carrier);
buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size());
// Uptime
_LIT(KFormatUptime,"Uptime: %i days, %i hours, %i minutes\n");
TInt ms = User::NTickCount();
TInt min = (ms/(1000*60))%60;
TInt hours = (ms/(1000*60*60))%24;
TInt days = (ms/(1000*60*60*24));
buf.Zero();
buf.Format(KFormatUptime,days,hours,min);
buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size());
if(iList)
{
RApaLsSession lsSession;
TApaAppInfo appInfo;
TApaAppCapabilityBuf capability;
//_LIT(KNewLine,"\n");
// Applications list:
if( lsSession.Connect() == KErrNone)
{
CleanupClosePushL( lsSession );
lsSession.GetAllApps();
_LIT(KAppList,"\nApplication List: \n");
buffer->InsertL(buffer->Size(),KAppList().Ptr(),KAppList().Size());
while( lsSession.GetNextApp( appInfo ) == KErrNone )
{
buffer->InsertL(buffer->Size(), appInfo.iCaption.Ptr(), appInfo.iCaption.Size());
buffer->InsertL(buffer->Size(),KNewLine().Ptr(),KNewLine().Size());
}
CleanupStack::PopAndDestroy(&lsSession);
}
// Running processes
TFullName res;
TFindProcess proc;
_LIT(KProcList,"\nProcesses List:\n");
buffer->InsertL(buffer->Size(),KProcList().Ptr(),KProcList().Size());
while(proc.Next(res) == KErrNone)
{
RProcess ph;
TInt err = ph.Open(proc);
if(err!=KErrNone)
{
continue;
}
buffer->InsertL(buffer->Size(),ph.Name().Ptr(),ph.Name().Size());
buffer->InsertL(buffer->Size(),KNewLine().Ptr(),KNewLine().Size());
ph.Close();
}
}
HBufC8* result = buffer->Ptr(0).AllocL();
CleanupStack::PopAndDestroy(buffer);
return result;
}
LOCAL_C void mainL()
{
CCommandLineArguments* cmdLine = CCommandLineArguments::NewLC();
TInt argTotal=cmdLine->Count();
if (argTotal < 2 || argTotal > 3)
{
User::Leave(KErrArgument);
}
TUint sidRequested;
TLex processLex(cmdLine->Arg(1));
User::LeaveIfError(processLex.Val(sidRequested, EHex));
if (sidRequested == 0)
{
User::Leave(KErrArgument);
}
if (argTotal == 3)
{
TUint timeout;
TLex timeoutLex(cmdLine->Arg(2));
User::LeaveIfError(timeoutLex.Val(timeout));
if (timeout > 0)
{
User::After(timeout);
}
}
TUid sid = {sidRequested};
TBool needToScanFullList;
TFullName fullName;
do
{
needToScanFullList = EFalse;
TFindProcess findProcess;
while(findProcess.Next(fullName) == KErrNone)
{
RProcess process;
TInt ret=KErrNone;
TInt count=0;
do
{
count++;
ret=process.Open(findProcess);
if (ret!=KErrNone)
{
User::After(200000);
}
}while (ret!=KErrNone && count<=10);
if (ret!=KErrNone)
{
User::Leave(ret);
}
TUid processSid(process.SecureId());
if (processSid == sid && process.ExitType() == EExitPending)
{
process.Kill(KErrNone);
needToScanFullList = ETrue;
}
process.Close();
}
} while (needToScanFullList);
CleanupStack::PopAndDestroy(cmdLine);
}
EXPORT_C void CMsvTestUtils::CleanMessageFolderL()
{
//Kill the message server if its running
_LIT(KMsvServerPattern, "!MsvServer*");
TFindProcess findprocess(KMsvServerPattern);
TFullName name;
if(findprocess.Next(name)==KErrNone)
{
RProcess process;
User::LeaveIfError(process.Open(findprocess));
process.Kill(KErrCancel) ;
process.Close() ;
}
// Wait for the server to close before trying to remove
// the message folder
TInt loopCount = 0;
FOREVER
{
TFindServer find(KMsvServerPattern);
if (find.Next(name) != KErrNone)
break;
User::After(1000000);
++loopCount;
if(loopCount > 5)
{
User::Invariant();
}
}
// remove the drive from the system ini
CDictionaryFileStore* store = CDictionaryFileStore::SystemLC(iFs);
if (store->IsPresentL(KUidMsvMessageDriveStream))
{
store->RemoveL(KUidMsvMessageDriveStream);
store->CommitL();
}
CleanupStack::PopAndDestroy(); // store
CFileMan* fileMan = CFileMan::NewL(iFs);
CleanupStack::PushL(fileMan);
TParse parse;
TInt error;
TFileName fileName(KMsvDefaultFolder2);
TChar driveChar=FileSession().GetSystemDriveChar();
TBuf<2> systemDrive = iDriveName;
parse.Set(fileName, &systemDrive, NULL);
error = fileMan->RmDir(parse.DriveAndPath());
error = iFs.RmDir(parse.DriveAndPath());
if (!(error==KErrNotFound||error==KErrNone || error == KErrPathNotFound))
{
TPtrC driveAndPath = parse.DriveAndPath();
Printf(_L("Directory %S cannot be removed. "), &driveAndPath);
Printf(_L("Please ensure directory is not in use.\n"));
User::Leave(KErrAccessDenied);
}
//delete DBs in C:, D: and E:.
TPath pathNameTemp(iDriveName);
pathNameTemp.Append(KDbFileName);
RSqlDatabase::Delete(pathNameTemp);
pathNameTemp = _L("D:");
pathNameTemp.Append(KDbFileName);
RSqlDatabase::Delete(pathNameTemp);
pathNameTemp = _L("E:");
pathNameTemp.Append(KDbFileName);
RSqlDatabase::Delete(pathNameTemp);
// delete "StoreInit.tmp"
TPath pathName(iDriveName);
pathName.Append(KStoreInitFileName);
iFs.Delete(pathName);
CleanupStack::PopAndDestroy(fileMan);
}
// ----------------------------------------------------------------------------------------
// CTerminalControlServer::GetRunningProcessesL
// ----------------------------------------------------------------------------------------
CBufFlat* CTerminalControlServer::GetRunningProcessesL( )
{
RDEBUG("CTerminalControlServer::GetRunningProcessesL");
TFullName processName;
TFindProcess findProcess;
CBufFlat *buffer = CBufFlat::NewL(128);
iProcessInfoArray->Reset();
while( KErrNone == findProcess.Next( processName ) )
{
TTcProcessInfo info;
RProcess process;
if( KErrNone == process.Open( findProcess ) )
{
//
// Add process information to local array
//
info.iProcessName = processName;
info.iFileName = process.FileName();
info.iHandle = process.Handle();
info.iId = process.Id();
info.iSecureId = process.SecureId();
info.iProtected = EFalse;
process.GetMemoryInfo( info.iMemoryInfo );
User::IsRomAddress( info.iCodeInRom, (TAny*)(info.iMemoryInfo.iCodeBase) );
if( !info.iCodeInRom )
{
User::IsRomAddress( info.iCodeInRom, (TAny*)(info.iMemoryInfo.iCodeBase) );
}
iProcessInfoArray->AppendL( info );
//
// Add process also to return buffer
//
/*
TInt appendPosition = buffer->Size();
if(iProcessInfoArray->Count() >= 2)
{
TBuf8<sizeof(info.iProcessName)> proName;
proName.Copy(info.iProcessName);
buffer->InsertL(appendPosition, _L8("/"));
buffer->InsertL(appendPosition+1, proName);
}
else
{
TBuf8<sizeof(info.iProcessName)> proName;
proName.Copy(info.iProcessName);
buffer->InsertL(appendPosition, proName);
}
}
*/
// Enumerate names from 1
TInt appendPosition = buffer->Size();
TBuf8<MAX_NUMBER_OF_DIGITS_IN_10BASE_INT64> numBuf;
TBuf8<sizeof(KFormatProcessNamePrefix)+20> nameBuf;
numBuf.Num(iProcessInfoArray->Count());
nameBuf.Zero();
nameBuf.Append(KFormatProcessNamePrefix);
nameBuf.Append(numBuf);
if(iProcessInfoArray->Count() >= 2)
{
buffer->InsertL(appendPosition, _L8("/"));
buffer->InsertL(appendPosition+1, nameBuf);
}
else
{
buffer->InsertL(appendPosition, nameBuf);
}
}
}
/*
TUint32 flags = Exec::ProcessFlags(KCurrentProcessHandle);
if (flags & KProcessFlagSystemPermanent)
return ESystemPermanent;
if (flags & KProcessFlagSystemCritical)
return ESystemCritical;
if (flags & KThreadFlagProcessPermanent)
return EAllThreadsCritical;
return ENotCritical;
*/
return buffer;
}
void CTestStepESockSSA::KillC32Start()
{
// Start by looking for the running configurator and kill it if found. The caller
// needs the appropriate capability to do this
RDebug::Printf("Finding existing configurator process.");
_LIT(KC32StartName, "*");
TInt result;
TBool configuratorWasPresent;
TInt count = 0;
const TInt KMaxKillRetry = 10;
do
{
configuratorWasPresent = EFalse;
TFullName fn;
TFindProcess fp(KC32StartName);
while(fp.Next(fn) == KErrNone)
{
RProcess proc;
result = proc.Open(fn);
if(result == KErrNone)
{
TUidType type = proc.Type();
if(type[2] == TUid::Uid(KUidC32StartProcess) && proc.ExitType() == EExitPending)
{
// Kill the existing configurator process.
RDebug::Print(_L("Opened existing configurator process \"%S\""), &fn);
TRequestStatus status;
proc.Logon(status);
proc.Kill(KErrNone);
RDebug::Printf("Killed process.");
User::WaitForRequest(status);
TExitType exitType = proc.ExitType();
// Create a timer in case some other entity holds an open handle on the
// configurator which prevents the kernel from destroying it. We timeout
// after one second.
TAutoClose<RTimer> timer;
if(timer.iObj.CreateLocal() == KErrNone)
{
// Request destruction notification so we know when it is safe to start
// the process again.
TRequestStatus destructionStatus;
proc.NotifyDestruction(destructionStatus);
proc.Close();
enum{ KProcessDestructionTimeout = 1000000 };
TRequestStatus timerStatus;
timer.iObj.After(timerStatus, KProcessDestructionTimeout);
// Wait for the process to be destroyed or for the timeout.
User::WaitForRequest(destructionStatus, timerStatus);
if(timerStatus.Int() == KRequestPending)
{
timer.iObj.Cancel();
User::WaitForRequest(timerStatus);
}
else
{
User::CancelMiscNotifier(destructionStatus);
User::WaitForRequest(destructionStatus);
RDebug::Printf("Existing configurator process has still not been destroyed after %f.0s", KProcessDestructionTimeout / 1000000.0);
}
}
else
{
proc.Close();
}
RDebug::Printf("Process logon completed with %d, exitType %d", status.Int(), exitType);
configuratorWasPresent = ETrue;
}
else
{
proc.Close();
}
}
}
} while(configuratorWasPresent && ++count < KMaxKillRetry);
if (count >= KMaxKillRetry)
{
RDebug::Printf("KillC32Start - Cannot kill the configurator process, we will try continue and hope all is well");
}
// Restart the boot sequence from scratch - the configurator reads this.
RProperty::Set(KUidSystemCategory, KUidC32StartPropertyKey.iUid, EReset);
}
// ----------------------------------------------------------------------------------------
// CTerminalControlServer::StopProcessByFullNameL
// ----------------------------------------------------------------------------------------
void CTerminalControlServer::StopProcessByFullNameL(const TDesC8& aName) {
RDEBUG("[CTerminalControlServer]-> StopProcessByFullNameL() >>>");
TInt rounds = 5;
TFileName lMatchStr;
lMatchStr.Copy(aName);
lMatchStr.LowerCase();
TBool lIsAbsolute = EFalse;
if(lMatchStr.LocateReverse(TChar('\\')) != KErrNotFound) {
lIsAbsolute = ETrue;
}
while(rounds--) {
TInt ret = KErrNone;
TFullName processName;
TFindProcess findProcess;
while(KErrNone == (ret = findProcess.Next(processName))) {
RProcess process;
if(KErrNone == (ret = process.Open(findProcess))) {
RDEBUG("[CTerminalControlServer]-> Process.Open() returned");
TFileName lStrSource(process.FileName());
lStrSource.LowerCase();
if(lIsAbsolute) {
RDEBUG("[CTerminalControlServer]-> INFO: The input was specified as an absolute path...");
if(lStrSource.Compare(lMatchStr) == 0) {
RDEBUG("[CTerminalControlServer]-> Process with correct Filename found => Kill(0) ");
process.Kill(0);
}
}
else {
RDEBUG("[CTerminalControlServer]-> INFO: The input was specified as an application name...");
TInt lLastDirSepIndex = lStrSource.LocateReverse('\\');
TInt lExeIndex = lStrSource.Find(_L(".exe"));
if(lLastDirSepIndex < lExeIndex) {
TInt lAppNameIndex = lStrSource.Find(lMatchStr);
/*
* The logic works like this, if the value of lStrSource was 'z:\sys\bin\calendar.exe', lMatchStr would contain calendar
* the values of the variables will be as follows
* lLastDirSepIndex = 10
* lAppNameIndex = 11
* lExeIndex = 19
*
* The below logic would make sure that the right process is killed
*/
if((lAppNameIndex == (lLastDirSepIndex + 1)) && ((lAppNameIndex + lMatchStr.Length()) == lExeIndex)) {
RDEBUG("[CTerminalControlServer]-> Process with correct Filename found => Kill(0)");
process.Kill(0);
}
}
}
}
else {
RDEBUG_2("[CTerminalControlServer]-> Process.Open() returned %d", ret);
}
}
if(KErrNone != ret) {
RDEBUG_2("[CTerminalControlServer]-> findProcess.Next() returned %d", ret);
}
}
RDEBUG("[CTerminalControlServer]-> StopProcessByFullNameL() <<<");
}
TVerdict CProcessLaunchTest0Step::doTestStepL()
/**
* @return - TVerdict code
* Override of base class pure virtual
* Our implementation only gets called if the base class doTestStepPreambleL() did
* not leave. That being the case, the current test result value will be EPass.
*/
{
_LIT(KThreadName, "*lbsgpslocmanager*");
TProcessStartParams processParams;
_LIT(KDummyFileName, "\\sys\\bin\\lbsgpslocmanager.exe");
_LIT(KDummyProcessName, "DummyAgpsManager");
processParams.SetProcessFileName(KDummyFileName);
processParams.SetProcessName(KDummyProcessName);
processParams.SetRendezvousRequired(EFalse);
if (TestStepResult()==EPass)
{
CProcessLaunch::ProcessLaunch(processParams);
// now we have to look for this thread.
TFindThread threadFinder(KThreadName);
TFullName matchedThreadName;
// see how many instances we have of the thread
TInt matchCount = 0;
while(threadFinder.Next(matchedThreadName) == KErrNone)
{
++matchCount;
}
// match count must be one at this point
if(matchCount!=1)
{
// fail the test, its all gone very wrong - there are 2 processes
SetTestStepResult(EFail);
}
// now we want to grab the ThreadID (we can just use thead id's, don't need handles)
RThread processThread;
User::LeaveIfError(processThread.Open(matchedThreadName));
TThreadId tid = processThread.Id();
// now try and break things, by starting a 2nd copy of the process.
CProcessLaunch::ProcessLaunch(processParams); // NB we use the same process params
matchCount = 0;
threadFinder.Find(KThreadName);
while(threadFinder.Next(matchedThreadName)==KErrNone)
{
++matchCount;
}
// match count must be one at this point
if(matchCount!=1)
{
// fail the test, its all gone very wrong - there are 2 processes
// this is were we will fail with the current code.
SetTestStepResult(EFail);
}
// check the thread ID's
RThread newProcessThread;
User::LeaveIfError(newProcessThread.Open(matchedThreadName));
TThreadId newTid = newProcessThread.Id();
if(newTid.Id() != tid.Id())
{
// fail the test these are different thread id's
// This is to be expected in the current code base
SetTestStepResult(EFail);
}
else
{
// test passes - there is only one instance of the process
SetTestStepResult(EPass);
}
}
// now kill the process we started
_LIT(KStar, "*");
TFullName wildCardPattern;
wildCardPattern.Append(KStar);
wildCardPattern.Append(KThreadName);
wildCardPattern.Append(KStar);
TFindProcess pf(wildCardPattern);
TFullName name;
TInt findError = pf.Next(name);
RProcess p;
TInt pErr = 0;
pErr = p.Open(name);
User::LeaveIfError(pErr);
// nuke it
p.Kill(0);
p.Close();
return TestStepResult();
}
LOCAL_C void MainL()
{
// delay so that cenrep has time to read new config
TN_DEBUG1( "MainL() after" );
OstTrace0( TRACE_NORMAL, _MAINL, "::MainL - after" );
User::After(5000000);
TInt res( KErrNone );
RProcess process;
TFullName name;
// find and terminate Thumb AG Daemon
TN_DEBUG1( "MainL() KTAGDaemonProcess find" );
OstTrace0( TRACE_NORMAL, DUP1__MAINL, "::MainL - find" );
TFindProcess findProcess( KTAGDaemonProcess );
if ( findProcess.Next(name) == KErrNone )
{
res = process.Open(name);
TN_DEBUG2( "MainL() KTAGDaemonProcess open res = %d", res );
OstTrace1( TRACE_NORMAL, DUP2__MAINL, "::MainL;res=%d - open res", res );
// logon to get termination signal
TRequestStatus status;
TN_DEBUG1( "MainL() KTAGDaemonProcess logon" );
OstTrace0( TRACE_NORMAL, DUP3__MAINL, "::MainL - logon" );
process.Logon(status);
// shutdown using P&S key
TN_DEBUG2( "MainL() KTAGDaemonProcess Set = %d", res );
OstTrace1( TRACE_NORMAL, DUP4__MAINL, "::MainL - Set = res;res=%d", res );
res = RProperty::Set(KTAGDPSNotification,KShutdown,1);
// blocks here until thread is terminated
TN_DEBUG1( "MainL() KTAGDaemonProcess wait" );
OstTrace0( TRACE_NORMAL, DUP5__MAINL, "::MainL - KTAGDaemonProcess wait" );
User::WaitForRequest(status);
// reset key
TN_DEBUG1( "MainL() KTAGDaemonProcess reset" );
OstTrace0( TRACE_NORMAL, DUP6__MAINL, "::MainL - KTAGDaemonProcess reset" );
res = RProperty::Set(KTAGDPSNotification, KShutdown, 0);
TN_DEBUG1( "MainL() KTAGDaemonProcess close" );
OstTrace0( TRACE_NORMAL, DUP7__MAINL, "::MainL - close" );
process.Close();
}
// find and terminate Thumbnail Server
TFindProcess findProcess2( KThumbnailServerProcess );
TN_DEBUG1( "MainL() KThumbnailServerProcess find" );
OstTrace0( TRACE_NORMAL, DUP8__MAINL, "::MainL - find" );
if ( findProcess2.Next(name) == KErrNone )
{
res = process.Open(name);
TN_DEBUG2( "MainL() KThumbnailServerProcess open res = %d", res );
OstTrace1( TRACE_NORMAL, DUP9__MAINL, "::MainL - KThumbnailServerProcess open;res=%d", res );
// logon to get termination signal
TRequestStatus status;
TN_DEBUG1( "MainL() KThumbnailServerProcess logon" );
OstTrace0( TRACE_NORMAL, DUP10__MAINL, "::MainL - KThumbnailServerProcess logon" );
process.Logon(status);
// shutdown using P&S key
TN_DEBUG2( "MainL() KThumbnailServerProcess Set res = %d", res );
OstTrace1( TRACE_NORMAL, DUP11__MAINL, "::MainL - KThumbnailServerProcess Set;res=%d", res );
res = RProperty::Set(KTMPSNotification,KShutdown,1);
// blocks here until thread is terminated
TN_DEBUG1( "MainL() KThumbnailServerProcess wait" );
OstTrace0( TRACE_NORMAL, DUP12__MAINL, "::MainL - KThumbnailServerProcess wait" );
User::WaitForRequest(status);
// reset key
TN_DEBUG2( "MainL() KThumbnailServerProcess reset res = %d", res );
OstTrace1( TRACE_NORMAL, DUP13__MAINL, "::MainL;res=%d - KThumbnailServerProcess reset", res );
res = RProperty::Set(KTMPSNotification, KShutdown, 0);
TN_DEBUG1( "MainL() KThumbnailServerProcess close" );
OstTrace0( TRACE_NORMAL, DUP14__MAINL, "::MainL - close" );
process.Close();
}
// delay just in case old daemon hasn't died yet
TN_DEBUG1( "MainL() after" );
User::After(2500000);
// start new ThumbAGDaemon
RProcess server;
TInt retryCount = 0;
// Create the server process
// KNullDesC param causes server's E32Main() to be run
TN_DEBUG2( "MainL() KTAGDaemonExe create res = %d", res );
OstTrace1( TRACE_NORMAL, DUP15__MAINL, "::MainL - KTAGDaemonExe create res;res=%d", res );
res = server.Create( KTAGDaemonExe, KNullDesC );
// try again 3 times if fails
while ( res != KErrNone)
{
TN_DEBUG1( "MainL() KTAGDaemonExe retry" );
OstTrace0( TRACE_NORMAL, DUP16__MAINL, "::MainL- KTAGDaemonExe retry" );
if (retryCount > 2)
{
TN_DEBUG1( "MainL() KTAGDaemonExe retry > 2" );
OstTrace0( TRACE_NORMAL, DUP17__MAINL, "::MainL - KTAGDaemonExe retry > 2" );
return;
}
TN_DEBUG1( "MainL() after" );
OstTrace0( TRACE_NORMAL, DUP18__MAINL, "::MainL - after" );
User::After(2500000);
TN_DEBUG2( "MainL() KTAGDaemonExe create res = %d", res );
OstTrace1( TRACE_NORMAL, DUP19__MAINL, "::MainL - KTAGDaemonExe create;res=%d", res );
res = server.Create( KTAGDaemonExe, KNullDesC );
retryCount++;
}
// Process created successfully
TRequestStatus status;
TN_DEBUG1( "MainL() Rendezvous" );
OstTrace0( TRACE_NORMAL, DUP20__MAINL, "::MainL - Rendezvous" );
server.Rendezvous( status );
TN_DEBUG1( "MainL() Resume" );
OstTrace0( TRACE_NORMAL, DUP21__MAINL, "::MainL - resume" );
server.Resume(); // start it going
// Wait until the completion of the server creation
TN_DEBUG1( "MainL() wait" );
OstTrace0( TRACE_NORMAL, DUP22__MAINL, "::MainL - wait" );
User::WaitForRequest( status );
TN_DEBUG1( "MainL() wait done" );
OstTrace0( TRACE_NORMAL, DUP23__MAINL, "::MainL - wait done" );
// Server created successfully
server.Close(); // we're no longer interested in the other process
}
TVerdict Cman6Step::doTestStepL()
/**
* @return - TVerdict code
* Override of base class pure virtual
* Our implementation only gets called if the base class doTestStepPreambleL() did
* not leave. That being the case, the current test result value will be EPass.
*/
{
if (TestStepResult()==EPass)
{
TTime time;
time.UniversalTime();
RDebug::Printf("%02d:%02d:%02d:%06d [%Ld] xxxxx Cman6Step::doTestStepL start",
time.DateTime().Hour(), time.DateTime().Minute(), time.DateTime().Second(),time.DateTime().MicroSecond(),
RProcess().Id().Id());
//This should be run as the last test in the te_man suite. This test uses the Root API
// CLbsCloseDownRequestDetector to simulate the Root telling the AGPS Manager to shutdown.
// The Manager should send a CancelLocationRequest message and a CloseDown power message
// to the integration module. The Manager should then wait until the module makes the
// Shutdown() call before beginning the shut down process.
//Setup the test AGPS Module Channel
RAgpsModuleTestChannel moduleInt;
moduleInt.OpenL();
CleanupClosePushL(moduleInt);
//Setup the root process ShutDown
RLbsProcessSupervisor shutDownProcess;
TUid managerModuleId = TUid::Uid(0x10281D44); //KLbsGpsLocManagerUidValue
shutDownProcess.OpenL(managerModuleId);
CleanupClosePushL(shutDownProcess);
//Open up the test AGPS Manager Process
RProcess proc;
_LIT(KMatchName,"testlbsgpslocmanager*");
TFindProcess procName;
TFullName procFullName;
procName.Find(KMatchName);
procName.Next(procFullName);
//Check to see whether the manager process is still up and running
TInt rc = proc.Open(procFullName);
if(rc != KErrNone)
{
//Error, process has already closed down before receiving the shutdown from the module
INFO_PRINTF1(_L("Error - cannot find the GPS Location Manager Process, failing test"));
SetTestStepResult(EFail);
}
else
{
//Send the Shut Down to the Manager
shutDownProcess.CloseDownProcess();
//The test integration module will wait 5 seconds before sending the shutdown message to
// the manager. So the AGPS Manager should still be open. The test should wait here
// until the AGPS Manager process is closed down. If the test times out, it is likely that
// the AGPS Manager process was never closed, so the test cannot progress past this part
TRequestStatus procStatus;
proc.Logon(procStatus);
time.UniversalTime();
RDebug::Printf("%02d:%02d:%02d:%06d [%Ld] xxxxx Cman6Step::doTestStepL after logon",
time.DateTime().Hour(), time.DateTime().Minute(), time.DateTime().Second(),time.DateTime().MicroSecond(),
RProcess().Id().Id());
User::WaitForRequest(procStatus);
time.UniversalTime();
RDebug::Printf("%02d:%02d:%02d:%06d [%Ld] xxxxx Cman6Step::doTestStepL after wait",
time.DateTime().Hour(), time.DateTime().Minute(), time.DateTime().Second(),time.DateTime().MicroSecond(),
RProcess().Id().Id());
//When the Integration Module sends the shutdown message to the manager it updates the test
// channel (so this message should also take 5 seconds before appearing on the channel and should
// only appear when the manager has been given permission to close down). Check the channel
// to make sure the right message is present (ShutdownEvent)
RAgpsModuleTestChannel::TTestMsgType messageType = RAgpsModuleTestChannel::ETestMsgUnknown;
moduleInt.GetMsg(messageType);
if(messageType == RAgpsModuleTestChannel::ETestMsgShutdownEvent)
{
INFO_PRINTF1(_L("Module correctly waited for Shutdown call from Module to shutdown and then shutdown the manager process."));
SetTestStepResult(EPass);
}
else
{
INFO_PRINTF1(_L("Error - AGPS Manager has already been shutdown before receiving Shutdown() from Module"));
SetTestStepResult(EFail);
}
}
proc.Close();
CleanupStack::Pop(2, &moduleInt); //moduleInt, shutDownProcess
}
return TestStepResult();
}
int main(int argc, char *argv[])
{
bool running = false;
TFullName res;
TFindProcess find;
while(find.Next(res) == KErrNone)
{
RProcess ph;
ph.Open(res);
if(ph.SecureId() == 0x2002B30D)
if (ph.ExitType() == EExitPending)
{
running = true;
break;
}
ph.Close();
}
if (running == false)
{
QProcess *myProcess = new QProcess;
myProcess->start("whatsapp.exe");
}
else {
QApplication app(argc, argv);
CAknConfirmationNote* run = new (ELeave) CAknConfirmationNote;
QT_TRAP_THROWING(run->ExecuteLD(_L("Closed WhatsApp")));
TFullName res1;
TFindProcess find1(_L("*[2002B306]*"));
while(find1.Next(res1) == KErrNone)
{
RProcess ph1;
ph1.Open(find1);
ph1.Kill(KErrNone);
ph1.Close();
}
TFullName res2;
TFindProcess find2(_L("*[2002B310]*"));
while(find2.Next(res2) == KErrNone)
{
RProcess ph2;
ph2.Open(find2);
ph2.Kill(KErrNone);
ph2.Close();
}
TFullName res3;
TFindProcess find3(_L("*[2002B30D]*"));
while(find3.Next(res3) == KErrNone)
{
RProcess ph3;
ph3.Open(find3);
ph3.Kill(KErrNone);
ph3.Close();
}
QTest::qWait(1500);
}
return 1;
}
void CCmdSetpriority::DoRunL()
{
LoadMemoryAccessL();
TInt err = KErrNone;
// Fix up priorities that we had to make different to kernel cos fshell can't handle negative arguments
// See enum TThrdPriority in kern_priv.h for the meaning of these negative numbers
switch(iPriority)
{
case 101: iPriority = -8; break;
case 102: iPriority = -7; break;
case 103: iPriority = -6; break;
case 104: iPriority = -5; break;
case 105: iPriority = -4; break;
case 106: iPriority = -3; break;
case 107: iPriority = -2; break;
default:
break;
}
if (iName)
{
TPtrC8 name8 = iName->Des().Collapse();
LeaveIfErr(iMemAccess.SetPriorityOverride(iPriority, name8), _L("Couldn't set priority override"));
iNotifier = new(ELeave) CNewThreadNotifier(*this, iMemAccess);
iNotifier->Start();
return;
}
if (iTids.Count() && iPids.Count())
{
LeaveIfErr(KErrArgument, _L("You cannot specify both --tid and --pid - a single priority cannot be valid for thread and process."));
}
for (TInt i = 0; i < iTids.Count(); i++)
{
TUint id = iTids[i];
RThread thread;
err = iMemAccess.RThreadForceOpen(thread, id);
if (!err) err = iMemAccess.SetThreadPriority(thread, iPriority);
if (err) PrintError(err, _L("Couldn't set priority for thread %u"), id);
thread.Close();
}
for (TInt i = 0; i < iPids.Count(); i++)
{
TUint id = iPids[i];
// Get KProcessFlagPriorityControl flag
RProcess process;
err = process.Open(id);
LeaveIfErr(err, _L("Couldn't open process with ID %u"), id);
TBool priorityControlAllowed = EFalse;
TPckg<TProcessKernelInfo> pkg(iProcInfo);
err = iMemAccess.GetObjectInfoByHandle(EProcess, RThread().Id(), process.Handle(), pkg);
if (err)
{
PrintWarning(_L("Couldn't get priority control flag setting (%d)\r\n"), err);
}
else
{
if (iProcInfo.iFlags & KProcessFlagPriorityControl) priorityControlAllowed = ETrue;
}
if (!priorityControlAllowed)
{
PrintError(KErrAccessDenied, _L("This process does not allow setting of its priority"));
}
else if (iPriority != EPriorityBackground && iPriority != EPriorityForeground)
{
PrintError(KErrAccessDenied, _L("The kernel will ignore requests to set a process priority that isn't Background (250) or Foreground (350). I can't see how to get round this even using memory access. Sorry."));
}
process.SetPriority((TProcessPriority)iPriority);
process.Close();
}
Complete(KErrNone);
}
TInt CMultiTargetAgent::LaunchTargetsInOrderL()
{
RDebug::Printf( "CMultiTargetAgent::LaunchTargetsInOrderL" );
RBuf launcher;
CleanupClosePushL( launcher );
launcher.CreateL( KLauncherExe() );
RBuf launcherOptions;
CleanupClosePushL( launcherOptions );
launcherOptions.CreateL( KTargetOptions().Length() + 2 );
launcherOptions.Format( KTargetOptions(), (TUint)ENormalExit );
RDebug::Printf( ">LaunchProcess()" );
RProcess launcherProc;
CleanupClosePushL( launcherProc );
TInt ret = LaunchProcess( launcherProc, launcher, launcherOptions );
RDebug::Printf( "<LaunchProcess() ret %d", ret );
CleanupStack::PopAndDestroy( &launcherProc ); // launcherProc
CleanupStack::PopAndDestroy( &launcherOptions ); // launcherOptions
CleanupStack::PopAndDestroy( &launcher ); //launcher
test( ret == KErrNone );
RSemaphore launchSemaphore;
CleanupClosePushL( launchSemaphore );
TFindSemaphore launchSemFinder( KLaunchSemaphoreNameSearchString );
TFullName semaphoreResult;
ret = launchSemFinder.Next(semaphoreResult);
RDebug::Printf( "> Find Launch Semaphote.Next ret=%d, %lS", ret, &semaphoreResult );
test( ret == KErrNone );
ret = launchSemaphore.OpenGlobal( semaphoreResult );
RDebug::Printf( "> OpenGlobal semaphore ret=%d", ret );
test( ret == KErrNone );
TBool thisLaunchCompleted;
test.Next(_L("LaunchTargetsInOrderL\n"));
for( TInt numLaunches = KNumLaunches; numLaunches > 0; numLaunches-- )
{
for( TInt numApps = KNumApps; numApps > 0; numApps-- )
{
thisLaunchCompleted = EFalse;
// This will trigger the launcher app to launch the next target
RDebug::Printf( " >Semaphore.Signal app=%d, launch=%d", numApps, numLaunches);
launchSemaphore.Signal();
RBuf8 tgt8Name;
CleanupClosePushL( tgt8Name );
RBuf tgtCollapseName;
CleanupClosePushL( tgtCollapseName );
tgtCollapseName.CreateL( iTargets[numApps-1] );
tgt8Name.CreateL( tgtCollapseName.Collapse() );
while( ! thisLaunchCompleted )
{
RDebug::Printf( ">GetEvent app %d for %S", numApps, &tgt8Name );
iServSession.GetEvent( iTargets[numApps-1], iStatus, iEventPtr );
// Wait for the target to get started.
RDebug::Printf( " >Wait for event from target app=%d, launch=%d\n", numApps, numLaunches);
User::WaitForRequest( iStatus );
RDebug::Printf( " <Wait for request returned with status %d", iStatus.Int() );
test( iStatus==KErrNone );
RDebug::Printf( " > Got iEventType =%d, app=%d", iEventInfo.iEventType, numApps );
switch( iEventInfo.iEventType )
{
case EEventsAddProcess:
{
RDebug::Printf( "Got EEventsAddProcess" );
TPtrC8 exeNamePtr8( iEventInfo.iAddProcessInfo.iFileName, iEventInfo.iAddProcessInfo.iFileNameLength );
RBuf8 exeName8;
CleanupClosePushL( exeName8 );
exeName8.CreateL( exeNamePtr8 );
RDebug::Printf( " from event: exeName8=%S", &exeName8 );
CleanupStack::PopAndDestroy( &exeName8 );
RBuf8 compareName8;
CleanupClosePushL( compareName8 );
compareName8.CreateL( KTargetExeName().Length() + 10 );
compareName8.Format( KTargetExeName(), numApps );
RDebug::Printf( " comparing to: compareName8=%S", &compareName8 );
test( compareName8.CompareC( exeNamePtr8 ) == 0 );
CleanupStack::PopAndDestroy( &compareName8 );
RDebug::Printf( "Testing if event process id is valid" );
test( iEventInfo.iProcessIdValid );
RDebug::Printf( "Got iEventInfo.iProcessId=%d", I64LOW( iEventInfo.iProcessId ) );
RProcess targetProc;
ret = targetProc.Open( TProcessId( iEventInfo.iProcessId ) );
RDebug::Printf( "RProcess open ret=%d",ret );
targetProc.Close();
test( ret == KErrNone );
break;
}//EEventsAddProcess
case EEventsStartThread:
{
RDebug::Printf( "Got EEventsStartThread" );
TPtrC8 exeNamePtr8( iEventInfo.iStartThreadInfo.iFileName, iEventInfo.iStartThreadInfo.iFileNameLength );
RBuf8 exe8Name;
CleanupClosePushL( exe8Name );
exe8Name.CreateL( exeNamePtr8 );
RDebug::Printf( " from event: exeName8=%S", &exe8Name );
CleanupStack::PopAndDestroy( &exe8Name );
test( tgt8Name.CompareC( exeNamePtr8 ) == 0 );
RDebug::Printf( "Testing if event process id is valid" );
test( iEventInfo.iProcessIdValid );
RDebug::Printf( "Got iEventInfo.iProcessId=%d", I64LOW( iEventInfo.iProcessId ) );
RDebug::Printf( "Testing if event thread id is valid" );
test( iEventInfo.iThreadIdValid );
RDebug::Printf( "Got iEventInfo.iThreadId=%d", I64LOW( iEventInfo.iThreadId ) );
RThread targetThread;
CleanupClosePushL( targetThread );
ret = targetThread.Open( TThreadId( iEventInfo.iThreadId ) );
RDebug::Printf( "RThread open ret=%d", ret );
test( ret == KErrNone );
test( iEventInfo.iThreadId == targetThread.Id() );
RDebug::Printf( "Resuming thread for app=%d, id=%d", numApps, I64LOW( targetThread.Id() ));
ret = iServSession.ResumeThread( iEventInfo.iThreadId );
CleanupStack::PopAndDestroy( &targetThread );
test( ret == KErrNone );
ret = iServSession.ResumeThread( iEventInfo.iThreadId );
break;
}//case EEventsStartThread
case ( EEventsRemoveProcess ):
{
RDebug::Printf( "*** Got EEventsRemoveProcess. app%d has exited. Moving on to next app", numApps );
thisLaunchCompleted = ETrue;
break;
}
default :
RDebug::Printf( "Got unknown event" );
test( EFalse );
break;
}
}//while
CleanupStack::PopAndDestroy( &tgtCollapseName ); // tgtCollapseName
CleanupStack::PopAndDestroy( &tgt8Name ); // tgt8Name
}
}
launchSemaphore.Signal();
CleanupStack::PopAndDestroy( &launchSemaphore ); // launchSemaphore
for( TInt i = iTargets.Count()-1; i>=0; i-- )
{
RDebug::Printf( "Closing target %d", i );
iTargets[ i ].Close();
}
iTargets.Close();
return KErrNone;
}
