/*

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

*

*/

#include <e32math.h>

#include "rsenservicemanager.h"

#include "senservicemanagerdefines.h" // IPC enumerations

#include "sendebug.h" // internal Utils\inc - filelogging MACROs

#include "senlogger.h"

#include "senchunk.h"

#if defined(__WINS__) && !defined(EKA2)

    static const TUint KServerMinHeapSize =  0x1000;  //  4K

    static const TUint KServerMaxHeapSize = 0x100000;  // 1000K

#endif

static TInt StartServerL();

static TInt CreateServerProcessL();

RSenServiceManager::RSenServiceManager()//(RFileLogger* aLog)

    : RSessionBase()//,

      //iLog(aLog)

    {

    // No implementation required

    }

/*

void RSenServiceManager::SetLog(RFileLogger* aLog)

    {

    iLog = aLog;

    }

*/    

void RSenServiceManager::SetChannel(TInt aChannel)

{

	iTLSLogChannel = aChannel;

}

TInt RSenServiceManager::Connect()

    {

    TLSLOG(KSenServiceManagerLogChannel, KMinLogLevel,(_L("RSenServiceManager::Connect")));

    TInt error(KErrNone);

    TRAPD (err, error = ::StartServerL();)

    if (err != KErrNone)

        {

        error = err;

        }

    if (KErrNone == error)

        {

        error = CreateSession(KSenServiceManager,

                              Version(),

                              KDefaultMessageSlots);

#ifdef _SENDEBUG

        if(error != KErrNone)

            {

            TLSLOG_L(KSenServiceManagerLogChannel, KMinLogLevel,"CSenServiceManagerImpl::DoCancel");

            TLSLOG_FORMAT((KSenServiceManagerLogChannel, KMinLogLevel , _L8("- CreateSession returned error: (%d)"), error));

            }

        else

            {

            TLSLOG_L(KSenServiceManagerLogChannel, KMinLogLevel,"RSenServiceManager::Connect");

            TLSLOG_L(KSenServiceManagerLogChannel, KMinLogLevel,"- CreateSession returned KErrNone");

            }

#endif // _SENDEBUG

        }

#ifdef _SENDEBUG

    else

        {

        TLSLOG_FORMAT((KSenServiceManagerLogChannel, KMinLogLevel , _L8("RSenServiceManager::Connect - StartServer failed, error: (%d)"),

                    error));

        }

#endif // _SENDEBUG

    return error;

    }

TVersion RSenServiceManager::Version() const

    {

    TLSLOG(iTLSLogChannel, KMinLogLevel,(_L("RSenServiceManager::Version")));

    return(TVersion(KWsfServMajorVersionNumber,

                    KWsfServMinorVersionNumber,

                    KWsfServBuildVersionNumber));

    }

TInt RSenServiceManager::InstallFramework(TDesC8& aMessage)

    {

#ifdef _SENDEBUG

    TLSLOG(iTLSLogChannel, KMinLogLevel,(_L("RSenServiceManager::InstallFramework")));

    TPtrC8 outBufferLeft = aMessage.Left(30);

    TLSLOG_FORMAT((iTLSLogChannel, KNormalLogLevel , _L8("Out: %S ..., length: (%d)"),

                        &outBufferLeft, aMessage.Length()));

#endif // _SENDEBUG

    TInt length = aMessage.Length();

    TIpcArgs args;

    args.Set(0,&aMessage);

    args.Set(1, length);

    return SendReceive(ESenServInstallFramework, args);

    }

// Note: cannot log here (without TLS), since flogger server session has not yet been opened(!)

TInt RSenServiceManager::ConnectionID()

    {

    TInt connectionID = SendReceive( ESenServConnectionID );

//    iTlsLogChannel = KSenHostletConnectionLogChannelBase + connectionID;

//    TLSLOG_FORMAT((iTlsLogChannel, KSenServiceManagerLogLevel,

//                   _L("- Connection ID: (%d)"), connectionID));

    return connectionID;

    }

TInt RSenServiceManager::AssociateService( TDesC8& aServiceID, TDesC8& aProviderID )

    {

#ifdef _SENDEBUG

    TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceManager::AssociateService");

    TPtrC8 outBufferLeft = aServiceID.Left(30);

    TLSLOG_FORMAT((iTLSLogChannel, KNormalLogLevel , _L8("Out: %S ..., length: (%d)"),

                    &outBufferLeft, aServiceID.Length()));

#endif // _SENDEBUG

    TInt servIdLength = aServiceID.Length();

    TInt provIdLength = aProviderID.Length();

    TIpcArgs args;

    args.Set(0, &aServiceID);

    args.Set(1, servIdLength);

    args.Set(2, &aProviderID);

    args.Set(3, provIdLength);

    return SendReceive(ESenServAssociateService, args);

    }

TInt RSenServiceManager::DissociateService(TDesC8& aServiceID,

                                           TDesC8& aProviderID)

    {

#ifdef _SENDEBUG

    TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceManager::DissociateService");

    TPtrC8 outBufferLeft = aServiceID.Left(30);

    TLSLOG_FORMAT((iTLSLogChannel, KNormalLogLevel , _L8("Out: %S ..., length: (%d)"),

                    &outBufferLeft, aServiceID.Length()));

#endif // _SENDEBUG

    TInt servIdLength = aServiceID.Length();

    TInt provIdLength = aProviderID.Length();

    TIpcArgs args;

    args.Set(0, &aServiceID);

    args.Set(1, servIdLength);

    args.Set(2, &aProviderID);

    args.Set(3, provIdLength);

    return SendReceive(ESenServDissociateService, args);

    }

TInt RSenServiceManager::RegisterIdentityProvider(TDesC8& aMessage)

    {

#ifdef _SENDEBUG

    TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceManager::RegisterIdentityProvider");

    TPtrC8 outBufferLeft = aMessage.Left(30);

    TLSLOG_FORMAT((iTLSLogChannel, KNormalLogLevel , _L8("Out: %S ..., length: (%d)"),

                        &outBufferLeft, aMessage.Length()));

#endif // _SENDEBUG

    TInt length = aMessage.Length();

    TIpcArgs args;

    args.Set(0, &aMessage);

    args.Set(1, length);

    return SendReceive(ESenServRegisterIdentityProvider, args);

    }

TInt RSenServiceManager::UnregisterIdentityProvider(TDesC8& aMessage)

    {

#ifdef _SENDEBUG

    TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceManager::UnregisterIdentityProvider");

    TPtrC8 outBufferLeft = aMessage.Left(30);

    TLSLOG_FORMAT((iTLSLogChannel, KNormalLogLevel , _L8("Out: %S ..., length: (%d)"),

                    &outBufferLeft, aMessage.Length()));

#endif // _SENDEBUG

    TInt length = aMessage.Length();

    TIpcArgs args;

    args.Set(0, &aMessage);

    args.Set(1, length);

    return SendReceive(ESenServUnregisterIdentityProvider, args);

    }

TInt RSenServiceManager::UnregisterServiceDescription(TDesC8& aMessage)

    {

#ifdef _SENDEBUG

    TLSLOG(iTLSLogChannel, KMinLogLevel,(_L("RSenServiceManager::UnregisterServiceDescription")));

    TPtrC8 outBufferLeft = aMessage.Left(30);

    TLSLOG_FORMAT((iTLSLogChannel, KNormalLogLevel , _L8("Out: %S ..., length: (%d)"),

                    &outBufferLeft, aMessage.Length()));

#endif // _SENDEBUG

    TInt length = aMessage.Length();

    TIpcArgs args;

    args.Set(0, &aMessage);

    args.Set(1, length);

    return SendReceive(ESenServUnregisterServiceDescription, args);

    }

TInt RSenServiceManager::RegisterServiceDescription(TDesC8& aMessage)

    {

#ifdef _SENDEBUG

    TLSLOG(iTLSLogChannel, KMinLogLevel,(_L("RSenServiceManager::RegisterServiceDescription")));

    TPtrC8 outBufferLeft = aMessage.Left(30);

    TLSLOG_FORMAT((iTLSLogChannel, KNormalLogLevel , _L8("Out: %S ..., length: (%d)"),

        &outBufferLeft, aMessage.Length()));

#endif // _SENDEBUG

    TInt length = aMessage.Length();

    TIpcArgs args;

    args.Set(0, &aMessage);

    args.Set(1, length);

    return SendReceive(ESenServRegisterServiceDescription, args);

    }

TInt RSenServiceManager::ServiceDescriptionsByUriL(CSenChunk& aSenChunk)

    {

    TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceManager::GetServiceDescriptionsByUri");

    TIpcArgs args;

    aSenChunk.ChunkToArgs(args, 0);

    TInt retVal = SendReceive(ESenServGetLengthOfServiceDescriptionByUri, args);

    return retVal;

    }

TInt RSenServiceManager::IdentityProvidersL(CSenChunk& aSenChunk)

    {

    TIpcArgs args;

    aSenChunk.ChunkToArgs(args, 0);

    TInt retVal = SendReceive(ESenServGetIdentityProviders, args);

    return retVal;

    }

TInt RSenServiceManager::ServiceDescriptionsByPatternL(CSenChunk& aSenChunk)

    {

    TIpcArgs args;

    aSenChunk.ChunkToArgs(args, 0);

    TInt retVal = SendReceive(ESenServGetLengthOfServiceDescriptionByPattern, args);

    return retVal;

    }

TInt RSenServiceManager::CredentialsL(CSenChunk& aSenChunk)

    {

    TIpcArgs args;

    aSenChunk.ChunkToArgs(args, 0);

    TInt retVal = SendReceive(ESenServGetGredentials, args);

    return retVal;

    }

TInt RSenServiceManager::AddCredentialL(CSenChunk& aSenChunk)

    {

    TIpcArgs args;

    aSenChunk.ChunkToArgs(args, 0);

    TInt retVal = SendReceive(ESenServAddCredential, args);

    return retVal;

    }

TInt RSenServiceManager::RemoveCredentialsL(CSenChunk& aSenChunk)

    {

    TIpcArgs args;

    aSenChunk.ChunkToArgs(args, 0);

    TInt retVal = SendReceive(ESenServRemoveCredential, args);

    return retVal;

    }

/*

RFileLogger* RSenServiceManager::Log() const

    {

    return iLog;

    }

*/

static TInt StartServerL()

    {

    TInt result(KErrNotFound);

#ifdef _SENDEBUG   

    RFileLogger log;

    CleanupClosePushL(log);

    User::LeaveIfError( log.Connect() );

    log.CreateLog( KSenServiceManagerLogDir, _L("SenStartServer.log"), EFileLoggingModeOverwrite );

    log.Write(_L("- StartServerL() - Log file opened."));

#endif // _SENDEBUG

    TFindServer findSenServiceManager(KSenServiceManager);

    TFullName name;

    result = findSenServiceManager.Next(name);

    if (result == KErrNone)

        {

        // Server already running

#ifdef _SENDEBUG        

        log.Write(_L8("- Server already running, KErrNone"));

        log.CloseLog();

        CleanupStack::PopAndDestroy(); // log.Close()

#endif // _SENDEBUG        

        return KErrNone;

        }

    RSemaphore semaphore;

    CleanupClosePushL(semaphore);

    // First, try to open the semaphore (if someone else created it already):

    result = semaphore.OpenGlobal( KSenServiceManagerSemaphoreName );

    if( result == KErrNone )

        {

        // If another client is starting up SEN.EXE, this client should return

        // to re-connect loop (wait one sec, max 5 times)

#ifdef _SENDEBUG        

        log.Write(_L8("- OpenGlobal OK => Another client already starting up SEN.EXE. About to WAIT and RE-CONNECT."));

#endif        

        result = KErrServerBusy;

        }

    else // could not find any already opened global semaphore ==> it is safe to create new one

        {   

        // Semaphore has not yet been created, so instantiate it now(!)

        result = semaphore.CreateGlobal( KSenServiceManagerSemaphoreName, 0 );

#ifdef _SENDEBUG        

        if( result != KErrNone )

            {

            log.Write(_L8("CreateGlobal failed"));

            log.WriteFormat(_L8("- error: %d"), result);

            }

#endif        

        }

    if (result != KErrNone)

        {

        CleanupStack::PopAndDestroy(); // semaphore.Close()

#ifdef _SENDEBUG        

        log.CloseLog();

#endif // _SENDEBUG        

        if( result != KErrServerBusy )

            {

#ifdef _SENDEBUG        

            log.Write(_L8("- CreateGlobal failed => Another client already starting up SEN.EXE. About to WAIT and RE-CONNECT."));

            CleanupStack::PopAndDestroy(); // log.Close()

#endif // _SENDEBUG        

            result = KErrServerBusy; // again, this error will activate re-connect loop (max 5 times)

            }

        return result;

        }

    result = CreateServerProcessL();

    if (result != KErrNone)

        {

        CleanupStack::PopAndDestroy(); // semaphore.Close()

#ifdef _SENDEBUG        

        log.Write(_L8("CreateServerProcessL failed"));

        log.CloseLog();

        CleanupStack::PopAndDestroy(); // log.Close()

#endif // _SENDEBUG         

        return result;

        }

    // Now start waiting for signal from server: it will release this semaphore from wait:

    semaphore.Wait();  

    CleanupStack::PopAndDestroy(); // semaphore.Close()

#ifdef _SENDEBUG        

    log.Write(_L("Log file closed."));

    log.CloseLog();

    CleanupStack::PopAndDestroy(); // log.Close()    

#endif // _SENDEBUG

    return  KErrNone;

    }

static TInt CreateServerProcessL()

    {

    TInt result(KErrNotFound);

#ifdef _SENDEBUG

    RFileLogger log;

    CleanupClosePushL(log);

    User::LeaveIfError( log.Connect() );

    // Note: this appends to the log created in StartServer()

    log.CreateLog(KSenServiceManagerLogDir, _L("SenStartServer.log"), EFileLoggingModeAppend);

    log.Write(_L("- CreateServerProcessL() - invoked by SM."));

#endif // _SENDEBUG

    const TUidType serverUid(KNullUid, KNullUid, KServerUid3);

#if defined(__WINS__) && !defined(EKA2)

    RLibrary lib;

    CleanupClosePushL(lib);

    RThread server;

    CleanupClosePushL(server);

    result = lib.Load(KSenServiceManagerFileName, serverUid);

    if ( result == KErrNone )

        {

#ifdef _SENDEB

        log.Write(_L8("Library successfully loaded, KErrNone"));

#endif // _SENDEBUG

        //  Get the WinsMain function

        TLibraryFunction functionWinsMain = lib.Lookup(1);

        //  Call it and cast the result to a thread function

        TThreadFunction serverThreadFunction = reinterpret_cast<TThreadFunction>(functionWinsMain());

        TName threadName(KSenServiceManagerFileName);

        // Append a random number to make it unique

        threadName.AppendNum(Math::Random(), EHex);

        result = server.Create( threadName,   // create new server thread

                                serverThreadFunction, // thread's main function

                                KDefaultStackSize,

                                NULL,

                                &lib,

                                NULL,

                                KServerMinHeapSize,

                                KServerMaxHeapSize,

                                EOwnerProcess );

        if ( result == KErrNone )

            {

            server.SetPriority( EPriorityMore );

            }

#ifdef _SENDEBUG

        else

            {

            log.Write(_L8("Failed to create server thread."));

            }

#endif // _SENDEBUG

        }

#ifdef _SENDEBUG

    else

        {

        log.Write(_L8("Could not load library"));

        }

#endif // _SENDEBUG

    CleanupStack::Pop(); // server (thread)

    CleanupStack::PopAndDestroy(); // lib

    CleanupClosePushL(server);

#else // NON WINS TARGET(S):

    RProcess server;

    CleanupClosePushL(server);

    result = server.Create(KSenServiceManagerFileName, KNullDesC, serverUid);	//CodeScannerWarnings

#endif

    if( result == KErrNone )

        {

#ifdef _SENDEBUG

        log.Write(_L8("Server successfully created, KErrNone"));

#endif // _SENDEBUG

        server.Resume();

        }

#ifdef _SENDEBUG

    else

        {

        log.Write(_L8("Could not create server"));

        }