/*

* Copyright (c) 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:  KMD event logger

*

*/

#include <e32base.h>

#include <vpnlogmessages.rsg>

#include "eventviewer.h"

#include "ikedebug.h"

#include "vpnclientuids.h"

// CLASS HEADER

#include "kmdeventlogger.h"

// ======== MEMBER FUNCTIONS ========

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

// Two-phased constructor.

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

//

CKmdEventLogger* CKmdEventLogger::NewL( MIkeDebug& aDebug )

    {

    CKmdEventLogger* self = new ( ELeave ) CKmdEventLogger( aDebug );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor.

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

//

CKmdEventLogger::~CKmdEventLogger()

    {

    iEventMediator.Close();

    }

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

// Constructor.

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

//

CKmdEventLogger::CKmdEventLogger( MIkeDebug& aDebug )

 : iDebug( aDebug )

    {

    }

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

// Second phase construction.

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

//

void CKmdEventLogger::ConstructL()

    {

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

    }

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

// From class MKmdEventLoggerIf

// Writes event to event log.

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

//

void CKmdEventLogger::LogEvent( TLogCategory aCategory,

                                TInt aMsgId,

                                TInt aStatus,

                                TUint32 aVpnIapId,

                                const TInetAddr* aGwIp,

                                const TInetAddr* aLocalAddr )

    {

    TUid uid = TUid::Uid( KUidKmdServer );    

    TBuf<40> ipAddr16;  

    TBuf8<40> ipAddr;

    TBuf8<40> localIpAddr;  

    TIapName vpnAccessPointName;

    TInt addrIndex = KErrNotFound;

    TInt iapIndex = KErrNotFound;

    TInt statusIndex = KErrNotFound;

    TInt realIpIndex = KErrNotFound;      

    TInt desCount = 0;

    TUint8* pointers[4];

    TInt lengths[4];

    switch ( aMsgId )

        {

        case R_VPN_MSG_VPN_GW_NO_RESP:

        case R_VPN_MSG_VPN_GW_AUTH_FAIL:

        case R_VPN_MSG_VPN_GW_AUTH_OK:

            addrIndex = 0;

            iapIndex  = 1;                  

            break;

        case R_VPN_MSG_VPN_GW_ERR_RESP_RECEIVED:

        case R_VPN_MSG_SENT_ERROR_RESPONSE:         

            addrIndex   = 0;

            iapIndex    = 1;

            statusIndex = 2;

            break;

        case R_VPN_MSG_DATA_DROPPED_DUE_POLICY:

            addrIndex   = 0;            

            statusIndex = 1;

            break;

        case R_VPN_MSG_ADDR_INFO_FOR_VPN_AP:

            iapIndex    = 0;            

            addrIndex   = 1;

            realIpIndex = 2;

            statusIndex = 3;

            break;

        case R_VPN_MSG_REAL_IAP_ACT_FAILED: 

            realIpIndex = 0;        

            iapIndex    = 1;

            statusIndex = 2;

            break;

        default:

            break;

        }   

    if ( addrIndex != KErrNotFound )

        {

        desCount ++;

        pointers[addrIndex] = (TUint8*)ipAddr.Ptr();        

        if ( aGwIp )

            {   

            aGwIp->Output(ipAddr16);

            ipAddr.Copy(ipAddr16);

            lengths[addrIndex] = ipAddr.Length();       

            }

        else

            {

            lengths[addrIndex] = 0;

            }

        }

    if ( statusIndex != KErrNotFound )

        {

        desCount ++;

        pointers[statusIndex] = (TUint8*)&aStatus;

        lengths[statusIndex]  = sizeof(aStatus);

        }

    if ( iapIndex != KErrNotFound )

        {

        //

        // VPN IAP id shall be converted to VPN access point name using

        // eventviewer API.

        //

        desCount ++;

        pointers[iapIndex] = (TUint8*)vpnAccessPointName.Ptr();     

        if ( aVpnIapId != 0 )

            {   

            EventViewer::GetIapName(aVpnIapId, vpnAccessPointName);

            lengths[iapIndex] = vpnAccessPointName.Length();

            }

        else

            {

            lengths[iapIndex] = 0;

            }

        }

    if ( realIpIndex != KErrNotFound )

        {

        desCount ++;

        pointers[realIpIndex] = (TUint8*)localIpAddr.Ptr();

        ipAddr16.SetLength(0);        

        if ( aLocalAddr != NULL )

            {

            aLocalAddr->Output(ipAddr16);

            }

        localIpAddr.Copy(ipAddr16);

        lengths[realIpIndex] = localIpAddr.Length();

        }

    TInt ret( KErrNone );

    switch ( desCount )

        {

        case 0:

            {

            ret = iEventMediator.ReportLogEvent( uid,

                                                 aCategory,

                                                 aMsgId,

                                                 0 );

            }

            break;             

        case 1:

            {

            TPtr8 parm1(pointers[0], lengths[0], lengths[0]);

            ret = iEventMediator.ReportLogEvent( uid,

                                                 aCategory,

                                                 aMsgId,

                                                 1,

                                                 &parm1 );

            }

            break;

        case 2:

            {

            TPtr8 parm1(pointers[0], lengths[0], lengths[0]);

            TPtr8 parm2(pointers[1], lengths[1], lengths[1]);

            ret = iEventMediator.ReportLogEvent( uid,

                                                 aCategory,

                                                 aMsgId,

                                                 2,

                                                 &parm1,

                                                 &parm2 );

            }

            break;

        case 3:

            {

            TPtr8 parm1(pointers[0], lengths[0], lengths[0]);

            TPtr8 parm2(pointers[1], lengths[1], lengths[1]);

            TPtr8 parm3(pointers[2], lengths[2], lengths[2]);        

            ret = iEventMediator.ReportLogEvent( uid,

                                                 aCategory,

                                                 aMsgId,

                                                 3,

                                                 &parm1,

                                                 &parm2,

                                                 &parm3 );

            }

            break;

        case 4:

            {

            TPtr8 parm1(pointers[0], lengths[0], lengths[0]);

            TPtr8 parm2(pointers[1], lengths[1], lengths[1]);

            TPtr8 parm3(pointers[2], lengths[2], lengths[2]);

            TPtr8 parm4(pointers[3], lengths[3], lengths[3]);                   

            ret = iEventMediator.ReportLogEvent( uid,

                                                 aCategory,

                                                 aMsgId,

                                                 4,

                                                 &parm1,

                                                 &parm2,

                                                 &parm3,

                                                 &parm4 );

            }

            break;

        default:

            ret = ret;

            break;

        }

    DEBUG_LOG3( _L("Logging event %x with %d parameters, report status = %d"),

            aMsgId, desCount, ret );

    }

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

// From class MKmdEventLoggerIf

// Writes event to event log.

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

//

void CKmdEventLogger::LogEvent( TKmdLogCategory aCategory,

                                TInt aMsgId,

                                TInt aStatus,

                                TUint32 aVpnIapId,

                                const TInetAddr* aGwIp,

                                const TInetAddr* aLocalAddr )

    {

    TLogCategory logCategory;

    switch ( aCategory )

        {

        case KLogInfo:

            logCategory = EInfo;

            break;

        case KLogWarning:

            logCategory = EWarning;

            break;

        case KLogError:

            logCategory = EError;

            break;

        default:

            logCategory = EDebug;

            break;

        }

    LogEvent( logCategory,

              aMsgId,

              aStatus,

              aVpnIapId,

              aGwIp,

              aLocalAddr );

    }