TBool CLbsRootApiTest22Step::CheckProcessIsRunning(const TDesC& aProcessNamePattern)
{
TInt err = KErrNone;
RProcess process;
TFullName fullName;
TFindProcess findProcess;
TBool runningInstanceFound = EFalse;
findProcess.Find(aProcessNamePattern);
while (err = findProcess.Next(fullName), err == KErrNone)
{
TInt processOpenErr = process.Open(findProcess);
if (processOpenErr == KErrNone)
{
TExitType exitType = process.ExitType();
if (exitType == EExitPending)
{
// found a running instance of the process,
// so assume everything is ok; return ETrue
runningInstanceFound = ETrue;
process.Close();
break;
}
}
process.Close();
}
return runningInstanceFound;
}
/**
Helper function to find and kill the specified process
*/
TInt CCmdTestSsmCommand::FindAndKill(const TDesC& aProcessName)
{
TFullName searchTerm(aProcessName);
StripExtension( searchTerm );
searchTerm += _L("*");
TFindProcess find(searchTerm);
TFullName name;
TInt instancesFound = 0;
while(find.Next(name) == KErrNone)
{
RProcess process;
const TInt err = process.Open(find);
if (KErrNone == err)
{
if (process.ExitType() == EExitPending)
{
instancesFound++;
process.Kill(KErrCancel);
process.Close();
INFO_PRINTF2(_L("Process %S found and killed"), &aProcessName);
}
process.Close();
}
}
return instancesFound;
}
void CLbsRootApiTest17Step::FinishLbsTestStep(TRequestStatus& aStatus,TBool& aFinished)
{
RProcess nrh;
RProcess agps;
RProcess ng;
TInt err;
err = nrh.Open(KNrhProcessName);
if(err)
{
SetTestStepResult(EFail);
}
err = agps.Open(KAgpsProcessName);
if(err)
{
SetTestStepResult(EFail);
nrh.Close();
}
err = ng.Open(KNgProcessName);
if(err)
{
SetTestStepResult(EFail);
nrh.Close();
agps.Close();
}
INFO_PRINTF1(_L("CLbsRootApiTest17Step : RequestSystemCloseDown"));
iLbsRootProcessApi.RequestSystemCloseDown(aStatus);
aFinished = ETrue;
}
void CLbsRootApiTest2Step::CheckProcessesAreUp()
{
RProcess process;
TInt err = process.Open(KNrhProcessName);
if(err)
{
INFO_PRINTF1(_L("CLbsRootApiTest2Step : ***ERROR - NRH not found"));
SetTestStepResult(EFail);
}
process.Close();
err = process.Open(KAgpsProcessName);
if(err)
{
INFO_PRINTF1(_L("CLbsRootApiTest2Step : ***ERROR - GPS LOC Manager not found"));
SetTestStepResult(EFail);
}
process.Close();
err = process.Open(KNgProcessName);
if(err)
{
INFO_PRINTF1(_L("CLbsRootApiTest2Step : ***ERROR - Network Gateway not found"));
SetTestStepResult(EFail);
}
process.Close();
}
//------------------------------------------------------------
// RCntParserServer::Connect()
//------------------------------------------------------------
EXPORT_C TInt RCntParserServer::Connect()
{
LOGGER_ENTERFN( "RCntParserServer::Connect()" );
TInt r = KErrNone;
if( iConnected == ECntParserNotConnected )
{
r = CreateSession( KCntParserName, Version(), KDefaultMessageSlots );
if(r==KErrNone)
{
iConnected=ECntParserConnected;
}
else
{
RProcess p;
TInt err = p.Create(KTxtServer, KNullDesC);
if ( err != KErrNone )
{
// Loading failed.
return err;
}
TRequestStatus status;
p.Rendezvous( status );
if( status != KRequestPending )
{
p.Kill(0); // abort startup
p.Close();
return KErrGeneral; // status can be KErrNone: don't return status.Int()
}
else
{
p.Resume(); // logon OK - start the server
}
User::WaitForRequest( status );
if( status != KErrNone )
{
p.Close();
return status.Int();
}
r = CreateSession( KCntParserName, Version() );
if( r == KErrNone )
{
iConnected = ECntParserConnected;
}
p.Close();
}
}
else
{
r = KErrCouldNotConnect;
}
LOGGER_WRITE_1( "RCntParserServer::Connect() : return %d", r );
return r;
}
TBool IsProcessRunning(const TDesC& aProcessName)
{
TFullName name;
TBool IsProcessRunning(EFalse);
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.
RDebug::Print(_L(":: Process name: \"%S\".\n"), &name);
continue;
}
}
RProcess proc;
if(proc.Open(name) == KErrNone)
{
if (EExitKill == proc.ExitType())
{
RDebug::Print(_L("\"%S\" process killed.\n"), &name);
proc.Close();
IsProcessRunning = EFalse;
}
else
{
IsProcessRunning = ETrue;
RDebug::Print(_L("\"%S\" process is running.\n"), &name);
}
if(IsProcessRunning)
{
RDebug::Print(_L("Waiting additional time...\n"), &name);
User::After(1000000);
if (EExitKill == proc.ExitType())
{
RDebug::Print(_L("\"%S\" process now killed.\n"), &name);
IsProcessRunning = EFalse;
}
proc.Close();
}
}
}
return IsProcessRunning;
}
// ---------------------------------------------------------
// RLbtServer::Connect
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
EXPORT_C TInt RLbtServer::Connect()
{
__ASSERT_ALWAYS(Handle() == 0, User::Panic(KLbtClientPanicCategory, ELbtServerHandleNotClosed));
TRAPD(ret, ConstructL());
if (ret == KErrNone)
{
ret = CreateSession(KLbtServerCoreName, Version(), KDefaultMessageSlots);
if( ret == KErrNotFound )
{
RProcess lbtServer;
ret = lbtServer.Create(KServerCoreProcessName, KNullDesC);
if( ret != KErrNone )
{
lbtServer.Close();
return ret;
}
TRequestStatus status;
lbtServer.Rendezvous(status);
if( status != KRequestPending )
{
User::WaitForRequest(status);
lbtServer.Kill(KErrNone);
lbtServer.Close();
return KErrNotFound;
}
else
{
lbtServer.Resume();
}
User::WaitForRequest(status);
lbtServer.Close();
ret = status.Int();
if( !( ret == KErrNone || ret == KErrAlreadyExists ) )
{
return ret;
}
ret = CreateSession(KLbtServerCoreName, Version(), KDefaultMessageSlots);
}
}
return ret;
}
static TInt StartDummyServer()
{
const TUidType serverUid(KNullUid, TUid::Uid(KSendAsServerExeUid));
TRequestStatus started( KRequestPending );
RProcess server;
TInt err = server.Create(KDummyServerExe, KNullDesC(), serverUid);
if( err != KErrNone )
{
return err;
}
TRequestStatus status;
server.Rendezvous(status);
if( status != KRequestPending )
{
server.Kill(0); // abort start-up
}
else
{
server.Resume(); // wait for server start-up.
}
User::WaitForRequest(status);
err = (server.ExitType() == EExitPanic ) ? KErrGeneral : status.Int();
server.Close();
return err;
}
//
// Starts the IntegrityServices Server in a new process
//
static TInt StartIntegrityServicesServer()
{
const TUidType serverUid(KExecutableImageUid, KNullUid, KIntegrityServicesServerUid3);
RProcess server;
TInt err = server.Create(KIntegrityServicesServerImage, KNullDesC);
if (err != KErrNone)
{
return err;
}
TRequestStatus stat;
server.Rendezvous(stat);
if (stat != KRequestPending)
{
server.Kill(0); // abort startup
}
else
{
server.Resume(); // logon OK, start the server
}
User::WaitForRequest(stat); // wait for start or death
// We can't use the 'exit reason' if the server panicked as this is the
// panic 'reason' and may be 0 which cannot be distinguished from KErrNone.
err = (server.ExitType() == EExitPanic) ? KErrGeneral : stat.Int();
server.Close();
return err;
}
TInt CCapabilityTestStep::StartServer()
{
TInt err = KErrNone ;
// EKA2 is simple No path required
TBuf<32> serverFile;
serverFile.Copy(_L("C32start"));
//serverFile.Copy(_L("PARAM_SVR_SUITENAME"));
_LIT(KExe,".exe");
serverFile.Append(KExe);
RProcess server;
err = server.Create(serverFile,_L(""));
if(err != KErrNone)
return err;
// Synchronise with the server
TRequestStatus reqStatus;
server.Rendezvous(reqStatus);
server.Resume();
//Server will call the reciprocal static synchronise call
User::WaitForRequest(reqStatus);
//server.Close();
if(reqStatus.Int() != KErrNone)
return reqStatus.Int();
server.Close();
return err;
}
//______________________________________________________________________________
// RConsoleProxy
static TInt StartServer(const TDesC& aServerName, const TDesC& aServerArgs)
{
TPtrC processName(aServerName);
if (processName.Length() && processName[0] == '!')
{
processName.Set(processName.Mid(1));
}
RProcess server;
TInt r = server.Create(processName, aServerArgs);
if (r!=KErrNone) return r;
TRequestStatus stat;
server.Rendezvous(stat);
if (stat != KRequestPending)
{
server.Kill(0);
}
else
{
server.Resume();
}
User::WaitForRequest(stat); // wait for start or death
r = (server.ExitType() == EExitPanic) ? KErrGeneral : stat.Int();
server.Close();
return r;
}
void QSfwTestUtil::removeDatabases_symbian()
{
#if defined(__WINS__) && !defined(SYMBIAN_EMULATOR_SUPPORTS_PERPROCESS_WSD)
QDir dir("C:/Data/temp/QtServiceFW");
#else
TFindServer findServer(_L("!qsfwdatabasemanagerserver"));
TFullName name;
if (findServer.Next(name) == KErrNone)
{
RProcess dbServer;
if (dbServer.Open(_L("qsfwdatabasemanagerserver")) == KErrNone)
{
dbServer.Kill(KErrNone);
dbServer.Close();
}
}
QDir dir("c:/private/2002AC7F");
#endif
QString qtVersion(qVersion());
qtVersion = qtVersion.left(qtVersion.size() - 2); //strip off patch version
QString dbIdentifier = "_system";
QString dbName = QString("QtServiceFramework_") + qtVersion + dbIdentifier + QLatin1String(".db");
QFile::remove(QDir::toNativeSeparators(dir.path() + QDir::separator() + dbName));
}
void CWsTop::SessionExited(CWsClient *aClient)
{
if (iShuttingDown)
{
RProcess proc;
TInt err=aClient->Client().Process(proc);
if (err==KErrNone && proc.Id()!=RProcess().Id())
proc.Kill(0);
else
const_cast<RThread&>(aClient->Client()).Kill(0);
if (err==KErrNone)
proc.Close();
}
else if (iHeapCheckMode!=EWsCheckHeapOnDisconnectModeNone && aClient==iTriggerHeapCheckOnClientExit)
{
if (iHeapCheckMode==EWsCheckHeapOnDisconnectModeOnce)
{
iHeapCheckMode=EWsCheckHeapOnDisconnectModeNone;
}
iTriggerHeapCheckOnClientExit=NULL;
iDoHeapCheckAndRestart=ETrue;
Exit();
}
if (iServer->SessionCount()==1 && iShellBootMode==EShellBootModeNoReboot && iShell==NULL)
StartShell();
}
TInt StartServer()
{
TRACE_STATIC_FUNC
const TUid KKBTHIDSrvUid3 =
{
BTHID_SRV_UID
};
const TUidType serverUid(KNullUid,KNullUid, KKBTHIDSrvUid3);
RProcess server;
TInt r = server.Create(KBTHidServerFilename, KNullDesC, serverUid);
if (r != KErrNone)
return r;
server.SetPriority(EPriorityHigh);
TRequestStatus stat;
server.Rendezvous(stat);
if (stat != KRequestPending)
{
server.Kill(0);
}
else
{
server.Resume();
}
User::WaitForRequest(stat);
TRACE_INFO((_L("[BTHID] Server started, code %d"), stat.Int()))
r = (server.ExitType() == EExitPanic) ? KErrGeneral : stat.Int();
server.Close();
return r;
}
/**
Start the server process. Simultaneous launching of two such processes should be detected when the second one attempts to
create the server object, failing with KErrAlreadyExists.
*/
static TInt StartServer()
{
const TUidType serverUid(KNullUid,KNullUid,KServerUid3);
RProcess server;
TInt r = server.Create(KTestServerImg,KNullDesC,serverUid);
if (r!=KErrNone)
{
return r;
}
TRequestStatus stat;
server.Rendezvous(stat);
if (stat!=KRequestPending)
{
server.Kill(0);
}
else
{
server.Resume();
}
// wait for start or death
User::WaitForRequest(stat);
server.Close();
return stat.Int();
}
/**
Start a test application asynchronously using wait-for-start.
A timeout is specified in order to instantiate the CTimeoutWaiter class
*/
void CSsTestStepAppStart::DoTestWaitForStartSyncL()
{
INFO_PRINTF1( _L("\n\nPerforming App-start Wait-for-start sync test") );
CSsmStartupProperties* startupProperties = CSsmStartupProperties::NewL();
CleanupStack::PushL( startupProperties );
startupProperties->SetFileParamsL( KTestAppGood, KNullDesC );
startupProperties->SetCommandTypeL( ESsmCmdStartApp );
startupProperties->SetExecutionBehaviour( ESsmWaitForSignal );
startupProperties->SetRetries( 3 );
startupProperties->SetTimeout( KSsTestAppStartTimeout );
RProcess process;
CSsmStartSafe* ss = CSsmStartSafe::NewLC();
CTestAndStopper* testAndStopper = new(ELeave) CTestAndStopper( *ss, *startupProperties, process, KFireAndForgetTimeout, this );
CleanupStack::PushL( testAndStopper );
CActiveScheduler::Start();
process.Close();
CleanupStack::PopAndDestroy( 3, startupProperties );
TEST( 1 == FindAndKill(KTestAppGood) );
}
// -----------------------------------------------------------------------------
// StartServer
// Static function to start the server process thread.
// Start the server process/thread which lives in an EPOCEXE object.
// Returns: TInt: KErrNone (0) if no error
// -----------------------------------------------------------------------------
//
static TInt StartServer()
{
const TUidType serverUid(KNullUid, KNullUid, KVoIPServerUid3);
// Only one instance of the server is allowed. Attempt of launching
// second instance of the server will fail with KErrAlreadyExists.
RProcess server;
TInt r = server.Create(KVoIPServerName, KNullDesC, serverUid);
if (r != KErrNone)
{
return r;
}
TRequestStatus stat;
server.Rendezvous(stat);
if (stat != KRequestPending)
{
server.Kill(0); // abort startup
}
else
{
server.Resume(); // logon OK - start the server
}
User::WaitForRequest(stat); // wait for start or death
// Panic reason cannot be '0' as it would conflict with KErrNone
r = (server.ExitType() == EExitPanic) ? KErrGeneral : stat.Int();
server.Close();
return r;
}
void HandleStart()
{
RDebug::Print(_L("TrkLauncher::HandleStart()"));
if (!IsAlreadyRunning())
{
TInt result;
RProcess p;
//start TrkConsole process
result = p.Create(KTrkConsoleExe, TPtr(NULL, 0), TUidType(KNullUid, KNullUid, KTrkConsoleExeUid));
if (result == KErrNone)
{
RDebug::Print(_L("TrkLauncher - Trk process resume"));
p.Resume();
RDebug::Print(_L("TrkLauncher - After Trk process resume"));
p.Close();
RDebug::Print(_L("TrkLauncher - After Trk process close"));
}
else
{
RDebug::Print(_L("TrkLauncher - Trk process not created with %d \n"),result);
RDebug::Print(_L("TrkLauncher - Returning without process creation"));
}
}
}
// ---------------------------------------------------------------------------
// start btnotif server from client.
// ---------------------------------------------------------------------------
//
TInt StartBTNotifSrv()
{
const TUidType serverUid( KNullUid, KNullUid, KBTNotifServerUid3 );
// Create a new server process. Simultaneous launching of two processes
// should be detected when the second one attempts to create the server
// object, failing with KErrAlreadyExists.
RProcess server;
TInt err = server.Create( KBTNotifServerName, KNullDesC, serverUid );
if( err != KErrNone )
{
return err;
}
TRequestStatus status;
server.Rendezvous( status );
if( status != KRequestPending )
{
server.Kill( KErrCancel ); // Abort startup
}
else
{
server.Resume();
}
User::WaitForRequest( status ); // Wait for start or death
err = status.Int();
if( server.ExitType() == EExitPanic )
{
// The server actually panicked; inform the client.
err = KErrDied;
}
server.Close();
return err;
}
void CSignalServer::RemoveSession()
{
iSessionCount--;
TInt lIdx = 0;
for(lIdx = 0; lIdx < iProcessHdlList.Count();)
{
TProcessId lPid(iProcessHdlList[lIdx].mPid);
RProcess lProcHdl;
if(lProcHdl.Open(lPid) != KErrNone)
{
iProcessHdlList[lIdx].mPipe.Close();
iProcessHdlList.Remove(lIdx);
}
else
{
lProcHdl.Close();
lIdx++;
}
}
if( iSessionCount == 0 )
{
iShutDown->Start();
}
}
TInt CSignalServer::CheckForCapability(const RMessage2& aMessage)
{
RThread lThread;
RProcess lProcess;
TInt lRetVal = KErrGeneral;
TInt lPid = aMessage.Int0();
TInt lSigNo = aMessage.Int1();
if(lSigNo != SIGKILL && lSigNo != SIGSTOP)
return KErrNone;
lRetVal = aMessage.Client(lThread);
if(lRetVal!= KErrNone)
return lRetVal;
lRetVal = lThread.Process(lProcess);
if(lRetVal!= KErrNone)
return lRetVal;
if(!lProcess.HasCapability(ECapabilityPowerMgmt) && lPid!=lProcess.Id())
lRetVal = KErrGeneral;
else
lRetVal = KErrNone;
lThread.Close();
lProcess.Close();
return lRetVal;
}
int InstallOperation::startJavaInstaller()
{
JELOG2(EDebugApi);
std::string args = java::runtime::JAVA_INSTALLER_STARTER_DLL;
args += " poll -address=debugapi";
std::auto_ptr<HBufC> cmdLine(stringToDes(args.c_str()));
std::auto_ptr<HBufC> exe(stringToDes(java::runtime::JAVA_PROCESS));
RProcess process;
int rc = process.Create(exe->Des(), cmdLine->Des());
if (KErrNone == rc)
{
// wait for JavaInstaller exit
TRequestStatus status;
process.Logon(status);
process.Resume();
User::WaitForRequest(status);
rc = status.Int();
process.Close();
}
LOG1(EDebugApi, EInfo,"javainstaller exit code: %d", rc);
return rc;
}
/*
-----------------------------------------------------------------------------
----------------------------------------------------------------------------
*/
TBool CTraceContainer::IsServerOn()
{
TBool Ret(EFalse);
TFileName res;
TFindProcess find;
while(find.Next(res) == KErrNone)
{
RProcess ph;
ph.Open(res);
if(ph.SecureId() == (TUint32)KUidTraceServerUID.iUid)
{
TExitType Exxit =ph.ExitType();
if(Exxit == EExitPending)
{
Ret = ETrue;
break;
}
}
ph.Close();
}
return Ret;
}
EXPORT_C void RPackagerTestClient::ConnectL()
/** Check and create server process if it is not already running,
then create a server session. Also constructs packager member. */
{
// Assume the server is already running and attempt to create a session
// 4 message slots
TInt err = CreateSession(KPackagerServerTestName,TVersion(1,1,1),4);
if(err == KErrNotFound)
{
// Server not running
// Use the RProcess API to start it.
RProcess server;
User::LeaveIfError(server.Create(KPackagerServerTestExe,KNullDesC));
// Synchronise with the server
TRequestStatus reqStatus;
server.Rendezvous(reqStatus);
// Start the test harness
server.Resume();
// Server will call the reciprocal static synchronise cal User::WaitForRequest(reqStatus);
User::WaitForRequest(reqStatus);
server.Close();
User::LeaveIfError(reqStatus.Int() != KErrNone);
// Create the root server session
User::LeaveIfError(CreateSession(KPackagerServerTestName,TVersion(0,0,0),4));
}
iPackager = CCntPackager::NewL();
}
// ---------------------------------------------------------------------------
// RPeninputServerImpl::StartThread
// Creates the server thread on WINS and server process on MARM.
// Access to the thread/process creation is controlled with
// a global mutex which allows only one client thread to do
// the actual server creation in WINS. In MARM the creation of
// new server exits with KErrAlreadyExits if another thread
// already created it.
// ---------------------------------------------------------------------------
//
TInt RPeninputServerImpl::StartThreadL()
{
if(iWaitScheduler)
return KErrLaunchingServer;
TInt ret = KErrNone;
// check if server already exists
TFindServer findPeninputServer( KPeninputServerName );
TFullName name;
if (findPeninputServer.Next( name ) == KErrNone)
{
// if server is already running return immediately
return KErrAlreadyExists;
}
// request status which gets signaled when server has been initialized
RProcess server;
User::LeaveIfError(server.Create(KPeninputServerExe,KNullDesC()));
TRequestStatus status;
//User::WaitForRequest(status);
iObserver = CPeninputServerObserver::NewL(this,
0);
server.Rendezvous(iObserver->RequestStatus());
server.Resume();
server.Close();
iWaitScheduler = CPeninputServerWaiter::NewL();
iWaitScheduler->Start();
ret = iWaitScheduler->Error();
return ret;
}
//This function is used in the test code to kill ECOMSERVER
//processes (or some other) when they leftover and may problem in ECOMSERVERTEST
static TInt KillProcess(const TDesC& aProcessName)
{
TFullName name;
RDebug::Print(_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.
RDebug::Print(_L(":: Process name: \"%S\".\n"), &name);
continue;
}
}
RProcess proc;
if(proc.Open(name) == KErrNone)
{
proc.Kill(0);
RDebug::Print(_L("\"%S\" process killed.\n"), &name);
}
proc.Close();
}
return KErrNone;
}
static void RunHelper(const TDesC& aFileToDelete, TInt aExpectedError)
/**
Invoke the helper executable, tell it to delete the supplied file.
@param aFileToDelete Name of file which helper executable should delete
with RLoader::Delete.
@param aExpectedError The expected return code from RLoader::Delete.
*/
{
TInt r;
// run the helper exe, which will try to delete the file with RLoader::Delete
RProcess ph;
r = ph.Create(_L("tld_helper_caps.exe"), aFileToDelete);
test(r == KErrNone);
TRequestStatus rsh;
ph.Logon(rsh);
test(rsh == KRequestPending);
ph.Resume();
User::WaitForRequest(rsh);
// process has died so check the panic category and reason match the expected values
test(ph.ExitType() == EExitPanic);
test(ph.ExitCategory() == KTldPanicCat);
test(ph.ExitReason() == aExpectedError);
ph.Close();
}
// ---------------------------------------------------------------------------
// StartServerL()
// Starts Fota Downlaod Interrupt Monitory server
// ---------------------------------------------------------------------------
TInt StartServerL()
{
FLOG(_L("StartServerLt Started"));
TInt res = KErrNone;
RProcess server;
RSemaphore sem;
res = sem.CreateGlobal(KFotaServerScem, EOwnerProcess);
res=server.Create(KFotaServerName,KNullDesC);
FLOG(_L("StartServerL-- create server error as %d"),res);
if (res!=KErrNone)
{
return res;
}
server.Resume(); // logon OK - start the server
sem.Wait();
sem.Close();
server.Close();
FLOG(_L("StartServerL-- server.ExitType() returns %d"),res);
return res;
}
/**
* Function used by RClassControllerClient::Connect member function.
* It exists to create a new process which contains the server side code.
*
* @return Value of error code created
*/
static TInt StartServer()
{
const TUidType serverUid(KNullUid, KNullUid, KObexCCUid);
RProcess server;
TInt err = server.Create(KServerExe, KNullDesC, serverUid);
if ( err != KErrNone )
{
return err;
}
TRequestStatus stat;
server.Rendezvous(stat);
if ( stat != KRequestPending )
{
server.Kill(0); // abort startup
}
else
{
server.Resume(); // logon OK - start the server
}
User::WaitForRequest(stat); // wait for start or death
// we can't use the 'exit reason' if the server paniced as this
// is the panic 'reason' and may be '0' which cannot be distinguished
// from KErrNone
err = (server.ExitType() == EExitPanic) ? KErrServerTerminated : stat.Int();
server.Close();
return err;
}
static TInt StartServer()
//
// Start the server process. Simultaneous launching
// of two such processes should be detected when the second one attempts to
// create the server object, failing with KErrAlreadyExists.
//
{
const TUidType serverUid(KNullUid,KNullUid,KServerUid3);
TInt r=KErrNone;
RProcess server;
r=server.Create(KTestServerImg,KNullDesC,serverUid);
if (r!=KErrNone)
return r;
TRequestStatus stat;
server.Rendezvous(stat);
if (stat!=KRequestPending)
server.Kill(0); // abort startup
else
server.Resume(); // logon OK - start the server
User::WaitForRequest(stat); // wait for start or death
server.Close();
return stat.Int();
}
