/*

* Copyright (c) 2000-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:   Event viewer

*

*/

#include <e32base.h>

#include <f32file.h>

#include <barsc.h>

#include <barsread.h>

#include <vpnlogmessages.rsg>

#include <cmmanagerext.h>

#include <cmdestinationext.h>

#include <utf.h>

#include "eventviewer.h"

#include "eventviewer2.h"

#include "log_eventviewer.h"

/////////////////////////////////////////////

// Method IDs

////////////////////////////////////////////

#define KGetMostRecentEvent           0

#define KGetNextEvent                 1

#define KGetPreviousEvent             2

#define KGetEventUsingEventNumber     3

//////////////////////////////////////////////////////////////

// Create EventViewer object

/////////////////////////////////////////////////////////////

EXPORT_C CEventViewer* CEventViewer::NewL()

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    LOG(Log::Printf(_L("Constructing EventViewer\n")));

    CleanupStack::Pop();        // self

    return self;

    }

/////////////////////////////////////////////////////////////

// CEventViewer::CEventViewer()

// C++ default constructor

/////////////////////////////////////////////////////////////

//

//  CEventViewer::CEventViewer() : iEikonEnv(*iCoeEnv)

//      {

//      }

//////////////////////////////////////////////////////////////

// Phase 2 constructor

/////////////////////////////////////////////////////////////

void CEventViewer::ConstructL()

    {

    TInt status = iFS.Connect();

    if (status != KErrNone)

        {

        LOG(Log::Printf(_L("iFS.Connect failed %d\n"), status));

        User::Leave(status);

        }

    status = iEventMediator.Connect();

    if (status != KErrNone)

        {

        LOG(Log::Printf(_L("iEventMediator.Connect failed %d\n"), status));

        User::Leave(status);

        }

    status = OpenLogFile();                             // Open log file and read file header

    if (status != KErrNone)

        {

        LOG(Log::Printf(_L("OpenLogFile failed %d\n"), status));

        User::Leave(status);

        }

    OpenResourceFileL();

    }

//////////////////////////////////////////////////////////////

// Destructor

/////////////////////////////////////////////////////////////

CEventViewer::~CEventViewer()

    {

    LOG(Log::Printf(_L("Destructing EventViewer\n")));

    delete iLogFileBuf;

    iLogFileBuf = 0;

    CloseLogFile();

    delete iResultBuf;

    iResultBuf = 0;

    iResourceFile.Close();

    iFS.Close();

    iEventMediator.Close();

    }

//////////////////////////////////////////////////////////////

// OpenResourceFileL()

// Used in ConstructL to get resource file

//////////////////////////////////////////////////////////////

//

void CEventViewer::OpenResourceFileL()

   {

   //RResourceFile resourceFile;

   _LIT(KResourceFile, "\\resource\\vpnlogmessages.rsc");

   TFileName resourceFileName(KResourceFile);

   TFileName dllName;

   Dll::FileName(dllName);

   TBuf<2> drive = dllName.Left(2);

   resourceFileName.Insert(0, drive);

   iResourceFile.OpenL(iFS, resourceFileName);

   iResourceFile.ConfirmSignatureL();

   }

//////////////////////////////////////////////////////////////

// Release resources allocated for a call

/////////////////////////////////////////////////////////////

//void CEventViewer::ReleaseResourcesL()

//    {

//    }

//////////////////////////////////////////////////////////////////

//  

// GetMostRecentEvent

//

/////////////////////////////////////////////////////////////////

EXPORT_C TInt CEventViewer::GetMostRecentEvent( 

                             HBufC*&  aEventText,

                             TEventProperties& aEventProperties) 

    {

    TInt status = GetRequestedEvent(

                            aEventText,

                            aEventProperties,

                            0,         // Event number       

                            KGetMostRecentEvent);

    return status;

    }

//////////////////////////////////////////////////////////////////

//  

// GetNextEvent

//

/////////////////////////////////////////////////////////////////

EXPORT_C TInt CEventViewer::GetNextEvent( 

                                HBufC*&  aEventText,

                                TEventProperties& aEventProperties)

    {

    TInt status = GetRequestedEvent(

                             aEventText,

                             aEventProperties,

                             0,                           // Event number        

                             KGetNextEvent);

    return status;

    }

//////////////////////////////////////////////////////////////////

//  

// GetPrevousEvent

//

/////////////////////////////////////////////////////////////////

EXPORT_C TInt CEventViewer::GetPreviousEvent( 

                                         HBufC*&  aEventText,

                                         TEventProperties& aEventProperties)

    {

    TInt status = GetRequestedEvent(

                             aEventText,

                             aEventProperties,

                             0,                   // Event number 

                             KGetPreviousEvent);

    return status;

    }

//////////////////////////////////////////////////////////////////

//  

// GetEventUsingEventNumber

//

/////////////////////////////////////////////////////////////////

EXPORT_C TInt CEventViewer::GetEventUsingEventNumber( 

                                                HBufC*&  aEventText,

                                                TUint32   aEventNumber, 

                                                TEventProperties& aEventProperties)

    {

    TInt status = GetRequestedEvent(

                            aEventText,

                            aEventProperties,

                            aEventNumber, 

                            KGetEventUsingEventNumber);

    return status;

    }

//////////////////////////////////////////////////////////////////

//  

// GetRequestedEvent - Get Requested Event

// This is a common function for API calls. It searches the event

// that the API user has requested. The function returns a buffer

// containing the event text and TEventProperties structure that

// contains  some parameters relating to the event.

//

/////////////////////////////////////////////////////////////////

    TInt CEventViewer::GetRequestedEvent( 

                                          HBufC*&                 aEventText,

                                          TEventProperties&        aEventProperties,

                                          TUint32                  aEventNumber, 

                                          TInt                     aMethodId)

    {

    TInt status = 0;              

    TRAPD (err, status = GetRequestedEventL(

                                           aEventText,

                                           aEventProperties,

                                           aEventNumber, 

                                           aMethodId))

    if (err != KErrNone)

        {

        LOG(Log::Printf(_L("API request failed, status %d\n"), err));

        status = err;

        }

    return status;

    }

TInt CEventViewer::GetRequestedEventL( 

                                     HBufC*&                 aEventText,

                                     TEventProperties&        aEventProperties,

                                     TUint32                  aEventNumber, 

                                     TInt                     aMethodId)

    {

    TInt status;

    LOG(Log::Printf(_L("API request received, method =  %d\n"), aMethodId));

    //

    // Store the API parameters to this object

    //

    iEventText = &aEventText;

    iEventProperties = &aEventProperties;

    //

    // Produce the event number that the user is requesting

    //

    switch (aMethodId)

        {

        case KGetMostRecentEvent:

            {

            // Read the log file to memory buffer if not yet done

            if (iLogFileBuf == 0)

                {

                status = ReadWholeLogFileToMemoryBuffer();

                if (status != KErrNone)

                    {

                    break;

                    }

                TakeCopyOfFileHeader(iCurrFileHeader, iPreviousFileHeader);

                }

            // Check if the log file has been modified and read the log

            // file header

            else

                {

                status = ReadLogFileHeader();

                if (status != KErrNone)

                    {

                    break;

                    }

                if (IsLogFileModified())

                    {

                    TakeCopyOfFileHeader(iCurrFileHeader, iPreviousFileHeader);

                    }

                }

            iRequestedEventNumber = iCurrFileHeader.iCurrEventNumber;

            break;

            }

        case KGetNextEvent:

            {

            iRequestedEventNumber++;

            break;

            }

        case KGetPreviousEvent:

            {

            iRequestedEventNumber--;

            break;

            }

        case KGetEventUsingEventNumber:

            {

            iRequestedEventNumber = aEventNumber;

            break;

            }

        default:    

            {

            break;

            }

        }   

    //

    // Check the validity of requested event number

    //

    if (iRequestedEventNumber == 0 ||

        iRequestedEventNumber > iCurrFileHeader.iCurrEventNumber ||

        iLogFileBuf == 0)                // Logfile not yet in memory   

        {

        LOG(Log::Printf(_L("API request completed, requested event not found \n")));

        return KErrNotFound;

        }

    //

    // Search the event from the memory resident log file

    //

    status = EventLookup(iRequestedEventNumber);

    if (status != KErrNone)

        {

        return status;              // Event not found

        }

    //

    // Event found, copy the packed format log element parameters to an

    // unpacked object

    //

    CopyPackedLogElemToUnpackedObject(iPositionOfCurrLogElem);

    //

    // Search the event text relating to the MsgId

    //

    HBufC* eventTextBuf;

    eventTextBuf = SearchEventTextL(iUnpackedLogElem.iMsgId);

    if (eventTextBuf == 0)

        {

        return KErrNoMemory;

        }

    //

    // Modify the event text with the descriptor data

    // DescrPtr points to a list of following elements:

    //  TInt   DataLength

    //  TInt8  Data

    //

    TUint32 descrDataPosition = iPositionOfCurrLogElem + LOG_ELEM_HEADER_LTH; 

    HBufC* modifiedEventTextBuf = ModifyEventText(

                                     eventTextBuf,

                                    iUnpackedLogElem.iDescrCount,     // Count of descriptor elements

                                    descrDataPosition);               // Descriptors: lth,lth,...data,data...

    if (modifiedEventTextBuf == 0)

        {

        return KErrNoMemory;

        }

    //

    // An event is available, return data to the caller

    //

   *iEventText = modifiedEventTextBuf;           

    iResultBuf  = 0;

    iEventProperties->iEventNumber               = iUnpackedLogElem.iEventNumber;     

    iEventProperties->iMsgId                     = iUnpackedLogElem.iMsgId;

    TTime tmpTime(iUnpackedLogElem.iTimeStamp);  

    iEventProperties->iTimeStamp                 = tmpTime;

    iEventProperties->iSourceComponent           = iUnpackedLogElem.iSourceComponent;

    iEventProperties->iCategory                  = iUnpackedLogElem.iCategory;

    LOG(Log::Printf(_L("API request completed OK \n")));

    return KErrNone;

    }

    //////////////////////////////////////////////////////////////////////

    // EventLookup

    // This function searches an event from the log file buffer that

    // matches with the requested event number.

    //////////////////////////////////////////////////////////////////////

TInt CEventViewer::EventLookup(TUint32 aEventNumber)

    {

    TUint32 positionOfLogElemEnd = iCurrFileHeader.iPositionOfNextFree;

    TUint32 positionOfLogElem;

    TInt    searchGoing = ETrue;

    TInt status = KErrNone;              

    iWrappingOccured = EFalse;

    //

    // Loop here until matching event found or end of elements reached

    // or any error found

    //

    while (searchGoing && status == KErrNone)

        {

    //

    // Check if wrapping 1

    //

        if (positionOfLogElemEnd == EVENTLOG_FILE_HEADER_LTH)

            {

            if (iCurrFileHeader.iPositionOfWrapping != 0)

                {

                positionOfLogElemEnd = iCurrFileHeader.iPositionOfWrapping;  // Wrapping occurs

                iWrappingOccured = ETrue;

                }

            else

                {

                status = KErrNotFound;

                continue;

                }

            }

    //

    // Produce the start position of an event   

    //

        status = GetStartPositionOfLogElem( positionOfLogElemEnd,

                                            &positionOfLogElem);

        if (status != KErrNone)

            {

            continue;

            }

    //

    // Check if requested event has been found

    //

        if (iUnpackedLogElem.iEventNumber != aEventNumber)

            {

            positionOfLogElemEnd = positionOfLogElem;

            continue;                           // Not found, continue

            }

    //

    // Requested event found, stop the loop  

    //

        status = KErrNone;

        iPositionOfCurrLogElem = positionOfLogElem;

        searchGoing = EFalse;

        }

    return status;

    }

/////////////////////////////////////////////////////////////////////

// SearchEventText

// This function searches from the localization file the text string

// relating to the MsgId parameter and allocates an buffer in which

// it returns the data to the caller.

//

/////////////////////////////////////////////////////////////////////

HBufC*  CEventViewer::SearchEventTextL( TUint32 aMsgId)

    {

    HBufC8* resourceBuf = NULL;

    HBufC* textDataBuf = NULL;

    //

    // MsgId is a code defined in epoc32\include\eventviewererr.rsg

    // file. It refers to a message in .rsc file.

    //

    TInt msgNumber = STATIC_CAST(TInt, aMsgId); 

    resourceBuf = iResourceFile.AllocReadL( msgNumber);

    TResourceReader resourceReader;

    resourceReader.SetBuffer(resourceBuf);

    textDataBuf = HBufC::New(resourceBuf->Length());

    if (textDataBuf)

        {

        TPtr textDataPtr(textDataBuf->Des());

        resourceReader.Read((void*)textDataBuf->Ptr(), resourceBuf->Length());

        textDataPtr.SetLength(resourceBuf->Length()/2);

        }

    delete resourceBuf;

    return textDataBuf;

    }

/////////////////////////////////////////////////////////////////////

// ModifyEventText

// This function modifies the event text by the descriptors.

// Both the event text and descriptors are parameters of the

// function.

//

/////////////////////////////////////////////////////////////////////

HBufC*  CEventViewer::ModifyEventText(

                         HBufC*  aEventTextSrc,

                         TUint32 aDescrCount,         // Count of descriptor elements

                         TUint32 aDescrDataPosition)  // Descriptors: lth data lth data.... 

    {

    HBufC* modifiedEventText;

    //

    // If descriptors exist, build pointer to the first

    // length definition. The format of descriptor data

    // is as follows:

    //   -- TUInt32 Length of parameter 1 (lth1)

    //   -- TUInt32 Length of parameter 2 (lth2)

    //   -- TUInt32 Length of parameter n (lthx)

    //   -- TInt8[lth1] Data 1

    //   -- TInt8[lth2] Data 2

    //   -- TInt8[lthx] Data n

    //              Variable length data, The format of 

    //              data is defined by the conversion

    //              specification characters in the text string

    //

    //

    // No descriptors, return localisation data  buffer

    //

    if (aDescrCount == 0)

        {

        return aEventTextSrc;

        }

    //

    // Build TPtr8 pointer for descriptor list

    //