// ==========================================================================
// METHOD: Initialize
//
// DESIGN:
// ==========================================================================
TBool CDebugLogTlsData::Initialize()
{
TInt returnValue = ( iFs.Connect() == KErrNone );
if( returnValue )
{
// Request notification of directory adds/deletes in the logs directory.
iFs.NotifyChange( ENotifyDir, iStatus, KDebugLogsBaseDirectory );
SetActive();
// Dynamically create the name of the log files based on the application name
// and thread ID. This will eliminate multiple processes/thread usage of
// this debug logging infrastructure from scribbling each others traces.
RProcess thisProcess;
RThread thisThread;
// The file name is the process name followed by the thread ID.
TParsePtrC fileNameParser( thisProcess.FileName() );
iFileName.Copy( fileNameParser.Name() );
iFileName.Append( KUnderscore );
iFileName.Append( thisThread.Name() );
iFileName.Append( KDebugLogFileExt );
} // end if
return returnValue;
} // END Initialize
/**
* Load the initial contents of the setting items. By default,
* the setting items are populated with the default values from
* the design. You can override those values here.
* <p>
* Note: this call alone does not update the UI.
* LoadSettingsL() must be called afterwards.
*/
void CSymbian_ua_guiSettingItemList::LoadSettingValuesL()
{
// load values into iSettings
TFileName path;
TFileName pathWithoutDrive;
CEikonEnv::Static()->FsSession().PrivatePath( pathWithoutDrive );
// Extract drive letter into appDrive:
#ifdef __WINS__
path.Copy( _L("c:") );
#else
RProcess process;
path.Copy( process.FileName().Left(2) );
#endif
path.Append( pathWithoutDrive );
path.Append( KtxDicFileName );
TFindFile AufFolder(CCoeEnv::Static()->FsSession());
if(KErrNone == AufFolder.FindByDir(path, KNullDesC))
{
CDictionaryFileStore* MyDStore = CDictionaryFileStore::OpenLC(CCoeEnv::Static()->FsSession(),AufFolder.File(), TUid::Uid(1));
TUid FileUid;
FileUid.iUid = KRegistrar;
if(MyDStore->IsPresentL(FileUid))
{
RDictionaryReadStream in;
in.OpenLC(*MyDStore,FileUid);
in >> iSettings.Ed_registrar();
CleanupStack::PopAndDestroy(1);// in
}
static TDriveUnit exeDrive()
{
RProcess me;
TFileName processFileName = me.FileName();
TDriveUnit drive(processFileName);
return drive;
}
/**
* @brief Completes the second phase of Symbian object construction.
* Put initialization code that could leave here.
*/
void Csymbian_ua_guiAppUi::ConstructL()
{
// [[[ begin generated region: do not modify [Generated Contents]
BaseConstructL (EAknEnableSkin);
InitializeContainersL();
// ]]] end generated region [Generated Contents]
// Create private folder
RProcess process;
TFileName path;
path.Copy (process.FileName().Left (2));
if (path.Compare (_L ("c")) || path.Compare (_L ("C")))
CEikonEnv::Static()->FsSession().CreatePrivatePath (EDriveC);
else if (path.Compare (_L ("e")) || path.Compare (_L ("E")))
CEikonEnv::Static()->FsSession().CreatePrivatePath (EDriveE);
// Init PJSUA
if (symbian_ua_init() != 0) {
symbian_ua_destroy();
Exit();
}
ExecuteDlg_wait_initLD();
CTimer::ConstructL();
CActiveScheduler::Add (this);
After (4000000);
}
/*
Static factory constructor. Uses two phase construction and leaves nothing on the
CleanupStack. Creates a CTestPnP object.
@param None
@return Instance of the test server
*/
CTestPnP* CTestPnP::NewL()
{
CTestPnP * server = new (ELeave) CTestPnP();
CleanupStack::PushL(server);
// CServer base class call
RProcess handle = RProcess();
TParsePtrC serverName(handle.FileName());
server->ConstructL(serverName.Name());
CleanupStack::Pop(server);
return server;
}
void CListsStep::ListExecutables()
/**
* @return void
* This tests we can succesfully list the executables and that the returned values make sense
*/
{
INFO_PRINTF1(_L("Lists Test Suite: ListExecutables") );
if (TestStepResult()==EPass)
{
RExecutablePointerList execList;
TRAPD( err, iSess.GetExecutablesL( execList ) );
if(err != KErrNone)
{
SetTestStepResult(EFail);
INFO_PRINTF2(_L("Error %d from iSess.GetExecutablesL()/n"), err);
return;
}
if( execList.Count() == 0 )
{
SetTestStepResult(EFail);
INFO_PRINTF1(_L("Error : GetExecutablesL() returned empty list/n") );
return;
}
else
{
RProcess thisProc;
TInt i;
for( i=0; i < execList.Count(); i++ )
{
if( execList[i]->Name() == thisProc.FileName() )
{
break;
}
}
if( i == execList.Count() )
{
SetTestStepResult(EFail);
INFO_PRINTF1(_L("Error : This executable could not be found in GetExecutablesL() list/n") );
return;
}
}
execList.ResetAndDestroy();
execList.Close();
}
}
/**
Same code for Secure and non-secure variants
Called inside the MainL() function to create and start the
CTestServer derived server.
@return - Instance of the test server
*/
CTe_graphicsperformanceSuite* CTe_graphicsperformanceSuite::NewL()
{
CTe_graphicsperformanceSuite * server = new (ELeave) CTe_graphicsperformanceSuite();
CleanupStack::PushL(server);
// Get server name from process so we can use SetCap to change the capabilites and use this server with a different filename
RProcess handle = RProcess();
TParsePtrC serverName(handle.FileName());
server->ConstructL(serverName.Name());
CleanupStack::Pop(server);
return server;
}
~QSymbianPrintExitInfo()
{
RProcess myProc;
TFullName fullName = myProc.FileName();
TInt cells = User::CountAllocCells();
TInt processHandleCount=0;
TInt threadHandleCount=0;
RThread().HandleCount(processHandleCount, threadHandleCount);
RDebug::Print(_L("%S exiting with %d allocated cells, %d handles"),
&fullName,
cells - initCells,
(processHandleCount + threadHandleCount) - (initProcessHandleCount + initThreadHandleCount));
}
CcapsignalTestServer* CcapsignalTestServer::NewL()
{
CcapsignalTestServer *server = new(ELeave) CcapsignalTestServer();
CleanupStack::PushL(server);
//server->ConstructL(KServerName);
RProcess handle = RProcess();
TParsePtrC serverName(handle.FileName());
server->StartL(serverName.Name());
CleanupStack::Pop(server);
return server;
}
TVerdict CAppFwkStartSafeTestStepAppTimeout::doTestStepL( void )
{
CStartSafe *startSafe = CStartSafe::NewL();
CleanupStack::PushL( startSafe );
CStartupProperties *prop = CStartupProperties::NewL();
CleanupStack::PushL( prop );
RProcess proc;
CleanupClosePushL( proc );
prop->SetFileParamsL( KTestAppSlow, KNullDesC );
prop->SetStartupType( EStartApp );
prop->SetStartMethod( EWaitForStart );
prop->SetNoOfRetries( 0 );
prop->SetTimeout( KWaitTime );
TInt tried = 0;
INFO_PRINTF2( _L("Start the app and wait for %d milliseconds"), KWaitTime );
TRAPD( err, startSafe->StartL(*prop, proc, tried) );
if ( KErrTimedOut == err )
{
SetTestStepResult( EPass );
INFO_PRINTF1( _L("Timed out - Test passed") );
}
else
{
SetTestStepResult( EFail );
ERR_PRINTF1( _L("No time-out - Test failed") );
TPtrC procNamePtr = proc.FileName().Right( KTestAppSlow().Length() );
// Check that the process is the app we think it is.
if( 0 == procNamePtr.Compare( KTestAppSlow()) )
{
proc.Kill( KErrNone );
}
}
CleanupStack::PopAndDestroy( 3, startSafe );
return TestStepResult();
}
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();
}
CSimTestServer* CSimTestServer::NewL()
/**
* @return - Instance of the test server
* Same code for Secure and non-secure variants
* Called inside the MainL() function to create and start the
* CTestServer derived server.
*/
{
CSimTestServer * testServer = new (ELeave) CSimTestServer();
CleanupStack::PushL(testServer);
RProcess handle = RProcess();
TParsePtrC serverName(handle.FileName());
testServer->ConstructL(serverName.Name());
CleanupStack::Pop(testServer);
return testServer;
}
CTestHtmlToCrtConverterSuite* CTestHtmlToCrtConverterSuite::NewL()
/**
* @return - Instance of the test server
* Same code for Secure and non-secure variants
* Called inside the MainL() function to create and start the
* CTestServer derived server.
*/
{
CTestHtmlToCrtConverterSuite * server = new (ELeave) CTestHtmlToCrtConverterSuite();
CleanupStack::PushL(server);
// CServer base class call
RProcess handle = RProcess();
TParsePtrC serverName(handle.FileName());
server->ConstructL(serverName.Name());
CleanupStack::Pop(server);
return server;
}
void CCommandLineArguments::ConstructL()
{
// allocate args array
iArgs=new (ELeave) CArrayFixFlat<TPtrC> (10);
RProcess me;
// get raw command line
User::CommandLine(iCommandLine);
iFileName=me.FileName();
// scan for each argument
TText* out=(TText*) iCommandLine.Ptr();
const TText* scan=iCommandLine.Ptr();
const TText* end=scan+iCommandLine.Length();
while (scan < end) // scan one argument
{
while (scan < end && *scan==' ') // skip leading space
scan++;
if (scan == end) // ignore if blank
break;
TBool quoted=*scan=='\"'; // note leading quote
if (quoted)
scan++;
TText* start=out; // note start in output
if (!quoted) // if not quoted, scan for blank
{
while (scan < end && *scan!=' ')
*out++ = *scan++;
}
else // quoted, scan for quote
{
for (;;) // one quote-or-double sequence
{
while (scan < end && *scan!='\"') // all up to quote
*out++ = *scan++;
if (scan < end) // skip quote
scan++;
if (scan < end && *scan=='\"') // transfer if quote is doubled
*out++ = *scan++;
else // finished this arg
break;
}
}
TPtrC arg(start, out-start);
iArgs->AppendL(arg);
}
}
LOCAL_C void OverrideEShell(void)
//
// Copies the executable file as the eshell so that it is automatically run
//
{
test.Next(_L("OverideEShell"));
RProcess myProc;
if (myProc.FileName().CompareF(StartupExeName) == 0)
test.Printf(_L("OverrideEShell: running as eshell\n"));
else
{
RFile logFile;
TInt r;
TFileName tempDirName=_L("");
// Copy over this executable and create a progress file.
test.Printf(_L("Copying %S to %S\n"), &TestExeName, &StartupExeName);
if(PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin))
tempDirName = _L("?:\\SYS\\BIN\\");
else
tempDirName = _L("?:\\SYSTEM\\BIN\\");
tempDirName[0] = gSessionPath[0];
r=TheFs.MkDirAll(tempDirName);
test_Value(r, r == KErrNone||r==KErrAlreadyExists);
CFileMan* fileMan=NULL;
TRAP(r,fileMan = CFileMan::NewL(TheFs));
test_KErrNone(r);
//Copy the test from Z drive.
TFileName temp=_L("Z:\\SYS\\BIN\\T_SCN32DR3.EXE");
r = fileMan->Copy(temp, TestExeName, CFileMan::EOverWrite);
test_KErrNone(r);
r = fileMan->Copy(TestExeName, StartupExeName, CFileMan::EOverWrite);
test_KErrNone(r);
//Mask read attribute. Fix for DEF081323
r = fileMan->Attribs(StartupExeName, 0, KEntryAttReadOnly, 0);
test_KErrNone(r);
r = fileMan->Attribs(TestExeName, 0, KEntryAttReadOnly, 0);
test_KErrNone(r);
r = logFile.Replace(TheFs,LogFileName,EFileShareExclusive|EFileWrite);
test_KErrNone(r);
logFile.Close();
delete fileMan;
}
}
CTFntStoreServer* CTFntStoreServer::NewL()
/**
@return - Instance of the test server
Same code for Secure and non-secure variants
Called inside the MainL() function to create and start the
CTestServer derived server.
*/
{
CTFntStoreServer * server = new (ELeave) CTFntStoreServer();
CleanupStack::PushL(server);
// Get server name from process so we can use SetCap to change the capabilites and use this server with a different filename
RProcess handle = RProcess();
TParsePtrC serverName(handle.FileName());
// CServer base class call
server->StartL(serverName.Name());
CleanupStack::Pop(server);
return server;
}
/*
-----------------------------------------------------------------------------
----------------------------------------------------------------------------
*/
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;
}
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);
}
}
void CIAUpdateXmlParser::SetPrivateDriveL(
RFs& aFs,
const TDesC& aFileName ) const
{
IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateXmlParser::SetPrivateDriveL() begin: %S",
&aFileName);
// This will set the correct drive and private path
// for the file server session.
// First try to find the file from the private directory
// of the drive where the process exists.
RProcess process;
// Set the session private path according to
// the process file name drive.
TInt driveNum(
SetSessionPrivatePathL( aFs, process.FileName() ) );
// Get the session path that was set above.
IAUPDATE_TRACE_1("[IAUPDATE] Find file: %d", driveNum);
TFileName sessionPath;
User::LeaveIfError( aFs.SessionPath( sessionPath ) );
IAUPDATE_TRACE_1("[IAUPDATE] Session path: %S", &sessionPath);
// Use the file finder to check if the file actually exists
// in the given drive path. If it does not, the file finder
// will automatically check from other drives. So, here we
// should always find the file if any exists.
TFindFile finder( aFs );
User::LeaveIfError( finder.FindByDir( aFileName, sessionPath ) );
// The drive may have changed if the file was not found from
// the first suggested drive. So, be sure to have the correct
// private path.
driveNum = SetSessionPrivatePathL( aFs, finder.File() );
// Use the drive info to check if the drive is ROM drive.
// We prefer non ROM drives. But, accept ROM if nothing else is
// available.
IAUPDATE_TRACE_1("[IAUPDATE] Check ROM info: %d", driveNum);
TDriveInfo info;
User::LeaveIfError( aFs.Drive( info, driveNum ) );
TBool isRomDrive( info.iDriveAtt & KDriveAttRom );
if ( !isRomDrive )
{
// The current file is not in ROM drive so use that.
IAUPDATE_TRACE("[IAUPDATE] First file search done. Non ROM found.");
IAUPDATE_TRACE("[IAUPDATE] CIAUpdateXmlParser::SetPrivateDriveL() end");
return;
}
// Because previous finding was ROM file, try to find a non ROM file.
IAUPDATE_TRACE("[IAUPDATE] Try to find non ROM file.");
TInt findErrorCode( finder.Find() );
if ( findErrorCode == KErrNotFound )
{
// Because no new file is found, use the current settings.
IAUPDATE_TRACE("[IAUPDATE] Second search done. No file found.");
IAUPDATE_TRACE("[IAUPDATE] CIAUpdateXmlParser::SetPrivateDriveL() end");
return;
}
User::LeaveIfError( findErrorCode );
IAUPDATE_TRACE("[IAUPDATE] New file found. Use that.");
// Update the session path for the correct file.
SetSessionPrivatePathL( aFs, finder.File() );
IAUPDATE_TRACE("[IAUPDATE] CIAUpdateXmlParser::SetPrivateDriveL() end");
}
TVerdict CAppFwkStartSafeTestStepAppStartRvError::doTestStepL()
{
TInt threadHandles_Before;
TInt processHandles_Before;
TInt threadHandles_After;
TInt processHandles_After;
RThread().HandleCount(processHandles_Before, threadHandles_Before);
CStartSafe *startSafe = CStartSafe::NewL();
CleanupStack::PushL( startSafe );
CStartupProperties *prop = CStartupProperties::NewL();
CleanupStack::PushL( prop );
RProcess proc;
CleanupClosePushL( proc );
prop->SetFileParamsL( KTestAppRvError, KNullDesC );
prop->SetStartupType( EStartApp );
prop->SetStartMethod( EWaitForStart );
prop->SetNoOfRetries( KStartSafeAppStartRvErrorRetries );
prop->SetTimeout( KStartSafeAppStartErrorNominalTimeout );
TInt tried = 0;
INFO_PRINTF1( _L("Start the Test Application") );
TRAPD( err, startSafe->StartL(*prop, proc, tried) );
// Ensure that the process-name of the test-app is not extant.
TPtrC procNamePtr = proc.FileName().Right( KTestAppRvError().Length() );
TInt nameComparison = procNamePtr.Compare( KTestAppRvError() );
if ( (0 == nameComparison) )
{
ERR_PRINTF2( _L("Application whose process-name is\"%S\" was found, but should not have been"), &procNamePtr );
// Dispose of the erroneously extant test-app.
proc.Kill( KErrNone );
SetTestStepResult( EFail );
ERR_PRINTF1( _L("Test failed") );
}
else if( (KStartSafeAppStartRvErrorRetries +1) != tried )
{
ERR_PRINTF1( _L("Process-name (correctly) not found, but...") );
ERR_PRINTF3( _L("Total tries = %d should have been %d"), tried, (KStartSafeAppStartRvErrorRetries +1) );
SetTestStepResult( EFail );
}
else
{
INFO_PRINTF1( _L("Process was (correctly) not found") );
INFO_PRINTF2( _L("Error code %d"), err );
// The 'erroneous' rendezvous code
TESTE( KErrGeneral, err );
}
CleanupStack::PopAndDestroy( 3, startSafe );
RThread().HandleCount(processHandles_After, threadHandles_After);
TEST(processHandles_After == processHandles_Before);
TEST(threadHandles_After == threadHandles_Before);
return TestStepResult();
}
void CTWServScreenConstructServer::ConstructL()
{
RProcess handle = RProcess();
TParsePtrC serverName(handle.FileName());
CTestServer::ConstructL(serverName.Name());
}
//
// 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
}
void CT_WServRateLimiterTestServer::ConstructL()
{
RProcess handle = RProcess();
TParsePtrC serverName(handle.FileName());
CTestServer::ConstructL(serverName.Name());
}
TVerdict CAppFwkStartSafeTestStepAppStartAppArcInit::doTestStepL( void )
{
CStartSafe* startSafe = CStartSafe::NewL();
CleanupStack::PushL( startSafe );
CStartupProperties* prop = CStartupProperties::NewL();
CleanupStack::PushL( prop );
RProcess proc;
CleanupClosePushL( proc );
prop->SetFileParamsL( KTestAppGood, KNullDesC );
prop->SetStartupType( EStartApp );
prop->SetStartMethod( EDeferredWaitForStart );
TRequestStatus startupTRS;
TRequestStatus apparcSessionTRS;
INFO_PRINTF1(_L("Starting the Test-App process asynchronously"));
startSafe->StartL( *prop, proc, startupTRS );
User::WaitForRequest( startupTRS );
INFO_PRINTF2( _L("Rendezvous completed with %d"), startupTRS.Int() );
// StartL should have left if it was unsuccessful,
// but ensure that the process's name is that of the test-app.
TPtrC procNamePtr = proc.FileName().Right( KTestAppGood().Length() );
TInt nameComparison = procNamePtr.Compare( KTestAppGood() );
if( 0 == nameComparison )
{
INFO_PRINTF2( _L("Application \"%S\" started correctly"), &procNamePtr );
}
else
{
ERR_PRINTF1( _L("Application-start unsuccessful. Test not completed") );
SetTestStepResult( EFail );
return TestStepResult();
}
startSafe->InitAppArcServer( apparcSessionTRS ); // try to initiate apparc, to see if that causes any problems
User::WaitForRequest( apparcSessionTRS );
if ( ( startupTRS == KErrNone) && ( apparcSessionTRS == KErrNone) )
{
SetTestStepResult( EPass );
INFO_PRINTF1( _L("Test passed") );
// Dispose of the test-app
proc.Kill( KErrNone );
}
else
{
SetTestStepResult( EFail );
ERR_PRINTF3( _L("Test failed.startupTRS = %d apparcSessionTRS = %d "), startupTRS.Int(), apparcSessionTRS.Int() );
}
CleanupStack::PopAndDestroy( 3, startSafe );
return TestStepResult();
}
// ----------------------------------------------------------------------------------------
// 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;
}
// ----------------------------------------------------------------------------------------
// 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() <<<");
}
