/*
* Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
* class for imps server.
*
*/
// INCLUDE FILES
#include <e32base.h>
#include <e32std.h>
#include "impsservercommon.h"
#include "impshandler.h"
#include "impsclient.h"
#include "impserrors.h"
#include "impsutils.h"
#include "impsclientsrv.h"
#include "impsconst.h"
// CONSTANTS
const TInt KWaitForServerRetries = 3;
// MACROS
#ifndef _DEBUG
#define _NO_IMPS_LOGGING_
#endif
// ================= MEMBER FUNCTIONS =======================
// ----------------------------------------------------------------------------
// RImpsEng::RImpsEng
// ----------------------------------------------------------------------------
EXPORT_C RImpsEng::RImpsEng()
: RSessionBase(),
iSessionOk (EFalse )
{
}
// ----------------------------------------------------------------------------
// RImpsEng::Connect
// ----------------------------------------------------------------------------
EXPORT_C TInt RImpsEng::Connect( TInt aRate /*, TBool aReqular*/ )
{
// This has similar functionality than old version RImpsClient
TInt err = KErrNone;
#ifndef _NO_IMPS_LOGGING_
CImpsClientLogger::Log(_L("Client: Connect rate=0x%x"), aRate);
#endif
for ( TInt tries = 0; tries < KWaitForServerRetries ; tries++ )
{
#ifndef _NO_IMPS_LOGGING_
CImpsClientLogger::Log(_L("Client: Calling CreateSession "));
#endif
err = CreateSession(
KImpsServerName, Version(), KImpsDefaultMessageSlots );
if ( err == KErrNone )
{
iSessionOk = ETrue;
break; // connected to existing server - ok
}
// problems other than server not here - propagate error
if ( err != KErrNotFound && err != KErrServerTerminated )
{
break;
}
err = StartServer( aRate, 0 ); // start a new server
}
#ifndef _NO_IMPS_LOGGING_
const TSecureId currentSID( RProcess().SecureId() );
CImpsClientLogger::Log(_L("Client Connect returns=0x%x currentSID=0x%x"), err, (TInt)currentSID);
TBuf<256> name;
RProcess currentProcess;
name.Append( RProcess().FullName() );
CImpsClientLogger::Log( _L("Client CONNECT Process name: %S"), &name );
#endif
return err;
}
// ----------------------------------------------------------------------------
// RImpsEng::Close
// ----------------------------------------------------------------------------
EXPORT_C void RImpsEng::Close()
{
#ifndef _NO_IMPS_LOGGING_
const TSecureId currentSID( RProcess().SecureId() );
CImpsClientLogger::Log(_L("Client Close currentSID=0x%x"), (TInt)currentSID);
TBuf<256> name;
RProcess currentProcess;
name.Append( RProcess().FullName() );
CImpsClientLogger::Log( _L("Client CLOSE Process name: %S"), &name );
#endif
iSessionOk = EFalse;
RSessionBase::Close(); // deletes session object
}
// ----------------------------------------------------------------------------
// RImpsEng::StartServer
// ----------------------------------------------------------------------------
TInt RImpsEng::StartServer( TInt aRate, TInt /*aRound*/ )
{
#ifndef _NO_IMPS_LOGGING_
CImpsClientLogger::Log(_L("Client: StartServer rate=0x%x"), aRate);
#endif
TInt ret( KErrNone );
TRequestStatus status = KRequestPending;
TImpsSignal signal( aRate );
if ( !IsServerStarted() )
{
// launch server process
RProcess server;
#ifndef _NO_IMPS_LOGGING_
CImpsClientLogger::Log(_L("Client: PROCESS TO START"));
#endif
ret = server.Create(
KImpsServerExe,
signal.Get() );
if ( ret )
{
// we are lost
#ifndef _NO_IMPS_LOGGING_
CImpsClientLogger::Log(_L("Client: process START FAILED"));
#endif
return ret;
}
server.Rendezvous( status );
if ( status != KRequestPending )
{
server.Kill(0); // abort startup
}
else
{
server.Resume(); // logon OK - start the server
}
#ifndef _NO_IMPS_LOGGING_
CImpsClientLogger::Log(_L("Client: WaitForAnyRequest"));
#endif
// wait for start or death
User::WaitForRequest( status );
#ifndef _NO_IMPS_LOGGING_
CImpsClientLogger::Log(_L("WaitForRequest return=%d"), status.Int() );
#endif
// 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 : status.Int();
server.Close();
} // if !IsStarted
#ifndef _NO_IMPS_LOGGING_
CImpsClientLogger::Log(_L("StartServer return=0x%x"), ret);
#endif
return ret;
}
// ----------------------------------------------------------------------------
// RImpsEng::IsServerStarted
// ----------------------------------------------------------------------------
TBool RImpsEng::IsServerStarted()
{
TFindServer findServer( KImpsServerName );
TFullName name;
return ( findServer.Next( name ) == KErrNone );
}
// ----------------------------------------------------------------------------
// RImpsEng::Version()
// Returns the client side version number.
// ----------------------------------------------------------------------------
TVersion RImpsEng::Version() const
{
return TVersion( KImpsServMajorVersionNumber, KImpsServMinorVersionNumber,
KImpsServBuildVersionNumber );
}
// ----------------------------------------------------------------------------
// RImpsEng::CspIdentifier()
// ----------------------------------------------------------------------------
TImpsCspIdentifier* RImpsEng::CspIdentifier()
{
return &iCspId;
}
// ----------------------------------------------------------------------------
// RImpsEng::SetCspIdentifier()
// ----------------------------------------------------------------------------
void RImpsEng::SetCspIdentifier( TImpsCspIdentifier aCspId )
{
TInt err ( KErrNone );
TRAP ( err, iCspId.SetSapL( aCspId.Sap() ) );
TRAP ( err, iCspId.SetUserIdL( aCspId.UserId() ) );
}
// ---------------------------------------------------------
// RImpsClient2::RImpsClient2
// ---------------------------------------------------------
//
EXPORT_C RImpsClient2::RImpsClient2() :
iHandler( NULL ),
iActiveCommand( NULL ),
iRunning( EFalse ),
iOpId( 0 ),
iLimitUpperValue( 0 ),
iLimitLowerValue( 0 ),
iEngine( NULL )
{}
// ---------------------------------------------------------
// RImpsClient2::DoAssign
// ---------------------------------------------------------
//
TInt RImpsClient2::DoAssign(
const TDesC& aClientId )
{
TInt err = KErrNone;
TPtrC myId;
myId.Set( aClientId );
err = SendReceive( EImpsServAssign, TIpcArgs( &myId ) );
return err;
}
// ---------------------------------------------------------
// RImpsClient2::DoUnregister
// SubSession Close
// ---------------------------------------------------------
//
void RImpsClient2::DoUnregister()
{
#ifndef _NO_IMPS_LOGGING_
CImpsClientLogger::Log(_L("Client: DoUnregister cli=%d"), (TInt)this);
#endif
if ( iRunning )
{
// Send cancel message to the server thread
TInt srvRet = SendReceive( EImpsServCloseSub, TIpcArgs() );
// Server completes pending next event request message for this subsession
__ASSERT_DEBUG( iHandler,
User::Panic( KImpsPanicCategory,
EImpsNotifyHandlerMissing ) );
if ( !srvRet && iHandler->IsActive() )
{
#ifndef _NO_IMPS_LOGGING_
CImpsClientLogger::Log(_L("Client2: WaitForRequest START %d"), srvRet);
#endif
User::WaitForRequest( iHandler->iStatus );
#ifndef _NO_IMPS_LOGGING_
CImpsClientLogger::Log(_L("Client2: WaitForRequest END"));
#endif
}
iRunning = EFalse;
RSubSessionBase::CloseSubSession( EImpsServDeleteSub );
}
// Cancel active objects before deleting them.
// Server is informed about cancel above so that it will not send data.
if ( iHandler )
{
iHandler->Cancel();
}
if ( iActiveCommand )
{
iActiveCommand->Cancel();
}
// Now this is safe, i.e. no requests outstanding for the handler
delete iHandler;
iHandler = NULL;
delete iActiveCommand;
iActiveCommand = NULL;
}
// ----------------------------------------------------------------------------
// RImpsClient2::RegisterStatusObserverL
// ----------------------------------------------------------------------------
EXPORT_C void RImpsClient2::RegisterStatusObserverL(
MImpsStatusHandler2* aObserver )
{
if ( !iHandler )
{
// Register must have been done in derived client API!
User::Leave( KImpsErrorNotRegistered );
}
if ( iHandler->StatusHandler() == NULL )
{
iHandler->SetStatusHandlerL( aObserver );
}
}
// ----------------------------------------------------------------------------
// RImpsClient2::UnregisterStatusObserverL
// ----------------------------------------------------------------------------
EXPORT_C void RImpsClient2::UnregisterStatusObserverL( )
{
// Check if null if somebody calls this after Unregister anyway ...
if ( iHandler )
{
if ( iHandler->StatusHandler() != NULL )
{
iHandler->SetStatusHandlerL( NULL );
}
}
}
// ----------------------------------------------------------------------------
// RImpsClient2::RegisterErrorObserverL
// ----------------------------------------------------------------------------
EXPORT_C void RImpsClient2::RegisterErrorObserverL(
MImpsErrorHandler2& aObserver )
{
if ( !iHandler )
{
// Register must have been done in derived client API!
User::Leave( KImpsErrorNotRegistered );
}
if ( iHandler->ErrorHandler() == NULL )
{
iHandler->SetErrorHandlerL( &aObserver );
}
}
// ----------------------------------------------------------------------------
// RImpsClient2::UnregisterErrorObserverL
// ----------------------------------------------------------------------------
EXPORT_C void RImpsClient2::UnregisterErrorObserverL( )
{
// Check if null if somebody calls this after Unregister anyway ...
if ( iHandler )
{
if ( iHandler->ErrorHandler() != NULL )
{
iHandler->SetErrorHandlerL( NULL );
}
}
}
// ----------------------------------------------------------------------------
// RImpsClient2::MaxTransactionContentLengthL
// ----------------------------------------------------------------------------
EXPORT_C TInt RImpsClient2::MaxTransactionContentLengthL( )
{
TInt ret = SendReceive( EImpsServBuffSizeReq, TIpcArgs() );
if ( ret < 0 )
{
User::Leave( ret );
}
return ret;
}
// ----------------------------------------------------------------------------
// RImpsClient2::ErrorHandlerL
// ----------------------------------------------------------------------------
MImpsErrorHandler2* RImpsClient2::ErrorHandler()
{
if ( iHandler )
{
return ( iHandler->ErrorHandler() );
}
return (MImpsErrorHandler2*)NULL;
}
// ----------------------------------------------------------------------------
// RImpsClient2::GetServicesL
// ----------------------------------------------------------------------------
EXPORT_C void RImpsClient2::GetServicesL( TImpsServices& aServices )
{
#ifndef _NO_IMPS_LOGGING_
CImpsClientLogger::Log(_L("Client2: GetServicesL starts"));
#endif
// result buffer
TBuf<sizeof( TImpsServices ) + 4> myBuf( sizeof( TImpsServices ) + 4 );
// Server will write the data to myservices
TInt ret = SendReceive( EImpsServServices, TIpcArgs( &myBuf ) );
#ifndef _NO_IMPS_LOGGING_
CImpsClientLogger::Log(_L("Client2: GetServicesL SendReceive ret=%d"), ret );
#endif
User::LeaveIfError( ret );
// convert descriptor to TImpsServices
TInt32 tempSize = 0;
const TUint8* textPtr = (const TUint8*)myBuf.Ptr();
Mem::Copy( &tempSize, textPtr, sizeof( tempSize) );
#ifndef _NO_IMPS_LOGGING_
CImpsClientLogger::Log(_L("Client2: GetServicesL tempSize=%d"), tempSize);
#endif
textPtr = textPtr + sizeof( tempSize );
// copy result to the call parameter
Mem::Copy( (void*)&aServices, textPtr, tempSize );
#ifndef _NO_IMPS_LOGGING_
CImpsClientLogger::Log(_L("Client2: GetServicesL ends Ok"));
#endif
}
// ----------------------------------------------------------------------------
// RImpsClient2::WVVersionL
// ----------------------------------------------------------------------------
EXPORT_C TPtrC RImpsClient2::WVVersionL()
{
TInt ret = SendReceive( EImpsServCspVersion, TIpcArgs() );
if ( ret == EImpsCspVersion12 )
{
return TPtrC( KImpsVersionStr );
}
return TPtrC( KImpsVersionStr12 );
}
// ----------------------------------------------------------------------------
// RImpsClient2::CspIdentifierL( )
// ----------------------------------------------------------------------------
EXPORT_C TImpsCspIdentifier* RImpsClient2::CspIdentifierL( )
{
TInt ret = SendReceive( EImpsServIsLogged, TIpcArgs() );
if ( ret < 0 )
{
User::Leave( KErrNotFound );
}
return iEngine->CspIdentifier();
}
// ----------------------------------------------------------------------------
// RImpsClient2::CancelTransaction
// ----------------------------------------------------------------------------
EXPORT_C void RImpsClient2::CancelTransaction( TInt aOperationId )
{
TInt ret = SendReceive( EImpsServCancelTrans, TIpcArgs( aOperationId ) );
#ifndef _NO_IMPS_LOGGING_
CImpsClientLogger::Log(_L("RImpsClient2::CancelTransaction opId=%d ret=%d"), aOperationId, ret );
#endif
}
// ----------------------------------------------------------------------------
// RImpsClient2::SetExpiryTime
// ----------------------------------------------------------------------------
EXPORT_C void RImpsClient2::SetExpiryTime( TInt aSeconds )
{
TInt ret = SendReceive( EImpsServSetExpiry, TIpcArgs( aSeconds ) );
#ifndef _NO_IMPS_LOGGING_
CImpsClientLogger::Log(_L("RImpsClient2::SetExpiryTime time=%d ret=%d"), aSeconds, ret );
#endif
}
// ----------------------------------------------------------------------------
// RImpsClient2::IncreaseOpId
// ----------------------------------------------------------------------------
void RImpsClient2::IncreaseOpId( )
{
iOpId++;
if( iOpId >= iLimitUpperValue )
{
iOpId = iLimitLowerValue;
}
}
// ----------------------------------------------------------------------------
// RImpsClient2::SetOpIdRange
// ----------------------------------------------------------------------------
void RImpsClient2::SetOpIdRange( )
{
iLimitLowerValue = REINTERPRET_CAST(TInt, Dll::Tls() );
iLimitUpperValue = iLimitLowerValue + 100;
// Check that counter does not go around
if ( iLimitUpperValue & KImpsOOMReply )
{
// start from 50, if this ever happens
iLimitLowerValue = 50;
iLimitUpperValue = iLimitLowerValue + 100;
}
Dll::SetTls( REINTERPRET_CAST(TAny*, iLimitUpperValue ) );
iOpId = iLimitLowerValue;
}
// ----------------------------------------------------------------------------
// RImpsClient2::DoRegister2
// ----------------------------------------------------------------------------
TInt RImpsClient2::DoRegister2(
RImpsEng& aEngine, CImpsHandler2* aHandler, TInt aReq )
{
#ifndef _NO_IMPS_LOGGING_
CImpsClientLogger::Log(_L("Client2: DoRegister2 cli=%d"), (TInt)this);
#endif
iEngine = &aEngine;
// add bit mask for extra info (handle-new and any-content)
TInt srvReg = aReq;
TInt bits = 0;
bits = ( bits & ~KImpsReqHandleNew )
| ( iHandleNew ? KImpsReqHandleNew : 0x0000 );
bits = ( bits & ~KImpsReqAnyContent )
| ( iAnyContent ? KImpsReqAnyContent : 0x0000 );
bits = bits << 16;
srvReg = srvReg | bits;
TImpsServRequest req = (TImpsServRequest)srvReg;
TInt err = CreateSubSession( aEngine, req );
if ( !err )
{
iRunning = ETrue;
aHandler->EventHandled();
}
return err;
}
// ----------------------------------------------------------------------------
// RImpsClient2::CspIdentifier( )
// ----------------------------------------------------------------------------
TImpsCspIdentifier* RImpsClient2::CspIdentifier( )
{
return iEngine->CspIdentifier();
}
// End of File