/*
* 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 "SenHostletConnectionLog.h"
#include "senservicemanagerdefines.h" // internal Core\inc  - IPC enumerations

#include "rsenhostletconnection.h"
#include "senchunk.h"

#include "sendebug.h"
#include "senlogger.h"

#include <SenSoapMessage.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();

RSenHostletConnection::RSenHostletConnection()
    : RSessionBase(), iTlsLogChannel(1000)
    {
    // No implementation required
    }

TInt RSenHostletConnection::Connect()
    {
    TLSLOG_L(iTlsLogChannel, KMinLogLevel, "RSenHostletConnection::Connect");
    TInt error(KErrNone);
    TRAPD(err, error = ::StartServerL());
    
    if(err != KErrNone)
        {
        error = err;
        }
    if(KErrNone == error)
        {
        TLSLOG(iTlsLogChannel, KMinLogLevel,
            _L("RSenHostletConnection::Connect - Now creating session"));
        error = CreateSession(KSenServiceManager,
                              Version(),
                              KDefaultMessageSlots);
#ifdef _SENDEBUG
        if(error != KErrNone)
            {
            TLSLOG_FORMAT((iTlsLogChannel, KMinLogLevel,
            _L("RSenHostletConnection::Connect - CreateSession returned error: (%d)"), error));
            }
        else
            {
            TLSLOG_L(iTlsLogChannel, KMinLogLevel, "RSenHostletConnection::Connect - CreateSession returned KErrNone");
            }
#endif // _SENDEBUG
        }
#ifdef _SENDEBUG
    else
        {
        TLSLOG_FORMAT((iTlsLogChannel, KMinLogLevel,
        _L8("RSenHostletConnection::Connect - StartServerL failed, error: (%d)"), error));
        }
#endif // _SENDEBUG
    return error;
    }

TVersion RSenHostletConnection::Version() const
    {
    TLSLOG(iTlsLogChannel, KMinLogLevel, _L("RSenHostletConnection::Version"));
    return(TVersion(KWsfServMajorVersionNumber,
                    KWsfServMinorVersionNumber,
                    KWsfServBuildVersionNumber));
    }
    
void RSenHostletConnection::CancelSession(TRequestStatus& aStatus)
    {
    TLSLOG_L(iTlsLogChannel, KMinLogLevel, "RSenServiceConnection::CancelSession(sync)");
    SendReceive(ESenServCancelSession, aStatus);
    }


// SYNC: Called from CSenHostletConnection::ConstructL
TInt RSenHostletConnection::Establish(TDesC8& aHostletServiceDescription)
    {
    TLSLOG_L(iTlsLogChannel, KMinLogLevel, "RSenHostletConnection::EstablishL");

    TLSLOG_ALL(iTlsLogChannel, KMaxLogLevel, aHostletServiceDescription);

    TInt sdLength = aHostletServiceDescription.Length();

    TIpcArgs args;
    args.Set(0, &aHostletServiceDescription);
    args.Set(1, sdLength);

    return SendReceive(ESenServEstablishHostletConnection, args);
    }

// ASYNC: Completes when request handle is ready to be acquired
void RSenHostletConnection::AwaitRequest(TRequestStatus& aStatus,
                                         TDes8& aErrPtr,
                                         TDes8& aTxnPtr)
    {
    TLSLOG_L(iTlsLogChannel, KMinLogLevel, "RSenHostletConnection::AwaitRequest");

    TIpcArgs args;
    args.Set(0, &aErrPtr);
    args.Set(1, &aTxnPtr);
    SendReceive(ESenServAwaitHostletRequest, args, aStatus);
    }

// SYNC: returns RHandleBase ID if successful
TInt RSenHostletConnection::AcquireRequestHandle( TDes8& aErrPtr, TDes8& aTxnPtr )
    {
    TLSLOG_L(iTlsLogChannel, KMinLogLevel, "RSenHostletConnection::AcquireRequestHandle");

    TIpcArgs args;
    args.Set(0, &aErrPtr);
    args.Set(1, &aTxnPtr);
    return SendReceive(ESenServTransaction, args);
    }

void RSenHostletConnection::ProvideResponse( TRequestStatus& aStatus, 
                                             TDes8& aErrPtr,
                                             TDes8& aTxnPtr,
                                             CSenChunk& aClientOp,
                                             const TInt aResponseCode )
    {
    TLSLOG_L(iTlsLogChannel, KMinLogLevel, "RSenHostletConnection::ProvideResponse");

    TIpcArgs args;
    args.Set(0, &aErrPtr);
    args.Set(1, &aTxnPtr);
    aClientOp.ChunkToArgs(args,2);
    args.Set(3, aResponseCode);
    SendReceive(ESenServProvideHostletResponse, args, aStatus);
    }

TInt RSenHostletConnection::ConnectionID()
    {
    TInt connectionID = SendReceive( ESenServConnectionID );
                   
    iTlsLogChannel = KSenHostletConnectionLogChannelBase + connectionID;
    //TLSLOG_FORMAT((iTlsLogChannel, KMinLogLevel, _L("- Connection ID: (%d)"), connectionID));
    return connectionID;
    }
    
TInt RSenHostletConnection::RegisterTransferObserver(
        const TDesC* aServerName, TAny* aConnection)
    {
    TLSLOG_L(iTlsLogChannel, KMinLogLevel, "RSenHostletConnection::RegisterTransferObserver");
    CActiveSchedulerWait asWait;
    TIpcArgs args(aServerName, aConnection, &asWait);
    TRequestStatus rs = KRequestPending;
    SendReceive(ESenObserveTransfer, args, rs);
    Mem::FillZ(&asWait, sizeof(asWait));
    asWait.Start();
    User::WaitForRequest(rs);
    TLSLOG_L(iTlsLogChannel, KMinLogLevel, "RSenHostletConnection::RegisterTransferObserver Completed");
    return rs.Int();
    }

//void RSenHostletConnection::SetTlsLogChannel(TInt aTlsLogChannel)
//    {
//    iTlsLogChannel = aTlsLogChannel;
//    }

static TInt StartServerL()
    {
    TInt result(KErrNotFound);
    
#ifdef _SENDEBUG    
    RFileLogger log;
    CleanupClosePushL(log);
    User::LeaveIfError( log.Connect() );
    log.CreateLog(KSenHostletConnectionLogDir, _L("SenStartServer.log"), EFileLoggingModeAppend);
    log.Write(_L("StartServerL() invoked by HC."));
#endif

    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(KErrNone);

#ifdef _SENDEBUG
    RFileLogger log;
    CleanupClosePushL(log);
    User::LeaveIfError( log.Connect() );
    // Note: this appends to the log created in StartServer()
    log.CreateLog(KSenHostletConnectionLogDir, _L("SenStartServer.log"), EFileLoggingModeAppend);
    log.Write(_L("CreateServerProcessL() invoked by HC."));
#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 successful, server thread now has the handle to library:

        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);//CodeScannerWarning
#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"));
        }
#endif // _SENDEBUG

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

#ifdef _SENDEBUG
    CleanupStack::PopAndDestroy(); // log.Close();
#endif

    return result;
    }
    

// End of file