/*

* 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 )