/*

* Copyright (c) 2005-2009 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:  PC Connectivity server

*

*/

#include <s32mem.h> // For RMemReadStream

#include <utf.h>

#include "sconpcconnclientserver.h"

#include "sconpcconnserver.h"

#include "sconpcd.h"

#include "sconcsc.h"

#include "sconconmlhandler.h"

#include "debug.h"

#ifdef DEBUG_XML

#include <s32file.h>

_LIT8( KTimeFormat, "%02d:%02d:%02d.%03d" );

_LIT8( KXmlBegin, "\nXML:\n" );

#endif

_LIT( KSCONGetMetadataRequest, "METADATA:" );

//------------------------------------------------------------

// Global functions 

//------------------------------------------------------------

// -----------------------------------------------------------------------------

// E32Main()

// Entry point 

// -----------------------------------------------------------------------------

//

TInt E32Main()

    {

    TRACE_FUNC_ENTRY;

    __UHEAP_MARK;

    TInt error( KErrNone );

    error = CSConPCConnServer::RunServer();

    __UHEAP_MARKEND;

    TRACE_FUNC_EXIT;

    return error;

    }

// -----------------------------------------------------------------------------

// PanicServer()

// Panics the server with panic reason aPanic 

// -----------------------------------------------------------------------------

//

GLDEF_C void PanicServer(TPCConnServPanic aPanic)

    {

    LOGGER_WRITE_1( "CSConPCConnSession::PanicServer() : Panic code  %d", aPanic );  

    _LIT(KTxtServerPanic,"PCConn server panic");

    User::Panic(KTxtServerPanic,aPanic);

    }

// -----------------------------------------------------------------------------

// CSConPCConnServer::CSConPCConnServer ()

// Default constructor - can not leave

// -----------------------------------------------------------------------------

//

CSConPCConnServer::CSConPCConnServer () : CServer2( EPriorityStandard)

    {

    LOGGER_WRITE( "* * * *  CSConPCConnServer  * * * *" );

    }

// -----------------------------------------------------------------------------

// CSConPCConnServer::~CSConPCConnServer()

// Default destructor

// -----------------------------------------------------------------------------

//

EXPORT_C CSConPCConnServer::~CSConPCConnServer()

    {

    TRACE_FUNC;

    }

// -----------------------------------------------------------------------------

// CSConPCConnServer::NewLC()

// Creates a new instance of CSConPCConnServer

// -----------------------------------------------------------------------------

//

EXPORT_C CSConPCConnServer*  CSConPCConnServer::NewLC()

    {

    TRACE_FUNC_ENTRY;

    CSConPCConnServer* self  = new (ELeave) CSConPCConnServer();

    CleanupStack::PushL( self );

    self->StartL( KSConPCConnServerName );

    TRACE_FUNC_EXIT;

    return self;

    }

// -----------------------------------------------------------------------------

// CSConPCConnServer::NewSessionL()

// Creates a new session to the client

// -----------------------------------------------------------------------------

//

CSession2* CSConPCConnServer::NewSessionL( 

    const TVersion &aVersion, const RMessage2& /*aMessage*/ ) const

    {

    TRACE_FUNC_ENTRY;

    // check version

    TVersion version( KSConPCConnServerVersionMajor, 

                                  KSConPCConnServerVersionMinor, 

                                  KSConPCConnServerVersionBuild);

    if (!User::QueryVersionSupported(version, aVersion))

        {

        User::Leave(KErrNotSupported);

        }

    // check client identity

    RThread client;

    Message().Client( client );

    TSecureId clientId = client.SecureId();

    if ( clientId != KSConPCConnClientSecureId )

        {

        LOGGER_WRITE( "CSConPCConnServer::NewSessionL() : Secure ID does not match" );

        User::Leave( KErrAccessDenied );

        }

    TRACE_FUNC_EXIT;

    return CSConPCConnSession::NewL( *CONST_CAST( CSConPCConnServer*, this));

    }

// -----------------------------------------------------------------------------

// CSConPCConnServer::RunServer()

// Starts the server

// -----------------------------------------------------------------------------

//

TInt CSConPCConnServer::RunServer()

    {

    TRACE_FUNC_ENTRY;

    CTrapCleanup* cleanup = CTrapCleanup::New();

    TInt ret = KErrNoMemory;

    if( cleanup )

        {

        TRAP( ret, CSConPCConnServer::RunServerL(  ) );

        delete cleanup;

        }

    if( ret != KErrNone )

        {

        // Signal the client that server creation failed

        RProcess::Rendezvous( ret );

        }

    TRACE_FUNC_EXIT;

    return ret;

    }

// -----------------------------------------------------------------------------

// CSConPCConnServer::RunServerL()

// Starts the server

// -----------------------------------------------------------------------------

//

void CSConPCConnServer::RunServerL()

    {

    // Create and install the active scheduler we need

    TRACE_FUNC_ENTRY;

    CActiveScheduler *as=new (ELeave)CActiveScheduler;

    CleanupStack::PushL( as );

    CActiveScheduler::Install( as );

    // Create server

    CSConPCConnServer* server = CSConPCConnServer::NewLC();

    // Initialisation complete, now signal the client

    User::LeaveIfError( RThread().RenameMe( KSConPCConnServerName ) );

    RProcess::Rendezvous( KErrNone );

    // Ready to run

    CActiveScheduler::Start();

    // Cleanup the scheduler

    CleanupStack::PopAndDestroy( 2, as );

    TRACE_FUNC_EXIT;

    }

// -----------------------------------------------------------------------------

// CSConPCConnServer::IncSessionCount()

// Increments session count

// -----------------------------------------------------------------------------

//

void CSConPCConnServer::IncSessionCount()

    {

    TRACE_FUNC_ENTRY;

    iSessionCount++;

    LOGGER_WRITE_1( "There are now %d sessions", iSessionCount );

    TRACE_FUNC_EXIT;

    }    

// -----------------------------------------------------------------------------

// CSConPCConnServer::DecSessionCount()

// Decrements session count

// -----------------------------------------------------------------------------

//

void CSConPCConnServer::DecSessionCount()

    {

    TRACE_FUNC_ENTRY;

    iSessionCount--;

    LOGGER_WRITE_1( "There are still %d sessions", iSessionCount );

    if ( iSessionCount < 1 )

        {

        Cancel();

        CActiveScheduler::Stop();   

        }

    TRACE_FUNC_EXIT;

    } 

// -----------------------------------------------------------------------------

// CSConPCConnSession::CSConPCConnSession()

// Default constructor 

// -----------------------------------------------------------------------------

//

CSConPCConnSession::CSConPCConnSession (

     CSConPCConnServer& aServer ) : iServer (aServer)

    {

    TRACE_FUNC_ENTRY;

    iServer.IncSessionCount();

    TRACE_FUNC_EXIT;

    }

// -----------------------------------------------------------------------------

// CSConPCConnSession::CSConPCConnSession()

// Default destructor - frees resources

// -----------------------------------------------------------------------------

//

CSConPCConnSession::~CSConPCConnSession()

    {

    TRACE_FUNC_ENTRY;

    iServer.DecSessionCount();

    if ( iConMLHandler )

        {

        delete iConMLHandler;

        iConMLHandler = NULL;

        iConMLHandlerLib.Close();

        }

    if ( iPCDHandler )

        {

        delete iPCDHandler;

        iPCDHandler = NULL;

        iPCDlib.Close();

        }

    if ( iCSCHandler )

        {

        delete iCSCHandler;

        iCSCHandler = NULL;

        iCSClib.Close();

        }

    if ( iBuffer )

        {

        delete iBuffer;

        iBuffer = NULL;

        }

    iChunk.Close();

    TRACE_FUNC_EXIT;

    }

// -----------------------------------------------------------------------------

// CSConPCConnSession::NewL()

// Creates a new instance of CSConPCConnSession

// -----------------------------------------------------------------------------

//

EXPORT_C CSConPCConnSession *CSConPCConnSession::NewL(

    CSConPCConnServer& aServer)

    {

    TRACE_FUNC_ENTRY;

    CSConPCConnSession* self = new ( ELeave ) CSConPCConnSession(aServer);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    TRACE_FUNC_EXIT;

    return self;

    }

// -----------------------------------------------------------------------------

// CSConPCConnSession::ConstructL()

// 2nd phase constructor

// -----------------------------------------------------------------------------

//

void CSConPCConnSession::ConstructL()

    {

    TRACE_FUNC_ENTRY;

    TInt ret ( KErrNone );

    iResult = KErrNone;

#ifdef DEBUG_XML

    // create log file 

    RFs fs;

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

    CleanupClosePushL( fs );

    RFile file;

    TInt err = file.Create ( fs, KSConConMLDebugFile, EFileWrite );

    if( err == KErrNone )

        {

        // file created, close it

        file.Close();

        }       

    CleanupStack::PopAndDestroy( &fs );               

#endif

    // initialize buffer

    iBuffer = CBufFlat::NewL ( KSConPCConnBufferMaxSize );

    // load handlers

    if ( !iPCDHandler )

        {

        TRAP( ret, LoadPCDDllL() );

        if ( ret != KErrNone) 

            {

            LOGGER_WRITE_1( "CSConPCConnSession::ConstructL() : PCD load failed with error code %d", ret );

            User::Leave( ret );

            }

        }   

    if ( !iCSCHandler )

        {

        TRAP( ret, LoadCSCDllL() );

        if ( ret != KErrNone) 

            {

            LOGGER_WRITE_1( "CSConPCConnSession::ConstructL() : CSC dll load failed with error code %d", ret ); 

            User::Leave ( ret );

            }

        }

    // Load parser

    if ( !iConMLHandler )

        {

        TRAPD( ret, LoadConMLHandlerDllL() );

        if ( ret != KErrNone)

            {

            LOGGER_WRITE_1( "CSConPCConnSession::ConstructL() : Parser dll load failed with error code %d", ret );

            User::Leave ( ret );

            }

        }

    TRACE_FUNC_EXIT;

    }

// -----------------------------------------------------------------------------

// CSConPCConnSession::ServiceL()

// Gets the client's request

// -----------------------------------------------------------------------------

//

void CSConPCConnSession::ServiceL( const RMessage2 &aMessage)

    {

    TRACE_FUNC_ENTRY;

    TRAPD(err,DispatchRequestL(aMessage) );

    if ( err != KErrNone )

        {

        LOGGER_WRITE_1( "CSConPCConnSession::ServiceL() : leave code %d", err );

        PanicServer( E_DispatchRequest );

        }

    TRACE_FUNC_EXIT;

    }

// -----------------------------------------------------------------------------

// CSConPCConnSession::DispatchRequestL()

// Identifies an IPC command from the client 

// -----------------------------------------------------------------------------

//

void CSConPCConnSession::DispatchRequestL(const RMessage2 &aMessage)

    {

    TRACE_FUNC_ENTRY;

    TInt ret (KErrNone);

    switch (aMessage.Function())

        {

        case EPutMessage:

            LOGGER_WRITE( "CSConPCConnSession::DispatchRequestL() : EPutMessage" );

            ret = HandlePutMessageL();

            break;

        case EGetMessage:

            LOGGER_WRITE( "CSConPCConnSession::DispatchRequestL() : EGetMessage" );

            ret = HandleGetMessageL();

            break;

        case EResetMessage:

            LOGGER_WRITE( "CSConPCConnSession::DispatchRequestL() : EResetMessage" );

            ret = HandleResetMessage();

            break;

        case EChunkMessage:

            LOGGER_WRITE( "CSConPCConnSession::DispatchRequestL() : EChunkMessage" );

            ret = HandleChunkMessage( aMessage );

            break;

        default:

            PanicServer (E_BadRequest);

            break;

        }

    aMessage.Complete( ret );

    TRACE_FUNC_EXIT;

    }

// -----------------------------------------------------------------------------

// CSConPCConnSession::HandlePutMessageL()

// Handles a PUT -type message from the client

// -----------------------------------------------------------------------------

//

TInt CSConPCConnSession::HandlePutMessageL()

    {

    TRACE_FUNC_ENTRY;

    LOGGER_WRITE_1( "CSConPCConnSession::HandlePutMessageL() : begin : Heap count : %d", User::Heap().Count() );

    TInt ret ( KErrNone );

    if ( !iPCDHandler )

        {

        TRAP( ret, LoadPCDDllL() );

        if ( ret != KErrNone) 

            {

            LOGGER_WRITE_1( "CSConPCConnSession::HandlePutMessageL (): PCD dll load failed with error code %d", ret );    

            return ( ret );

            }

        }   

    if ( ! iConMLHandler )

        {

        TRAP ( ret, LoadConMLHandlerDllL() );

        if ( ret != KErrNone )

            {

            LOGGER_WRITE_1( "CSConPCConnSession::HandlePutMessageL (): ConML Handler dll load failed with error code %d", ret );  

            return ( ret );

            }

        }

    TInt length ( 0 );

    RMemReadStream buf( iChunk.Base(), iChunk.Size() );

    iBuffer->Reset();

    length = buf.ReadInt32L();

    HBufC8* name = HBufC8::NewLC( length );

    TPtr8 namePtr = name->Des();

    buf.ReadL( namePtr, length);

    length = buf.ReadInt32L();

    HBufC8* type = HBufC8::NewLC( length );

    TPtr8 typePtr = type->Des();

    buf.ReadL( typePtr, length);

    // WBXML Document

    length = buf.ReadInt32L();

    HBufC8* data = HBufC8::NewLC( length );

    TPtr8 dataPtr = data->Des();

    buf.ReadL( dataPtr, length );

    iBuffer->ResizeL( length );

    iBuffer->Write( 0, dataPtr );

    buf.Close();

#ifdef DEBUG_XML

    RFs fs;

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

    CleanupClosePushL( fs );

    RFile file;

    if ( file.Open( fs, KSConConMLDebugFile, EFileWrite ) == KErrNone )

        {

        RFileWriteStream fws;

        TInt fileSize;

        file.Size( fileSize );

        TTime now;

        now.HomeTime();

        TDateTime time = now.DateTime();

        TBuf8<16> timeLine;

        timeLine.Format (KTimeFormat, time.Hour(), time.Minute(), 

                                    time.Second(), time.MicroSecond() );

        fws.Attach( file, fileSize );

        fws.PushL();

        fws.WriteL( timeLine );

        _LIT8( KPutMessage, "__________PUT-MESSAGE \nWBXML:\n" );

        fws.WriteL( KPutMessage );

        fws.WriteL( iBuffer->Ptr(0), iBuffer->Size() );

        TRAP_IGNORE( fws.CommitL() );

        fws.Close();

        CleanupStack::PopAndDestroy( &fws );

        }

    file.Close();   

    CleanupStack::PopAndDestroy( &fs );

#endif

    if ( ( typePtr.Compare( KSConPCDWBXMLObjectType ) == KErrNone) || 

         ( typePtr.Compare( KSConPCDWBXMLObjectType2 )== KErrNone) )

        {

        LOGGER_WRITE( "CSConPCConnSession::HandlePutMessageL() : Object type PCD " );

        TRAPD( err, ret = iConMLHandler->ParseDocumentL( *iBuffer, this ) );    

        if ( err != KErrNone )

            {

            ret = err;

            }

        if ( ret == KErrNone )

            {

            // Possible error code returned from PCCS 

            ret = iResult;

            }

        }