/*
* Copyright (c) 2006 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:   Implementation of DevTokenClientSession
*
*/



#include <e32std.h>
#include <e32uid.h>
#include <e32debug.h>
#include "DevTokenUtils.h"
#include "DevTokenServerName.h"
#include "DevTokenClientSession.h"
#include "DevtokenLog.h"

//Forward declaration
static TInt StartServer();

_LIT(KDevTokenServerImg,"DevTokenServer");

// Tokentype session class for Device token certificate stores
// Both device certificate store and trust site certificate store share
// the same token type.

// ======== LOCAL FUNCTIONS ========

// -----------------------------------------------------------------------------
// TInt StartServer()
// Client-server startup code
// -----------------------------------------------------------------------------
//
TInt StartServer()
    {
    // Server startup is different for WINS in EKA1 mode ONLY (lack of process
    // emulation - we load the library in this instance
    const TUidType serverUid(KNullUid, KNullUid, KUidDevTokenServer);

    RProcess server;  
    TInt r = server.Create(KDevTokenServerImg, KNullDesC, serverUid);
    
    RDebug::Print( _L(" StartServer ") );
    
    if ( r != KErrNone )
        {
        RDebug::Print( _L("StartServer1 %d"), r );
        return r;
        }

    // Synchronise with the process to make sure it hasn't died straight away
    TRequestStatus stat;
    server.Rendezvous(stat);
    if ( stat != KRequestPending )
        {
        // logon failed - server is not yet running, so cannot have terminated
        server.Kill(0);       // Abort startup
        }
    else
        {
        // logon OK - start the server
        server.Resume();
        }

    RDebug::Print( _L(" StartServer 2") );

    // Wait to synchronise with server - if it dies in the meantime, it
    // also gets completed
    User::WaitForRequest(stat); 
    
    RDebug::Print( _L(" StartServer 3") );
    // 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();
    
    RDebug::Print( _L(" StartServer 4 %d"), r );
    
    server.Close();
    return (r);
    }
    
    
// ======== MEMBER FUNCTIONS ========

// -----------------------------------------------------------------------------
// RDevTokenClientSession::RDevTokenClientSession()
// -----------------------------------------------------------------------------
//
RDevTokenClientSession::RDevTokenClientSession()
    {
    }


// -----------------------------------------------------------------------------
// RDevTokenClientSession::ClientSessionL()
// -----------------------------------------------------------------------------
//
RDevTokenClientSession* RDevTokenClientSession::ClientSessionL()
    {
    return new( ELeave ) RDevTokenClientSession();
    }


// -----------------------------------------------------------------------------
// RDevTokenClientSession::SendRequest()
// -----------------------------------------------------------------------------
//
TInt RDevTokenClientSession::SendRequest(TDevTokenMessages aRequest, const TIpcArgs& aArgs) const
    {
    return SendReceive(aRequest, aArgs);
    }


// -----------------------------------------------------------------------------
// RDevTokenClientSession::SendAsyncRequest()
// -----------------------------------------------------------------------------
//
void RDevTokenClientSession::SendAsyncRequest(TDevTokenMessages aRequest, const TIpcArgs& aArgs, TRequestStatus* aStatus) const
    {
    __ASSERT_ALWAYS(aStatus, DevTokenPanic(EBadArgument));
    if (aStatus)
        {
        *aStatus = KRequestPending;
        SendReceive(aRequest, aArgs, *aStatus);
        }
    }


// -----------------------------------------------------------------------------
// TInt RDevTokenClientSession::Connect(EDevTokenEnum aToken)
// Connect to the server, attempting to start it if necessary
// -----------------------------------------------------------------------------
//
TInt RDevTokenClientSession::Connect(EDevTokenEnum aToken)
    {
    // The version is made up of three pieces of information:
    // 1. iMajor - The token we want to talk to
    // 2. iMinor - The protocol version number
    // 3. iBuild - unused
    TVersion version(aToken, KDevTokenProtolVersion, 0);

    TInt retry=2;
    for (;;)
        {
        TInt r=CreateSession(KDevTokenServerName, version, 1);

        TRACE_PRINT("connect");
        
        if ( r!=KErrNotFound && r!=KErrServerTerminated )
            {
            RDebug::Print( _L("connect1 %d"), r );
            return r; 
            }

        if (--retry==0)
            {
            RDebug::Print( _L(" connect2 %d"), r );
            return r; 
            }

        r=StartServer();
        
        if ( r!=KErrNone && r!=KErrAlreadyExists )
            {
            RDebug::Print( _L(" connect3 %d"), r );
            return r;  
            }

        }
    }

//EOF