void CTestCalInterimApiInstanceSuiteServer::StartAlarmAlertServer()
{
// Start the Alarm Server
TBuf<256> buffer;
buffer.Append('p');
buffer.Append('p');
buffer.Append(EKeyEscape);
RProcess alarmServer;
// Create the Connection to the alarm alert server
alarmServer.Create(KConsoleAlarmAlertServerImg, buffer, serverUid);
TRequestStatus stat;
alarmServer.Rendezvous(stat);
if (stat != KRequestPending)
{
alarmServer.Kill(0);
}
else
{
alarmServer.Resume();
}
User::WaitForRequest(stat);
TInt result = stat.Int();
if(result != KErrNone && result != KErrAlreadyExists)
{
User::LeaveIfError(result);
}
}
/**
Launch a process
@param aProcess The RProcess object to use to create the process
@param aExeName File name of the executable to create the process from
@param aCommandLine The command line to pass to the new process
@return KErrNone on success, or one of the other system wide error codes
*/
TInt CMultiTargetAgent::LaunchProcess(RProcess& aProcess, TDesC & aExeName, TDesC & aCommandLine )
{
TInt err = aProcess.Create( aExeName, aCommandLine );
if(err != KErrNone)
{
RDebug::Printf( "aProcess.Create ret %d", err);
return err;
}
TRequestStatus status = KRequestPending;
aProcess.Rendezvous(status);
if(KRequestPending != status.Int())
{
// startup failed so kill the process
aProcess.Kill(KErrNone);
return status.Int();
}
else
{
// start up succeeded so resume the process
aProcess.Resume();
// Give the process a chance to run
User::After( 500000 );
return KErrNone;
}
}
// ---------------------------------------------------------------------------
// 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;
}
/**
* 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;
}
// -----------------------------------------------------------------------------
// CreateServerProcess
// Static function to create the server process.
// -----------------------------------------------------------------------------
//
static TInt CreateServerProcess()
{
TInt err( KErrNone );
RProcess server;
err = server.Create( KSnsrDispCtrlSrvName, KNullDesC, EOwnerThread );
if ( !err )
{
TRequestStatus status;
server.Rendezvous( status );
if ( status != KRequestPending )
{
server.Kill( 0 ); // Abort startup.
}
else
{
server.Resume(); // Logon OK - start the server.
}
User::WaitForRequest( status ); // 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
: status.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();
}
// -----------------------------------------------------------------------------
// StartServer
// Static method to start the server.
// 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( TUid aUid3, const TDesC& aFileName )
{
const TUidType serverUid( KNullUid, KNullUid, aUid3 );
RProcess server;
TInt r = server.Create( aFileName, 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
// 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
r = (server.ExitType() == EExitPanic) ? KErrGeneral : stat.Int();
server.Close();
return r;
}
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();
}
EXPORT_C TInt RFTokenClient::Connect()
{
TInt err = KErrNone;
TFindServer serveFinder(FTOKEN_SERVER_NAME);
TFullName fullName;
if (serveFinder.Next(fullName) != KErrNone)
{
const TUidType serverUid(KNullUid,KNullUid,KServerUid3);
RProcess server;
err = server.Create(_L("Z:\\sys\\bin\\!ftokenserver.exe"),FTOKEN_SERVER_NAME,serverUid);
if (!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
err = stat.Int();
}
}
if ( !err )
{
err = CreateSession(FTOKEN_SERVER_NAME,TVersion(1,1,1));
}
return err;
}
/**
Launch a process
@param aExeName the executable used to create the process
@param aCommandLine the commandline parameters passed to the new process file name of the executable used to create the process
@return KErrNone on success, or one of the other system wide error codes
*/
TInt CRunModeAgent::LaunchProcessL( RProcess& aProcess, const TDesC& aExeName, const TDesC& aCommandLine )
{
LOG_ENTRY();
RBuf launcherOptions;
launcherOptions.CleanupClosePushL();
const TInt additionalWords = 1;
launcherOptions.CreateL( aCommandLine.Length() + additionalWords );
launcherOptions.Format( aCommandLine, iParams.iTestTargetPriority);
LOG_DES(_L("launcherOptions %S"), &launcherOptions);
TInt err = aProcess.Create( aExeName, launcherOptions );
CleanupStack::PopAndDestroy();
// check that there was no error raised
if (err != KErrNone)
return err;
// rendezvous with process
TRequestStatus status = KRequestPending;
aProcess.Rendezvous(status);
// start the test target
aProcess.Resume();
User::WaitForRequest(status);
if(KErrNone != status.Int())
{
aProcess.Kill(KErrNone);
}
LOG_EXIT();
return status.Int();
}
TInt LaunchServer(RProcess& aServer)
{
TheTest.Printf(_L("Launching LogServer...\n"));
const TUid KServerUid3 = {0x0101f401d};
const TUidType serverUid(KNullUid,KNullUid,KServerUid3);
TInt err = aServer.Create(KServerProcess, _L(""),serverUid);
if(err == KErrNone)
{
aServer.SetPriority(EPriorityForeground);
//Start server and wait until it is running
TRequestStatus serverStat;
aServer.SetJustInTime(false);
aServer.Resume();
aServer.Rendezvous(serverStat);
User::WaitForRequest(serverStat);
}
return err;
}
// ----------------------------------------------------
// CPresenceCacheClient::StartServer
//
// ----------------------------------------------------
//
TInt CPresenceCacheClient::StartServer()
{
TInt result;
TRequestStatus status = KRequestPending;
TFindServer findCacheServer( NName::KSymbianServer );
TFullName name;
result = findCacheServer.Next( name );
if ( result == KErrNone )
{
// Server already running
return KErrNone;
}
RProcess server;
result = server.Create( NName::KExecutable, KNullDesC );
if( result != KErrNone )
return result;
server.Rendezvous( status );
status != KRequestPending ? server.Kill( 0 ) : server.Resume();
//Wait for start or death
User::WaitForRequest( status );
result = server.ExitType() == EExitPanic ? KErrGeneral : status.Int();
server.Close();
return result;
}
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;
}
// ---------------------------------------------------------------------------
// 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;
}
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;
}
/**
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();
}
// -----------------------------------------------------------------------------
// 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;
}
// -----------------------------------------------------------------------------
// RPsmServer::StartServer
// Starts server.
// -----------------------------------------------------------------------------
//
TInt RPsmServer::StartServer() const
{
COMPONENT_TRACE( ( _L( "PSM Client - RPsmServer::StartServer()" ) ) );
RProcess server;
const TUidType serverUid( KNullUid, KPsmServerUid2, KNullUid );
TInt err = server.Create( ServerLocation(), // psmserver.exe
KNullDesC, // A descriptor containing data passed as
// an argument to the thread function of
// the new process's main thread, when it
// is first scheduled.
serverUid, // PSM server UID
EOwnerProcess ); // Ownership of this process handle
// Return error code if we couldn't create a process
if ( err == KErrNone )
{
// Rendezvous is used to detect server start
TRequestStatus stat;
server.Rendezvous( stat );
if ( stat != KRequestPending )
{
ERROR_TRACE( ( _L( "PSM Client - RPsmServer::StartServer - ERROR: Rendezvous failure: %d" ), stat.Int() ) );
server.Kill( 0 ); // Abort startup
}
else
{
server.Resume(); // Logon OK - start the server
}
COMPONENT_TRACE( ( _L( "PSM Client - RPsmServer::StartServer - Waiting server startup" ) ) );
User::WaitForRequest( stat ); // Wait for start or death
COMPONENT_TRACE( ( _L( "PSM Client - RPsmServer::StartServer - Server startup wait finished" ) ) );
// 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
if ( server.ExitType() == EExitPanic )
{
ERROR_TRACE( ( _L( "PSM Client - RPsmServer::StartServer - ERROR: Server paniced at startup" ) ) );
err = KErrGeneral;
}
else
{
err = stat.Int();
}
// We can close the handle now
server.Close();
}
COMPONENT_TRACE( ( _L( "PSM Client - RPsmServer::StartServer - return %d" ), err ) );
return err;
}
//------------------------------------------------------------
// 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;
}
// Secure variants much simpler
// For EKA2, just an E32Main and a MainL()
LOCAL_C void MainL()
/**
* Secure variant
* Much simpler, uses the new Rendezvous() call to sync with the client
*/
{
CActiveScheduler* sched=NULL;
sched=new(ELeave) CActiveScheduler;
CActiveScheduler::Install(sched);
CTestCITAlarmServerSuite* server = NULL;
// Create the CTestServer derived server
TRAPD(err,server = CTestCITAlarmServerSuite::NewL());
if(!err)
{
RProcess::Rendezvous(KErrNone);
#ifdef __WINS__
// Automated hardware testing is run on a Techview image,
// but automated emulator testing is run in TEXTSHELL
// mode. Connecting to the alarm server without an alert server
// running will fail, so it is necessary to start the console
// alarm alert server in TEXTSHELL mode, as the 'real' alert server
// is started by Techview.
// Start console alarm alert server so it does not
// acknowledge, alarms...
RProcess consoleAlertServer;
_LIT(KConsoleAlarmAlertServerImg,"ConsoleAlarmAlertServer");
const TUid KServerUid2={0x1000008D};
const TUid KServerUid3={0x101F502A};
const TUidType KServerUid(KNullUid,KServerUid2,KServerUid3);
consoleAlertServer.Create(KConsoleAlarmAlertServerImg, KNullDesC(), KServerUid);
TRequestStatus stat;
consoleAlertServer.Rendezvous(stat);
if (stat != KRequestPending)
{
consoleAlertServer.Kill(0);
}
else
{
consoleAlertServer.Resume();
}
User::WaitForRequest(stat);
TInt result = stat.Int();
if(result != KErrNone && result != KErrAlreadyExists)
{
User::LeaveIfError(result);
}
#endif //WINS
sched->Start();
}
delete server;
delete sched;
}
LOCAL_C void mainL()
{
CCommandLineArguments* cmdLine = CCommandLineArguments::NewLC();
CConsoleBase* console = Console::NewL(_L("Siftestintegrationlockfile"),TSize(KConsFullScreen,KConsFullScreen));
CleanupStack::PushL(console);
TInt argTotal(cmdLine->Count());
if (argTotal < 2 || argTotal > 3)
{
console->Printf(_L("Incorrect arguments specified: expected 1, received %d"), argTotal - 1);
User::Leave(KErrArgument);
}
TPtrC filename(cmdLine->Arg(1));
_LIT(KDoLockFileParam, " lockfile");
if (argTotal == 2)
{
RBuf params;
params.CreateL(filename.Length() + KDoLockFileParam().Length());
params.CleanupClosePushL();
params.Append(cmdLine->Arg(1));
params.Append(KDoLockFileParam());
// Since this executable is used by TEF, we wish to lock the file after the launched process has exited, so we spawn this process again with a different set of parameters
RProcess newInstance;
User::LeaveIfError(newInstance.Create(_L("Siftestintegrationlockfile"), params));
CleanupClosePushL(newInstance);
newInstance.Resume();
TRequestStatus status;
newInstance.Rendezvous(status);
User::WaitForRequest(status);
User::LeaveIfError(status.Int());
CleanupStack::PopAndDestroy(2, ¶ms); // newInstance
}
else
{
// This is the execution for locking the file, invoked using the branch above
console->Printf(_L("Locking file %S for read"), &filename);
RFs fs;
User::LeaveIfError(fs.Connect());
CleanupClosePushL(fs);
RFile file;
User::LeaveIfError(file.Open(fs, filename, EFileShareReadersOnly|EFileRead));
CleanupClosePushL(file);
// Signal the invoker only here, so that the file will definitely get locked before TEF proceeds to the next step
RProcess::Rendezvous(KErrNone);
User::After(10*1000*1000); // Wait for 10 seconds
CleanupStack::PopAndDestroy(2 , &fs); // file
}
CleanupStack::PopAndDestroy(2, cmdLine); // console,
}
EXPORT_C TInt RUpsTestServ::Connect(const TDesC& aServerName, TBool aDebugMode)
/**
* @param aServerName - Human readable name of the test server
* @param aDebugMode - Set to true for just in time debugging
* @return int - Standard error codes
* Secure version of the API call. Expects the server binary to be
* ServerXXX.exe
*/
{
if(aServerName.Length() > iServerName.MaxLength())
return KErrTooBig;
iServerName = aServerName;
// Assume the server is already running and attempt to create a session
// 4 message slots
TInt err = CreateSession(aServerName,Version(),-1);
if(err == KErrNotFound || err == KErrServerTerminated)
{
// Server not running
// Construct the server binary name
TBuf<KMaxTestExecuteNameLength> serverFile;
RProcess server;
_LIT(KEmpty,"");
_LIT(KExe,".exe");
serverFile.Copy(aServerName);
serverFile.Append(KExe);
err = server.Create(serverFile,KEmpty);
if(err != KErrNone)
return err;
// Synchronise with the server
TRequestStatus reqStatus;
server.Rendezvous(reqStatus);
// Set just in time debugging for the process
if(aDebugMode)
server.SetJustInTime(ETrue);
else
server.SetJustInTime(EFalse);
// Start the test harness
server.Resume();
// Server will call the reciprocal static synchronise call
User::WaitForRequest(reqStatus);
server.Close();
if(reqStatus.Int() != KErrNone)
return reqStatus.Int();
// Create the root server session
err = CreateSession(aServerName,Version(),-1);
}
return err;
}
// ---------------------------------------------------------
// 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;
}
TInt RLbsLocMonitorSession::StartServer()
{
TRequestStatus started;
started = KRequestPending;
#ifdef _DEBUG
RDebug::Print(_L("EPos: LocMonitor API: Starting <Test> Location Monitor Server..."));
#endif
//const TUid KLocMonServerUid2 = { 0x1000009B };
const TUidType serverUid(KNullUid, KNullUid, KLocMonServerUid3);
// Simultaneous launching of two such processes should be detected
// when the second one attempts to create the server object,
// failing with KErrAlreadyExists.
//
RProcess server;
TInt ret = server.Create(KLocMonServerName, KNullDesC, serverUid);
if (ret != KErrNone)
{
#ifdef _DEBUG
RDebug::Print(_L("EPos: LocMonitor API: server start failed %d"), ret);
#endif
return ret;
}
TRequestStatus died;
server.Rendezvous(died);
if (died != KRequestPending)
{
// logon failed - server is not yet running, so cannot have terminated
User::WaitForRequest(died); // eat signal
server.Kill(0); // abort startup
}
else
{
server.Resume();
User::WaitForRequest(died); // 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
ret = (server.ExitType() == EExitPanic) ? KErrGeneral : died.Int();
server.Close();
return ret;
}
/**
* Runs the featreg_maketestconfig.exe, waiting for completion.
* @return KErrNone on success, or negative error code, or positive panic code if exe process panicked.
*/
TInt CTe_FeatReg_StepBase::RunMakeTestConfig(const TDesC& aConfigName)
{
TRequestStatus runStatus;
RProcess setupProc;
TInt result = setupProc.Create(KFeatRegMakeTestConfigExe, aConfigName);
if (result != KErrNone)
{
return result;
}
setupProc.Resume();
setupProc.Rendezvous(runStatus);
User::WaitForRequest(runStatus);
setupProc.Close();
return runStatus.Int();
}
/*
*
* Run the Host FS starter program
*
*/
void TSyborgFSStartup::InitHostFS()
{
_LIT(KHostFSMounter, "z:\\sys\\bin\\SVPHOSTFS.EXE");
RProcess ws;
TInt r=ws.Create(KHostFSMounter, KNullDesC);
if (r == KErrNone)
{
TRequestStatus stat;
ws.Rendezvous(stat);
ws.Resume();
User::WaitForRequest(stat); // wait for start or death
ws.Close();
}
}
EXPORT_C TInt RTestExecuteLogServ::Connect()
/**
* @return int - Standard error codes
* EKA2 all variants and EKA1 target.
* Server is an exe
*/
{
TVersion version(KTestExecuteLoggerMajorVersion,KTestExecuteLoggerMinorVersion,KTestExecuteLoggerBuildVersion);
// Assume the server is already running and attempt to create a session
TInt err = CreateSession(KTestExecuteLogServerName,version,8);
if(err == KErrNotFound)
{
// Server not running
// Construct the server binary name
_LIT(KEmpty,"");
// EKA2 is simple
// No path required
TBuf<32> serverFile;
serverFile.Copy(KTestExecuteLogServerName);
_LIT(KExe,".exe");
serverFile.Append(KExe);
RProcess server;
err = server.Create(serverFile,KEmpty);
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();
// Create the root server session
err = CreateSession(KTestExecuteLogServerName,version,8);
}
#ifdef TEF_SHARE_AUTO
// Makes the session shared among all threads in the process
if( err == KErrNone )
{
err = ShareAuto();
}
#endif
return err;
}
